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