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