?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4/test: Run DrsDeleteObjectTestCase as part of S4 testing
[Samba.git] / source3 / locking / posix.c
blobe6acbe8bac4f2f38e397067043c0452150a585f5
1 /*
2 Unix SMB/CIFS implementation.
3 Locking functions
4 Copyright (C) Jeremy Allison 1992-2006
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19 Revision History:
20
21 POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
22 */
23
24 #include "includes.h"
25
26 #undef DBGC_CLASS
27 #define DBGC_CLASS DBGC_LOCKING
28
29 /*
30 * The pending close database handle.
31 */
32
33 static struct db_context *posix_pending_close_db;
34
35 /****************************************************************************
36 First - the functions that deal with the underlying system locks - these
37 functions are used no matter if we're mapping CIFS Windows locks or CIFS
38 POSIX locks onto POSIX.
39 ****************************************************************************/
40
41 /****************************************************************************
42 Utility function to map a lock type correctly depending on the open
43 mode of a file.
44 ****************************************************************************/
45
46 static int map_posix_lock_type( files_struct *fsp, enum brl_type lock_type)
47 {
48 if((lock_type == WRITE_LOCK) && !fsp->can_write) {
49 /*
50 * Many UNIX's cannot get a write lock on a file opened read-only.
51 * Win32 locking semantics allow this.
52 * Do the best we can and attempt a read-only lock.
53 */
54 DEBUG(10,("map_posix_lock_type: Downgrading write lock to read due to read-only file.\n"));
55 return F_RDLCK;
56 }
57
58 /*
59 * This return should be the most normal, as we attempt
60 * to always open files read/write.
61 */
62
63 return (lock_type == READ_LOCK) ? F_RDLCK : F_WRLCK;
64 }
65
66 /****************************************************************************
67 Debugging aid :-).
68 ****************************************************************************/
69
70 static const char *posix_lock_type_name(int lock_type)
71 {
72 return (lock_type == F_RDLCK) ? "READ" : "WRITE";
73 }
74
75 /****************************************************************************
76 Check to see if the given unsigned lock range is within the possible POSIX
77 range. Modifies the given args to be in range if possible, just returns
78 False if not.
79 ****************************************************************************/
80
81 static bool posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
82 uint64_t u_offset, uint64_t u_count)
83 {
84 SMB_OFF_T offset = (SMB_OFF_T)u_offset;
85 SMB_OFF_T count = (SMB_OFF_T)u_count;
86
87 /*
88 * For the type of system we are, attempt to
89 * find the maximum positive lock offset as an SMB_OFF_T.
90 */
91
92 #if defined(MAX_POSITIVE_LOCK_OFFSET) /* Some systems have arbitrary limits. */
93
94 SMB_OFF_T max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
95
96 #elif defined(LARGE_SMB_OFF_T) && !defined(HAVE_BROKEN_FCNTL64_LOCKS)
97
98 /*
99 * In this case SMB_OFF_T is 64 bits,
100 * and the underlying system can handle 64 bit signed locks.
101 */
102
103 SMB_OFF_T mask2 = ((SMB_OFF_T)0x4) << (SMB_OFF_T_BITS-4);
104 SMB_OFF_T mask = (mask2<<1);
105 SMB_OFF_T max_positive_lock_offset = ~mask;
106
107 #else /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
108
109 /*
110 * In this case either SMB_OFF_T is 32 bits,
111 * or the underlying system cannot handle 64 bit signed locks.
112 * All offsets & counts must be 2^31 or less.
113 */
114
115 SMB_OFF_T max_positive_lock_offset = 0x7FFFFFFF;
116
117 #endif /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
118
119 /*
120 * POSIX locks of length zero mean lock to end-of-file.
121 * Win32 locks of length zero are point probes. Ignore
122 * any Win32 locks of length zero. JRA.
123 */
124
125 if (count == (SMB_OFF_T)0) {
126 DEBUG(10,("posix_lock_in_range: count = 0, ignoring.\n"));
127 return False;
128 }
129
130 /*
131 * If the given offset was > max_positive_lock_offset then we cannot map this at all
132 * ignore this lock.
133 */
134
135 if (u_offset & ~((uint64_t)max_positive_lock_offset)) {
136 DEBUG(10,("posix_lock_in_range: (offset = %.0f) offset > %.0f and we cannot handle this. Ignoring lock.\n",
137 (double)u_offset, (double)((uint64_t)max_positive_lock_offset) ));
138 return False;
139 }
140
141 /*
142 * We must truncate the count to less than max_positive_lock_offset.
143 */
144
145 if (u_count & ~((uint64_t)max_positive_lock_offset)) {
146 count = max_positive_lock_offset;
147 }
148
149 /*
150 * Truncate count to end at max lock offset.
151 */
152
153 if (offset + count < 0 || offset + count > max_positive_lock_offset) {
154 count = max_positive_lock_offset - offset;
155 }
156
157 /*
158 * If we ate all the count, ignore this lock.
159 */
160
161 if (count == 0) {
162 DEBUG(10,("posix_lock_in_range: Count = 0. Ignoring lock u_offset = %.0f, u_count = %.0f\n",
163 (double)u_offset, (double)u_count ));
164 return False;
165 }
166
167 /*
168 * The mapping was successful.
169 */
170
171 DEBUG(10,("posix_lock_in_range: offset_out = %.0f, count_out = %.0f\n",
172 (double)offset, (double)count ));
173
174 *offset_out = offset;
175 *count_out = count;
176
177 return True;
178 }
179
180 bool smb_vfs_call_lock(struct vfs_handle_struct *handle,
181 struct files_struct *fsp, int op, SMB_OFF_T offset,
182 SMB_OFF_T count, int type)
183 {
184 VFS_FIND(lock);
185 return handle->fns->lock(handle, fsp, op, offset, count, type);
186 }
187
188 /****************************************************************************
189 Actual function that does POSIX locks. Copes with 64 -> 32 bit cruft and
190 broken NFS implementations.
191 ****************************************************************************/
192
193 static bool posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
194 {
195 bool ret;
196
197 DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fh->fd,op,(double)offset,(double)count,type));
198
199 ret = SMB_VFS_LOCK(fsp, op, offset, count, type);
200
201 if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno == EINVAL))) {
202
203 DEBUG(0,("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n",
204 (double)offset,(double)count));
205 DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
206 DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
207
208 /*
209 * If the offset is > 0x7FFFFFFF then this will cause problems on
210 * 32 bit NFS mounted filesystems. Just ignore it.
211 */
212
213 if (offset & ~((SMB_OFF_T)0x7fffffff)) {
214 DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
215 return True;
216 }
217
218 if (count & ~((SMB_OFF_T)0x7fffffff)) {
219 /* 32 bit NFS file system, retry with smaller offset */
220 DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
221 errno = 0;
222 count &= 0x7fffffff;
223 ret = SMB_VFS_LOCK(fsp, op, offset, count, type);
224 }
225 }
226
227 DEBUG(8,("posix_fcntl_lock: Lock call %s\n", ret ? "successful" : "failed"));
228 return ret;
229 }
230
231 bool smb_vfs_call_getlock(struct vfs_handle_struct *handle,
232 struct files_struct *fsp, SMB_OFF_T *poffset,
233 SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
234 {
235 VFS_FIND(getlock);
236 return handle->fns->getlock(handle, fsp, poffset, pcount, ptype, ppid);
237 }
238
239 /****************************************************************************
240 Actual function that gets POSIX locks. Copes with 64 -> 32 bit cruft and
241 broken NFS implementations.
242 ****************************************************************************/
243
244 static bool posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype)
245 {
246 pid_t pid;
247 bool ret;
248
249 DEBUG(8,("posix_fcntl_getlock %d %.0f %.0f %d\n",
250 fsp->fh->fd,(double)*poffset,(double)*pcount,*ptype));
251
252 ret = SMB_VFS_GETLOCK(fsp, poffset, pcount, ptype, &pid);
253
254 if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno == EINVAL))) {
255
256 DEBUG(0,("posix_fcntl_getlock: WARNING: lock request at offset %.0f, length %.0f returned\n",
257 (double)*poffset,(double)*pcount));
258 DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
259 DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
260
261 /*
262 * If the offset is > 0x7FFFFFFF then this will cause problems on
263 * 32 bit NFS mounted filesystems. Just ignore it.
264 */
265
266 if (*poffset & ~((SMB_OFF_T)0x7fffffff)) {
267 DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
268 return True;
269 }
270
271 if (*pcount & ~((SMB_OFF_T)0x7fffffff)) {
272 /* 32 bit NFS file system, retry with smaller offset */
273 DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
274 errno = 0;
275 *pcount &= 0x7fffffff;
276 ret = SMB_VFS_GETLOCK(fsp,poffset,pcount,ptype,&pid);
277 }
278 }
279
280 DEBUG(8,("posix_fcntl_getlock: Lock query call %s\n", ret ? "successful" : "failed"));
281 return ret;
282 }
283
284 /****************************************************************************
285 POSIX function to see if a file region is locked. Returns True if the
286 region is locked, False otherwise.
287 ****************************************************************************/
288
289 bool is_posix_locked(files_struct *fsp,
290 uint64_t *pu_offset,
291 uint64_t *pu_count,
292 enum brl_type *plock_type,
293 enum brl_flavour lock_flav)
294 {
295 SMB_OFF_T offset;
296 SMB_OFF_T count;
297 int posix_lock_type = map_posix_lock_type(fsp,*plock_type);
298
299 DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, "
300 "type = %s\n", fsp_str_dbg(fsp), (double)*pu_offset,
301 (double)*pu_count, posix_lock_type_name(*plock_type)));
302
303 /*
304 * If the requested lock won't fit in the POSIX range, we will
305 * never set it, so presume it is not locked.
306 */
307
308 if(!posix_lock_in_range(&offset, &count, *pu_offset, *pu_count)) {
309 return False;
310 }
311
312 if (!posix_fcntl_getlock(fsp,&offset,&count,&posix_lock_type)) {
313 return False;
314 }
315
316 if (posix_lock_type == F_UNLCK) {
317 return False;
318 }
319
320 if (lock_flav == POSIX_LOCK) {
321 /* Only POSIX lock queries need to know the details. */
322 *pu_offset = (uint64_t)offset;
323 *pu_count = (uint64_t)count;
324 *plock_type = (posix_lock_type == F_RDLCK) ? READ_LOCK : WRITE_LOCK;
325 }
326 return True;
327 }
328
329 /****************************************************************************
330 Next - the functions that deal with in memory database storing representations
331 of either Windows CIFS locks or POSIX CIFS locks.
332 ****************************************************************************/
333
334 /* The key used in the in-memory POSIX databases. */
335
336 struct lock_ref_count_key {
337 struct file_id id;
338 char r;
339 };
340
341 /*******************************************************************
342 Form a static locking key for a dev/inode pair for the lock ref count
343 ******************************************************************/
344
345 static TDB_DATA locking_ref_count_key_fsp(files_struct *fsp,
346 struct lock_ref_count_key *tmp)
347 {
348 ZERO_STRUCTP(tmp);
349 tmp->id = fsp->file_id;
350 tmp->r = 'r';
351 return make_tdb_data((uint8_t *)tmp, sizeof(*tmp));
352 }
353
354 /*******************************************************************
355 Convenience function to get an fd_array key from an fsp.
356 ******************************************************************/
357
358 static TDB_DATA fd_array_key_fsp(files_struct *fsp)
359 {
360 return make_tdb_data((uint8 *)&fsp->file_id, sizeof(fsp->file_id));
361 }
362
363 /*******************************************************************
364 Create the in-memory POSIX lock databases.
365 ********************************************************************/
366
367 bool posix_locking_init(bool read_only)
368 {
369 if (posix_pending_close_db != NULL) {
370 return true;
371 }
372
373 posix_pending_close_db = db_open_rbt(NULL);
374
375 if (posix_pending_close_db == NULL) {
376 DEBUG(0,("Failed to open POSIX pending close database.\n"));
377 return false;
378 }
379
380 return true;
381 }
382
383 /*******************************************************************
384 Delete the in-memory POSIX lock databases.
385 ********************************************************************/
386
387 bool posix_locking_end(void)
388 {
389 /*
390 * Shouldn't we close all fd's here?
391 */
392 TALLOC_FREE(posix_pending_close_db);
393 return true;
394 }
395
396 /****************************************************************************
397 Next - the functions that deal with storing fd's that have outstanding
398 POSIX locks when closed.
399 ****************************************************************************/
400
401 /****************************************************************************
402 The records in posix_pending_close_tdb are composed of an array of ints
403 keyed by dev/ino pair.
404 The first int is a reference count of the number of outstanding locks on
405 all open fd's on this dev/ino pair. Any subsequent ints are the fd's that
406 were open on this dev/ino pair that should have been closed, but can't as
407 the lock ref count is non zero.
408 ****************************************************************************/
409
410 /****************************************************************************
411 Keep a reference count of the number of Windows locks open on this dev/ino
412 pair. Creates entry if it doesn't exist.
413 ****************************************************************************/
414
415 static void increment_windows_lock_ref_count(files_struct *fsp)
416 {
417 struct lock_ref_count_key tmp;
418 struct db_record *rec;
419 int lock_ref_count = 0;
420 NTSTATUS status;
421
422 rec = posix_pending_close_db->fetch_locked(
423 posix_pending_close_db, talloc_tos(),
424 locking_ref_count_key_fsp(fsp, &tmp));
425
426 SMB_ASSERT(rec != NULL);
427
428 if (rec->value.dptr != NULL) {
429 SMB_ASSERT(rec->value.dsize == sizeof(lock_ref_count));
430 memcpy(&lock_ref_count, rec->value.dptr,
431 sizeof(lock_ref_count));
432 }
433
434 lock_ref_count++;
435
436 status = rec->store(rec, make_tdb_data((uint8 *)&lock_ref_count,
437 sizeof(lock_ref_count)), 0);
438
439 SMB_ASSERT(NT_STATUS_IS_OK(status));
440
441 TALLOC_FREE(rec);
442
443 DEBUG(10,("increment_windows_lock_ref_count for file now %s = %d\n",
444 fsp_str_dbg(fsp), lock_ref_count));
445 }
446
447 /****************************************************************************
448 Bulk delete - subtract as many locks as we've just deleted.
449 ****************************************************************************/
450
451 void reduce_windows_lock_ref_count(files_struct *fsp, unsigned int dcount)
452 {
453 struct lock_ref_count_key tmp;
454 struct db_record *rec;
455 int lock_ref_count = 0;
456 NTSTATUS status;
457
458 rec = posix_pending_close_db->fetch_locked(
459 posix_pending_close_db, talloc_tos(),
460 locking_ref_count_key_fsp(fsp, &tmp));
461
462 SMB_ASSERT((rec != NULL)
463 && (rec->value.dptr != NULL)
464 && (rec->value.dsize == sizeof(lock_ref_count)));
465
466 memcpy(&lock_ref_count, rec->value.dptr, sizeof(lock_ref_count));
467
468 SMB_ASSERT(lock_ref_count > 0);
469
470 lock_ref_count -= dcount;
471
472 status = rec->store(rec, make_tdb_data((uint8 *)&lock_ref_count,
473 sizeof(lock_ref_count)), 0);
474
475 SMB_ASSERT(NT_STATUS_IS_OK(status));
476
477 TALLOC_FREE(rec);
478
479 DEBUG(10,("reduce_windows_lock_ref_count for file now %s = %d\n",
480 fsp_str_dbg(fsp), lock_ref_count));
481 }
482
483 static void decrement_windows_lock_ref_count(files_struct *fsp)
484 {
485 reduce_windows_lock_ref_count(fsp, 1);
486 }
487
488 /****************************************************************************
489 Fetch the lock ref count.
490 ****************************************************************************/
491
492 static int get_windows_lock_ref_count(files_struct *fsp)
493 {
494 struct lock_ref_count_key tmp;
495 TDB_DATA dbuf;
496 int res;
497 int lock_ref_count = 0;
498
499 res = posix_pending_close_db->fetch(
500 posix_pending_close_db, talloc_tos(),
501 locking_ref_count_key_fsp(fsp, &tmp), &dbuf);
502
503 SMB_ASSERT(res == 0);
504
505 if (dbuf.dsize != 0) {
506 SMB_ASSERT(dbuf.dsize == sizeof(lock_ref_count));
507 memcpy(&lock_ref_count, dbuf.dptr, sizeof(lock_ref_count));
508 TALLOC_FREE(dbuf.dptr);
509 }
510
511 DEBUG(10,("get_windows_lock_count for file %s = %d\n",
512 fsp_str_dbg(fsp), lock_ref_count));
513
514 return lock_ref_count;
515 }
516
517 /****************************************************************************
518 Delete a lock_ref_count entry.
519 ****************************************************************************/
520
521 static void delete_windows_lock_ref_count(files_struct *fsp)
522 {
523 struct lock_ref_count_key tmp;
524 struct db_record *rec;
525
526 rec = posix_pending_close_db->fetch_locked(
527 posix_pending_close_db, talloc_tos(),
528 locking_ref_count_key_fsp(fsp, &tmp));
529
530 SMB_ASSERT(rec != NULL);
531
532 /* Not a bug if it doesn't exist - no locks were ever granted. */
533
534 rec->delete_rec(rec);
535 TALLOC_FREE(rec);
536
537 DEBUG(10,("delete_windows_lock_ref_count for file %s\n",
538 fsp_str_dbg(fsp)));
539 }
540
541 /****************************************************************************
542 Add an fd to the pending close tdb.
543 ****************************************************************************/
544
545 static void add_fd_to_close_entry(files_struct *fsp)
546 {
547 struct db_record *rec;
548 uint8_t *new_data;
549 NTSTATUS status;
550
551 rec = posix_pending_close_db->fetch_locked(
552 posix_pending_close_db, talloc_tos(),
553 fd_array_key_fsp(fsp));
554
555 SMB_ASSERT(rec != NULL);
556
557 new_data = TALLOC_ARRAY(
558 rec, uint8_t, rec->value.dsize + sizeof(fsp->fh->fd));
559
560 SMB_ASSERT(new_data != NULL);
561
562 memcpy(new_data, rec->value.dptr, rec->value.dsize);
563 memcpy(new_data + rec->value.dsize,
564 &fsp->fh->fd, sizeof(fsp->fh->fd));
565
566 status = rec->store(
567 rec, make_tdb_data(new_data,
568 rec->value.dsize + sizeof(fsp->fh->fd)), 0);
569
570 SMB_ASSERT(NT_STATUS_IS_OK(status));
571
572 TALLOC_FREE(rec);
573
574 DEBUG(10,("add_fd_to_close_entry: added fd %d file %s\n",
575 fsp->fh->fd, fsp_str_dbg(fsp)));
576 }
577
578 /****************************************************************************
579 Remove all fd entries for a specific dev/inode pair from the tdb.
580 ****************************************************************************/
581
582 static void delete_close_entries(files_struct *fsp)
583 {
584 struct db_record *rec;
585
586 rec = posix_pending_close_db->fetch_locked(
587 posix_pending_close_db, talloc_tos(),
588 fd_array_key_fsp(fsp));
589
590 SMB_ASSERT(rec != NULL);
591 rec->delete_rec(rec);
592 TALLOC_FREE(rec);
593 }
594
595 /****************************************************************************
596 Get the array of POSIX pending close records for an open fsp. Returns number
597 of entries.
598 ****************************************************************************/
599
600 static size_t get_posix_pending_close_entries(TALLOC_CTX *mem_ctx,
601 files_struct *fsp, int **entries)
602 {
603 TDB_DATA dbuf;
604 int res;
605
606 res = posix_pending_close_db->fetch(
607 posix_pending_close_db, mem_ctx, fd_array_key_fsp(fsp),
608 &dbuf);
609
610 SMB_ASSERT(res == 0);
611
612 if (dbuf.dsize == 0) {
613 *entries = NULL;
614 return 0;
615 }
616
617 *entries = (int *)dbuf.dptr;
618 return (size_t)(dbuf.dsize / sizeof(int));
619 }
620
621 /****************************************************************************
622 Deal with pending closes needed by POSIX locking support.
623 Note that posix_locking_close_file() is expected to have been called
624 to delete all locks on this fsp before this function is called.
625 ****************************************************************************/
626
627 int fd_close_posix(struct files_struct *fsp)
628 {
629 int saved_errno = 0;
630 int ret;
631 int *fd_array = NULL;
632 size_t count, i;
633
634 if (!lp_locking(fsp->conn->params) ||
635 !lp_posix_locking(fsp->conn->params))
636 {
637 /*
638 * No locking or POSIX to worry about or we want POSIX semantics
639 * which will lose all locks on all fd's open on this dev/inode,
640 * just close.
641 */
642 return close(fsp->fh->fd);
643 }
644
645 if (get_windows_lock_ref_count(fsp)) {
646
647 /*
648 * There are outstanding locks on this dev/inode pair on
649 * other fds. Add our fd to the pending close tdb and set
650 * fsp->fh->fd to -1.
651 */
652
653 add_fd_to_close_entry(fsp);
654 return 0;
655 }
656
657 /*
658 * No outstanding locks. Get the pending close fd's
659 * from the tdb and close them all.
660 */
661
662 count = get_posix_pending_close_entries(talloc_tos(), fsp, &fd_array);
663
664 if (count) {
665 DEBUG(10,("fd_close_posix: doing close on %u fd's.\n",
666 (unsigned int)count));
667
668 for(i = 0; i < count; i++) {
669 if (close(fd_array[i]) == -1) {
670 saved_errno = errno;
671 }
672 }
673
674 /*
675 * Delete all fd's stored in the tdb
676 * for this dev/inode pair.
677 */
678
679 delete_close_entries(fsp);
680 }
681
682 TALLOC_FREE(fd_array);
683
684 /* Don't need a lock ref count on this dev/ino anymore. */
685 delete_windows_lock_ref_count(fsp);
686
687 /*
688 * Finally close the fd associated with this fsp.
689 */
690
691 ret = close(fsp->fh->fd);
692
693 if (ret == 0 && saved_errno != 0) {
694 errno = saved_errno;
695 ret = -1;
696 }
697
698 return ret;
699 }
700
701 /****************************************************************************
702 Next - the functions that deal with the mapping CIFS Windows locks onto
703 the underlying system POSIX locks.
704 ****************************************************************************/
705
706 /*
707 * Structure used when splitting a lock range
708 * into a POSIX lock range. Doubly linked list.
709 */
710
711 struct lock_list {
712 struct lock_list *next;
713 struct lock_list *prev;
714 SMB_OFF_T start;
715 SMB_OFF_T size;
716 };
717
718 /****************************************************************************
719 Create a list of lock ranges that don't overlap a given range. Used in calculating
720 POSIX locks and unlocks. This is a difficult function that requires ASCII art to
721 understand it :-).
722 ****************************************************************************/
723
724 static struct lock_list *posix_lock_list(TALLOC_CTX *ctx,
725 struct lock_list *lhead,
726 const struct lock_context *lock_ctx, /* Lock context lhead belongs to. */
727 files_struct *fsp,
728 const struct lock_struct *plocks,
729 int num_locks)
730 {
731 int i;
732
733 /*
734 * Check the current lock list on this dev/inode pair.
735 * Quit if the list is deleted.
736 */
737
738 DEBUG(10,("posix_lock_list: curr: start=%.0f,size=%.0f\n",
739 (double)lhead->start, (double)lhead->size ));
740
741 for (i=0; i<num_locks && lhead; i++) {
742 const struct lock_struct *lock = &plocks[i];
743 struct lock_list *l_curr;
744
745 /* Ignore all but read/write locks. */
746 if (lock->lock_type != READ_LOCK && lock->lock_type != WRITE_LOCK) {
747 continue;
748 }
749
750 /* Ignore locks not owned by this process. */
751 if (!procid_equal(&lock->context.pid, &lock_ctx->pid)) {
752 continue;
753 }
754
755 /*
756 * Walk the lock list, checking for overlaps. Note that
757 * the lock list can expand within this loop if the current
758 * range being examined needs to be split.
759 */
760
761 for (l_curr = lhead; l_curr;) {
762
763 DEBUG(10,("posix_lock_list: lock: fnum=%d: start=%.0f,size=%.0f:type=%s", lock->fnum,
764 (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
765
766 if ( (l_curr->start >= (lock->start + lock->size)) ||
767 (lock->start >= (l_curr->start + l_curr->size))) {
768
769 /* No overlap with existing lock - leave this range alone. */
770 /*********************************************
771 +---------+
772 | l_curr |
773 +---------+
774 +-------+
775 | lock |
776 +-------+
777 OR....
778 +---------+
779 | l_curr |
780 +---------+
781 **********************************************/
782
783 DEBUG(10,(" no overlap case.\n" ));
784
785 l_curr = l_curr->next;
786
787 } else if ( (l_curr->start >= lock->start) &&
788 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
789
790 /*
791 * This range is completely overlapped by this existing lock range
792 * and thus should have no effect. Delete it from the list.
793 */
794 /*********************************************
795 +---------+
796 | l_curr |
797 +---------+
798 +---------------------------+
799 | lock |
800 +---------------------------+
801 **********************************************/
802 /* Save the next pointer */
803 struct lock_list *ul_next = l_curr->next;
804
805 DEBUG(10,(" delete case.\n" ));
806
807 DLIST_REMOVE(lhead, l_curr);
808 if(lhead == NULL) {
809 break; /* No more list... */
810 }
811
812 l_curr = ul_next;
813
814 } else if ( (l_curr->start >= lock->start) &&
815 (l_curr->start < lock->start + lock->size) &&
816 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
817
818 /*
819 * This range overlaps the existing lock range at the high end.
820 * Truncate by moving start to existing range end and reducing size.
821 */
822 /*********************************************
823 +---------------+
824 | l_curr |
825 +---------------+
826 +---------------+
827 | lock |
828 +---------------+
829 BECOMES....
830 +-------+
831 | l_curr|
832 +-------+
833 **********************************************/
834
835 l_curr->size = (l_curr->start + l_curr->size) - (lock->start + lock->size);
836 l_curr->start = lock->start + lock->size;
837
838 DEBUG(10,(" truncate high case: start=%.0f,size=%.0f\n",
839 (double)l_curr->start, (double)l_curr->size ));
840
841 l_curr = l_curr->next;
842
843 } else if ( (l_curr->start < lock->start) &&
844 (l_curr->start + l_curr->size > lock->start) &&
845 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
846
847 /*
848 * This range overlaps the existing lock range at the low end.
849 * Truncate by reducing size.
850 */
851 /*********************************************
852 +---------------+
853 | l_curr |
854 +---------------+
855 +---------------+
856 | lock |
857 +---------------+
858 BECOMES....
859 +-------+
860 | l_curr|
861 +-------+
862 **********************************************/
863
864 l_curr->size = lock->start - l_curr->start;
865
866 DEBUG(10,(" truncate low case: start=%.0f,size=%.0f\n",
867 (double)l_curr->start, (double)l_curr->size ));
868
869 l_curr = l_curr->next;
870
871 } else if ( (l_curr->start < lock->start) &&
872 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
873 /*
874 * Worst case scenario. Range completely overlaps an existing
875 * lock range. Split the request into two, push the new (upper) request
876 * into the dlink list, and continue with the entry after l_new (as we
877 * know that l_new will not overlap with this lock).
878 */
879 /*********************************************
880 +---------------------------+
881 | l_curr |
882 +---------------------------+
883 +---------+
884 | lock |
885 +---------+
886 BECOMES.....
887 +-------+ +---------+
888 | l_curr| | l_new |
889 +-------+ +---------+
890 **********************************************/
891 struct lock_list *l_new = TALLOC_P(ctx, struct lock_list);
892
893 if(l_new == NULL) {
894 DEBUG(0,("posix_lock_list: talloc fail.\n"));
895 return NULL; /* The talloc_destroy takes care of cleanup. */
896 }
897
898 ZERO_STRUCTP(l_new);
899 l_new->start = lock->start + lock->size;
900 l_new->size = l_curr->start + l_curr->size - l_new->start;
901
902 /* Truncate the l_curr. */
903 l_curr->size = lock->start - l_curr->start;
904
905 DEBUG(10,(" split case: curr: start=%.0f,size=%.0f \
906 new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
907 (double)l_new->start, (double)l_new->size ));
908
909 /*
910 * Add into the dlink list after the l_curr point - NOT at lhead.
911 */
912 DLIST_ADD_AFTER(lhead, l_new, l_curr);
913
914 /* And move after the link we added. */
915 l_curr = l_new->next;
916
917 } else {
918
919 /*
920 * This logic case should never happen. Ensure this is the
921 * case by forcing an abort.... Remove in production.
922 */
923 char *msg = NULL;
924
925 if (asprintf(&msg, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
926 lock: start = %.0f, size = %.0f", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size ) != -1) {
927 smb_panic(msg);
928 } else {
929 smb_panic("posix_lock_list");
930 }
931 }
932 } /* end for ( l_curr = lhead; l_curr;) */
933 } /* end for (i=0; i<num_locks && ul_head; i++) */
934
935 return lhead;
936 }
937
938 /****************************************************************************
939 POSIX function to acquire a lock. Returns True if the
940 lock could be granted, False if not.
941 ****************************************************************************/
942
943 bool set_posix_lock_windows_flavour(files_struct *fsp,
944 uint64_t u_offset,
945 uint64_t u_count,
946 enum brl_type lock_type,
947 const struct lock_context *lock_ctx,
948 const struct lock_struct *plocks,
949 int num_locks,
950 int *errno_ret)
951 {
952 SMB_OFF_T offset;
953 SMB_OFF_T count;
954 int posix_lock_type = map_posix_lock_type(fsp,lock_type);
955 bool ret = True;
956 size_t lock_count;
957 TALLOC_CTX *l_ctx = NULL;
958 struct lock_list *llist = NULL;
959 struct lock_list *ll = NULL;
960
961 DEBUG(5,("set_posix_lock_windows_flavour: File %s, offset = %.0f, "
962 "count = %.0f, type = %s\n", fsp_str_dbg(fsp),
963 (double)u_offset, (double)u_count,
964 posix_lock_type_name(lock_type)));
965
966 /*
967 * If the requested lock won't fit in the POSIX range, we will
968 * pretend it was successful.
969 */
970
971 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
972 increment_windows_lock_ref_count(fsp);
973 return True;
974 }
975
976 /*
977 * Windows is very strange. It allows read locks to be overlayed
978 * (even over a write lock), but leaves the write lock in force until the first
979 * unlock. It also reference counts the locks. This means the following sequence :
980 *
981 * process1 process2
982 * ------------------------------------------------------------------------
983 * WRITE LOCK : start = 2, len = 10
984 * READ LOCK: start =0, len = 10 - FAIL
985 * READ LOCK : start = 0, len = 14
986 * READ LOCK: start =0, len = 10 - FAIL
987 * UNLOCK : start = 2, len = 10
988 * READ LOCK: start =0, len = 10 - OK
989 *
990 * Under POSIX, the same sequence in steps 1 and 2 would not be reference counted, but
991 * would leave a single read lock over the 0-14 region.
992 */
993
994 if ((l_ctx = talloc_init("set_posix_lock")) == NULL) {
995 DEBUG(0,("set_posix_lock_windows_flavour: unable to init talloc context.\n"));
996 return False;
997 }
998
999 if ((ll = TALLOC_P(l_ctx, struct lock_list)) == NULL) {
1000 DEBUG(0,("set_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1001 talloc_destroy(l_ctx);
1002 return False;
1003 }
1004
1005 /*
1006 * Create the initial list entry containing the
1007 * lock we want to add.
1008 */
1009
1010 ZERO_STRUCTP(ll);
1011 ll->start = offset;
1012 ll->size = count;
1013
1014 DLIST_ADD(llist, ll);
1015
1016 /*
1017 * The following call calculates if there are any
1018 * overlapping locks held by this process on
1019 * fd's open on the same file and splits this list
1020 * into a list of lock ranges that do not overlap with existing
1021 * POSIX locks.
1022 */
1023
1024 llist = posix_lock_list(l_ctx,
1025 llist,
1026 lock_ctx, /* Lock context llist belongs to. */
1027 fsp,
1028 plocks,
1029 num_locks);
1030
1031 /*
1032 * Add the POSIX locks on the list of ranges returned.
1033 * As the lock is supposed to be added atomically, we need to
1034 * back out all the locks if any one of these calls fail.
1035 */
1036
1037 for (lock_count = 0, ll = llist; ll; ll = ll->next, lock_count++) {
1038 offset = ll->start;
1039 count = ll->size;
1040
1041 DEBUG(5,("set_posix_lock_windows_flavour: Real lock: Type = %s: offset = %.0f, count = %.0f\n",
1042 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1043
1044 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1045 *errno_ret = errno;
1046 DEBUG(5,("set_posix_lock_windows_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1047 posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1048 ret = False;
1049 break;
1050 }
1051 }
1052
1053 if (!ret) {
1054
1055 /*
1056 * Back out all the POSIX locks we have on fail.
1057 */
1058
1059 for (ll = llist; lock_count; ll = ll->next, lock_count--) {
1060 offset = ll->start;
1061 count = ll->size;
1062
1063 DEBUG(5,("set_posix_lock_windows_flavour: Backing out locks: Type = %s: offset = %.0f, count = %.0f\n",
1064 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1065
1066 posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK);
1067 }
1068 } else {
1069 /* Remember the number of Windows locks we have on this dev/ino pair. */
1070 increment_windows_lock_ref_count(fsp);
1071 }
1072
1073 talloc_destroy(l_ctx);
1074 return ret;
1075 }
1076
1077 /****************************************************************************
1078 POSIX function to release a lock. Returns True if the
1079 lock could be released, False if not.
1080 ****************************************************************************/
1081
1082 bool release_posix_lock_windows_flavour(files_struct *fsp,
1083 uint64_t u_offset,
1084 uint64_t u_count,
1085 enum brl_type deleted_lock_type,
1086 const struct lock_context *lock_ctx,
1087 const struct lock_struct *plocks,
1088 int num_locks)
1089 {
1090 SMB_OFF_T offset;
1091 SMB_OFF_T count;
1092 bool ret = True;
1093 TALLOC_CTX *ul_ctx = NULL;
1094 struct lock_list *ulist = NULL;
1095 struct lock_list *ul = NULL;
1096
1097 DEBUG(5,("release_posix_lock_windows_flavour: File %s, offset = %.0f, "
1098 "count = %.0f\n", fsp_str_dbg(fsp),
1099 (double)u_offset, (double)u_count));
1100
1101 /* Remember the number of Windows locks we have on this dev/ino pair. */
1102 decrement_windows_lock_ref_count(fsp);
1103
1104 /*
1105 * If the requested lock won't fit in the POSIX range, we will
1106 * pretend it was successful.
1107 */
1108
1109 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1110 return True;
1111 }
1112
1113 if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1114 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1115 return False;
1116 }
1117
1118 if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
1119 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1120 talloc_destroy(ul_ctx);
1121 return False;
1122 }
1123
1124 /*
1125 * Create the initial list entry containing the
1126 * lock we want to remove.
1127 */
1128
1129 ZERO_STRUCTP(ul);
1130 ul->start = offset;
1131 ul->size = count;
1132
1133 DLIST_ADD(ulist, ul);
1134
1135 /*
1136 * The following call calculates if there are any
1137 * overlapping locks held by this process on
1138 * fd's open on the same file and creates a
1139 * list of unlock ranges that will allow
1140 * POSIX lock ranges to remain on the file whilst the
1141 * unlocks are performed.
1142 */
1143
1144 ulist = posix_lock_list(ul_ctx,
1145 ulist,
1146 lock_ctx, /* Lock context ulist belongs to. */
1147 fsp,
1148 plocks,
1149 num_locks);
1150
1151 /*
1152 * If there were any overlapped entries (list is > 1 or size or start have changed),
1153 * and the lock_type we just deleted from
1154 * the upper layer tdb was a write lock, then before doing the unlock we need to downgrade
1155 * the POSIX lock to a read lock. This allows any overlapping read locks
1156 * to be atomically maintained.
1157 */
1158
1159 if (deleted_lock_type == WRITE_LOCK &&
1160 (!ulist || ulist->next != NULL || ulist->start != offset || ulist->size != count)) {
1161
1162 DEBUG(5,("release_posix_lock_windows_flavour: downgrading lock to READ: offset = %.0f, count = %.0f\n",
1163 (double)offset, (double)count ));
1164
1165 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
1166 DEBUG(0,("release_posix_lock_windows_flavour: downgrade of lock failed with error %s !\n", strerror(errno) ));
1167 talloc_destroy(ul_ctx);
1168 return False;
1169 }
1170 }
1171
1172 /*
1173 * Release the POSIX locks on the list of ranges returned.
1174 */
1175
1176 for(; ulist; ulist = ulist->next) {
1177 offset = ulist->start;
1178 count = ulist->size;
1179
1180 DEBUG(5,("release_posix_lock_windows_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1181 (double)offset, (double)count ));
1182
1183 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1184 ret = False;
1185 }
1186 }
1187
1188 talloc_destroy(ul_ctx);
1189 return ret;
1190 }
1191
1192 /****************************************************************************
1193 Next - the functions that deal with mapping CIFS POSIX locks onto
1194 the underlying system POSIX locks.
1195 ****************************************************************************/
1196
1197 /****************************************************************************
1198 POSIX function to acquire a lock. Returns True if the
1199 lock could be granted, False if not.
1200 As POSIX locks don't stack or conflict (they just overwrite)
1201 we can map the requested lock directly onto a system one. We
1202 know it doesn't conflict with locks on other contexts as the
1203 upper layer would have refused it.
1204 ****************************************************************************/
1205
1206 bool set_posix_lock_posix_flavour(files_struct *fsp,
1207 uint64_t u_offset,
1208 uint64_t u_count,
1209 enum brl_type lock_type,
1210 int *errno_ret)
1211 {
1212 SMB_OFF_T offset;
1213 SMB_OFF_T count;
1214 int posix_lock_type = map_posix_lock_type(fsp,lock_type);
1215
1216 DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %.0f, count "
1217 "= %.0f, type = %s\n", fsp_str_dbg(fsp),
1218 (double)u_offset, (double)u_count,
1219 posix_lock_type_name(lock_type)));
1220
1221 /*
1222 * If the requested lock won't fit in the POSIX range, we will
1223 * pretend it was successful.
1224 */
1225
1226 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1227 return True;
1228 }
1229
1230 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1231 *errno_ret = errno;
1232 DEBUG(5,("set_posix_lock_posix_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1233 posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1234 return False;
1235 }
1236 return True;
1237 }
1238
1239 /****************************************************************************
1240 POSIX function to release a lock. Returns True if the
1241 lock could be released, False if not.
1242 We are given a complete lock state from the upper layer which is what the lock
1243 state should be after the unlock has already been done, so what
1244 we do is punch out holes in the unlock range where locks owned by this process
1245 have a different lock context.
1246 ****************************************************************************/
1247
1248 bool release_posix_lock_posix_flavour(files_struct *fsp,
1249 uint64_t u_offset,
1250 uint64_t u_count,
1251 const struct lock_context *lock_ctx,
1252 const struct lock_struct *plocks,
1253 int num_locks)
1254 {
1255 bool ret = True;
1256 SMB_OFF_T offset;
1257 SMB_OFF_T count;
1258 TALLOC_CTX *ul_ctx = NULL;
1259 struct lock_list *ulist = NULL;
1260 struct lock_list *ul = NULL;
1261
1262 DEBUG(5,("release_posix_lock_posix_flavour: File %s, offset = %.0f, "
1263 "count = %.0f\n", fsp_str_dbg(fsp),
1264 (double)u_offset, (double)u_count));
1265
1266 /*
1267 * If the requested lock won't fit in the POSIX range, we will
1268 * pretend it was successful.
1269 */
1270
1271 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1272 return True;
1273 }
1274
1275 if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1276 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1277 return False;
1278 }
1279
1280 if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
1281 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1282 talloc_destroy(ul_ctx);
1283 return False;
1284 }
1285
1286 /*
1287 * Create the initial list entry containing the
1288 * lock we want to remove.
1289 */
1290
1291 ZERO_STRUCTP(ul);
1292 ul->start = offset;
1293 ul->size = count;
1294
1295 DLIST_ADD(ulist, ul);
1296
1297 /*
1298 * Walk the given array creating a linked list
1299 * of unlock requests.
1300 */
1301
1302 ulist = posix_lock_list(ul_ctx,
1303 ulist,
1304 lock_ctx, /* Lock context ulist belongs to. */
1305 fsp,
1306 plocks,
1307 num_locks);
1308
1309 /*
1310 * Release the POSIX locks on the list of ranges returned.
1311 */
1312
1313 for(; ulist; ulist = ulist->next) {
1314 offset = ulist->start;
1315 count = ulist->size;
1316
1317 DEBUG(5,("release_posix_lock_posix_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1318 (double)offset, (double)count ));
1319
1320 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1321 ret = False;
1322 }
1323 }
1324
1325 talloc_destroy(ul_ctx);
1326 return ret;
1327 }
Samba GIT mirror