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