2 Unix SMB/CIFS implementation.
4 Copyright (C) Jeremy Allison 1992-2006
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.
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.
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/>.
21 POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
27 #define DBGC_CLASS DBGC_LOCKING
30 * The pending close database handle.
33 static TDB_CONTEXT *posix_pending_close_tdb;
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 ****************************************************************************/
41 /****************************************************************************
42 Utility function to map a lock type correctly depending on the open
44 ****************************************************************************/
46 static int map_posix_lock_type( files_struct *fsp, enum brl_type lock_type)
48 if((lock_type == WRITE_LOCK) && !fsp->can_write) {
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.
54 DEBUG(10,("map_posix_lock_type: Downgrading write lock to read due to read-only file.\n"));
59 * This return should be the most normal, as we attempt
60 * to always open files read/write.
63 return (lock_type == READ_LOCK) ? F_RDLCK : F_WRLCK;
66 /****************************************************************************
68 ****************************************************************************/
70 static const char *posix_lock_type_name(int lock_type)
72 return (lock_type == F_RDLCK) ? "READ" : "WRITE";
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
79 ****************************************************************************/
81 static BOOL posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
82 SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
84 SMB_OFF_T offset = (SMB_OFF_T)u_offset;
85 SMB_OFF_T count = (SMB_OFF_T)u_count;
88 * For the type of system we are, attempt to
89 * find the maximum positive lock offset as an SMB_OFF_T.
92 #if defined(MAX_POSITIVE_LOCK_OFFSET) /* Some systems have arbitrary limits. */
94 SMB_OFF_T max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
96 #elif defined(LARGE_SMB_OFF_T) && !defined(HAVE_BROKEN_FCNTL64_LOCKS)
99 * In this case SMB_OFF_T is 64 bits,
100 * and the underlying system can handle 64 bit signed locks.
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;
107 #else /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
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.
115 SMB_OFF_T max_positive_lock_offset = 0x7FFFFFFF;
117 #endif /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
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.
125 if (count == (SMB_OFF_T)0) {
126 DEBUG(10,("posix_lock_in_range: count = 0, ignoring.\n"));
131 * If the given offset was > max_positive_lock_offset then we cannot map this at all
135 if (u_offset & ~((SMB_BIG_UINT)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)((SMB_BIG_UINT)max_positive_lock_offset) ));
142 * We must truncate the count to less than max_positive_lock_offset.
145 if (u_count & ~((SMB_BIG_UINT)max_positive_lock_offset)) {
146 count = max_positive_lock_offset;
150 * Truncate count to end at max lock offset.
153 if (offset + count < 0 || offset + count > max_positive_lock_offset) {
154 count = max_positive_lock_offset - offset;
158 * If we ate all the count, ignore this lock.
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 ));
168 * The mapping was successful.
171 DEBUG(10,("posix_lock_in_range: offset_out = %.0f, count_out = %.0f\n",
172 (double)offset, (double)count ));
174 *offset_out = offset;
180 /****************************************************************************
181 Actual function that does POSIX locks. Copes with 64 -> 32 bit cruft and
182 broken NFS implementations.
183 ****************************************************************************/
185 static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
189 DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fh->fd,op,(double)offset,(double)count,type));
191 ret = SMB_VFS_LOCK(fsp,fsp->fh->fd,op,offset,count,type);
193 if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno == EINVAL))) {
195 DEBUG(0,("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n",
196 (double)offset,(double)count));
197 DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
198 DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
201 * If the offset is > 0x7FFFFFFF then this will cause problems on
202 * 32 bit NFS mounted filesystems. Just ignore it.
205 if (offset & ~((SMB_OFF_T)0x7fffffff)) {
206 DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
210 if (count & ~((SMB_OFF_T)0x7fffffff)) {
211 /* 32 bit NFS file system, retry with smaller offset */
212 DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
215 ret = SMB_VFS_LOCK(fsp,fsp->fh->fd,op,offset,count,type);
219 DEBUG(8,("posix_fcntl_lock: Lock call %s\n", ret ? "successful" : "failed"));
223 /****************************************************************************
224 Actual function that gets POSIX locks. Copes with 64 -> 32 bit cruft and
225 broken NFS implementations.
226 ****************************************************************************/
228 static BOOL posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype)
233 DEBUG(8,("posix_fcntl_getlock %d %.0f %.0f %d\n",
234 fsp->fh->fd,(double)*poffset,(double)*pcount,*ptype));
236 ret = SMB_VFS_GETLOCK(fsp,fsp->fh->fd,poffset,pcount,ptype,&pid);
238 if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno == EINVAL))) {
240 DEBUG(0,("posix_fcntl_getlock: WARNING: lock request at offset %.0f, length %.0f returned\n",
241 (double)*poffset,(double)*pcount));
242 DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
243 DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
246 * If the offset is > 0x7FFFFFFF then this will cause problems on
247 * 32 bit NFS mounted filesystems. Just ignore it.
250 if (*poffset & ~((SMB_OFF_T)0x7fffffff)) {
251 DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
255 if (*pcount & ~((SMB_OFF_T)0x7fffffff)) {
256 /* 32 bit NFS file system, retry with smaller offset */
257 DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
259 *pcount &= 0x7fffffff;
260 ret = SMB_VFS_GETLOCK(fsp,fsp->fh->fd,poffset,pcount,ptype,&pid);
264 DEBUG(8,("posix_fcntl_getlock: Lock query call %s\n", ret ? "successful" : "failed"));
268 /****************************************************************************
269 POSIX function to see if a file region is locked. Returns True if the
270 region is locked, False otherwise.
271 ****************************************************************************/
273 BOOL is_posix_locked(files_struct *fsp,
274 SMB_BIG_UINT *pu_offset,
275 SMB_BIG_UINT *pu_count,
276 enum brl_type *plock_type,
277 enum brl_flavour lock_flav)
281 int posix_lock_type = map_posix_lock_type(fsp,*plock_type);
283 DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, type = %s\n",
284 fsp->fsp_name, (double)*pu_offset, (double)*pu_count, posix_lock_type_name(*plock_type) ));
287 * If the requested lock won't fit in the POSIX range, we will
288 * never set it, so presume it is not locked.
291 if(!posix_lock_in_range(&offset, &count, *pu_offset, *pu_count)) {
295 if (!posix_fcntl_getlock(fsp,&offset,&count,&posix_lock_type)) {
299 if (posix_lock_type == F_UNLCK) {
303 if (lock_flav == POSIX_LOCK) {
304 /* Only POSIX lock queries need to know the details. */
305 *pu_offset = (SMB_BIG_UINT)offset;
306 *pu_count = (SMB_BIG_UINT)count;
307 *plock_type = (posix_lock_type == F_RDLCK) ? READ_LOCK : WRITE_LOCK;
312 /****************************************************************************
313 Next - the functions that deal with in memory database storing representations
314 of either Windows CIFS locks or POSIX CIFS locks.
315 ****************************************************************************/
317 /* The key used in the in-memory POSIX databases. */
319 struct lock_ref_count_key {
324 /*******************************************************************
325 Form a static locking key for a dev/inode pair for the fd array.
326 ******************************************************************/
328 static TDB_DATA fd_array_key(struct file_id id)
330 static struct file_id key;
333 kbuf.dptr = (uint8 *)&key;
334 kbuf.dsize = sizeof(key);
338 /*******************************************************************
339 Form a static locking key for a dev/inode pair for the lock ref count
340 ******************************************************************/
342 static TDB_DATA locking_ref_count_key(struct file_id id)
344 static struct lock_ref_count_key key;
347 memset(&key, '\0', sizeof(key));
350 kbuf.dptr = (uint8 *)&key;
351 kbuf.dsize = sizeof(key);
355 /*******************************************************************
356 Convenience function to get an fd_array key from an fsp.
357 ******************************************************************/
359 static TDB_DATA fd_array_key_fsp(files_struct *fsp)
361 return fd_array_key(fsp->file_id);
364 /*******************************************************************
365 Convenience function to get a lock ref count key from an fsp.
366 ******************************************************************/
368 static TDB_DATA locking_ref_count_key_fsp(files_struct *fsp)
370 return locking_ref_count_key(fsp->file_id);
373 /*******************************************************************
374 Create the in-memory POSIX lock databases.
375 ********************************************************************/
377 BOOL posix_locking_init(int read_only)
379 if (posix_pending_close_tdb) {
383 if (!posix_pending_close_tdb) {
384 posix_pending_close_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL,
385 read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644);
387 if (!posix_pending_close_tdb) {
388 DEBUG(0,("Failed to open POSIX pending close database.\n"));
395 /*******************************************************************
396 Delete the in-memory POSIX lock databases.
397 ********************************************************************/
399 BOOL posix_locking_end(void)
401 if (posix_pending_close_tdb && tdb_close(posix_pending_close_tdb) != 0) {
407 /****************************************************************************
408 Next - the functions that deal with storing fd's that have outstanding
409 POSIX locks when closed.
410 ****************************************************************************/
412 /****************************************************************************
413 The records in posix_pending_close_tdb are composed of an array of ints
414 keyed by dev/ino pair.
415 The first int is a reference count of the number of outstanding locks on
416 all open fd's on this dev/ino pair. Any subsequent ints are the fd's that
417 were open on this dev/ino pair that should have been closed, but can't as
418 the lock ref count is non zero.
419 ****************************************************************************/
421 /****************************************************************************
422 Keep a reference count of the number of Windows locks open on this dev/ino
423 pair. Creates entry if it doesn't exist.
424 ****************************************************************************/
426 static void increment_windows_lock_ref_count(files_struct *fsp)
428 TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
432 dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
433 if (dbuf.dptr == NULL) {
434 dbuf.dptr = (uint8 *)SMB_MALLOC_P(int);
436 smb_panic("increment_windows_lock_ref_count: malloc fail");
438 memset(dbuf.dptr, '\0', sizeof(int));
439 dbuf.dsize = sizeof(int);
442 memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
444 memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
446 if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
447 smb_panic("increment_windows_lock_ref_count: tdb_store_fail");
449 SAFE_FREE(dbuf.dptr);
451 DEBUG(10,("increment_windows_lock_ref_count for file now %s = %d\n",
452 fsp->fsp_name, lock_ref_count ));
455 static void decrement_windows_lock_ref_count(files_struct *fsp)
457 TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
461 dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
463 smb_panic("decrement_windows_lock_ref_count: logic error");
466 memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
468 memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
470 if (lock_ref_count < 0) {
471 smb_panic("decrement_windows_lock_ref_count: lock_count logic error");
474 if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
475 smb_panic("decrement_windows_lock_ref_count: tdb_store_fail");
477 SAFE_FREE(dbuf.dptr);
479 DEBUG(10,("decrement_windows_lock_ref_count for file now %s = %d\n",
480 fsp->fsp_name, lock_ref_count ));
483 /****************************************************************************
484 Bulk delete - subtract as many locks as we've just deleted.
485 ****************************************************************************/
487 void reduce_windows_lock_ref_count(files_struct *fsp, unsigned int dcount)
489 TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
493 dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
498 memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
499 lock_ref_count -= dcount;
501 if (lock_ref_count < 0) {
502 smb_panic("reduce_windows_lock_ref_count: lock_count logic error");
504 memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
506 if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
507 smb_panic("reduce_windows_lock_ref_count: tdb_store_fail");
509 SAFE_FREE(dbuf.dptr);
511 DEBUG(10,("reduce_windows_lock_ref_count for file now %s = %d\n",
512 fsp->fsp_name, lock_ref_count ));
515 /****************************************************************************
516 Fetch the lock ref count.
517 ****************************************************************************/
519 static int get_windows_lock_ref_count(files_struct *fsp)
521 TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
525 dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
529 memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
531 SAFE_FREE(dbuf.dptr);
533 DEBUG(10,("get_windows_lock_count for file %s = %d\n",
534 fsp->fsp_name, lock_ref_count ));
535 return lock_ref_count;
538 /****************************************************************************
539 Delete a lock_ref_count entry.
540 ****************************************************************************/
542 static void delete_windows_lock_ref_count(files_struct *fsp)
544 TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
546 /* Not a bug if it doesn't exist - no locks were ever granted. */
547 tdb_delete(posix_pending_close_tdb, kbuf);
548 DEBUG(10,("delete_windows_lock_ref_count for file %s\n", fsp->fsp_name));
551 /****************************************************************************
552 Add an fd to the pending close tdb.
553 ****************************************************************************/
555 static void add_fd_to_close_entry(files_struct *fsp)
557 TDB_DATA kbuf = fd_array_key_fsp(fsp);
563 dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
565 dbuf.dptr = (uint8 *)SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(int));
567 smb_panic("add_fd_to_close_entry: SMB_REALLOC failed");
570 memcpy(dbuf.dptr + dbuf.dsize, &fsp->fh->fd, sizeof(int));
571 dbuf.dsize += sizeof(int);
573 if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
574 smb_panic("add_fd_to_close_entry: tdb_store_fail");
577 DEBUG(10,("add_fd_to_close_entry: added fd %d file %s\n",
578 fsp->fh->fd, fsp->fsp_name ));
580 SAFE_FREE(dbuf.dptr);
583 /****************************************************************************
584 Remove all fd entries for a specific dev/inode pair from the tdb.
585 ****************************************************************************/
587 static void delete_close_entries(files_struct *fsp)
589 TDB_DATA kbuf = fd_array_key_fsp(fsp);
591 if (tdb_delete(posix_pending_close_tdb, kbuf) == -1) {
592 smb_panic("delete_close_entries: tdb_delete failed");
596 /****************************************************************************
597 Get the array of POSIX pending close records for an open fsp. Caller must
598 free. Returns number of entries.
599 ****************************************************************************/
601 static size_t get_posix_pending_close_entries(files_struct *fsp, int **entries)
603 TDB_DATA kbuf = fd_array_key_fsp(fsp);
610 dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
616 *entries = (int *)dbuf.dptr;
617 count = (size_t)(dbuf.dsize / sizeof(int));
622 /****************************************************************************
623 Deal with pending closes needed by POSIX locking support.
624 Note that posix_locking_close_file() is expected to have been called
625 to delete all locks on this fsp before this function is called.
626 ****************************************************************************/
628 NTSTATUS fd_close_posix(struct connection_struct *conn, files_struct *fsp)
632 int *fd_array = NULL;
635 if (!lp_locking(fsp->conn->params) || !lp_posix_locking(conn->params)) {
637 * No locking or POSIX to worry about or we want POSIX semantics
638 * which will lose all locks on all fd's open on this dev/inode,
641 ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
644 return map_nt_error_from_unix(errno);
649 if (get_windows_lock_ref_count(fsp)) {
652 * There are outstanding locks on this dev/inode pair on other fds.
653 * Add our fd to the pending close tdb and set fsp->fh->fd to -1.
656 add_fd_to_close_entry(fsp);
662 * No outstanding locks. Get the pending close fd's
663 * from the tdb and close them all.
666 count = get_posix_pending_close_entries(fsp, &fd_array);
669 DEBUG(10,("fd_close_posix: doing close on %u fd's.\n", (unsigned int)count ));
671 for(i = 0; i < count; i++) {
672 if (SMB_VFS_CLOSE(fsp,fd_array[i]) == -1) {
678 * Delete all fd's stored in the tdb
679 * for this dev/inode pair.
682 delete_close_entries(fsp);
687 /* Don't need a lock ref count on this dev/ino anymore. */
688 delete_windows_lock_ref_count(fsp);
691 * Finally close the fd associated with this fsp.
694 ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
696 if (ret == 0 && saved_errno != 0) {
704 return map_nt_error_from_unix(errno);
710 /****************************************************************************
711 Next - the functions that deal with the mapping CIFS Windows locks onto
712 the underlying system POSIX locks.
713 ****************************************************************************/
716 * Structure used when splitting a lock range
717 * into a POSIX lock range. Doubly linked list.
721 struct lock_list *next;
722 struct lock_list *prev;
727 /****************************************************************************
728 Create a list of lock ranges that don't overlap a given range. Used in calculating
729 POSIX locks and unlocks. This is a difficult function that requires ASCII art to
731 ****************************************************************************/
733 static struct lock_list *posix_lock_list(TALLOC_CTX *ctx,
734 struct lock_list *lhead,
735 const struct lock_context *lock_ctx, /* Lock context lhead belongs to. */
737 const struct lock_struct *plocks,
743 * Check the current lock list on this dev/inode pair.
744 * Quit if the list is deleted.
747 DEBUG(10,("posix_lock_list: curr: start=%.0f,size=%.0f\n",
748 (double)lhead->start, (double)lhead->size ));
750 for (i=0; i<num_locks && lhead; i++) {
751 const struct lock_struct *lock = &plocks[i];
752 struct lock_list *l_curr;
754 /* Ignore all but read/write locks. */
755 if (lock->lock_type != READ_LOCK && lock->lock_type != WRITE_LOCK) {
759 /* Ignore locks not owned by this process. */
760 if (!procid_equal(&lock->context.pid, &lock_ctx->pid)) {
765 * Walk the lock list, checking for overlaps. Note that
766 * the lock list can expand within this loop if the current
767 * range being examined needs to be split.
770 for (l_curr = lhead; l_curr;) {
772 DEBUG(10,("posix_lock_list: lock: fnum=%d: start=%.0f,size=%.0f:type=%s", lock->fnum,
773 (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
775 if ( (l_curr->start >= (lock->start + lock->size)) ||
776 (lock->start >= (l_curr->start + l_curr->size))) {
778 /* No overlap with existing lock - leave this range alone. */
779 /*********************************************
790 **********************************************/
792 DEBUG(10,(" no overlap case.\n" ));
794 l_curr = l_curr->next;
796 } else if ( (l_curr->start >= lock->start) &&
797 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
800 * This range is completely overlapped by this existing lock range
801 * and thus should have no effect. Delete it from the list.
803 /*********************************************
807 +---------------------------+
809 +---------------------------+
810 **********************************************/
811 /* Save the next pointer */
812 struct lock_list *ul_next = l_curr->next;
814 DEBUG(10,(" delete case.\n" ));
816 DLIST_REMOVE(lhead, l_curr);
818 break; /* No more list... */
823 } else if ( (l_curr->start >= lock->start) &&
824 (l_curr->start < lock->start + lock->size) &&
825 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
828 * This range overlaps the existing lock range at the high end.
829 * Truncate by moving start to existing range end and reducing size.
831 /*********************************************
842 **********************************************/
844 l_curr->size = (l_curr->start + l_curr->size) - (lock->start + lock->size);
845 l_curr->start = lock->start + lock->size;
847 DEBUG(10,(" truncate high case: start=%.0f,size=%.0f\n",
848 (double)l_curr->start, (double)l_curr->size ));
850 l_curr = l_curr->next;
852 } else if ( (l_curr->start < lock->start) &&
853 (l_curr->start + l_curr->size > lock->start) &&
854 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
857 * This range overlaps the existing lock range at the low end.
858 * Truncate by reducing size.
860 /*********************************************
871 **********************************************/
873 l_curr->size = lock->start - l_curr->start;
875 DEBUG(10,(" truncate low case: start=%.0f,size=%.0f\n",
876 (double)l_curr->start, (double)l_curr->size ));
878 l_curr = l_curr->next;
880 } else if ( (l_curr->start < lock->start) &&
881 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
883 * Worst case scenario. Range completely overlaps an existing
884 * lock range. Split the request into two, push the new (upper) request
885 * into the dlink list, and continue with the entry after l_new (as we
886 * know that l_new will not overlap with this lock).
888 /*********************************************
889 +---------------------------+
891 +---------------------------+
896 +-------+ +---------+
898 +-------+ +---------+
899 **********************************************/
900 struct lock_list *l_new = TALLOC_P(ctx, struct lock_list);
903 DEBUG(0,("posix_lock_list: talloc fail.\n"));
904 return NULL; /* The talloc_destroy takes care of cleanup. */
908 l_new->start = lock->start + lock->size;
909 l_new->size = l_curr->start + l_curr->size - l_new->start;
911 /* Truncate the l_curr. */
912 l_curr->size = lock->start - l_curr->start;
914 DEBUG(10,(" split case: curr: start=%.0f,size=%.0f \
915 new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
916 (double)l_new->start, (double)l_new->size ));
919 * Add into the dlink list after the l_curr point - NOT at lhead.
920 * Note we can't use DLINK_ADD here as this inserts at the head of the given list.
923 l_new->prev = l_curr;
924 l_new->next = l_curr->next;
925 l_curr->next = l_new;
927 /* And move after the link we added. */
928 l_curr = l_new->next;
933 * This logic case should never happen. Ensure this is the
934 * case by forcing an abort.... Remove in production.
938 slprintf(msg, sizeof(msg)-1, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
939 lock: start = %.0f, size = %.0f", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size );
943 } /* end for ( l_curr = lhead; l_curr;) */
944 } /* end for (i=0; i<num_locks && ul_head; i++) */
949 /****************************************************************************
950 POSIX function to acquire a lock. Returns True if the
951 lock could be granted, False if not.
952 ****************************************************************************/
954 BOOL set_posix_lock_windows_flavour(files_struct *fsp,
955 SMB_BIG_UINT u_offset,
956 SMB_BIG_UINT u_count,
957 enum brl_type lock_type,
958 const struct lock_context *lock_ctx,
959 const struct lock_struct *plocks,
965 int posix_lock_type = map_posix_lock_type(fsp,lock_type);
968 TALLOC_CTX *l_ctx = NULL;
969 struct lock_list *llist = NULL;
970 struct lock_list *ll = NULL;
972 DEBUG(5,("set_posix_lock_windows_flavour: File %s, offset = %.0f, count = %.0f, type = %s\n",
973 fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
976 * If the requested lock won't fit in the POSIX range, we will
977 * pretend it was successful.
980 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
981 increment_windows_lock_ref_count(fsp);
986 * Windows is very strange. It allows read locks to be overlayed
987 * (even over a write lock), but leaves the write lock in force until the first
988 * unlock. It also reference counts the locks. This means the following sequence :
991 * ------------------------------------------------------------------------
992 * WRITE LOCK : start = 2, len = 10
993 * READ LOCK: start =0, len = 10 - FAIL
994 * READ LOCK : start = 0, len = 14
995 * READ LOCK: start =0, len = 10 - FAIL
996 * UNLOCK : start = 2, len = 10
997 * READ LOCK: start =0, len = 10 - OK
999 * Under POSIX, the same sequence in steps 1 and 2 would not be reference counted, but
1000 * would leave a single read lock over the 0-14 region.
1003 if ((l_ctx = talloc_init("set_posix_lock")) == NULL) {
1004 DEBUG(0,("set_posix_lock_windows_flavour: unable to init talloc context.\n"));
1008 if ((ll = TALLOC_P(l_ctx, struct lock_list)) == NULL) {
1009 DEBUG(0,("set_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1010 talloc_destroy(l_ctx);
1015 * Create the initial list entry containing the
1016 * lock we want to add.
1023 DLIST_ADD(llist, ll);
1026 * The following call calculates if there are any
1027 * overlapping locks held by this process on
1028 * fd's open on the same file and splits this list
1029 * into a list of lock ranges that do not overlap with existing
1033 llist = posix_lock_list(l_ctx,
1035 lock_ctx, /* Lock context llist belongs to. */
1041 * Add the POSIX locks on the list of ranges returned.
1042 * As the lock is supposed to be added atomically, we need to
1043 * back out all the locks if any one of these calls fail.
1046 for (lock_count = 0, ll = llist; ll; ll = ll->next, lock_count++) {
1050 DEBUG(5,("set_posix_lock_windows_flavour: Real lock: Type = %s: offset = %.0f, count = %.0f\n",
1051 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1053 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1055 DEBUG(5,("set_posix_lock_windows_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1056 posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1065 * Back out all the POSIX locks we have on fail.
1068 for (ll = llist; lock_count; ll = ll->next, lock_count--) {
1072 DEBUG(5,("set_posix_lock_windows_flavour: Backing out locks: Type = %s: offset = %.0f, count = %.0f\n",
1073 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1075 posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK);
1078 /* Remember the number of Windows locks we have on this dev/ino pair. */
1079 increment_windows_lock_ref_count(fsp);
1082 talloc_destroy(l_ctx);
1086 /****************************************************************************
1087 POSIX function to release a lock. Returns True if the
1088 lock could be released, False if not.
1089 ****************************************************************************/
1091 BOOL release_posix_lock_windows_flavour(files_struct *fsp,
1092 SMB_BIG_UINT u_offset,
1093 SMB_BIG_UINT u_count,
1094 enum brl_type deleted_lock_type,
1095 const struct lock_context *lock_ctx,
1096 const struct lock_struct *plocks,
1102 TALLOC_CTX *ul_ctx = NULL;
1103 struct lock_list *ulist = NULL;
1104 struct lock_list *ul = NULL;
1106 DEBUG(5,("release_posix_lock_windows_flavour: File %s, offset = %.0f, count = %.0f\n",
1107 fsp->fsp_name, (double)u_offset, (double)u_count ));
1109 /* Remember the number of Windows locks we have on this dev/ino pair. */
1110 decrement_windows_lock_ref_count(fsp);
1113 * If the requested lock won't fit in the POSIX range, we will
1114 * pretend it was successful.
1117 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1121 if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1122 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1126 if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
1127 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1128 talloc_destroy(ul_ctx);
1133 * Create the initial list entry containing the
1134 * lock we want to remove.
1141 DLIST_ADD(ulist, ul);
1144 * The following call calculates if there are any
1145 * overlapping locks held by this process on
1146 * fd's open on the same file and creates a
1147 * list of unlock ranges that will allow
1148 * POSIX lock ranges to remain on the file whilst the
1149 * unlocks are performed.
1152 ulist = posix_lock_list(ul_ctx,
1154 lock_ctx, /* Lock context ulist belongs to. */
1160 * If there were any overlapped entries (list is > 1 or size or start have changed),
1161 * and the lock_type we just deleted from
1162 * the upper layer tdb was a write lock, then before doing the unlock we need to downgrade
1163 * the POSIX lock to a read lock. This allows any overlapping read locks
1164 * to be atomically maintained.
1167 if (deleted_lock_type == WRITE_LOCK &&
1168 (!ulist || ulist->next != NULL || ulist->start != offset || ulist->size != count)) {
1170 DEBUG(5,("release_posix_lock_windows_flavour: downgrading lock to READ: offset = %.0f, count = %.0f\n",
1171 (double)offset, (double)count ));
1173 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
1174 DEBUG(0,("release_posix_lock_windows_flavour: downgrade of lock failed with error %s !\n", strerror(errno) ));
1175 talloc_destroy(ul_ctx);
1181 * Release the POSIX locks on the list of ranges returned.
1184 for(; ulist; ulist = ulist->next) {
1185 offset = ulist->start;
1186 count = ulist->size;
1188 DEBUG(5,("release_posix_lock_windows_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1189 (double)offset, (double)count ));
1191 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1196 talloc_destroy(ul_ctx);
1200 /****************************************************************************
1201 Next - the functions that deal with mapping CIFS POSIX locks onto
1202 the underlying system POSIX locks.
1203 ****************************************************************************/
1205 /****************************************************************************
1206 POSIX function to acquire a lock. Returns True if the
1207 lock could be granted, False if not.
1208 As POSIX locks don't stack or conflict (they just overwrite)
1209 we can map the requested lock directly onto a system one. We
1210 know it doesn't conflict with locks on other contexts as the
1211 upper layer would have refused it.
1212 ****************************************************************************/
1214 BOOL set_posix_lock_posix_flavour(files_struct *fsp,
1215 SMB_BIG_UINT u_offset,
1216 SMB_BIG_UINT u_count,
1217 enum brl_type lock_type,
1222 int posix_lock_type = map_posix_lock_type(fsp,lock_type);
1224 DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %.0f, count = %.0f, type = %s\n",
1225 fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
1228 * If the requested lock won't fit in the POSIX range, we will
1229 * pretend it was successful.
1232 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1236 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1238 DEBUG(5,("set_posix_lock_posix_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1239 posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1245 /****************************************************************************
1246 POSIX function to release a lock. Returns True if the
1247 lock could be released, False if not.
1248 We are given a complete lock state from the upper layer which is what the lock
1249 state should be after the unlock has already been done, so what
1250 we do is punch out holes in the unlock range where locks owned by this process
1251 have a different lock context.
1252 ****************************************************************************/
1254 BOOL release_posix_lock_posix_flavour(files_struct *fsp,
1255 SMB_BIG_UINT u_offset,
1256 SMB_BIG_UINT u_count,
1257 const struct lock_context *lock_ctx,
1258 const struct lock_struct *plocks,
1264 TALLOC_CTX *ul_ctx = NULL;
1265 struct lock_list *ulist = NULL;
1266 struct lock_list *ul = NULL;
1268 DEBUG(5,("release_posix_lock_posix_flavour: File %s, offset = %.0f, count = %.0f\n",
1269 fsp->fsp_name, (double)u_offset, (double)u_count ));
1272 * If the requested lock won't fit in the POSIX range, we will
1273 * pretend it was successful.
1276 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1280 if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1281 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1285 if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
1286 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1287 talloc_destroy(ul_ctx);
1292 * Create the initial list entry containing the
1293 * lock we want to remove.
1300 DLIST_ADD(ulist, ul);
1303 * Walk the given array creating a linked list
1304 * of unlock requests.
1307 ulist = posix_lock_list(ul_ctx,
1309 lock_ctx, /* Lock context ulist belongs to. */
1315 * Release the POSIX locks on the list of ranges returned.
1318 for(; ulist; ulist = ulist->next) {
1319 offset = ulist->start;
1320 count = ulist->size;
1322 DEBUG(5,("release_posix_lock_posix_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1323 (double)offset, (double)count ));
1325 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1330 talloc_destroy(ul_ctx);