source: branches/samba-3.0/source/smbd/blocking.c@ 1029

Last change on this file since 1029 was 71, checked in by Paul Smedley, 18 years ago

Update source to 3.0.26a
File size: 25.8 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Blocking Locking functions
4 Copyright (C) Jeremy Allison 1998-2003
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
21#include "includes.h"
22#undef DBGC_CLASS
23#define DBGC_CLASS DBGC_LOCKING
24
25extern int max_send;
26
27/****************************************************************************
28 This is the structure to queue to implement blocking locks.
29 notify. It consists of the requesting SMB and the expiry time.
30*****************************************************************************/
31
32typedef struct _blocking_lock_record {
33 struct _blocking_lock_record *next;
34 struct _blocking_lock_record *prev;
35 int com_type;
36 files_struct *fsp;
37 struct timeval expire_time;
38 int lock_num;
39 SMB_BIG_UINT offset;
40 SMB_BIG_UINT count;
41 uint32 lock_pid;
42 uint32 blocking_pid; /* PID that blocks us. */
43 enum brl_flavour lock_flav;
44 enum brl_type lock_type;
45 char *inbuf;
46 int length;
47} blocking_lock_record;
48
49/* dlink list we store pending lock records on. */
50static blocking_lock_record *blocking_lock_queue;
51
52/* dlink list we move cancelled lock records onto. */
53static blocking_lock_record *blocking_lock_cancelled_queue;
54
55/****************************************************************************
56 Destructor for the above structure.
57****************************************************************************/
58
59static void free_blocking_lock_record(blocking_lock_record *blr)
60{
61 SAFE_FREE(blr->inbuf);
62 SAFE_FREE(blr);
63}
64
65/****************************************************************************
66 Determine if this is a secondary element of a chained SMB.
67 **************************************************************************/
68
69static BOOL in_chained_smb(void)
70{
71 return (chain_size != 0);
72}
73
74static void received_unlock_msg(int msg_type, struct process_id src,
75 void *buf, size_t len,
76 void *private_data);
77
78/****************************************************************************
79 Function to push a blocking lock request onto the lock queue.
80****************************************************************************/
81
82BOOL push_blocking_lock_request( struct byte_range_lock *br_lck,
83 char *inbuf, int length,
84 files_struct *fsp,
85 int lock_timeout,
86 int lock_num,
87 uint32 lock_pid,
88 enum brl_type lock_type,
89 enum brl_flavour lock_flav,
90 SMB_BIG_UINT offset,
91 SMB_BIG_UINT count,
92 uint32 blocking_pid)
93{
94 static BOOL set_lock_msg;
95 blocking_lock_record *blr;
96 NTSTATUS status;
97
98 if(in_chained_smb() ) {
99 DEBUG(0,("push_blocking_lock_request: cannot queue a chained request (currently).\n"));
100 return False;
101 }
102
103 /*
104 * Now queue an entry on the blocking lock queue. We setup
105 * the expiration time here.
106 */
107
108 if((blr = SMB_MALLOC_P(blocking_lock_record)) == NULL) {
109 DEBUG(0,("push_blocking_lock_request: Malloc fail !\n" ));
110 return False;
111 }
112
113 blr->next = NULL;
114 blr->prev = NULL;
115
116 if((blr->inbuf = (char *)SMB_MALLOC(length)) == NULL) {
117 DEBUG(0,("push_blocking_lock_request: Malloc fail (2)!\n" ));
118 SAFE_FREE(blr);
119 return False;
120 }
121
122 blr->com_type = CVAL(inbuf,smb_com);
123 blr->fsp = fsp;
124 if (lock_timeout == -1) {
125 blr->expire_time.tv_sec = 0;
126 blr->expire_time.tv_usec = 0; /* Never expire. */
127 } else {
128 blr->expire_time = timeval_current_ofs(lock_timeout/1000,
129 (lock_timeout % 1000) * 1000);
130 }
131 blr->lock_num = lock_num;
132 blr->lock_pid = lock_pid;
133 blr->blocking_pid = blocking_pid;
134 blr->lock_flav = lock_flav;
135 blr->lock_type = lock_type;
136 blr->offset = offset;
137 blr->count = count;
138 memcpy(blr->inbuf, inbuf, length);
139 blr->length = length;
140
141 /* Add a pending lock record for this. */
142 status = brl_lock(br_lck,
143 lock_pid,
144 procid_self(),
145 offset,
146 count,
147 lock_type == READ_LOCK ? PENDING_READ_LOCK : PENDING_WRITE_LOCK,
148 blr->lock_flav,
149 lock_timeout ? True : False, /* blocking_lock. */
150 NULL);
151
152 if (!NT_STATUS_IS_OK(status)) {
153 DEBUG(0,("push_blocking_lock_request: failed to add PENDING_LOCK record.\n"));
154 DLIST_REMOVE(blocking_lock_queue, blr);
155 free_blocking_lock_record(blr);
156 return False;
157 }
158
159 DLIST_ADD_END(blocking_lock_queue, blr, blocking_lock_record *);
160
161 /* Ensure we'll receive messages when this is unlocked. */
162 if (!set_lock_msg) {
163 message_register(MSG_SMB_UNLOCK, received_unlock_msg,
164 NULL);
165 set_lock_msg = True;
166 }
167
168 DEBUG(3,("push_blocking_lock_request: lock request length=%d blocked with "
169 "expiry time (%u sec. %u usec) (+%d msec) for fnum = %d, name = %s\n",
170 length, (unsigned int)blr->expire_time.tv_sec,
171 (unsigned int)blr->expire_time.tv_usec, lock_timeout,
172 blr->fsp->fnum, blr->fsp->fsp_name ));
173
174 /* Push the MID of this packet on the signing queue. */
175 srv_defer_sign_response(SVAL(inbuf,smb_mid));
176
177 return True;
178}
179
180/****************************************************************************
181 Return a smd with a given size.
182*****************************************************************************/
183
184static void send_blocking_reply(char *outbuf, int outsize)
185{
186 if(outsize > 4)
187 smb_setlen(outbuf,outsize - 4);
188
189 if (!send_smb(smbd_server_fd(),outbuf))
190 exit_server_cleanly("send_blocking_reply: send_smb failed.");
191}
192
193/****************************************************************************
194 Return a lockingX success SMB.
195*****************************************************************************/
196
197static void reply_lockingX_success(blocking_lock_record *blr)
198{
199 char *outbuf = get_OutBuffer();
200 int bufsize = BUFFER_SIZE;
201 char *inbuf = blr->inbuf;
202 int outsize = 0;
203
204 construct_reply_common(inbuf, outbuf);
205 set_message(outbuf,2,0,True);
206
207 /*
208 * As this message is a lockingX call we must handle
209 * any following chained message correctly.
210 * This is normally handled in construct_reply(),
211 * but as that calls switch_message, we can't use
212 * that here and must set up the chain info manually.
213 */
214
215 outsize = chain_reply(inbuf,outbuf,blr->length,bufsize);
216
217 outsize += chain_size;
218
219 send_blocking_reply(outbuf,outsize);
220}
221
222/****************************************************************************
223 Return a generic lock fail error blocking call.
224*****************************************************************************/
225
226static void generic_blocking_lock_error(blocking_lock_record *blr, NTSTATUS status)
227{
228 char *outbuf = get_OutBuffer();
229 char *inbuf = blr->inbuf;
230 construct_reply_common(inbuf, outbuf);
231
232 /* whenever a timeout is given w2k maps LOCK_NOT_GRANTED to
233 FILE_LOCK_CONFLICT! (tridge) */
234 if (NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
235 status = NT_STATUS_FILE_LOCK_CONFLICT;
236 }
237
238 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
239 /* Store the last lock error. */
240 files_struct *fsp = blr->fsp;
241
242 fsp->last_lock_failure.context.smbpid = blr->lock_pid;
243 fsp->last_lock_failure.context.tid = fsp->conn->cnum;
244 fsp->last_lock_failure.context.pid = procid_self();
245 fsp->last_lock_failure.start = blr->offset;
246 fsp->last_lock_failure.size = blr->count;
247 fsp->last_lock_failure.fnum = fsp->fnum;
248 fsp->last_lock_failure.lock_type = READ_LOCK; /* Don't care. */
249 fsp->last_lock_failure.lock_flav = blr->lock_flav;
250 }
251
252 ERROR_NT(status);
253 if (!send_smb(smbd_server_fd(),outbuf)) {
254 exit_server_cleanly("generic_blocking_lock_error: send_smb failed.");
255 }
256}
257
258/****************************************************************************
259 Return a lock fail error for a lockingX call. Undo all the locks we have
260 obtained first.
261*****************************************************************************/
262
263static void reply_lockingX_error(blocking_lock_record *blr, NTSTATUS status)
264{
265 char *inbuf = blr->inbuf;
266 files_struct *fsp = blr->fsp;
267 uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
268 SMB_BIG_UINT count = (SMB_BIG_UINT)0, offset = (SMB_BIG_UINT) 0;
269 uint32 lock_pid;
270 unsigned char locktype = CVAL(inbuf,smb_vwv3);
271 BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
272 char *data;
273 int i;
274
275 data = smb_buf(inbuf) + ((large_file_format ? 20 : 10)*num_ulocks);
276
277 /*
278 * Data now points at the beginning of the list
279 * of smb_lkrng structs.
280 */
281
282 /*
283 * Ensure we don't do a remove on the lock that just failed,
284 * as under POSIX rules, if we have a lock already there, we
285 * will delete it (and we shouldn't) .....
286 */
287
288 for(i = blr->lock_num - 1; i >= 0; i--) {
289 BOOL err;
290
291 lock_pid = get_lock_pid( data, i, large_file_format);
292 count = get_lock_count( data, i, large_file_format);
293 offset = get_lock_offset( data, i, large_file_format, &err);
294
295 /*
296 * We know err cannot be set as if it was the lock
297 * request would never have been queued. JRA.
298 */
299
300 do_unlock(fsp,
301 lock_pid,
302 count,
303 offset,
304 WINDOWS_LOCK);
305 }
306
307 generic_blocking_lock_error(blr, status);
308}
309
310/****************************************************************************
311 Return a lock fail error.
312*****************************************************************************/
313
314static void blocking_lock_reply_error(blocking_lock_record *blr, NTSTATUS status)
315{
316 switch(blr->com_type) {
317 case SMBlockingX:
318 reply_lockingX_error(blr, status);
319 break;
320 case SMBtrans2:
321 case SMBtranss2:
322 {
323 char *outbuf = get_OutBuffer();
324 char *inbuf = blr->inbuf;
325 construct_reply_common(inbuf, outbuf);
326 /* construct_reply_common has done us the favor to pre-fill the
327 * command field with SMBtranss2 which is wrong :-)
328 */
329 SCVAL(outbuf,smb_com,SMBtrans2);
330 ERROR_NT(status);
331 if (!send_smb(smbd_server_fd(),outbuf)) {
332 exit_server_cleanly("blocking_lock_reply_error: send_smb failed.");
333 }
334 break;
335 }
336 default:
337 DEBUG(0,("blocking_lock_reply_error: PANIC - unknown type on blocking lock queue - exiting.!\n"));
338 exit_server("PANIC - unknown type on blocking lock queue");
339 }
340}
341
342/****************************************************************************
343 Attempt to finish off getting all pending blocking locks for a lockingX call.
344 Returns True if we want to be removed from the list.
345*****************************************************************************/
346
347static BOOL process_lockingX(blocking_lock_record *blr)
348{
349 char *inbuf = blr->inbuf;
350 unsigned char locktype = CVAL(inbuf,smb_vwv3);
351 files_struct *fsp = blr->fsp;
352 uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
353 uint16 num_locks = SVAL(inbuf,smb_vwv7);
354 SMB_BIG_UINT count = (SMB_BIG_UINT)0, offset = (SMB_BIG_UINT)0;
355 uint32 lock_pid;
356 BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
357 char *data;
358 NTSTATUS status = NT_STATUS_OK;
359
360 data = smb_buf(inbuf) + ((large_file_format ? 20 : 10)*num_ulocks);
361
362 /*
363 * Data now points at the beginning of the list
364 * of smb_lkrng structs.
365 */
366
367 for(; blr->lock_num < num_locks; blr->lock_num++) {
368 struct byte_range_lock *br_lck = NULL;
369 BOOL err;
370
371 lock_pid = get_lock_pid( data, blr->lock_num, large_file_format);
372 count = get_lock_count( data, blr->lock_num, large_file_format);
373 offset = get_lock_offset( data, blr->lock_num, large_file_format, &err);
374
375 /*
376 * We know err cannot be set as if it was the lock
377 * request would never have been queued. JRA.
378 */
379 errno = 0;
380 br_lck = do_lock(fsp,
381 lock_pid,
382 count,
383 offset,
384 ((locktype & LOCKING_ANDX_SHARED_LOCK) ?
385 READ_LOCK : WRITE_LOCK),
386 WINDOWS_LOCK,
387 True,
388 &status,
389 &blr->blocking_pid);
390
391 TALLOC_FREE(br_lck);
392
393 if (NT_STATUS_IS_ERR(status)) {
394 break;
395 }
396 }
397
398 if(blr->lock_num == num_locks) {
399 /*
400 * Success - we got all the locks.
401 */
402
403 DEBUG(3,("process_lockingX file = %s, fnum=%d type=%d num_locks=%d\n",
404 fsp->fsp_name, fsp->fnum, (unsigned int)locktype, num_locks) );
405
406 reply_lockingX_success(blr);
407 return True;
408 } else if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
409 !NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
410 /*
411 * We have other than a "can't get lock"
412 * error. Free any locks we had and return an error.
413 * Return True so we get dequeued.
414 */
415
416 blocking_lock_reply_error(blr, status);
417 return True;
418 }
419
420 /*
421 * Still can't get all the locks - keep waiting.
422 */
423
424 DEBUG(10,("process_lockingX: only got %d locks of %d needed for file %s, fnum = %d. \
425Waiting....\n",
426 blr->lock_num, num_locks, fsp->fsp_name, fsp->fnum));
427
428 return False;
429}
430
431/****************************************************************************
432 Attempt to get the posix lock request from a SMBtrans2 call.
433 Returns True if we want to be removed from the list.
434*****************************************************************************/
435
436static BOOL process_trans2(blocking_lock_record *blr)
437{
438 char *inbuf = blr->inbuf;
439 char *outbuf;
440 char params[2];
441 NTSTATUS status;
442 struct byte_range_lock *br_lck = do_lock(blr->fsp,
443 blr->lock_pid,
444 blr->count,
445 blr->offset,
446 blr->lock_type,
447 blr->lock_flav,
448 True,
449 &status,
450 &blr->blocking_pid);
451 TALLOC_FREE(br_lck);
452
453 if (!NT_STATUS_IS_OK(status)) {
454 if (ERROR_WAS_LOCK_DENIED(status)) {
455 /* Still can't get the lock, just keep waiting. */
456 return False;
457 }
458 /*
459 * We have other than a "can't get lock"
460 * error. Send an error and return True so we get dequeued.
461 */
462 blocking_lock_reply_error(blr, status);
463 return True;
464 }
465
466 /* We finally got the lock, return success. */
467 outbuf = get_OutBuffer();
468 construct_reply_common(inbuf, outbuf);
469 SCVAL(outbuf,smb_com,SMBtrans2);
470 SSVAL(params,0,0);
471 /* Fake up max_data_bytes here - we know it fits. */
472 send_trans2_replies(outbuf, max_send, params, 2, NULL, 0, 0xffff);
473 return True;
474}
475
476
477/****************************************************************************
478 Process a blocking lock SMB.
479 Returns True if we want to be removed from the list.
480*****************************************************************************/
481
482static BOOL blocking_lock_record_process(blocking_lock_record *blr)
483{
484 switch(blr->com_type) {
485 case SMBlockingX:
486 return process_lockingX(blr);
487 case SMBtrans2:
488 case SMBtranss2:
489 return process_trans2(blr);
490 default:
491 DEBUG(0,("blocking_lock_record_process: PANIC - unknown type on blocking lock queue - exiting.!\n"));
492 exit_server("PANIC - unknown type on blocking lock queue");
493 }
494 return False; /* Keep compiler happy. */
495}
496
497/****************************************************************************
498 Cancel entries by fnum from the blocking lock pending queue.
499*****************************************************************************/
500
501void cancel_pending_lock_requests_by_fid(files_struct *fsp, struct byte_range_lock *br_lck)
502{
503 blocking_lock_record *blr, *next = NULL;
504
505 for(blr = blocking_lock_queue; blr; blr = next) {
506 next = blr->next;
507 if(blr->fsp->fnum == fsp->fnum) {
508 unsigned char locktype = 0;
509
510 if (blr->com_type == SMBlockingX) {
511 locktype = CVAL(blr->inbuf,smb_vwv3);
512 }
513
514 if (br_lck) {
515 DEBUG(10,("remove_pending_lock_requests_by_fid - removing request type %d for \
516file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
517
518 brl_lock_cancel(br_lck,
519 blr->lock_pid,
520 procid_self(),
521 blr->offset,
522 blr->count,
523 blr->lock_flav);
524
525 blocking_lock_cancel(fsp,
526 blr->lock_pid,
527 blr->offset,
528 blr->count,
529 blr->lock_flav,
530 locktype,
531 NT_STATUS_RANGE_NOT_LOCKED);
532 }
533 }
534 }
535}
536
537/****************************************************************************
538 Delete entries by mid from the blocking lock pending queue. Always send reply.
539*****************************************************************************/
540
541void remove_pending_lock_requests_by_mid(int mid)
542{
543 blocking_lock_record *blr, *next = NULL;
544
545 for(blr = blocking_lock_queue; blr; blr = next) {
546 next = blr->next;
547 if(SVAL(blr->inbuf,smb_mid) == mid) {
548 files_struct *fsp = blr->fsp;
549 struct byte_range_lock *br_lck = brl_get_locks(NULL, fsp);
550
551 if (br_lck) {
552 DEBUG(10,("remove_pending_lock_requests_by_mid - removing request type %d for \
553file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
554
555 brl_lock_cancel(br_lck,
556 blr->lock_pid,
557 procid_self(),
558 blr->offset,
559 blr->count,
560 blr->lock_flav);
561 TALLOC_FREE(br_lck);
562 }
563
564 blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
565 DLIST_REMOVE(blocking_lock_queue, blr);
566 free_blocking_lock_record(blr);
567 }
568 }
569}
570
571/****************************************************************************
572 Is this mid a blocking lock request on the queue ?
573*****************************************************************************/
574
575BOOL blocking_lock_was_deferred(int mid)
576{
577 blocking_lock_record *blr, *next = NULL;
578
579 for(blr = blocking_lock_queue; blr; blr = next) {
580 next = blr->next;
581 if(SVAL(blr->inbuf,smb_mid) == mid) {
582 return True;
583 }
584 }
585 return False;
586}
587
588/****************************************************************************
589 Set a flag as an unlock request affects one of our pending locks.
590*****************************************************************************/
591
592static void received_unlock_msg(int msg_type, struct process_id src,
593 void *buf, size_t len,
594 void *private_data)
595{
596 DEBUG(10,("received_unlock_msg\n"));
597 process_blocking_lock_queue();
598}
599
600/****************************************************************************
601 Return the number of milliseconds to the next blocking locks timeout, or default_timeout
602*****************************************************************************/
603
604unsigned int blocking_locks_timeout_ms(unsigned int default_timeout_ms)
605{
606 unsigned int timeout_ms = default_timeout_ms;
607 struct timeval tv_curr;
608 SMB_BIG_INT min_tv_dif_us = default_timeout_ms * 1000;
609 blocking_lock_record *blr = blocking_lock_queue;
610
611 /* note that we avoid the GetTimeOfDay() syscall if there are no blocking locks */
612 if (!blr) {
613 return timeout_ms;
614 }
615
616 tv_curr = timeval_current();
617
618 for (; blr; blr = blr->next) {
619 SMB_BIG_INT tv_dif_us;
620
621 if (timeval_is_zero(&blr->expire_time)) {
622 /*
623 * If we're blocked on pid 0xFFFFFFFF this is
624 * a POSIX lock, so calculate a timeout of
625 * 10 seconds.
626 */
627 if (blr->blocking_pid == 0xFFFFFFFF) {
628 tv_dif_us = 10 * 1000 * 1000;
629 min_tv_dif_us = MIN(min_tv_dif_us, tv_dif_us);
630 }
631 continue; /* Never timeout. */
632 }
633
634 tv_dif_us = usec_time_diff(&blr->expire_time, &tv_curr);
635 min_tv_dif_us = MIN(min_tv_dif_us, tv_dif_us);
636 }
637
638 if (min_tv_dif_us < 0) {
639 min_tv_dif_us = 0;
640 }
641
642 timeout_ms = (unsigned int)(min_tv_dif_us / (SMB_BIG_INT)1000);
643
644 if (timeout_ms < 1) {
645 timeout_ms = 1;
646 }
647
648 DEBUG(10,("blocking_locks_timeout_ms: returning %u\n", timeout_ms));
649
650 return timeout_ms;
651}
652
653/****************************************************************************
654 Process the blocking lock queue. Note that this is only called as root.
655*****************************************************************************/
656
657void process_blocking_lock_queue(void)
658{
659 struct timeval tv_curr = timeval_current();
660 blocking_lock_record *blr, *next = NULL;
661
662 /*
663 * Go through the queue and see if we can get any of the locks.
664 */
665
666 for (blr = blocking_lock_queue; blr; blr = next) {
667 connection_struct *conn = NULL;
668 uint16 vuid;
669 files_struct *fsp = NULL;
670
671 next = blr->next;
672
673 /*
674 * Ensure we don't have any old chain_fsp values
675 * sitting around....
676 */
677 chain_size = 0;
678 file_chain_reset();
679 fsp = blr->fsp;
680
681 conn = conn_find(SVAL(blr->inbuf,smb_tid));
682 vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID :
683 SVAL(blr->inbuf,smb_uid);
684
685 DEBUG(5,("process_blocking_lock_queue: examining pending lock fnum = %d for file %s\n",
686 fsp->fnum, fsp->fsp_name ));
687
688 if(!change_to_user(conn,vuid)) {
689 struct byte_range_lock *br_lck = brl_get_locks(NULL, fsp);
690
691 /*
692 * Remove the entry and return an error to the client.
693 */
694
695 if (br_lck) {
696 brl_lock_cancel(br_lck,
697 blr->lock_pid,
698 procid_self(),
699 blr->offset,
700 blr->count,
701 blr->lock_flav);
702 TALLOC_FREE(br_lck);
703 }
704
705 DEBUG(0,("process_blocking_lock_queue: Unable to become user vuid=%d.\n",
706 vuid ));
707 blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
708 DLIST_REMOVE(blocking_lock_queue, blr);
709 free_blocking_lock_record(blr);
710 continue;
711 }
712
713 if(!set_current_service(conn,SVAL(blr->inbuf,smb_flg),True)) {
714 struct byte_range_lock *br_lck = brl_get_locks(NULL, fsp);
715
716 /*
717 * Remove the entry and return an error to the client.
718 */
719
720 if (br_lck) {
721 brl_lock_cancel(br_lck,
722 blr->lock_pid,
723 procid_self(),
724 blr->offset,
725 blr->count,
726 blr->lock_flav);
727 TALLOC_FREE(br_lck);
728 }
729
730 DEBUG(0,("process_blocking_lock_queue: Unable to become service Error was %s.\n", strerror(errno) ));
731 blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
732 DLIST_REMOVE(blocking_lock_queue, blr);
733 free_blocking_lock_record(blr);
734 change_to_root_user();
735 continue;
736 }
737
738 /*
739 * Go through the remaining locks and try and obtain them.
740 * The call returns True if all locks were obtained successfully
741 * and False if we still need to wait.
742 */
743
744 if(blocking_lock_record_process(blr)) {
745 struct byte_range_lock *br_lck = brl_get_locks(NULL, fsp);
746
747 if (br_lck) {
748 brl_lock_cancel(br_lck,
749 blr->lock_pid,
750 procid_self(),
751 blr->offset,
752 blr->count,
753 blr->lock_flav);
754 TALLOC_FREE(br_lck);
755 }
756
757 DLIST_REMOVE(blocking_lock_queue, blr);
758 free_blocking_lock_record(blr);
759 change_to_root_user();
760 continue;
761 }
762
763 change_to_root_user();
764
765 /*
766 * We couldn't get the locks for this record on the list.
767 * If the time has expired, return a lock error.
768 */
769
770 if (!timeval_is_zero(&blr->expire_time) && timeval_compare(&blr->expire_time, &tv_curr) <= 0) {
771 struct byte_range_lock *br_lck = brl_get_locks(NULL, fsp);
772
773 /*
774 * Lock expired - throw away all previously
775 * obtained locks and return lock error.
776 */
777
778 if (br_lck) {
779 DEBUG(5,("process_blocking_lock_queue: pending lock fnum = %d for file %s timed out.\n",
780 fsp->fnum, fsp->fsp_name ));
781
782 brl_lock_cancel(br_lck,
783 blr->lock_pid,
784 procid_self(),
785 blr->offset,
786 blr->count,
787 blr->lock_flav);
788 TALLOC_FREE(br_lck);
789 }
790
791 blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
792 DLIST_REMOVE(blocking_lock_queue, blr);
793 free_blocking_lock_record(blr);
794 continue;
795 }
796
797 }
798}
799
800/****************************************************************************
801 Handle a cancel message. Lock already moved onto the cancel queue.
802*****************************************************************************/
803
804#define MSG_BLOCKING_LOCK_CANCEL_SIZE (sizeof(blocking_lock_record *) + sizeof(NTSTATUS))
805
806static void process_blocking_lock_cancel_message(int msg_type,
807 struct process_id src,
808 void *buf, size_t len,
809 void *private_data)
810{
811 NTSTATUS err;
812 const char *msg = (const char *)buf;
813 blocking_lock_record *blr;
814
815 if (buf == NULL) {
816 smb_panic("process_blocking_lock_cancel_message: null msg\n");
817 }
818
819 if (len != MSG_BLOCKING_LOCK_CANCEL_SIZE) {
820 DEBUG(0, ("process_blocking_lock_cancel_message: "
821 "Got invalid msg len %d\n", (int)len));
822 smb_panic("process_blocking_lock_cancel_message: bad msg\n");
823 }
824
825 memcpy(&blr, msg, sizeof(blr));
826 memcpy(&err, &msg[sizeof(blr)], sizeof(NTSTATUS));
827
828 DEBUG(10,("process_blocking_lock_cancel_message: returning error %s\n",
829 nt_errstr(err) ));
830
831 blocking_lock_reply_error(blr, err);
832 DLIST_REMOVE(blocking_lock_cancelled_queue, blr);
833 free_blocking_lock_record(blr);
834}
835
836/****************************************************************************
837 Send ourselves a blocking lock cancelled message. Handled asynchronously above.
838*****************************************************************************/
839
840BOOL blocking_lock_cancel(files_struct *fsp,
841 uint32 lock_pid,
842 SMB_BIG_UINT offset,
843 SMB_BIG_UINT count,
844 enum brl_flavour lock_flav,
845 unsigned char locktype,
846 NTSTATUS err)
847{
848 static BOOL initialized;
849 char msg[MSG_BLOCKING_LOCK_CANCEL_SIZE];
850 blocking_lock_record *blr;
851
852 if (!initialized) {
853 /* Register our message. */
854 message_register(MSG_SMB_BLOCKING_LOCK_CANCEL,
855 process_blocking_lock_cancel_message,
856 NULL);
857
858 initialized = True;
859 }
860
861 for (blr = blocking_lock_queue; blr; blr = blr->next) {
862 if (fsp == blr->fsp &&
863 lock_pid == blr->lock_pid &&
864 offset == blr->offset &&
865 count == blr->count &&
866 lock_flav == blr->lock_flav) {
867 break;
868 }
869 }
870
871 if (!blr) {
872 return False;
873 }
874
875 /* Check the flags are right. */
876 if (blr->com_type == SMBlockingX &&
877 (locktype & LOCKING_ANDX_LARGE_FILES) !=
878 (CVAL(blr->inbuf,smb_vwv3) & LOCKING_ANDX_LARGE_FILES)) {
879 return False;
880 }
881
882 /* Move to cancelled queue. */
883 DLIST_REMOVE(blocking_lock_queue, blr);
884 DLIST_ADD(blocking_lock_cancelled_queue, blr);
885
886 /* Create the message. */
887 memcpy(msg, &blr, sizeof(blr));
888 memcpy(&msg[sizeof(blr)], &err, sizeof(NTSTATUS));
889
890 message_send_pid(pid_to_procid(sys_getpid()),
891 MSG_SMB_BLOCKING_LOCK_CANCEL,
892 &msg, sizeof(msg), True);
893
894 return True;
895}
Note: See TracBrowser for help on using the repository browser.