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