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