?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:locking: remove dead code from brl_get_locks_readonly()
[Samba.git] / source3 / locking / brlock.c
blob1c4c4d0d293d37f7713de59adb7319dea404192e
1 /*
2 Unix SMB/CIFS implementation.
3 byte range locking code
4 Updated to handle range splits/merges.
5
6 Copyright (C) Andrew Tridgell 1992-2000
7 Copyright (C) Jeremy Allison 1992-2000
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 /* This module implements a tdb based byte range locking service,
24 replacing the fcntl() based byte range locking previously
25 used. This allows us to provide the same semantics as NT */
26
27 #include "includes.h"
28 #include "system/filesys.h"
29 #include "locking/proto.h"
30 #include "smbd/globals.h"
31 #include "dbwrap/dbwrap.h"
32 #include "dbwrap/dbwrap_open.h"
33 #include "serverid.h"
34 #include "messages.h"
35 #include "util_tdb.h"
36
37 #undef DBGC_CLASS
38 #define DBGC_CLASS DBGC_LOCKING
39
40 #define ZERO_ZERO 0
41
42 /* The open brlock.tdb database. */
43
44 static struct db_context *brlock_db;
45
46 struct byte_range_lock {
47 struct files_struct *fsp;
48 unsigned int num_locks;
49 bool modified;
50 bool have_read_oplocks;
51 struct lock_struct *lock_data;
52 struct db_record *record;
53 };
54
55 /****************************************************************************
56 Debug info at level 10 for lock struct.
57 ****************************************************************************/
58
59 static void print_lock_struct(unsigned int i, const struct lock_struct *pls)
60 {
61 DEBUG(10,("[%u]: smblctx = %llu, tid = %u, pid = %s, ",
62 i,
63 (unsigned long long)pls->context.smblctx,
64 (unsigned int)pls->context.tid,
65 server_id_str(talloc_tos(), &pls->context.pid) ));
66
67 DEBUG(10, ("start = %ju, size = %ju, fnum = %ju, %s %s\n",
68 (uintmax_t)pls->start,
69 (uintmax_t)pls->size,
70 (uintmax_t)pls->fnum,
71 lock_type_name(pls->lock_type),
72 lock_flav_name(pls->lock_flav)));
73 }
74
75 unsigned int brl_num_locks(const struct byte_range_lock *brl)
76 {
77 return brl->num_locks;
78 }
79
80 struct files_struct *brl_fsp(struct byte_range_lock *brl)
81 {
82 return brl->fsp;
83 }
84
85 bool brl_have_read_oplocks(const struct byte_range_lock *brl)
86 {
87 return brl->have_read_oplocks;
88 }
89
90 void brl_set_have_read_oplocks(struct byte_range_lock *brl,
91 bool have_read_oplocks)
92 {
93 DEBUG(10, ("Setting have_read_oplocks to %s\n",
94 have_read_oplocks ? "true" : "false"));
95 SMB_ASSERT(brl->record != NULL); /* otherwise we're readonly */
96 brl->have_read_oplocks = have_read_oplocks;
97 brl->modified = true;
98 }
99
100 /****************************************************************************
101 See if two locking contexts are equal.
102 ****************************************************************************/
103
104 static bool brl_same_context(const struct lock_context *ctx1,
105 const struct lock_context *ctx2)
106 {
107 return (serverid_equal(&ctx1->pid, &ctx2->pid) &&
108 (ctx1->smblctx == ctx2->smblctx) &&
109 (ctx1->tid == ctx2->tid));
110 }
111
112 /****************************************************************************
113 See if lck1 and lck2 overlap.
114 ****************************************************************************/
115
116 static bool brl_overlap(const struct lock_struct *lck1,
117 const struct lock_struct *lck2)
118 {
119 /* XXX Remove for Win7 compatibility. */
120 /* this extra check is not redundant - it copes with locks
121 that go beyond the end of 64 bit file space */
122 if (lck1->size != 0 &&
123 lck1->start == lck2->start &&
124 lck1->size == lck2->size) {
125 return True;
126 }
127
128 if (lck1->start >= (lck2->start+lck2->size) ||
129 lck2->start >= (lck1->start+lck1->size)) {
130 return False;
131 }
132 return True;
133 }
134
135 /****************************************************************************
136 See if lock2 can be added when lock1 is in place.
137 ****************************************************************************/
138
139 static bool brl_conflict(const struct lock_struct *lck1,
140 const struct lock_struct *lck2)
141 {
142 /* Ignore PENDING locks. */
143 if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
144 return False;
145
146 /* Read locks never conflict. */
147 if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK) {
148 return False;
149 }
150
151 /* A READ lock can stack on top of a WRITE lock if they have the same
152 * context & fnum. */
153 if (lck1->lock_type == WRITE_LOCK && lck2->lock_type == READ_LOCK &&
154 brl_same_context(&lck1->context, &lck2->context) &&
155 lck1->fnum == lck2->fnum) {
156 return False;
157 }
158
159 return brl_overlap(lck1, lck2);
160 }
161
162 /****************************************************************************
163 See if lock2 can be added when lock1 is in place - when both locks are POSIX
164 flavour. POSIX locks ignore fnum - they only care about dev/ino which we
165 know already match.
166 ****************************************************************************/
167
168 static bool brl_conflict_posix(const struct lock_struct *lck1,
169 const struct lock_struct *lck2)
170 {
171 #if defined(DEVELOPER)
172 SMB_ASSERT(lck1->lock_flav == POSIX_LOCK);
173 SMB_ASSERT(lck2->lock_flav == POSIX_LOCK);
174 #endif
175
176 /* Ignore PENDING locks. */
177 if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
178 return False;
179
180 /* Read locks never conflict. */
181 if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK) {
182 return False;
183 }
184
185 /* Locks on the same context don't conflict. Ignore fnum. */
186 if (brl_same_context(&lck1->context, &lck2->context)) {
187 return False;
188 }
189
190 /* One is read, the other write, or the context is different,
191 do they overlap ? */
192 return brl_overlap(lck1, lck2);
193 }
194
195 #if ZERO_ZERO
196 static bool brl_conflict1(const struct lock_struct *lck1,
197 const struct lock_struct *lck2)
198 {
199 if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
200 return False;
201
202 if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK) {
203 return False;
204 }
205
206 if (brl_same_context(&lck1->context, &lck2->context) &&
207 lck2->lock_type == READ_LOCK && lck1->fnum == lck2->fnum) {
208 return False;
209 }
210
211 if (lck2->start == 0 && lck2->size == 0 && lck1->size != 0) {
212 return True;
213 }
214
215 if (lck1->start >= (lck2->start + lck2->size) ||
216 lck2->start >= (lck1->start + lck1->size)) {
217 return False;
218 }
219
220 return True;
221 }
222 #endif
223
224 /****************************************************************************
225 Check to see if this lock conflicts, but ignore our own locks on the
226 same fnum only. This is the read/write lock check code path.
227 This is never used in the POSIX lock case.
228 ****************************************************************************/
229
230 static bool brl_conflict_other(const struct lock_struct *lock,
231 const struct lock_struct *rw_probe)
232 {
233 if (IS_PENDING_LOCK(lock->lock_type) ||
234 IS_PENDING_LOCK(rw_probe->lock_type)) {
235 return False;
236 }
237
238 if (lock->lock_type == READ_LOCK && rw_probe->lock_type == READ_LOCK) {
239 return False;
240 }
241
242 if (lock->lock_flav == POSIX_LOCK &&
243 rw_probe->lock_flav == POSIX_LOCK) {
244 /*
245 * POSIX flavour locks never conflict here - this is only called
246 * in the read/write path.
247 */
248 return False;
249 }
250
251 if (!brl_overlap(lock, rw_probe)) {
252 /*
253 * I/O can only conflict when overlapping a lock, thus let it
254 * pass
255 */
256 return false;
257 }
258
259 if (!brl_same_context(&lock->context, &rw_probe->context)) {
260 /*
261 * Different process, conflict
262 */
263 return true;
264 }
265
266 if (lock->fnum != rw_probe->fnum) {
267 /*
268 * Different file handle, conflict
269 */
270 return true;
271 }
272
273 if ((lock->lock_type == READ_LOCK) &&
274 (rw_probe->lock_type == WRITE_LOCK)) {
275 /*
276 * Incoming WRITE locks conflict with existing READ locks even
277 * if the context is the same. JRA. See LOCKTEST7 in
278 * smbtorture.
279 */
280 return true;
281 }
282
283 /*
284 * I/O request compatible with existing lock, let it pass without
285 * conflict
286 */
287
288 return false;
289 }
290
291 /****************************************************************************
292 Check if an unlock overlaps a pending lock.
293 ****************************************************************************/
294
295 static bool brl_pending_overlap(const struct lock_struct *lock, const struct lock_struct *pend_lock)
296 {
297 if ((lock->start <= pend_lock->start) && (lock->start + lock->size > pend_lock->start))
298 return True;
299 if ((lock->start >= pend_lock->start) && (lock->start < pend_lock->start + pend_lock->size))
300 return True;
301 return False;
302 }
303
304 /****************************************************************************
305 Amazingly enough, w2k3 "remembers" whether the last lock failure on a fnum
306 is the same as this one and changes its error code. I wonder if any
307 app depends on this ?
308 ****************************************************************************/
309
310 static NTSTATUS brl_lock_failed(files_struct *fsp,
311 const struct lock_struct *lock,
312 bool blocking_lock)
313 {
314 if (lock->start >= 0xEF000000 && (lock->start >> 63) == 0) {
315 /* amazing the little things you learn with a test
316 suite. Locks beyond this offset (as a 64 bit
317 number!) always generate the conflict error code,
318 unless the top bit is set */
319 if (!blocking_lock) {
320 fsp->last_lock_failure = *lock;
321 }
322 return NT_STATUS_FILE_LOCK_CONFLICT;
323 }
324
325 if (serverid_equal(&lock->context.pid, &fsp->last_lock_failure.context.pid) &&
326 lock->context.tid == fsp->last_lock_failure.context.tid &&
327 lock->fnum == fsp->last_lock_failure.fnum &&
328 lock->start == fsp->last_lock_failure.start) {
329 return NT_STATUS_FILE_LOCK_CONFLICT;
330 }
331
332 if (!blocking_lock) {
333 fsp->last_lock_failure = *lock;
334 }
335 return NT_STATUS_LOCK_NOT_GRANTED;
336 }
337
338 /****************************************************************************
339 Open up the brlock.tdb database.
340 ****************************************************************************/
341
342 void brl_init(bool read_only)
343 {
344 int tdb_flags;
345
346 if (brlock_db) {
347 return;
348 }
349
350 tdb_flags = TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH;
351
352 if (!lp_clustering()) {
353 /*
354 * We can't use the SEQNUM trick to cache brlock
355 * entries in the clustering case because ctdb seqnum
356 * propagation has a delay.
357 */
358 tdb_flags |= TDB_SEQNUM;
359 }
360
361 brlock_db = db_open(NULL, lock_path("brlock.tdb"),
362 SMB_OPEN_DATABASE_TDB_HASH_SIZE, tdb_flags,
363 read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644,
364 DBWRAP_LOCK_ORDER_2, DBWRAP_FLAG_NONE);
365 if (!brlock_db) {
366 DEBUG(0,("Failed to open byte range locking database %s\n",
367 lock_path("brlock.tdb")));
368 return;
369 }
370 }
371
372 /****************************************************************************
373 Close down the brlock.tdb database.
374 ****************************************************************************/
375
376 void brl_shutdown(void)
377 {
378 TALLOC_FREE(brlock_db);
379 }
380
381 #if ZERO_ZERO
382 /****************************************************************************
383 Compare two locks for sorting.
384 ****************************************************************************/
385
386 static int lock_compare(const struct lock_struct *lck1,
387 const struct lock_struct *lck2)
388 {
389 if (lck1->start != lck2->start) {
390 return (lck1->start - lck2->start);
391 }
392 if (lck2->size != lck1->size) {
393 return ((int)lck1->size - (int)lck2->size);
394 }
395 return 0;
396 }
397 #endif
398
399 /****************************************************************************
400 Lock a range of bytes - Windows lock semantics.
401 ****************************************************************************/
402
403 NTSTATUS brl_lock_windows_default(struct byte_range_lock *br_lck,
404 struct lock_struct *plock, bool blocking_lock)
405 {
406 unsigned int i;
407 files_struct *fsp = br_lck->fsp;
408 struct lock_struct *locks = br_lck->lock_data;
409 NTSTATUS status;
410
411 SMB_ASSERT(plock->lock_type != UNLOCK_LOCK);
412
413 if ((plock->start + plock->size - 1 < plock->start) &&
414 plock->size != 0) {
415 return NT_STATUS_INVALID_LOCK_RANGE;
416 }
417
418 for (i=0; i < br_lck->num_locks; i++) {
419 /* Do any Windows or POSIX locks conflict ? */
420 if (brl_conflict(&locks[i], plock)) {
421 if (!serverid_exists(&locks[i].context.pid)) {
422 locks[i].context.pid.pid = 0;
423 br_lck->modified = true;
424 continue;
425 }
426 /* Remember who blocked us. */
427 plock->context.smblctx = locks[i].context.smblctx;
428 return brl_lock_failed(fsp,plock,blocking_lock);
429 }
430 #if ZERO_ZERO
431 if (plock->start == 0 && plock->size == 0 &&
432 locks[i].size == 0) {
433 break;
434 }
435 #endif
436 }
437
438 if (!IS_PENDING_LOCK(plock->lock_type)) {
439 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_WINDOWS_BRL);
440 }
441
442 /* We can get the Windows lock, now see if it needs to
443 be mapped into a lower level POSIX one, and if so can
444 we get it ? */
445
446 if (!IS_PENDING_LOCK(plock->lock_type) && lp_posix_locking(fsp->conn->params)) {
447 int errno_ret;
448 if (!set_posix_lock_windows_flavour(fsp,
449 plock->start,
450 plock->size,
451 plock->lock_type,
452 &plock->context,
453 locks,
454 br_lck->num_locks,
455 &errno_ret)) {
456
457 /* We don't know who blocked us. */
458 plock->context.smblctx = 0xFFFFFFFFFFFFFFFFLL;
459
460 if (errno_ret == EACCES || errno_ret == EAGAIN) {
461 status = NT_STATUS_FILE_LOCK_CONFLICT;
462 goto fail;
463 } else {
464 status = map_nt_error_from_unix(errno);
465 goto fail;
466 }
467 }
468 }
469
470 /* no conflicts - add it to the list of locks */
471 locks = talloc_realloc(br_lck, locks, struct lock_struct,
472 (br_lck->num_locks + 1));
473 if (!locks) {
474 status = NT_STATUS_NO_MEMORY;
475 goto fail;
476 }
477
478 memcpy(&locks[br_lck->num_locks], plock, sizeof(struct lock_struct));
479 br_lck->num_locks += 1;
480 br_lck->lock_data = locks;
481 br_lck->modified = True;
482
483 return NT_STATUS_OK;
484 fail:
485 if (!IS_PENDING_LOCK(plock->lock_type)) {
486 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_WINDOWS_BRL);
487 }
488 return status;
489 }
490
491 /****************************************************************************
492 Cope with POSIX range splits and merges.
493 ****************************************************************************/
494
495 static unsigned int brlock_posix_split_merge(struct lock_struct *lck_arr, /* Output array. */
496 struct lock_struct *ex, /* existing lock. */
497 struct lock_struct *plock) /* proposed lock. */
498 {
499 bool lock_types_differ = (ex->lock_type != plock->lock_type);
500
501 /* We can't merge non-conflicting locks on different context - ignore fnum. */
502
503 if (!brl_same_context(&ex->context, &plock->context)) {
504 /* Just copy. */
505 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
506 return 1;
507 }
508
509 /* We now know we have the same context. */
510
511 /* Did we overlap ? */
512
513 /*********************************************
514 +---------+
515 | ex |
516 +---------+
517 +-------+
518 | plock |
519 +-------+
520 OR....
521 +---------+
522 | ex |
523 +---------+
524 **********************************************/
525
526 if ( (ex->start > (plock->start + plock->size)) ||
527 (plock->start > (ex->start + ex->size))) {
528
529 /* No overlap with this lock - copy existing. */
530
531 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
532 return 1;
533 }
534
535 /*********************************************
536 +---------------------------+
537 | ex |
538 +---------------------------+
539 +---------------------------+
540 | plock | -> replace with plock.
541 +---------------------------+
542 OR
543 +---------------+
544 | ex |
545 +---------------+
546 +---------------------------+
547 | plock | -> replace with plock.
548 +---------------------------+
549
550 **********************************************/
551
552 if ( (ex->start >= plock->start) &&
553 (ex->start + ex->size <= plock->start + plock->size) ) {
554
555 /* Replace - discard existing lock. */
556
557 return 0;
558 }
559
560 /*********************************************
561 Adjacent after.
562 +-------+
563 | ex |
564 +-------+
565 +---------------+
566 | plock |
567 +---------------+
568
569 BECOMES....
570 +---------------+-------+
571 | plock | ex | - different lock types.
572 +---------------+-------+
573 OR.... (merge)
574 +-----------------------+
575 | plock | - same lock type.
576 +-----------------------+
577 **********************************************/
578
579 if (plock->start + plock->size == ex->start) {
580
581 /* If the lock types are the same, we merge, if different, we
582 add the remainder of the old lock. */
583
584 if (lock_types_differ) {
585 /* Add existing. */
586 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
587 return 1;
588 } else {
589 /* Merge - adjust incoming lock as we may have more
590 * merging to come. */
591 plock->size += ex->size;
592 return 0;
593 }
594 }
595
596 /*********************************************
597 Adjacent before.
598 +-------+
599 | ex |
600 +-------+
601 +---------------+
602 | plock |
603 +---------------+
604 BECOMES....
605 +-------+---------------+
606 | ex | plock | - different lock types
607 +-------+---------------+
608
609 OR.... (merge)
610 +-----------------------+
611 | plock | - same lock type.
612 +-----------------------+
613
614 **********************************************/
615
616 if (ex->start + ex->size == plock->start) {
617
618 /* If the lock types are the same, we merge, if different, we
619 add the existing lock. */
620
621 if (lock_types_differ) {
622 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
623 return 1;
624 } else {
625 /* Merge - adjust incoming lock as we may have more
626 * merging to come. */
627 plock->start = ex->start;
628 plock->size += ex->size;
629 return 0;
630 }
631 }
632
633 /*********************************************
634 Overlap after.
635 +-----------------------+
636 | ex |
637 +-----------------------+
638 +---------------+
639 | plock |
640 +---------------+
641 OR
642 +----------------+
643 | ex |
644 +----------------+
645 +---------------+
646 | plock |
647 +---------------+
648
649 BECOMES....
650 +---------------+-------+
651 | plock | ex | - different lock types.
652 +---------------+-------+
653 OR.... (merge)
654 +-----------------------+
655 | plock | - same lock type.
656 +-----------------------+
657 **********************************************/
658
659 if ( (ex->start >= plock->start) &&
660 (ex->start <= plock->start + plock->size) &&
661 (ex->start + ex->size > plock->start + plock->size) ) {
662
663 /* If the lock types are the same, we merge, if different, we
664 add the remainder of the old lock. */
665
666 if (lock_types_differ) {
667 /* Add remaining existing. */
668 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
669 /* Adjust existing start and size. */
670 lck_arr[0].start = plock->start + plock->size;
671 lck_arr[0].size = (ex->start + ex->size) - (plock->start + plock->size);
672 return 1;
673 } else {
674 /* Merge - adjust incoming lock as we may have more
675 * merging to come. */
676 plock->size += (ex->start + ex->size) - (plock->start + plock->size);
677 return 0;
678 }
679 }
680
681 /*********************************************
682 Overlap before.
683 +-----------------------+
684 | ex |
685 +-----------------------+
686 +---------------+
687 | plock |
688 +---------------+
689 OR
690 +-------------+
691 | ex |
692 +-------------+
693 +---------------+
694 | plock |
695 +---------------+
696
697 BECOMES....
698 +-------+---------------+
699 | ex | plock | - different lock types
700 +-------+---------------+
701
702 OR.... (merge)
703 +-----------------------+
704 | plock | - same lock type.
705 +-----------------------+
706
707 **********************************************/
708
709 if ( (ex->start < plock->start) &&
710 (ex->start + ex->size >= plock->start) &&
711 (ex->start + ex->size <= plock->start + plock->size) ) {
712
713 /* If the lock types are the same, we merge, if different, we
714 add the truncated old lock. */
715
716 if (lock_types_differ) {
717 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
718 /* Adjust existing size. */
719 lck_arr[0].size = plock->start - ex->start;
720 return 1;
721 } else {
722 /* Merge - adjust incoming lock as we may have more
723 * merging to come. MUST ADJUST plock SIZE FIRST ! */
724 plock->size += (plock->start - ex->start);
725 plock->start = ex->start;
726 return 0;
727 }
728 }
729
730 /*********************************************
731 Complete overlap.
732 +---------------------------+
733 | ex |
734 +---------------------------+
735 +---------+
736 | plock |
737 +---------+
738 BECOMES.....
739 +-------+---------+---------+
740 | ex | plock | ex | - different lock types.
741 +-------+---------+---------+
742 OR
743 +---------------------------+
744 | plock | - same lock type.
745 +---------------------------+
746 **********************************************/
747
748 if ( (ex->start < plock->start) && (ex->start + ex->size > plock->start + plock->size) ) {
749
750 if (lock_types_differ) {
751
752 /* We have to split ex into two locks here. */
753
754 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
755 memcpy(&lck_arr[1], ex, sizeof(struct lock_struct));
756
757 /* Adjust first existing size. */
758 lck_arr[0].size = plock->start - ex->start;
759
760 /* Adjust second existing start and size. */
761 lck_arr[1].start = plock->start + plock->size;
762 lck_arr[1].size = (ex->start + ex->size) - (plock->start + plock->size);
763 return 2;
764 } else {
765 /* Just eat the existing locks, merge them into plock. */
766 plock->start = ex->start;
767 plock->size = ex->size;
768 return 0;
769 }
770 }
771
772 /* Never get here. */
773 smb_panic("brlock_posix_split_merge");
774 /* Notreached. */
775
776 /* Keep some compilers happy. */
777 return 0;
778 }
779
780 /****************************************************************************
781 Lock a range of bytes - POSIX lock semantics.
782 We must cope with range splits and merges.
783 ****************************************************************************/
784
785 static NTSTATUS brl_lock_posix(struct messaging_context *msg_ctx,
786 struct byte_range_lock *br_lck,
787 struct lock_struct *plock)
788 {
789 unsigned int i, count, posix_count;
790 struct lock_struct *locks = br_lck->lock_data;
791 struct lock_struct *tp;
792 bool signal_pending_read = False;
793 bool break_oplocks = false;
794 NTSTATUS status;
795
796 /* No zero-zero locks for POSIX. */
797 if (plock->start == 0 && plock->size == 0) {
798 return NT_STATUS_INVALID_PARAMETER;
799 }
800
801 /* Don't allow 64-bit lock wrap. */
802 if (plock->start + plock->size - 1 < plock->start) {
803 return NT_STATUS_INVALID_PARAMETER;
804 }
805
806 /* The worst case scenario here is we have to split an
807 existing POSIX lock range into two, and add our lock,
808 so we need at most 2 more entries. */
809
810 tp = talloc_array(br_lck, struct lock_struct, br_lck->num_locks + 2);
811 if (!tp) {
812 return NT_STATUS_NO_MEMORY;
813 }
814
815 count = posix_count = 0;
816
817 for (i=0; i < br_lck->num_locks; i++) {
818 struct lock_struct *curr_lock = &locks[i];
819
820 /* If we have a pending read lock, a lock downgrade should
821 trigger a lock re-evaluation. */
822 if (curr_lock->lock_type == PENDING_READ_LOCK &&
823 brl_pending_overlap(plock, curr_lock)) {
824 signal_pending_read = True;
825 }
826
827 if (curr_lock->lock_flav == WINDOWS_LOCK) {
828 /* Do any Windows flavour locks conflict ? */
829 if (brl_conflict(curr_lock, plock)) {
830 if (!serverid_exists(&curr_lock->context.pid)) {
831 curr_lock->context.pid.pid = 0;
832 br_lck->modified = true;
833 continue;
834 }
835 /* No games with error messages. */
836 TALLOC_FREE(tp);
837 /* Remember who blocked us. */
838 plock->context.smblctx = curr_lock->context.smblctx;
839 return NT_STATUS_FILE_LOCK_CONFLICT;
840 }
841 /* Just copy the Windows lock into the new array. */
842 memcpy(&tp[count], curr_lock, sizeof(struct lock_struct));
843 count++;
844 } else {
845 unsigned int tmp_count = 0;
846
847 /* POSIX conflict semantics are different. */
848 if (brl_conflict_posix(curr_lock, plock)) {
849 if (!serverid_exists(&curr_lock->context.pid)) {
850 curr_lock->context.pid.pid = 0;
851 br_lck->modified = true;
852 continue;
853 }
854 /* Can't block ourselves with POSIX locks. */
855 /* No games with error messages. */
856 TALLOC_FREE(tp);
857 /* Remember who blocked us. */
858 plock->context.smblctx = curr_lock->context.smblctx;
859 return NT_STATUS_FILE_LOCK_CONFLICT;
860 }
861
862 /* Work out overlaps. */
863 tmp_count += brlock_posix_split_merge(&tp[count], curr_lock, plock);
864 posix_count += tmp_count;
865 count += tmp_count;
866 }
867 }
868
869 /*
870 * Break oplocks while we hold a brl. Since lock() and unlock() calls
871 * are not symetric with POSIX semantics, we cannot guarantee our
872 * contend_level2_oplocks_begin/end calls will be acquired and
873 * released one-for-one as with Windows semantics. Therefore we only
874 * call contend_level2_oplocks_begin if this is the first POSIX brl on
875 * the file.
876 */
877 break_oplocks = (!IS_PENDING_LOCK(plock->lock_type) &&
878 posix_count == 0);
879 if (break_oplocks) {
880 contend_level2_oplocks_begin(br_lck->fsp,
881 LEVEL2_CONTEND_POSIX_BRL);
882 }
883
884 /* Try and add the lock in order, sorted by lock start. */
885 for (i=0; i < count; i++) {
886 struct lock_struct *curr_lock = &tp[i];
887
888 if (curr_lock->start <= plock->start) {
889 continue;
890 }
891 }
892
893 if (i < count) {
894 memmove(&tp[i+1], &tp[i],
895 (count - i)*sizeof(struct lock_struct));
896 }
897 memcpy(&tp[i], plock, sizeof(struct lock_struct));
898 count++;
899
900 /* We can get the POSIX lock, now see if it needs to
901 be mapped into a lower level POSIX one, and if so can
902 we get it ? */
903
904 if (!IS_PENDING_LOCK(plock->lock_type) && lp_posix_locking(br_lck->fsp->conn->params)) {
905 int errno_ret;
906
907 /* The lower layer just needs to attempt to
908 get the system POSIX lock. We've weeded out
909 any conflicts above. */
910
911 if (!set_posix_lock_posix_flavour(br_lck->fsp,
912 plock->start,
913 plock->size,
914 plock->lock_type,
915 &errno_ret)) {
916
917 /* We don't know who blocked us. */
918 plock->context.smblctx = 0xFFFFFFFFFFFFFFFFLL;
919
920 if (errno_ret == EACCES || errno_ret == EAGAIN) {
921 TALLOC_FREE(tp);
922 status = NT_STATUS_FILE_LOCK_CONFLICT;
923 goto fail;
924 } else {
925 TALLOC_FREE(tp);
926 status = map_nt_error_from_unix(errno);
927 goto fail;
928 }
929 }
930 }
931
932 /* If we didn't use all the allocated size,
933 * Realloc so we don't leak entries per lock call. */
934 if (count < br_lck->num_locks + 2) {
935 tp = talloc_realloc(br_lck, tp, struct lock_struct, count);
936 if (!tp) {
937 status = NT_STATUS_NO_MEMORY;
938 goto fail;
939 }
940 }
941
942 br_lck->num_locks = count;
943 TALLOC_FREE(br_lck->lock_data);
944 br_lck->lock_data = tp;
945 locks = tp;
946 br_lck->modified = True;
947
948 /* A successful downgrade from write to read lock can trigger a lock
949 re-evalutation where waiting readers can now proceed. */
950
951 if (signal_pending_read) {
952 /* Send unlock messages to any pending read waiters that overlap. */
953 for (i=0; i < br_lck->num_locks; i++) {
954 struct lock_struct *pend_lock = &locks[i];
955
956 /* Ignore non-pending locks. */
957 if (!IS_PENDING_LOCK(pend_lock->lock_type)) {
958 continue;
959 }
960
961 if (pend_lock->lock_type == PENDING_READ_LOCK &&
962 brl_pending_overlap(plock, pend_lock)) {
963 DEBUG(10,("brl_lock_posix: sending unlock message to pid %s\n",
964 procid_str_static(&pend_lock->context.pid )));
965
966 messaging_send(msg_ctx, pend_lock->context.pid,
967 MSG_SMB_UNLOCK, &data_blob_null);
968 }
969 }
970 }
971
972 return NT_STATUS_OK;
973 fail:
974 if (break_oplocks) {
975 contend_level2_oplocks_end(br_lck->fsp,
976 LEVEL2_CONTEND_POSIX_BRL);
977 }
978 return status;
979 }
980
981 NTSTATUS smb_vfs_call_brl_lock_windows(struct vfs_handle_struct *handle,
982 struct byte_range_lock *br_lck,
983 struct lock_struct *plock,
984 bool blocking_lock)
985 {
986 VFS_FIND(brl_lock_windows);
987 return handle->fns->brl_lock_windows_fn(handle, br_lck, plock,
988 blocking_lock);
989 }
990
991 /****************************************************************************
992 Lock a range of bytes.
993 ****************************************************************************/
994
995 NTSTATUS brl_lock(struct messaging_context *msg_ctx,
996 struct byte_range_lock *br_lck,
997 uint64_t smblctx,
998 struct server_id pid,
999 br_off start,
1000 br_off size,
1001 enum brl_type lock_type,
1002 enum brl_flavour lock_flav,
1003 bool blocking_lock,
1004 uint64_t *psmblctx)
1005 {
1006 NTSTATUS ret;
1007 struct lock_struct lock;
1008
1009 #if !ZERO_ZERO
1010 if (start == 0 && size == 0) {
1011 DEBUG(0,("client sent 0/0 lock - please report this\n"));
1012 }
1013 #endif
1014
1015 lock = (struct lock_struct) {
1016 .context.smblctx = smblctx,
1017 .context.pid = pid,
1018 .context.tid = br_lck->fsp->conn->cnum,
1019 .start = start,
1020 .size = size,
1021 .fnum = br_lck->fsp->fnum,
1022 .lock_type = lock_type,
1023 .lock_flav = lock_flav
1024 };
1025
1026 if (lock_flav == WINDOWS_LOCK) {
1027 ret = SMB_VFS_BRL_LOCK_WINDOWS(br_lck->fsp->conn, br_lck,
1028 &lock, blocking_lock);
1029 } else {
1030 ret = brl_lock_posix(msg_ctx, br_lck, &lock);
1031 }
1032
1033 #if ZERO_ZERO
1034 /* sort the lock list */
1035 TYPESAFE_QSORT(br_lck->lock_data, (size_t)br_lck->num_locks, lock_compare);
1036 #endif
1037
1038 /* If we're returning an error, return who blocked us. */
1039 if (!NT_STATUS_IS_OK(ret) && psmblctx) {
1040 *psmblctx = lock.context.smblctx;
1041 }
1042 return ret;
1043 }
1044
1045 static void brl_delete_lock_struct(struct lock_struct *locks,
1046 unsigned num_locks,
1047 unsigned del_idx)
1048 {
1049 if (del_idx >= num_locks) {
1050 return;
1051 }
1052 memmove(&locks[del_idx], &locks[del_idx+1],
1053 sizeof(*locks) * (num_locks - del_idx - 1));
1054 }
1055
1056 /****************************************************************************
1057 Unlock a range of bytes - Windows semantics.
1058 ****************************************************************************/
1059
1060 bool brl_unlock_windows_default(struct messaging_context *msg_ctx,
1061 struct byte_range_lock *br_lck,
1062 const struct lock_struct *plock)
1063 {
1064 unsigned int i, j;
1065 struct lock_struct *locks = br_lck->lock_data;
1066 enum brl_type deleted_lock_type = READ_LOCK; /* shut the compiler up.... */
1067
1068 SMB_ASSERT(plock->lock_type == UNLOCK_LOCK);
1069
1070 #if ZERO_ZERO
1071 /* Delete write locks by preference... The lock list
1072 is sorted in the zero zero case. */
1073
1074 for (i = 0; i < br_lck->num_locks; i++) {
1075 struct lock_struct *lock = &locks[i];
1076
1077 if (lock->lock_type == WRITE_LOCK &&
1078 brl_same_context(&lock->context, &plock->context) &&
1079 lock->fnum == plock->fnum &&
1080 lock->lock_flav == WINDOWS_LOCK &&
1081 lock->start == plock->start &&
1082 lock->size == plock->size) {
1083
1084 /* found it - delete it */
1085 deleted_lock_type = lock->lock_type;
1086 break;
1087 }
1088 }
1089
1090 if (i != br_lck->num_locks) {
1091 /* We found it - don't search again. */
1092 goto unlock_continue;
1093 }
1094 #endif
1095
1096 for (i = 0; i < br_lck->num_locks; i++) {
1097 struct lock_struct *lock = &locks[i];
1098
1099 if (IS_PENDING_LOCK(lock->lock_type)) {
1100 continue;
1101 }
1102
1103 /* Only remove our own locks that match in start, size, and flavour. */
1104 if (brl_same_context(&lock->context, &plock->context) &&
1105 lock->fnum == plock->fnum &&
1106 lock->lock_flav == WINDOWS_LOCK &&
1107 lock->start == plock->start &&
1108 lock->size == plock->size ) {
1109 deleted_lock_type = lock->lock_type;
1110 break;
1111 }
1112 }
1113
1114 if (i == br_lck->num_locks) {
1115 /* we didn't find it */
1116 return False;
1117 }
1118
1119 #if ZERO_ZERO
1120 unlock_continue:
1121 #endif
1122
1123 brl_delete_lock_struct(locks, br_lck->num_locks, i);
1124 br_lck->num_locks -= 1;
1125 br_lck->modified = True;
1126
1127 /* Unlock the underlying POSIX regions. */
1128 if(lp_posix_locking(br_lck->fsp->conn->params)) {
1129 release_posix_lock_windows_flavour(br_lck->fsp,
1130 plock->start,
1131 plock->size,
1132 deleted_lock_type,
1133 &plock->context,
1134 locks,
1135 br_lck->num_locks);
1136 }
1137
1138 /* Send unlock messages to any pending waiters that overlap. */
1139 for (j=0; j < br_lck->num_locks; j++) {
1140 struct lock_struct *pend_lock = &locks[j];
1141
1142 /* Ignore non-pending locks. */
1143 if (!IS_PENDING_LOCK(pend_lock->lock_type)) {
1144 continue;
1145 }
1146
1147 /* We could send specific lock info here... */
1148 if (brl_pending_overlap(plock, pend_lock)) {
1149 DEBUG(10,("brl_unlock: sending unlock message to pid %s\n",
1150 procid_str_static(&pend_lock->context.pid )));
1151
1152 messaging_send(msg_ctx, pend_lock->context.pid,
1153 MSG_SMB_UNLOCK, &data_blob_null);
1154 }
1155 }
1156
1157 contend_level2_oplocks_end(br_lck->fsp, LEVEL2_CONTEND_WINDOWS_BRL);
1158 return True;
1159 }
1160
1161 /****************************************************************************
1162 Unlock a range of bytes - POSIX semantics.
1163 ****************************************************************************/
1164
1165 static bool brl_unlock_posix(struct messaging_context *msg_ctx,
1166 struct byte_range_lock *br_lck,
1167 struct lock_struct *plock)
1168 {
1169 unsigned int i, j, count;
1170 struct lock_struct *tp;
1171 struct lock_struct *locks = br_lck->lock_data;
1172 bool overlap_found = False;
1173
1174 /* No zero-zero locks for POSIX. */
1175 if (plock->start == 0 && plock->size == 0) {
1176 return False;
1177 }
1178
1179 /* Don't allow 64-bit lock wrap. */
1180 if (plock->start + plock->size < plock->start ||
1181 plock->start + plock->size < plock->size) {
1182 DEBUG(10,("brl_unlock_posix: lock wrap\n"));
1183 return False;
1184 }
1185
1186 /* The worst case scenario here is we have to split an
1187 existing POSIX lock range into two, so we need at most
1188 1 more entry. */
1189
1190 tp = talloc_array(br_lck, struct lock_struct, br_lck->num_locks + 1);
1191 if (!tp) {
1192 DEBUG(10,("brl_unlock_posix: malloc fail\n"));
1193 return False;
1194 }
1195
1196 count = 0;
1197 for (i = 0; i < br_lck->num_locks; i++) {
1198 struct lock_struct *lock = &locks[i];
1199 unsigned int tmp_count;
1200
1201 /* Only remove our own locks - ignore fnum. */
1202 if (IS_PENDING_LOCK(lock->lock_type) ||
1203 !brl_same_context(&lock->context, &plock->context)) {
1204 memcpy(&tp[count], lock, sizeof(struct lock_struct));
1205 count++;
1206 continue;
1207 }
1208
1209 if (lock->lock_flav == WINDOWS_LOCK) {
1210 /* Do any Windows flavour locks conflict ? */
1211 if (brl_conflict(lock, plock)) {
1212 TALLOC_FREE(tp);
1213 return false;
1214 }
1215 /* Just copy the Windows lock into the new array. */
1216 memcpy(&tp[count], lock, sizeof(struct lock_struct));
1217 count++;
1218 continue;
1219 }
1220
1221 /* Work out overlaps. */
1222 tmp_count = brlock_posix_split_merge(&tp[count], lock, plock);
1223
1224 if (tmp_count == 0) {
1225 /* plock overlapped the existing lock completely,
1226 or replaced it. Don't copy the existing lock. */
1227 overlap_found = true;
1228 } else if (tmp_count == 1) {
1229 /* Either no overlap, (simple copy of existing lock) or
1230 * an overlap of an existing lock. */
1231 /* If the lock changed size, we had an overlap. */
1232 if (tp[count].size != lock->size) {
1233 overlap_found = true;
1234 }
1235 count += tmp_count;
1236 } else if (tmp_count == 2) {
1237 /* We split a lock range in two. */
1238 overlap_found = true;
1239 count += tmp_count;
1240
1241 /* Optimisation... */
1242 /* We know we're finished here as we can't overlap any
1243 more POSIX locks. Copy the rest of the lock array. */
1244
1245 if (i < br_lck->num_locks - 1) {
1246 memcpy(&tp[count], &locks[i+1],
1247 sizeof(*locks)*((br_lck->num_locks-1) - i));
1248 count += ((br_lck->num_locks-1) - i);
1249 }
1250 break;
1251 }
1252
1253 }
1254
1255 if (!overlap_found) {
1256 /* Just ignore - no change. */
1257 TALLOC_FREE(tp);
1258 DEBUG(10,("brl_unlock_posix: No overlap - unlocked.\n"));
1259 return True;
1260 }
1261
1262 /* Unlock any POSIX regions. */
1263 if(lp_posix_locking(br_lck->fsp->conn->params)) {
1264 release_posix_lock_posix_flavour(br_lck->fsp,
1265 plock->start,
1266 plock->size,
1267 &plock->context,
1268 tp,
1269 count);
1270 }
1271
1272 /* Realloc so we don't leak entries per unlock call. */
1273 if (count) {
1274 tp = talloc_realloc(br_lck, tp, struct lock_struct, count);
1275 if (!tp) {
1276 DEBUG(10,("brl_unlock_posix: realloc fail\n"));
1277 return False;
1278 }
1279 } else {
1280 /* We deleted the last lock. */
1281 TALLOC_FREE(tp);
1282 tp = NULL;
1283 }
1284
1285 contend_level2_oplocks_end(br_lck->fsp,
1286 LEVEL2_CONTEND_POSIX_BRL);
1287
1288 br_lck->num_locks = count;
1289 TALLOC_FREE(br_lck->lock_data);
1290 locks = tp;
1291 br_lck->lock_data = tp;
1292 br_lck->modified = True;
1293
1294 /* Send unlock messages to any pending waiters that overlap. */
1295
1296 for (j=0; j < br_lck->num_locks; j++) {
1297 struct lock_struct *pend_lock = &locks[j];
1298
1299 /* Ignore non-pending locks. */
1300 if (!IS_PENDING_LOCK(pend_lock->lock_type)) {
1301 continue;
1302 }
1303
1304 /* We could send specific lock info here... */
1305 if (brl_pending_overlap(plock, pend_lock)) {
1306 DEBUG(10,("brl_unlock: sending unlock message to pid %s\n",
1307 procid_str_static(&pend_lock->context.pid )));
1308
1309 messaging_send(msg_ctx, pend_lock->context.pid,
1310 MSG_SMB_UNLOCK, &data_blob_null);
1311 }
1312 }
1313
1314 return True;
1315 }
1316
1317 bool smb_vfs_call_brl_unlock_windows(struct vfs_handle_struct *handle,
1318 struct messaging_context *msg_ctx,
1319 struct byte_range_lock *br_lck,
1320 const struct lock_struct *plock)
1321 {
1322 VFS_FIND(brl_unlock_windows);
1323 return handle->fns->brl_unlock_windows_fn(handle, msg_ctx, br_lck,
1324 plock);
1325 }
1326
1327 /****************************************************************************
1328 Unlock a range of bytes.
1329 ****************************************************************************/
1330
1331 bool brl_unlock(struct messaging_context *msg_ctx,
1332 struct byte_range_lock *br_lck,
1333 uint64_t smblctx,
1334 struct server_id pid,
1335 br_off start,
1336 br_off size,
1337 enum brl_flavour lock_flav)
1338 {
1339 struct lock_struct lock;
1340
1341 lock.context.smblctx = smblctx;
1342 lock.context.pid = pid;
1343 lock.context.tid = br_lck->fsp->conn->cnum;
1344 lock.start = start;
1345 lock.size = size;
1346 lock.fnum = br_lck->fsp->fnum;
1347 lock.lock_type = UNLOCK_LOCK;
1348 lock.lock_flav = lock_flav;
1349
1350 if (lock_flav == WINDOWS_LOCK) {
1351 return SMB_VFS_BRL_UNLOCK_WINDOWS(br_lck->fsp->conn, msg_ctx,
1352 br_lck, &lock);
1353 } else {
1354 return brl_unlock_posix(msg_ctx, br_lck, &lock);
1355 }
1356 }
1357
1358 /****************************************************************************
1359 Test if we could add a lock if we wanted to.
1360 Returns True if the region required is currently unlocked, False if locked.
1361 ****************************************************************************/
1362
1363 bool brl_locktest(struct byte_range_lock *br_lck,
1364 const struct lock_struct *rw_probe)
1365 {
1366 bool ret = True;
1367 unsigned int i;
1368 struct lock_struct *locks = br_lck->lock_data;
1369 files_struct *fsp = br_lck->fsp;
1370
1371 /* Make sure existing locks don't conflict */
1372 for (i=0; i < br_lck->num_locks; i++) {
1373 /*
1374 * Our own locks don't conflict.
1375 */
1376 if (brl_conflict_other(&locks[i], rw_probe)) {
1377 if (br_lck->record == NULL) {
1378 /* readonly */
1379 return false;
1380 }
1381
1382 if (!serverid_exists(&locks[i].context.pid)) {
1383 locks[i].context.pid.pid = 0;
1384 br_lck->modified = true;
1385 continue;
1386 }
1387
1388 return False;
1389 }
1390 }
1391
1392 /*
1393 * There is no lock held by an SMB daemon, check to
1394 * see if there is a POSIX lock from a UNIX or NFS process.
1395 * This only conflicts with Windows locks, not POSIX locks.
1396 */
1397
1398 if(lp_posix_locking(fsp->conn->params) &&
1399 (rw_probe->lock_flav == WINDOWS_LOCK)) {
1400 /*
1401 * Make copies -- is_posix_locked might modify the values
1402 */
1403
1404 br_off start = rw_probe->start;
1405 br_off size = rw_probe->size;
1406 enum brl_type lock_type = rw_probe->lock_type;
1407
1408 ret = is_posix_locked(fsp, &start, &size, &lock_type, WINDOWS_LOCK);
1409
1410 DEBUG(10, ("brl_locktest: posix start=%ju len=%ju %s for %s "
1411 "file %s\n", (uintmax_t)start, (uintmax_t)size,
1412 ret ? "locked" : "unlocked",
1413 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
1414
1415 /* We need to return the inverse of is_posix_locked. */
1416 ret = !ret;
1417 }
1418
1419 /* no conflicts - we could have added it */
1420 return ret;
1421 }
1422
1423 /****************************************************************************
1424 Query for existing locks.
1425 ****************************************************************************/
1426
1427 NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
1428 uint64_t *psmblctx,
1429 struct server_id pid,
1430 br_off *pstart,
1431 br_off *psize,
1432 enum brl_type *plock_type,
1433 enum brl_flavour lock_flav)
1434 {
1435 unsigned int i;
1436 struct lock_struct lock;
1437 const struct lock_struct *locks = br_lck->lock_data;
1438 files_struct *fsp = br_lck->fsp;
1439
1440 lock.context.smblctx = *psmblctx;
1441 lock.context.pid = pid;
1442 lock.context.tid = br_lck->fsp->conn->cnum;
1443 lock.start = *pstart;
1444 lock.size = *psize;
1445 lock.fnum = fsp->fnum;
1446 lock.lock_type = *plock_type;
1447 lock.lock_flav = lock_flav;
1448
1449 /* Make sure existing locks don't conflict */
1450 for (i=0; i < br_lck->num_locks; i++) {
1451 const struct lock_struct *exlock = &locks[i];
1452 bool conflict = False;
1453
1454 if (exlock->lock_flav == WINDOWS_LOCK) {
1455 conflict = brl_conflict(exlock, &lock);
1456 } else {
1457 conflict = brl_conflict_posix(exlock, &lock);
1458 }
1459
1460 if (conflict) {
1461 *psmblctx = exlock->context.smblctx;
1462 *pstart = exlock->start;
1463 *psize = exlock->size;
1464 *plock_type = exlock->lock_type;
1465 return NT_STATUS_LOCK_NOT_GRANTED;
1466 }
1467 }
1468
1469 /*
1470 * There is no lock held by an SMB daemon, check to
1471 * see if there is a POSIX lock from a UNIX or NFS process.
1472 */
1473
1474 if(lp_posix_locking(fsp->conn->params)) {
1475 bool ret = is_posix_locked(fsp, pstart, psize, plock_type, POSIX_LOCK);
1476
1477 DEBUG(10, ("brl_lockquery: posix start=%ju len=%ju %s for %s "
1478 "file %s\n", (uintmax_t)*pstart,
1479 (uintmax_t)*psize, ret ? "locked" : "unlocked",
1480 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
1481
1482 if (ret) {
1483 /* Hmmm. No clue what to set smblctx to - use -1. */
1484 *psmblctx = 0xFFFFFFFFFFFFFFFFLL;
1485 return NT_STATUS_LOCK_NOT_GRANTED;
1486 }
1487 }
1488
1489 return NT_STATUS_OK;
1490 }
1491
1492
1493 bool smb_vfs_call_brl_cancel_windows(struct vfs_handle_struct *handle,
1494 struct byte_range_lock *br_lck,
1495 struct lock_struct *plock)
1496 {
1497 VFS_FIND(brl_cancel_windows);
1498 return handle->fns->brl_cancel_windows_fn(handle, br_lck, plock);
1499 }
1500
1501 /****************************************************************************
1502 Remove a particular pending lock.
1503 ****************************************************************************/
1504 bool brl_lock_cancel(struct byte_range_lock *br_lck,
1505 uint64_t smblctx,
1506 struct server_id pid,
1507 br_off start,
1508 br_off size,
1509 enum brl_flavour lock_flav)
1510 {
1511 bool ret;
1512 struct lock_struct lock;
1513
1514 lock.context.smblctx = smblctx;
1515 lock.context.pid = pid;
1516 lock.context.tid = br_lck->fsp->conn->cnum;
1517 lock.start = start;
1518 lock.size = size;
1519 lock.fnum = br_lck->fsp->fnum;
1520 lock.lock_flav = lock_flav;
1521 /* lock.lock_type doesn't matter */
1522
1523 if (lock_flav == WINDOWS_LOCK) {
1524 ret = SMB_VFS_BRL_CANCEL_WINDOWS(br_lck->fsp->conn, br_lck,
1525 &lock);
1526 } else {
1527 ret = brl_lock_cancel_default(br_lck, &lock);
1528 }
1529
1530 return ret;
1531 }
1532
1533 bool brl_lock_cancel_default(struct byte_range_lock *br_lck,
1534 struct lock_struct *plock)
1535 {
1536 unsigned int i;
1537 struct lock_struct *locks = br_lck->lock_data;
1538
1539 SMB_ASSERT(plock);
1540
1541 for (i = 0; i < br_lck->num_locks; i++) {
1542 struct lock_struct *lock = &locks[i];
1543
1544 /* For pending locks we *always* care about the fnum. */
1545 if (brl_same_context(&lock->context, &plock->context) &&
1546 lock->fnum == plock->fnum &&
1547 IS_PENDING_LOCK(lock->lock_type) &&
1548 lock->lock_flav == plock->lock_flav &&
1549 lock->start == plock->start &&
1550 lock->size == plock->size) {
1551 break;
1552 }
1553 }
1554
1555 if (i == br_lck->num_locks) {
1556 /* Didn't find it. */
1557 return False;
1558 }
1559
1560 brl_delete_lock_struct(locks, br_lck->num_locks, i);
1561 br_lck->num_locks -= 1;
1562 br_lck->modified = True;
1563 return True;
1564 }
1565
1566 /****************************************************************************
1567 Remove any locks associated with a open file.
1568 We return True if this process owns any other Windows locks on this
1569 fd and so we should not immediately close the fd.
1570 ****************************************************************************/
1571
1572 void brl_close_fnum(struct messaging_context *msg_ctx,
1573 struct byte_range_lock *br_lck)
1574 {
1575 files_struct *fsp = br_lck->fsp;
1576 uint32_t tid = fsp->conn->cnum;
1577 uint64_t fnum = fsp->fnum;
1578 unsigned int i;
1579 struct lock_struct *locks = br_lck->lock_data;
1580 struct server_id pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
1581 struct lock_struct *locks_copy;
1582 unsigned int num_locks_copy;
1583
1584 /* Copy the current lock array. */
1585 if (br_lck->num_locks) {
1586 locks_copy = (struct lock_struct *)talloc_memdup(br_lck, locks, br_lck->num_locks * sizeof(struct lock_struct));
1587 if (!locks_copy) {
1588 smb_panic("brl_close_fnum: talloc failed");
1589 }
1590 } else {
1591 locks_copy = NULL;
1592 }
1593
1594 num_locks_copy = br_lck->num_locks;
1595
1596 for (i=0; i < num_locks_copy; i++) {
1597 struct lock_struct *lock = &locks_copy[i];
1598
1599 if (lock->context.tid == tid && serverid_equal(&lock->context.pid, &pid) &&
1600 (lock->fnum == fnum)) {
1601 brl_unlock(msg_ctx,
1602 br_lck,
1603 lock->context.smblctx,
1604 pid,
1605 lock->start,
1606 lock->size,
1607 lock->lock_flav);
1608 }
1609 }
1610 }
1611
1612 bool brl_mark_disconnected(struct files_struct *fsp)
1613 {
1614 uint32_t tid = fsp->conn->cnum;
1615 uint64_t smblctx;
1616 uint64_t fnum = fsp->fnum;
1617 unsigned int i;
1618 struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
1619 struct byte_range_lock *br_lck = NULL;
1620
1621 if (fsp->op == NULL) {
1622 return false;
1623 }
1624
1625 smblctx = fsp->op->global->open_persistent_id;
1626
1627 if (!fsp->op->global->durable) {
1628 return false;
1629 }
1630
1631 if (fsp->current_lock_count == 0) {
1632 return true;
1633 }
1634
1635 br_lck = brl_get_locks(talloc_tos(), fsp);
1636 if (br_lck == NULL) {
1637 return false;
1638 }
1639
1640 for (i=0; i < br_lck->num_locks; i++) {
1641 struct lock_struct *lock = &br_lck->lock_data[i];
1642
1643 /*
1644 * as this is a durable handle, we only expect locks
1645 * of the current file handle!
1646 */
1647
1648 if (lock->context.smblctx != smblctx) {
1649 TALLOC_FREE(br_lck);
1650 return false;
1651 }
1652
1653 if (lock->context.tid != tid) {
1654 TALLOC_FREE(br_lck);
1655 return false;
1656 }
1657
1658 if (!serverid_equal(&lock->context.pid, &self)) {
1659 TALLOC_FREE(br_lck);
1660 return false;
1661 }
1662
1663 if (lock->fnum != fnum) {
1664 TALLOC_FREE(br_lck);
1665 return false;
1666 }
1667
1668 server_id_set_disconnected(&lock->context.pid);
1669 lock->context.tid = TID_FIELD_INVALID;
1670 lock->fnum = FNUM_FIELD_INVALID;
1671 }
1672
1673 br_lck->modified = true;
1674 TALLOC_FREE(br_lck);
1675 return true;
1676 }
1677
1678 bool brl_reconnect_disconnected(struct files_struct *fsp)
1679 {
1680 uint32_t tid = fsp->conn->cnum;
1681 uint64_t smblctx;
1682 uint64_t fnum = fsp->fnum;
1683 unsigned int i;
1684 struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
1685 struct byte_range_lock *br_lck = NULL;
1686
1687 if (fsp->op == NULL) {
1688 return false;
1689 }
1690
1691 smblctx = fsp->op->global->open_persistent_id;
1692
1693 if (!fsp->op->global->durable) {
1694 return false;
1695 }
1696
1697 /*
1698 * When reconnecting, we do not want to validate the brlock entries
1699 * and thereby remove our own (disconnected) entries but reactivate
1700 * them instead.
1701 */
1702
1703 br_lck = brl_get_locks(talloc_tos(), fsp);
1704 if (br_lck == NULL) {
1705 return false;
1706 }
1707
1708 if (br_lck->num_locks == 0) {
1709 TALLOC_FREE(br_lck);
1710 return true;
1711 }
1712
1713 for (i=0; i < br_lck->num_locks; i++) {
1714 struct lock_struct *lock = &br_lck->lock_data[i];
1715
1716 /*
1717 * as this is a durable handle we only expect locks
1718 * of the current file handle!
1719 */
1720
1721 if (lock->context.smblctx != smblctx) {
1722 TALLOC_FREE(br_lck);
1723 return false;
1724 }
1725
1726 if (lock->context.tid != TID_FIELD_INVALID) {
1727 TALLOC_FREE(br_lck);
1728 return false;
1729 }
1730
1731 if (!server_id_is_disconnected(&lock->context.pid)) {
1732 TALLOC_FREE(br_lck);
1733 return false;
1734 }
1735
1736 if (lock->fnum != FNUM_FIELD_INVALID) {
1737 TALLOC_FREE(br_lck);
1738 return false;
1739 }
1740
1741 lock->context.pid = self;
1742 lock->context.tid = tid;
1743 lock->fnum = fnum;
1744 }
1745
1746 fsp->current_lock_count = br_lck->num_locks;
1747 br_lck->modified = true;
1748 TALLOC_FREE(br_lck);
1749 return true;
1750 }
1751
1752 struct brl_forall_cb {
1753 void (*fn)(struct file_id id, struct server_id pid,
1754 enum brl_type lock_type,
1755 enum brl_flavour lock_flav,
1756 br_off start, br_off size,
1757 void *private_data);
1758 void *private_data;
1759 };
1760
1761 /****************************************************************************
1762 Traverse the whole database with this function, calling traverse_callback
1763 on each lock.
1764 ****************************************************************************/
1765
1766 static int brl_traverse_fn(struct db_record *rec, void *state)
1767 {
1768 struct brl_forall_cb *cb = (struct brl_forall_cb *)state;
1769 struct lock_struct *locks;
1770 struct file_id *key;
1771 unsigned int i;
1772 unsigned int num_locks = 0;
1773 TDB_DATA dbkey;
1774 TDB_DATA value;
1775
1776 dbkey = dbwrap_record_get_key(rec);
1777 value = dbwrap_record_get_value(rec);
1778
1779 /* In a traverse function we must make a copy of
1780 dbuf before modifying it. */
1781
1782 locks = (struct lock_struct *)talloc_memdup(
1783 talloc_tos(), value.dptr, value.dsize);
1784 if (!locks) {
1785 return -1; /* Terminate traversal. */
1786 }
1787
1788 key = (struct file_id *)dbkey.dptr;
1789 num_locks = value.dsize/sizeof(*locks);
1790
1791 if (cb->fn) {
1792 for ( i=0; i<num_locks; i++) {
1793 cb->fn(*key,
1794 locks[i].context.pid,
1795 locks[i].lock_type,
1796 locks[i].lock_flav,
1797 locks[i].start,
1798 locks[i].size,
1799 cb->private_data);
1800 }
1801 }
1802
1803 TALLOC_FREE(locks);
1804 return 0;
1805 }
1806
1807 /*******************************************************************
1808 Call the specified function on each lock in the database.
1809 ********************************************************************/
1810
1811 int brl_forall(void (*fn)(struct file_id id, struct server_id pid,
1812 enum brl_type lock_type,
1813 enum brl_flavour lock_flav,
1814 br_off start, br_off size,
1815 void *private_data),
1816 void *private_data)
1817 {
1818 struct brl_forall_cb cb;
1819 NTSTATUS status;
1820 int count = 0;
1821
1822 if (!brlock_db) {
1823 return 0;
1824 }
1825 cb.fn = fn;
1826 cb.private_data = private_data;
1827 status = dbwrap_traverse(brlock_db, brl_traverse_fn, &cb, &count);
1828
1829 if (!NT_STATUS_IS_OK(status)) {
1830 return -1;
1831 } else {
1832 return count;
1833 }
1834 }
1835
1836 /*******************************************************************
1837 Store a potentially modified set of byte range lock data back into
1838 the database.
1839 Unlock the record.
1840 ********************************************************************/
1841
1842 static void byte_range_lock_flush(struct byte_range_lock *br_lck)
1843 {
1844 size_t data_len;
1845 unsigned i;
1846 struct lock_struct *locks = br_lck->lock_data;
1847
1848 if (!br_lck->modified) {
1849 DEBUG(10, ("br_lck not modified\n"));
1850 goto done;
1851 }
1852
1853 i = 0;
1854
1855 while (i < br_lck->num_locks) {
1856 if (locks[i].context.pid.pid == 0) {
1857 /*
1858 * Autocleanup, the process conflicted and does not
1859 * exist anymore.
1860 */
1861 locks[i] = locks[br_lck->num_locks-1];
1862 br_lck->num_locks -= 1;
1863 } else {
1864 i += 1;
1865 }
1866 }
1867
1868 data_len = br_lck->num_locks * sizeof(struct lock_struct);
1869
1870 if (br_lck->have_read_oplocks) {
1871 data_len += 1;
1872 }
1873
1874 DEBUG(10, ("data_len=%d\n", (int)data_len));
1875
1876 if (data_len == 0) {
1877 /* No locks - delete this entry. */
1878 NTSTATUS status = dbwrap_record_delete(br_lck->record);
1879 if (!NT_STATUS_IS_OK(status)) {
1880 DEBUG(0, ("delete_rec returned %s\n",
1881 nt_errstr(status)));
1882 smb_panic("Could not delete byte range lock entry");
1883 }
1884 } else {
1885 TDB_DATA data;
1886 NTSTATUS status;
1887
1888 data.dsize = data_len;
1889 data.dptr = talloc_array(talloc_tos(), uint8_t, data_len);
1890 SMB_ASSERT(data.dptr != NULL);
1891
1892 memcpy(data.dptr, br_lck->lock_data,
1893 br_lck->num_locks * sizeof(struct lock_struct));
1894
1895 if (br_lck->have_read_oplocks) {
1896 data.dptr[data_len-1] = 1;
1897 }
1898
1899 status = dbwrap_record_store(br_lck->record, data, TDB_REPLACE);
1900 TALLOC_FREE(data.dptr);
1901 if (!NT_STATUS_IS_OK(status)) {
1902 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
1903 smb_panic("Could not store byte range mode entry");
1904 }
1905 }
1906
1907 DEBUG(10, ("seqnum=%d\n", dbwrap_get_seqnum(brlock_db)));
1908
1909 done:
1910 br_lck->modified = false;
1911 TALLOC_FREE(br_lck->record);
1912 }
1913
1914 static int byte_range_lock_destructor(struct byte_range_lock *br_lck)
1915 {
1916 byte_range_lock_flush(br_lck);
1917 return 0;
1918 }
1919
1920 /*******************************************************************
1921 Fetch a set of byte range lock data from the database.
1922 Leave the record locked.
1923 TALLOC_FREE(brl) will release the lock in the destructor.
1924 ********************************************************************/
1925
1926 struct byte_range_lock *brl_get_locks(TALLOC_CTX *mem_ctx, files_struct *fsp)
1927 {
1928 TDB_DATA key, data;
1929 struct byte_range_lock *br_lck = talloc(mem_ctx, struct byte_range_lock);
1930
1931 if (br_lck == NULL) {
1932 return NULL;
1933 }
1934
1935 br_lck->fsp = fsp;
1936 br_lck->num_locks = 0;
1937 br_lck->have_read_oplocks = false;
1938 br_lck->modified = False;
1939
1940 key.dptr = (uint8 *)&fsp->file_id;
1941 key.dsize = sizeof(struct file_id);
1942
1943 br_lck->record = dbwrap_fetch_locked(brlock_db, br_lck, key);
1944
1945 if (br_lck->record == NULL) {
1946 DEBUG(3, ("Could not lock byte range lock entry\n"));
1947 TALLOC_FREE(br_lck);
1948 return NULL;
1949 }
1950
1951 data = dbwrap_record_get_value(br_lck->record);
1952
1953 br_lck->lock_data = NULL;
1954
1955 talloc_set_destructor(br_lck, byte_range_lock_destructor);
1956
1957 br_lck->num_locks = data.dsize / sizeof(struct lock_struct);
1958
1959 if (br_lck->num_locks != 0) {
1960 br_lck->lock_data = talloc_array(
1961 br_lck, struct lock_struct, br_lck->num_locks);
1962 if (br_lck->lock_data == NULL) {
1963 DEBUG(0, ("malloc failed\n"));
1964 TALLOC_FREE(br_lck);
1965 return NULL;
1966 }
1967
1968 memcpy(br_lck->lock_data, data.dptr,
1969 talloc_get_size(br_lck->lock_data));
1970 }
1971
1972 DEBUG(10, ("data.dsize=%d\n", (int)data.dsize));
1973
1974 if ((data.dsize % sizeof(struct lock_struct)) == 1) {
1975 br_lck->have_read_oplocks = (data.dptr[data.dsize-1] == 1);
1976 }
1977
1978 if (DEBUGLEVEL >= 10) {
1979 unsigned int i;
1980 struct lock_struct *locks = br_lck->lock_data;
1981 DEBUG(10,("brl_get_locks_internal: %u current locks on file_id %s\n",
1982 br_lck->num_locks,
1983 file_id_string_tos(&fsp->file_id)));
1984 for( i = 0; i < br_lck->num_locks; i++) {
1985 print_lock_struct(i, &locks[i]);
1986 }
1987 }
1988
1989 return br_lck;
1990 }
1991
1992 struct brl_get_locks_readonly_state {
1993 TALLOC_CTX *mem_ctx;
1994 struct byte_range_lock **br_lock;
1995 };
1996
1997 static void brl_get_locks_readonly_parser(TDB_DATA key, TDB_DATA data,
1998 void *private_data)
1999 {
2000 struct brl_get_locks_readonly_state *state =
2001 (struct brl_get_locks_readonly_state *)private_data;
2002 struct byte_range_lock *br_lock;
2003
2004 br_lock = talloc_pooled_object(
2005 state->mem_ctx, struct byte_range_lock, 1, data.dsize);
2006 if (br_lock == NULL) {
2007 *state->br_lock = NULL;
2008 return;
2009 }
2010 br_lock->lock_data = (struct lock_struct *)talloc_memdup(
2011 br_lock, data.dptr, data.dsize);
2012 br_lock->num_locks = data.dsize / sizeof(struct lock_struct);
2013
2014 if ((data.dsize % sizeof(struct lock_struct)) == 1) {
2015 br_lock->have_read_oplocks = (data.dptr[data.dsize-1] == 1);
2016 } else {
2017 br_lock->have_read_oplocks = false;
2018 }
2019
2020 DEBUG(10, ("Got %d bytes, have_read_oplocks: %s\n", (int)data.dsize,
2021 br_lock->have_read_oplocks ? "true" : "false"));
2022
2023 *state->br_lock = br_lock;
2024 }
2025
2026 struct byte_range_lock *brl_get_locks_readonly(files_struct *fsp)
2027 {
2028 struct byte_range_lock *br_lock = NULL;
2029 struct brl_get_locks_readonly_state state;
2030 NTSTATUS status;
2031
2032 DEBUG(10, ("seqnum=%d, fsp->brlock_seqnum=%d\n",
2033 dbwrap_get_seqnum(brlock_db), fsp->brlock_seqnum));
2034
2035 if ((fsp->brlock_rec != NULL)
2036 && (dbwrap_get_seqnum(brlock_db) == fsp->brlock_seqnum)) {
2037 /*
2038 * We have cached the brlock_rec and the database did not
2039 * change.
2040 */
2041 return fsp->brlock_rec;
2042 }
2043
2044 /*
2045 * Parse the record fresh from the database
2046 */
2047
2048 state.mem_ctx = fsp;
2049 state.br_lock = &br_lock;
2050
2051 status = dbwrap_parse_record(
2052 brlock_db,
2053 make_tdb_data((uint8_t *)&fsp->file_id,
2054 sizeof(fsp->file_id)),
2055 brl_get_locks_readonly_parser, &state);
2056
2057 if (NT_STATUS_EQUAL(status,NT_STATUS_NOT_FOUND)) {
2058 /*
2059 * No locks on this file. Return an empty br_lock.
2060 */
2061 br_lock = talloc(fsp, struct byte_range_lock);
2062 if (br_lock == NULL) {
2063 return NULL;
2064 }
2065
2066 br_lock->have_read_oplocks = false;
2067 br_lock->num_locks = 0;
2068 br_lock->lock_data = NULL;
2069
2070 } else if (!NT_STATUS_IS_OK(status)) {
2071 DEBUG(3, ("Could not parse byte range lock record: "
2072 "%s\n", nt_errstr(status)));
2073 return NULL;
2074 }
2075 if (br_lock == NULL) {
2076 return NULL;
2077 }
2078
2079 br_lock->fsp = fsp;
2080 br_lock->modified = false;
2081 br_lock->record = NULL;
2082
2083 if (lp_clustering()) {
2084 /*
2085 * In the cluster case we can't cache the brlock struct
2086 * because dbwrap_get_seqnum does not work reliably over
2087 * ctdb. Thus we have to throw away the brlock struct soon.
2088 */
2089 talloc_steal(talloc_tos(), br_lock);
2090 } else {
2091 /*
2092 * Cache the brlock struct, invalidated when the dbwrap_seqnum
2093 * changes. See beginning of this routine.
2094 */
2095 TALLOC_FREE(fsp->brlock_rec);
2096 fsp->brlock_rec = br_lock;
2097 fsp->brlock_seqnum = dbwrap_get_seqnum(brlock_db);
2098 }
2099
2100 return br_lock;
2101 }
2102
2103 struct brl_revalidate_state {
2104 ssize_t array_size;
2105 uint32 num_pids;
2106 struct server_id *pids;
2107 };
2108
2109 /*
2110 * Collect PIDs of all processes with pending entries
2111 */
2112
2113 static void brl_revalidate_collect(struct file_id id, struct server_id pid,
2114 enum brl_type lock_type,
2115 enum brl_flavour lock_flav,
2116 br_off start, br_off size,
2117 void *private_data)
2118 {
2119 struct brl_revalidate_state *state =
2120 (struct brl_revalidate_state *)private_data;
2121
2122 if (!IS_PENDING_LOCK(lock_type)) {
2123 return;
2124 }
2125
2126 add_to_large_array(state, sizeof(pid), (void *)&pid,
2127 &state->pids, &state->num_pids,
2128 &state->array_size);
2129 }
2130
2131 /*
2132 * qsort callback to sort the processes
2133 */
2134
2135 static int compare_procids(const void *p1, const void *p2)
2136 {
2137 const struct server_id *i1 = (const struct server_id *)p1;
2138 const struct server_id *i2 = (const struct server_id *)p2;
2139
2140 if (i1->pid < i2->pid) return -1;
2141 if (i1->pid > i2->pid) return 1;
2142 return 0;
2143 }
2144
2145 /*
2146 * Send a MSG_SMB_UNLOCK message to all processes with pending byte range
2147 * locks so that they retry. Mainly used in the cluster code after a node has
2148 * died.
2149 *
2150 * Done in two steps to avoid double-sends: First we collect all entries in an
2151 * array, then qsort that array and only send to non-dupes.
2152 */
2153
2154 void brl_revalidate(struct messaging_context *msg_ctx,
2155 void *private_data,
2156 uint32_t msg_type,
2157 struct server_id server_id,
2158 DATA_BLOB *data)
2159 {
2160 struct brl_revalidate_state *state;
2161 uint32 i;
2162 struct server_id last_pid;
2163
2164 if (!(state = talloc_zero(NULL, struct brl_revalidate_state))) {
2165 DEBUG(0, ("talloc failed\n"));
2166 return;
2167 }
2168
2169 brl_forall(brl_revalidate_collect, state);
2170
2171 if (state->array_size == -1) {
2172 DEBUG(0, ("talloc failed\n"));
2173 goto done;
2174 }
2175
2176 if (state->num_pids == 0) {
2177 goto done;
2178 }
2179
2180 TYPESAFE_QSORT(state->pids, state->num_pids, compare_procids);
2181
2182 ZERO_STRUCT(last_pid);
2183
2184 for (i=0; i<state->num_pids; i++) {
2185 if (serverid_equal(&last_pid, &state->pids[i])) {
2186 /*
2187 * We've seen that one already
2188 */
2189 continue;
2190 }
2191
2192 messaging_send(msg_ctx, state->pids[i], MSG_SMB_UNLOCK,
2193 &data_blob_null);
2194 last_pid = state->pids[i];
2195 }
2196
2197 done:
2198 TALLOC_FREE(state);
2199 return;
2200 }
2201
2202 bool brl_cleanup_disconnected(struct file_id fid, uint64_t open_persistent_id)
2203 {
2204 bool ret = false;
2205 TALLOC_CTX *frame = talloc_stackframe();
2206 TDB_DATA key, val;
2207 struct db_record *rec;
2208 struct lock_struct *lock;
2209 unsigned n, num;
2210 NTSTATUS status;
2211
2212 key = make_tdb_data((void*)&fid, sizeof(fid));
2213
2214 rec = dbwrap_fetch_locked(brlock_db, frame, key);
2215 if (rec == NULL) {
2216 DEBUG(5, ("brl_cleanup_disconnected: failed to fetch record "
2217 "for file %s\n", file_id_string(frame, &fid)));
2218 goto done;
2219 }
2220
2221 val = dbwrap_record_get_value(rec);
2222 lock = (struct lock_struct*)val.dptr;
2223 num = val.dsize / sizeof(struct lock_struct);
2224 if (lock == NULL) {
2225 DEBUG(10, ("brl_cleanup_disconnected: no byte range locks for "
2226 "file %s\n", file_id_string(frame, &fid)));
2227 ret = true;
2228 goto done;
2229 }
2230
2231 for (n=0; n<num; n++) {
2232 struct lock_context *ctx = &lock[n].context;
2233
2234 if (!server_id_is_disconnected(&ctx->pid)) {
2235 DEBUG(5, ("brl_cleanup_disconnected: byte range lock "
2236 "%s used by server %s, do not cleanup\n",
2237 file_id_string(frame, &fid),
2238 server_id_str(frame, &ctx->pid)));
2239 goto done;
2240 }
2241
2242 if (ctx->smblctx != open_persistent_id) {
2243 DEBUG(5, ("brl_cleanup_disconnected: byte range lock "
2244 "%s expected smblctx %llu but found %llu"
2245 ", do not cleanup\n",
2246 file_id_string(frame, &fid),
2247 (unsigned long long)open_persistent_id,
2248 (unsigned long long)ctx->smblctx));
2249 goto done;
2250 }
2251 }
2252
2253 status = dbwrap_record_delete(rec);
2254 if (!NT_STATUS_IS_OK(status)) {
2255 DEBUG(5, ("brl_cleanup_disconnected: failed to delete record "
2256 "for file %s from %s, open %llu: %s\n",
2257 file_id_string(frame, &fid), dbwrap_name(brlock_db),
2258 (unsigned long long)open_persistent_id,
2259 nt_errstr(status)));
2260 goto done;
2261 }
2262
2263 DEBUG(10, ("brl_cleanup_disconnected: "
2264 "file %s cleaned up %u entries from open %llu\n",
2265 file_id_string(frame, &fid), num,
2266 (unsigned long long)open_persistent_id));
2267
2268 ret = true;
2269 done:
2270 talloc_free(frame);
2271 return ret;
2272 }
Samba GIT mirror