1 /* 2 * linux/fs/locks.c 3 * 4 * Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls. 5 * Doug Evans (dje@spiff.uucp), August 07, 1992 6 * 7 * Deadlock detection added. 8 * FIXME: one thing isn't handled yet: 9 * - mandatory locks (requires lots of changes elsewhere) 10 * Kelly Carmichael (kelly@[142.24.8.65]), September 17, 1994. 11 * 12 * Miscellaneous edits, and a total rewrite of posix_lock_file() code. 13 * Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994 14 * 15 * Converted file_lock_table to a linked list from an array, which eliminates 16 * the limits on how many active file locks are open. 17 * Chad Page (pageone@netcom.com), November 27, 1994 18 * 19 * Removed dependency on file descriptors. dup()'ed file descriptors now 20 * get the same locks as the original file descriptors, and a close() on 21 * any file descriptor removes ALL the locks on the file for the current 22 * process. Since locks still depend on the process id, locks are inherited 23 * after an exec() but not after a fork(). This agrees with POSIX, and both 24 * BSD and SVR4 practice. 25 * Andy Walker (andy@lysaker.kvaerner.no), February 14, 1995 26 * 27 * Scrapped free list which is redundant now that we allocate locks 28 * dynamically with kmalloc()/kfree(). 29 * Andy Walker (andy@lysaker.kvaerner.no), February 21, 1995 30 * 31 * Implemented two lock personalities - FL_FLOCK and FL_POSIX. 32 * 33 * FL_POSIX locks are created with calls to fcntl() and lockf() through the 34 * fcntl() system call. They have the semantics described above. 35 * 36 * FL_FLOCK locks are created with calls to flock(), through the flock() 37 * system call, which is new. Old C libraries implement flock() via fcntl() 38 * and will continue to use the old, broken implementation. 39 * 40 * FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated 41 * with a file pointer (filp). As a result they can be shared by a parent 42 * process and its children after a fork(). They are removed when the last 43 * file descriptor referring to the file pointer is closed (unless explicitly 44 * unlocked). 45 * 46 * FL_FLOCK locks never deadlock, an existing lock is always removed before 47 * upgrading from shared to exclusive (or vice versa). When this happens 48 * any processes blocked by the current lock are woken up and allowed to 49 * run before the new lock is applied. 50 * Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995 51 * 52 * Removed some race conditions in flock_lock_file(), marked other possible 53 * races. Just grep for FIXME to see them. 54 * Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996. 55 * 56 * Addressed Dmitry's concerns. Deadlock checking no longer recursive. 57 * Lock allocation changed to GFP_ATOMIC as we can't afford to sleep 58 * once we've checked for blocking and deadlocking. 59 * Andy Walker (andy@lysaker.kvaerner.no), April 03, 1996. 60 * 61 * Initial implementation of mandatory locks. SunOS turned out to be 62 * a rotten model, so I implemented the "obvious" semantics. 63 * See 'Documentation/mandatory.txt' for details. 64 * Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996. 65 * 66 * Don't allow mandatory locks on mmap()'ed files. Added simple functions to 67 * check if a file has mandatory locks, used by mmap(), open() and creat() to 68 * see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference 69 * Manual, Section 2. 70 * Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996. 71 * 72 * Tidied up block list handling. Added '/proc/locks' interface. 73 * Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996. 74 * 75 * Fixed deadlock condition for pathological code that mixes calls to 76 * flock() and fcntl(). 77 * Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996. 78 * 79 * Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use 80 * for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to 81 * guarantee sensible behaviour in the case where file system modules might 82 * be compiled with different options than the kernel itself. 83 * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996. 84 * 85 * Added a couple of missing wake_up() calls. Thanks to Thomas Meckel 86 * (Thomas.Meckel@mni.fh-giessen.de) for spotting this. 87 * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996. 88 * 89 * Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK 90 * locks. Changed process synchronisation to avoid dereferencing locks that 91 * have already been freed. 92 * Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996. 93 * 94 * Made the block list a circular list to minimise searching in the list. 95 * Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996. 96 * 97 * Made mandatory locking a mount option. Default is not to allow mandatory 98 * locking. 99 * Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996. 100 * 101 * Some adaptations for NFS support. 102 * Olaf Kirch (okir@monad.swb.de), Dec 1996, 103 * 104 * Fixed /proc/locks interface so that we can't overrun the buffer we are handed. 105 * Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997. 106 * 107 * Use slab allocator instead of kmalloc/kfree. 108 * Use generic list implementation from <linux/list.h>. 109 * Sped up posix_locks_deadlock by only considering blocked locks. 110 * Matthew Wilcox <willy@debian.org>, March, 2000. 111 * 112 * Leases and LOCK_MAND 113 * Matthew Wilcox <willy@debian.org>, June, 2000. 114 * Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000. 115 */ 116 117 #include <linux/capability.h> 118 #include <linux/file.h> 119 #include <linux/fs.h> 120 #include <linux/init.h> 121 #include <linux/module.h> 122 #include <linux/security.h> 123 #include <linux/slab.h> 124 #include <linux/smp_lock.h> 125 #include <linux/syscalls.h> 126 #include <linux/time.h> 127 #include <linux/rcupdate.h> 128 129 #include <asm/semaphore.h> 130 #include <asm/uaccess.h> 131 132 #define IS_POSIX(fl) (fl->fl_flags & FL_POSIX) 133 #define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK) 134 #define IS_LEASE(fl) (fl->fl_flags & FL_LEASE) 135 136 int leases_enable = 1; 137 int lease_break_time = 45; 138 139 #define for_each_lock(inode, lockp) \ 140 for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next) 141 142 static LIST_HEAD(file_lock_list); 143 static LIST_HEAD(blocked_list); 144 145 static struct kmem_cache *filelock_cache __read_mostly; 146 147 /* Allocate an empty lock structure. */ 148 static struct file_lock *locks_alloc_lock(void) 149 { 150 return kmem_cache_alloc(filelock_cache, GFP_KERNEL); 151 } 152 153 static void locks_release_private(struct file_lock *fl) 154 { 155 if (fl->fl_ops) { 156 if (fl->fl_ops->fl_release_private) 157 fl->fl_ops->fl_release_private(fl); 158 fl->fl_ops = NULL; 159 } 160 if (fl->fl_lmops) { 161 if (fl->fl_lmops->fl_release_private) 162 fl->fl_lmops->fl_release_private(fl); 163 fl->fl_lmops = NULL; 164 } 165 166 } 167 168 /* Free a lock which is not in use. */ 169 static void locks_free_lock(struct file_lock *fl) 170 { 171 BUG_ON(waitqueue_active(&fl->fl_wait)); 172 BUG_ON(!list_empty(&fl->fl_block)); 173 BUG_ON(!list_empty(&fl->fl_link)); 174 175 locks_release_private(fl); 176 kmem_cache_free(filelock_cache, fl); 177 } 178 179 void locks_init_lock(struct file_lock *fl) 180 { 181 INIT_LIST_HEAD(&fl->fl_link); 182 INIT_LIST_HEAD(&fl->fl_block); 183 init_waitqueue_head(&fl->fl_wait); 184 fl->fl_next = NULL; 185 fl->fl_fasync = NULL; 186 fl->fl_owner = NULL; 187 fl->fl_pid = 0; 188 fl->fl_file = NULL; 189 fl->fl_flags = 0; 190 fl->fl_type = 0; 191 fl->fl_start = fl->fl_end = 0; 192 fl->fl_ops = NULL; 193 fl->fl_lmops = NULL; 194 } 195 196 EXPORT_SYMBOL(locks_init_lock); 197 198 /* 199 * Initialises the fields of the file lock which are invariant for 200 * free file_locks. 201 */ 202 static void init_once(void *foo, struct kmem_cache *cache, unsigned long flags) 203 { 204 struct file_lock *lock = (struct file_lock *) foo; 205 206 if (!(flags & SLAB_CTOR_CONSTRUCTOR)) 207 return; 208 209 locks_init_lock(lock); 210 } 211 212 static void locks_copy_private(struct file_lock *new, struct file_lock *fl) 213 { 214 if (fl->fl_ops) { 215 if (fl->fl_ops->fl_copy_lock) 216 fl->fl_ops->fl_copy_lock(new, fl); 217 new->fl_ops = fl->fl_ops; 218 } 219 if (fl->fl_lmops) { 220 if (fl->fl_lmops->fl_copy_lock) 221 fl->fl_lmops->fl_copy_lock(new, fl); 222 new->fl_lmops = fl->fl_lmops; 223 } 224 } 225 226 /* 227 * Initialize a new lock from an existing file_lock structure. 228 */ 229 static void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl) 230 { 231 new->fl_owner = fl->fl_owner; 232 new->fl_pid = fl->fl_pid; 233 new->fl_file = NULL; 234 new->fl_flags = fl->fl_flags; 235 new->fl_type = fl->fl_type; 236 new->fl_start = fl->fl_start; 237 new->fl_end = fl->fl_end; 238 new->fl_ops = NULL; 239 new->fl_lmops = NULL; 240 } 241 242 void locks_copy_lock(struct file_lock *new, struct file_lock *fl) 243 { 244 locks_release_private(new); 245 246 __locks_copy_lock(new, fl); 247 new->fl_file = fl->fl_file; 248 new->fl_ops = fl->fl_ops; 249 new->fl_lmops = fl->fl_lmops; 250 251 locks_copy_private(new, fl); 252 } 253 254 EXPORT_SYMBOL(locks_copy_lock); 255 256 static inline int flock_translate_cmd(int cmd) { 257 if (cmd & LOCK_MAND) 258 return cmd & (LOCK_MAND | LOCK_RW); 259 switch (cmd) { 260 case LOCK_SH: 261 return F_RDLCK; 262 case LOCK_EX: 263 return F_WRLCK; 264 case LOCK_UN: 265 return F_UNLCK; 266 } 267 return -EINVAL; 268 } 269 270 /* Fill in a file_lock structure with an appropriate FLOCK lock. */ 271 static int flock_make_lock(struct file *filp, struct file_lock **lock, 272 unsigned int cmd) 273 { 274 struct file_lock *fl; 275 int type = flock_translate_cmd(cmd); 276 if (type < 0) 277 return type; 278 279 fl = locks_alloc_lock(); 280 if (fl == NULL) 281 return -ENOMEM; 282 283 fl->fl_file = filp; 284 fl->fl_pid = current->tgid; 285 fl->fl_flags = FL_FLOCK; 286 fl->fl_type = type; 287 fl->fl_end = OFFSET_MAX; 288 289 *lock = fl; 290 return 0; 291 } 292 293 static int assign_type(struct file_lock *fl, int type) 294 { 295 switch (type) { 296 case F_RDLCK: 297 case F_WRLCK: 298 case F_UNLCK: 299 fl->fl_type = type; 300 break; 301 default: 302 return -EINVAL; 303 } 304 return 0; 305 } 306 307 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX 308 * style lock. 309 */ 310 static int flock_to_posix_lock(struct file *filp, struct file_lock *fl, 311 struct flock *l) 312 { 313 off_t start, end; 314 315 switch (l->l_whence) { 316 case SEEK_SET: 317 start = 0; 318 break; 319 case SEEK_CUR: 320 start = filp->f_pos; 321 break; 322 case SEEK_END: 323 start = i_size_read(filp->f_path.dentry->d_inode); 324 break; 325 default: 326 return -EINVAL; 327 } 328 329 /* POSIX-1996 leaves the case l->l_len < 0 undefined; 330 POSIX-2001 defines it. */ 331 start += l->l_start; 332 if (start < 0) 333 return -EINVAL; 334 fl->fl_end = OFFSET_MAX; 335 if (l->l_len > 0) { 336 end = start + l->l_len - 1; 337 fl->fl_end = end; 338 } else if (l->l_len < 0) { 339 end = start - 1; 340 fl->fl_end = end; 341 start += l->l_len; 342 if (start < 0) 343 return -EINVAL; 344 } 345 fl->fl_start = start; /* we record the absolute position */ 346 if (fl->fl_end < fl->fl_start) 347 return -EOVERFLOW; 348 349 fl->fl_owner = current->files; 350 fl->fl_pid = current->tgid; 351 fl->fl_file = filp; 352 fl->fl_flags = FL_POSIX; 353 fl->fl_ops = NULL; 354 fl->fl_lmops = NULL; 355 356 return assign_type(fl, l->l_type); 357 } 358 359 #if BITS_PER_LONG == 32 360 static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, 361 struct flock64 *l) 362 { 363 loff_t start; 364 365 switch (l->l_whence) { 366 case SEEK_SET: 367 start = 0; 368 break; 369 case SEEK_CUR: 370 start = filp->f_pos; 371 break; 372 case SEEK_END: 373 start = i_size_read(filp->f_path.dentry->d_inode); 374 break; 375 default: 376 return -EINVAL; 377 } 378 379 start += l->l_start; 380 if (start < 0) 381 return -EINVAL; 382 fl->fl_end = OFFSET_MAX; 383 if (l->l_len > 0) { 384 fl->fl_end = start + l->l_len - 1; 385 } else if (l->l_len < 0) { 386 fl->fl_end = start - 1; 387 start += l->l_len; 388 if (start < 0) 389 return -EINVAL; 390 } 391 fl->fl_start = start; /* we record the absolute position */ 392 if (fl->fl_end < fl->fl_start) 393 return -EOVERFLOW; 394 395 fl->fl_owner = current->files; 396 fl->fl_pid = current->tgid; 397 fl->fl_file = filp; 398 fl->fl_flags = FL_POSIX; 399 fl->fl_ops = NULL; 400 fl->fl_lmops = NULL; 401 402 switch (l->l_type) { 403 case F_RDLCK: 404 case F_WRLCK: 405 case F_UNLCK: 406 fl->fl_type = l->l_type; 407 break; 408 default: 409 return -EINVAL; 410 } 411 412 return (0); 413 } 414 #endif 415 416 /* default lease lock manager operations */ 417 static void lease_break_callback(struct file_lock *fl) 418 { 419 kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG); 420 } 421 422 static void lease_release_private_callback(struct file_lock *fl) 423 { 424 if (!fl->fl_file) 425 return; 426 427 f_delown(fl->fl_file); 428 fl->fl_file->f_owner.signum = 0; 429 } 430 431 static int lease_mylease_callback(struct file_lock *fl, struct file_lock *try) 432 { 433 return fl->fl_file == try->fl_file; 434 } 435 436 static struct lock_manager_operations lease_manager_ops = { 437 .fl_break = lease_break_callback, 438 .fl_release_private = lease_release_private_callback, 439 .fl_mylease = lease_mylease_callback, 440 .fl_change = lease_modify, 441 }; 442 443 /* 444 * Initialize a lease, use the default lock manager operations 445 */ 446 static int lease_init(struct file *filp, int type, struct file_lock *fl) 447 { 448 if (assign_type(fl, type) != 0) 449 return -EINVAL; 450 451 fl->fl_owner = current->files; 452 fl->fl_pid = current->tgid; 453 454 fl->fl_file = filp; 455 fl->fl_flags = FL_LEASE; 456 fl->fl_start = 0; 457 fl->fl_end = OFFSET_MAX; 458 fl->fl_ops = NULL; 459 fl->fl_lmops = &lease_manager_ops; 460 return 0; 461 } 462 463 /* Allocate a file_lock initialised to this type of lease */ 464 static int lease_alloc(struct file *filp, int type, struct file_lock **flp) 465 { 466 struct file_lock *fl = locks_alloc_lock(); 467 int error = -ENOMEM; 468 469 if (fl == NULL) 470 goto out; 471 472 error = lease_init(filp, type, fl); 473 if (error) { 474 locks_free_lock(fl); 475 fl = NULL; 476 } 477 out: 478 *flp = fl; 479 return error; 480 } 481 482 /* Check if two locks overlap each other. 483 */ 484 static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) 485 { 486 return ((fl1->fl_end >= fl2->fl_start) && 487 (fl2->fl_end >= fl1->fl_start)); 488 } 489 490 /* 491 * Check whether two locks have the same owner. 492 */ 493 static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2) 494 { 495 if (fl1->fl_lmops && fl1->fl_lmops->fl_compare_owner) 496 return fl2->fl_lmops == fl1->fl_lmops && 497 fl1->fl_lmops->fl_compare_owner(fl1, fl2); 498 return fl1->fl_owner == fl2->fl_owner; 499 } 500 501 /* Remove waiter from blocker's block list. 502 * When blocker ends up pointing to itself then the list is empty. 503 */ 504 static void __locks_delete_block(struct file_lock *waiter) 505 { 506 list_del_init(&waiter->fl_block); 507 list_del_init(&waiter->fl_link); 508 waiter->fl_next = NULL; 509 } 510 511 /* 512 */ 513 static void locks_delete_block(struct file_lock *waiter) 514 { 515 lock_kernel(); 516 __locks_delete_block(waiter); 517 unlock_kernel(); 518 } 519 520 /* Insert waiter into blocker's block list. 521 * We use a circular list so that processes can be easily woken up in 522 * the order they blocked. The documentation doesn't require this but 523 * it seems like the reasonable thing to do. 524 */ 525 static void locks_insert_block(struct file_lock *blocker, 526 struct file_lock *waiter) 527 { 528 BUG_ON(!list_empty(&waiter->fl_block)); 529 list_add_tail(&waiter->fl_block, &blocker->fl_block); 530 waiter->fl_next = blocker; 531 if (IS_POSIX(blocker)) 532 list_add(&waiter->fl_link, &blocked_list); 533 } 534 535 /* Wake up processes blocked waiting for blocker. 536 * If told to wait then schedule the processes until the block list 537 * is empty, otherwise empty the block list ourselves. 538 */ 539 static void locks_wake_up_blocks(struct file_lock *blocker) 540 { 541 while (!list_empty(&blocker->fl_block)) { 542 struct file_lock *waiter = list_entry(blocker->fl_block.next, 543 struct file_lock, fl_block); 544 __locks_delete_block(waiter); 545 if (waiter->fl_lmops && waiter->fl_lmops->fl_notify) 546 waiter->fl_lmops->fl_notify(waiter); 547 else 548 wake_up(&waiter->fl_wait); 549 } 550 } 551 552 /* Insert file lock fl into an inode's lock list at the position indicated 553 * by pos. At the same time add the lock to the global file lock list. 554 */ 555 static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl) 556 { 557 list_add(&fl->fl_link, &file_lock_list); 558 559 /* insert into file's list */ 560 fl->fl_next = *pos; 561 *pos = fl; 562 563 if (fl->fl_ops && fl->fl_ops->fl_insert) 564 fl->fl_ops->fl_insert(fl); 565 } 566 567 /* 568 * Delete a lock and then free it. 569 * Wake up processes that are blocked waiting for this lock, 570 * notify the FS that the lock has been cleared and 571 * finally free the lock. 572 */ 573 static void locks_delete_lock(struct file_lock **thisfl_p) 574 { 575 struct file_lock *fl = *thisfl_p; 576 577 *thisfl_p = fl->fl_next; 578 fl->fl_next = NULL; 579 list_del_init(&fl->fl_link); 580 581 fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); 582 if (fl->fl_fasync != NULL) { 583 printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync); 584 fl->fl_fasync = NULL; 585 } 586 587 if (fl->fl_ops && fl->fl_ops->fl_remove) 588 fl->fl_ops->fl_remove(fl); 589 590 locks_wake_up_blocks(fl); 591 locks_free_lock(fl); 592 } 593 594 /* Determine if lock sys_fl blocks lock caller_fl. Common functionality 595 * checks for shared/exclusive status of overlapping locks. 596 */ 597 static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 598 { 599 if (sys_fl->fl_type == F_WRLCK) 600 return 1; 601 if (caller_fl->fl_type == F_WRLCK) 602 return 1; 603 return 0; 604 } 605 606 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific 607 * checking before calling the locks_conflict(). 608 */ 609 static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 610 { 611 /* POSIX locks owned by the same process do not conflict with 612 * each other. 613 */ 614 if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl)) 615 return (0); 616 617 /* Check whether they overlap */ 618 if (!locks_overlap(caller_fl, sys_fl)) 619 return 0; 620 621 return (locks_conflict(caller_fl, sys_fl)); 622 } 623 624 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific 625 * checking before calling the locks_conflict(). 626 */ 627 static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 628 { 629 /* FLOCK locks referring to the same filp do not conflict with 630 * each other. 631 */ 632 if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file)) 633 return (0); 634 if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND)) 635 return 0; 636 637 return (locks_conflict(caller_fl, sys_fl)); 638 } 639 640 static int interruptible_sleep_on_locked(wait_queue_head_t *fl_wait, int timeout) 641 { 642 int result = 0; 643 DECLARE_WAITQUEUE(wait, current); 644 645 __set_current_state(TASK_INTERRUPTIBLE); 646 add_wait_queue(fl_wait, &wait); 647 if (timeout == 0) 648 schedule(); 649 else 650 result = schedule_timeout(timeout); 651 if (signal_pending(current)) 652 result = -ERESTARTSYS; 653 remove_wait_queue(fl_wait, &wait); 654 __set_current_state(TASK_RUNNING); 655 return result; 656 } 657 658 static int locks_block_on_timeout(struct file_lock *blocker, struct file_lock *waiter, int time) 659 { 660 int result; 661 locks_insert_block(blocker, waiter); 662 result = interruptible_sleep_on_locked(&waiter->fl_wait, time); 663 __locks_delete_block(waiter); 664 return result; 665 } 666 667 int 668 posix_test_lock(struct file *filp, struct file_lock *fl) 669 { 670 struct file_lock *cfl; 671 672 lock_kernel(); 673 for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) { 674 if (!IS_POSIX(cfl)) 675 continue; 676 if (posix_locks_conflict(cfl, fl)) 677 break; 678 } 679 if (cfl) { 680 __locks_copy_lock(fl, cfl); 681 unlock_kernel(); 682 return 1; 683 } else 684 fl->fl_type = F_UNLCK; 685 unlock_kernel(); 686 return 0; 687 } 688 689 EXPORT_SYMBOL(posix_test_lock); 690 691 /* This function tests for deadlock condition before putting a process to 692 * sleep. The detection scheme is no longer recursive. Recursive was neat, 693 * but dangerous - we risked stack corruption if the lock data was bad, or 694 * if the recursion was too deep for any other reason. 695 * 696 * We rely on the fact that a task can only be on one lock's wait queue 697 * at a time. When we find blocked_task on a wait queue we can re-search 698 * with blocked_task equal to that queue's owner, until either blocked_task 699 * isn't found, or blocked_task is found on a queue owned by my_task. 700 * 701 * Note: the above assumption may not be true when handling lock requests 702 * from a broken NFS client. But broken NFS clients have a lot more to 703 * worry about than proper deadlock detection anyway... --okir 704 */ 705 static int posix_locks_deadlock(struct file_lock *caller_fl, 706 struct file_lock *block_fl) 707 { 708 struct list_head *tmp; 709 710 next_task: 711 if (posix_same_owner(caller_fl, block_fl)) 712 return 1; 713 list_for_each(tmp, &blocked_list) { 714 struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link); 715 if (posix_same_owner(fl, block_fl)) { 716 fl = fl->fl_next; 717 block_fl = fl; 718 goto next_task; 719 } 720 } 721 return 0; 722 } 723 724 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks 725 * at the head of the list, but that's secret knowledge known only to 726 * flock_lock_file and posix_lock_file. 727 * 728 * Note that if called with an FL_EXISTS argument, the caller may determine 729 * whether or not a lock was successfully freed by testing the return 730 * value for -ENOENT. 731 */ 732 static int flock_lock_file(struct file *filp, struct file_lock *request) 733 { 734 struct file_lock *new_fl = NULL; 735 struct file_lock **before; 736 struct inode * inode = filp->f_path.dentry->d_inode; 737 int error = 0; 738 int found = 0; 739 740 lock_kernel(); 741 if (request->fl_flags & FL_ACCESS) 742 goto find_conflict; 743 for_each_lock(inode, before) { 744 struct file_lock *fl = *before; 745 if (IS_POSIX(fl)) 746 break; 747 if (IS_LEASE(fl)) 748 continue; 749 if (filp != fl->fl_file) 750 continue; 751 if (request->fl_type == fl->fl_type) 752 goto out; 753 found = 1; 754 locks_delete_lock(before); 755 break; 756 } 757 758 if (request->fl_type == F_UNLCK) { 759 if ((request->fl_flags & FL_EXISTS) && !found) 760 error = -ENOENT; 761 goto out; 762 } 763 764 error = -ENOMEM; 765 new_fl = locks_alloc_lock(); 766 if (new_fl == NULL) 767 goto out; 768 /* 769 * If a higher-priority process was blocked on the old file lock, 770 * give it the opportunity to lock the file. 771 */ 772 if (found) 773 cond_resched(); 774 775 find_conflict: 776 for_each_lock(inode, before) { 777 struct file_lock *fl = *before; 778 if (IS_POSIX(fl)) 779 break; 780 if (IS_LEASE(fl)) 781 continue; 782 if (!flock_locks_conflict(request, fl)) 783 continue; 784 error = -EAGAIN; 785 if (request->fl_flags & FL_SLEEP) 786 locks_insert_block(fl, request); 787 goto out; 788 } 789 if (request->fl_flags & FL_ACCESS) 790 goto out; 791 locks_copy_lock(new_fl, request); 792 locks_insert_lock(&inode->i_flock, new_fl); 793 new_fl = NULL; 794 error = 0; 795 796 out: 797 unlock_kernel(); 798 if (new_fl) 799 locks_free_lock(new_fl); 800 return error; 801 } 802 803 static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock) 804 { 805 struct file_lock *fl; 806 struct file_lock *new_fl = NULL; 807 struct file_lock *new_fl2 = NULL; 808 struct file_lock *left = NULL; 809 struct file_lock *right = NULL; 810 struct file_lock **before; 811 int error, added = 0; 812 813 /* 814 * We may need two file_lock structures for this operation, 815 * so we get them in advance to avoid races. 816 * 817 * In some cases we can be sure, that no new locks will be needed 818 */ 819 if (!(request->fl_flags & FL_ACCESS) && 820 (request->fl_type != F_UNLCK || 821 request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { 822 new_fl = locks_alloc_lock(); 823 new_fl2 = locks_alloc_lock(); 824 } 825 826 lock_kernel(); 827 if (request->fl_type != F_UNLCK) { 828 for_each_lock(inode, before) { 829 struct file_lock *fl = *before; 830 if (!IS_POSIX(fl)) 831 continue; 832 if (!posix_locks_conflict(request, fl)) 833 continue; 834 if (conflock) 835 locks_copy_lock(conflock, fl); 836 error = -EAGAIN; 837 if (!(request->fl_flags & FL_SLEEP)) 838 goto out; 839 error = -EDEADLK; 840 if (posix_locks_deadlock(request, fl)) 841 goto out; 842 error = -EAGAIN; 843 locks_insert_block(fl, request); 844 goto out; 845 } 846 } 847 848 /* If we're just looking for a conflict, we're done. */ 849 error = 0; 850 if (request->fl_flags & FL_ACCESS) 851 goto out; 852 853 /* 854 * Find the first old lock with the same owner as the new lock. 855 */ 856 857 before = &inode->i_flock; 858 859 /* First skip locks owned by other processes. */ 860 while ((fl = *before) && (!IS_POSIX(fl) || 861 !posix_same_owner(request, fl))) { 862 before = &fl->fl_next; 863 } 864 865 /* Process locks with this owner. */ 866 while ((fl = *before) && posix_same_owner(request, fl)) { 867 /* Detect adjacent or overlapping regions (if same lock type) 868 */ 869 if (request->fl_type == fl->fl_type) { 870 /* In all comparisons of start vs end, use 871 * "start - 1" rather than "end + 1". If end 872 * is OFFSET_MAX, end + 1 will become negative. 873 */ 874 if (fl->fl_end < request->fl_start - 1) 875 goto next_lock; 876 /* If the next lock in the list has entirely bigger 877 * addresses than the new one, insert the lock here. 878 */ 879 if (fl->fl_start - 1 > request->fl_end) 880 break; 881 882 /* If we come here, the new and old lock are of the 883 * same type and adjacent or overlapping. Make one 884 * lock yielding from the lower start address of both 885 * locks to the higher end address. 886 */ 887 if (fl->fl_start > request->fl_start) 888 fl->fl_start = request->fl_start; 889 else 890 request->fl_start = fl->fl_start; 891 if (fl->fl_end < request->fl_end) 892 fl->fl_end = request->fl_end; 893 else 894 request->fl_end = fl->fl_end; 895 if (added) { 896 locks_delete_lock(before); 897 continue; 898 } 899 request = fl; 900 added = 1; 901 } 902 else { 903 /* Processing for different lock types is a bit 904 * more complex. 905 */ 906 if (fl->fl_end < request->fl_start) 907 goto next_lock; 908 if (fl->fl_start > request->fl_end) 909 break; 910 if (request->fl_type == F_UNLCK) 911 added = 1; 912 if (fl->fl_start < request->fl_start) 913 left = fl; 914 /* If the next lock in the list has a higher end 915 * address than the new one, insert the new one here. 916 */ 917 if (fl->fl_end > request->fl_end) { 918 right = fl; 919 break; 920 } 921 if (fl->fl_start >= request->fl_start) { 922 /* The new lock completely replaces an old 923 * one (This may happen several times). 924 */ 925 if (added) { 926 locks_delete_lock(before); 927 continue; 928 } 929 /* Replace the old lock with the new one. 930 * Wake up anybody waiting for the old one, 931 * as the change in lock type might satisfy 932 * their needs. 933 */ 934 locks_wake_up_blocks(fl); 935 fl->fl_start = request->fl_start; 936 fl->fl_end = request->fl_end; 937 fl->fl_type = request->fl_type; 938 locks_release_private(fl); 939 locks_copy_private(fl, request); 940 request = fl; 941 added = 1; 942 } 943 } 944 /* Go on to next lock. 945 */ 946 next_lock: 947 before = &fl->fl_next; 948 } 949 950 /* 951 * The above code only modifies existing locks in case of 952 * merging or replacing. If new lock(s) need to be inserted 953 * all modifications are done bellow this, so it's safe yet to 954 * bail out. 955 */ 956 error = -ENOLCK; /* "no luck" */ 957 if (right && left == right && !new_fl2) 958 goto out; 959 960 error = 0; 961 if (!added) { 962 if (request->fl_type == F_UNLCK) { 963 if (request->fl_flags & FL_EXISTS) 964 error = -ENOENT; 965 goto out; 966 } 967 968 if (!new_fl) { 969 error = -ENOLCK; 970 goto out; 971 } 972 locks_copy_lock(new_fl, request); 973 locks_insert_lock(before, new_fl); 974 new_fl = NULL; 975 } 976 if (right) { 977 if (left == right) { 978 /* The new lock breaks the old one in two pieces, 979 * so we have to use the second new lock. 980 */ 981 left = new_fl2; 982 new_fl2 = NULL; 983 locks_copy_lock(left, right); 984 locks_insert_lock(before, left); 985 } 986 right->fl_start = request->fl_end + 1; 987 locks_wake_up_blocks(right); 988 } 989 if (left) { 990 left->fl_end = request->fl_start - 1; 991 locks_wake_up_blocks(left); 992 } 993 out: 994 unlock_kernel(); 995 /* 996 * Free any unused locks. 997 */ 998 if (new_fl) 999 locks_free_lock(new_fl); 1000 if (new_fl2) 1001 locks_free_lock(new_fl2); 1002 return error; 1003 } 1004 1005 /** 1006 * posix_lock_file - Apply a POSIX-style lock to a file 1007 * @filp: The file to apply the lock to 1008 * @fl: The lock to be applied 1009 * @conflock: Place to return a copy of the conflicting lock, if found. 1010 * 1011 * Add a POSIX style lock to a file. 1012 * We merge adjacent & overlapping locks whenever possible. 1013 * POSIX locks are sorted by owner task, then by starting address 1014 * 1015 * Note that if called with an FL_EXISTS argument, the caller may determine 1016 * whether or not a lock was successfully freed by testing the return 1017 * value for -ENOENT. 1018 */ 1019 int posix_lock_file(struct file *filp, struct file_lock *fl, 1020 struct file_lock *conflock) 1021 { 1022 return __posix_lock_file(filp->f_path.dentry->d_inode, fl, conflock); 1023 } 1024 EXPORT_SYMBOL(posix_lock_file); 1025 1026 /** 1027 * posix_lock_file_wait - Apply a POSIX-style lock to a file 1028 * @filp: The file to apply the lock to 1029 * @fl: The lock to be applied 1030 * 1031 * Add a POSIX style lock to a file. 1032 * We merge adjacent & overlapping locks whenever possible. 1033 * POSIX locks are sorted by owner task, then by starting address 1034 */ 1035 int posix_lock_file_wait(struct file *filp, struct file_lock *fl) 1036 { 1037 int error; 1038 might_sleep (); 1039 for (;;) { 1040 error = posix_lock_file(filp, fl, NULL); 1041 if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP)) 1042 break; 1043 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 1044 if (!error) 1045 continue; 1046 1047 locks_delete_block(fl); 1048 break; 1049 } 1050 return error; 1051 } 1052 EXPORT_SYMBOL(posix_lock_file_wait); 1053 1054 /** 1055 * locks_mandatory_locked - Check for an active lock 1056 * @inode: the file to check 1057 * 1058 * Searches the inode's list of locks to find any POSIX locks which conflict. 1059 * This function is called from locks_verify_locked() only. 1060 */ 1061 int locks_mandatory_locked(struct inode *inode) 1062 { 1063 fl_owner_t owner = current->files; 1064 struct file_lock *fl; 1065 1066 /* 1067 * Search the lock list for this inode for any POSIX locks. 1068 */ 1069 lock_kernel(); 1070 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 1071 if (!IS_POSIX(fl)) 1072 continue; 1073 if (fl->fl_owner != owner) 1074 break; 1075 } 1076 unlock_kernel(); 1077 return fl ? -EAGAIN : 0; 1078 } 1079 1080 /** 1081 * locks_mandatory_area - Check for a conflicting lock 1082 * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ 1083 * for shared 1084 * @inode: the file to check 1085 * @filp: how the file was opened (if it was) 1086 * @offset: start of area to check 1087 * @count: length of area to check 1088 * 1089 * Searches the inode's list of locks to find any POSIX locks which conflict. 1090 * This function is called from rw_verify_area() and 1091 * locks_verify_truncate(). 1092 */ 1093 int locks_mandatory_area(int read_write, struct inode *inode, 1094 struct file *filp, loff_t offset, 1095 size_t count) 1096 { 1097 struct file_lock fl; 1098 int error; 1099 1100 locks_init_lock(&fl); 1101 fl.fl_owner = current->files; 1102 fl.fl_pid = current->tgid; 1103 fl.fl_file = filp; 1104 fl.fl_flags = FL_POSIX | FL_ACCESS; 1105 if (filp && !(filp->f_flags & O_NONBLOCK)) 1106 fl.fl_flags |= FL_SLEEP; 1107 fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK; 1108 fl.fl_start = offset; 1109 fl.fl_end = offset + count - 1; 1110 1111 for (;;) { 1112 error = __posix_lock_file(inode, &fl, NULL); 1113 if (error != -EAGAIN) 1114 break; 1115 if (!(fl.fl_flags & FL_SLEEP)) 1116 break; 1117 error = wait_event_interruptible(fl.fl_wait, !fl.fl_next); 1118 if (!error) { 1119 /* 1120 * If we've been sleeping someone might have 1121 * changed the permissions behind our back. 1122 */ 1123 if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID) 1124 continue; 1125 } 1126 1127 locks_delete_block(&fl); 1128 break; 1129 } 1130 1131 return error; 1132 } 1133 1134 EXPORT_SYMBOL(locks_mandatory_area); 1135 1136 /* We already had a lease on this file; just change its type */ 1137 int lease_modify(struct file_lock **before, int arg) 1138 { 1139 struct file_lock *fl = *before; 1140 int error = assign_type(fl, arg); 1141 1142 if (error) 1143 return error; 1144 locks_wake_up_blocks(fl); 1145 if (arg == F_UNLCK) 1146 locks_delete_lock(before); 1147 return 0; 1148 } 1149 1150 EXPORT_SYMBOL(lease_modify); 1151 1152 static void time_out_leases(struct inode *inode) 1153 { 1154 struct file_lock **before; 1155 struct file_lock *fl; 1156 1157 before = &inode->i_flock; 1158 while ((fl = *before) && IS_LEASE(fl) && (fl->fl_type & F_INPROGRESS)) { 1159 if ((fl->fl_break_time == 0) 1160 || time_before(jiffies, fl->fl_break_time)) { 1161 before = &fl->fl_next; 1162 continue; 1163 } 1164 lease_modify(before, fl->fl_type & ~F_INPROGRESS); 1165 if (fl == *before) /* lease_modify may have freed fl */ 1166 before = &fl->fl_next; 1167 } 1168 } 1169 1170 /** 1171 * __break_lease - revoke all outstanding leases on file 1172 * @inode: the inode of the file to return 1173 * @mode: the open mode (read or write) 1174 * 1175 * break_lease (inlined for speed) has checked there already 1176 * is a lease on this file. Leases are broken on a call to open() 1177 * or truncate(). This function can sleep unless you 1178 * specified %O_NONBLOCK to your open(). 1179 */ 1180 int __break_lease(struct inode *inode, unsigned int mode) 1181 { 1182 int error = 0, future; 1183 struct file_lock *new_fl, *flock; 1184 struct file_lock *fl; 1185 int alloc_err; 1186 unsigned long break_time; 1187 int i_have_this_lease = 0; 1188 1189 alloc_err = lease_alloc(NULL, mode & FMODE_WRITE ? F_WRLCK : F_RDLCK, 1190 &new_fl); 1191 1192 lock_kernel(); 1193 1194 time_out_leases(inode); 1195 1196 flock = inode->i_flock; 1197 if ((flock == NULL) || !IS_LEASE(flock)) 1198 goto out; 1199 1200 for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) 1201 if (fl->fl_owner == current->files) 1202 i_have_this_lease = 1; 1203 1204 if (mode & FMODE_WRITE) { 1205 /* If we want write access, we have to revoke any lease. */ 1206 future = F_UNLCK | F_INPROGRESS; 1207 } else if (flock->fl_type & F_INPROGRESS) { 1208 /* If the lease is already being broken, we just leave it */ 1209 future = flock->fl_type; 1210 } else if (flock->fl_type & F_WRLCK) { 1211 /* Downgrade the exclusive lease to a read-only lease. */ 1212 future = F_RDLCK | F_INPROGRESS; 1213 } else { 1214 /* the existing lease was read-only, so we can read too. */ 1215 goto out; 1216 } 1217 1218 if (alloc_err && !i_have_this_lease && ((mode & O_NONBLOCK) == 0)) { 1219 error = alloc_err; 1220 goto out; 1221 } 1222 1223 break_time = 0; 1224 if (lease_break_time > 0) { 1225 break_time = jiffies + lease_break_time * HZ; 1226 if (break_time == 0) 1227 break_time++; /* so that 0 means no break time */ 1228 } 1229 1230 for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) { 1231 if (fl->fl_type != future) { 1232 fl->fl_type = future; 1233 fl->fl_break_time = break_time; 1234 /* lease must have lmops break callback */ 1235 fl->fl_lmops->fl_break(fl); 1236 } 1237 } 1238 1239 if (i_have_this_lease || (mode & O_NONBLOCK)) { 1240 error = -EWOULDBLOCK; 1241 goto out; 1242 } 1243 1244 restart: 1245 break_time = flock->fl_break_time; 1246 if (break_time != 0) { 1247 break_time -= jiffies; 1248 if (break_time == 0) 1249 break_time++; 1250 } 1251 error = locks_block_on_timeout(flock, new_fl, break_time); 1252 if (error >= 0) { 1253 if (error == 0) 1254 time_out_leases(inode); 1255 /* Wait for the next lease that has not been broken yet */ 1256 for (flock = inode->i_flock; flock && IS_LEASE(flock); 1257 flock = flock->fl_next) { 1258 if (flock->fl_type & F_INPROGRESS) 1259 goto restart; 1260 } 1261 error = 0; 1262 } 1263 1264 out: 1265 unlock_kernel(); 1266 if (!alloc_err) 1267 locks_free_lock(new_fl); 1268 return error; 1269 } 1270 1271 EXPORT_SYMBOL(__break_lease); 1272 1273 /** 1274 * lease_get_mtime 1275 * @inode: the inode 1276 * @time: pointer to a timespec which will contain the last modified time 1277 * 1278 * This is to force NFS clients to flush their caches for files with 1279 * exclusive leases. The justification is that if someone has an 1280 * exclusive lease, then they could be modifiying it. 1281 */ 1282 void lease_get_mtime(struct inode *inode, struct timespec *time) 1283 { 1284 struct file_lock *flock = inode->i_flock; 1285 if (flock && IS_LEASE(flock) && (flock->fl_type & F_WRLCK)) 1286 *time = current_fs_time(inode->i_sb); 1287 else 1288 *time = inode->i_mtime; 1289 } 1290 1291 EXPORT_SYMBOL(lease_get_mtime); 1292 1293 /** 1294 * fcntl_getlease - Enquire what lease is currently active 1295 * @filp: the file 1296 * 1297 * The value returned by this function will be one of 1298 * (if no lease break is pending): 1299 * 1300 * %F_RDLCK to indicate a shared lease is held. 1301 * 1302 * %F_WRLCK to indicate an exclusive lease is held. 1303 * 1304 * %F_UNLCK to indicate no lease is held. 1305 * 1306 * (if a lease break is pending): 1307 * 1308 * %F_RDLCK to indicate an exclusive lease needs to be 1309 * changed to a shared lease (or removed). 1310 * 1311 * %F_UNLCK to indicate the lease needs to be removed. 1312 * 1313 * XXX: sfr & willy disagree over whether F_INPROGRESS 1314 * should be returned to userspace. 1315 */ 1316 int fcntl_getlease(struct file *filp) 1317 { 1318 struct file_lock *fl; 1319 int type = F_UNLCK; 1320 1321 lock_kernel(); 1322 time_out_leases(filp->f_path.dentry->d_inode); 1323 for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl); 1324 fl = fl->fl_next) { 1325 if (fl->fl_file == filp) { 1326 type = fl->fl_type & ~F_INPROGRESS; 1327 break; 1328 } 1329 } 1330 unlock_kernel(); 1331 return type; 1332 } 1333 1334 /** 1335 * __setlease - sets a lease on an open file 1336 * @filp: file pointer 1337 * @arg: type of lease to obtain 1338 * @flp: input - file_lock to use, output - file_lock inserted 1339 * 1340 * The (input) flp->fl_lmops->fl_break function is required 1341 * by break_lease(). 1342 * 1343 * Called with kernel lock held. 1344 */ 1345 static int __setlease(struct file *filp, long arg, struct file_lock **flp) 1346 { 1347 struct file_lock *fl, **before, **my_before = NULL, *lease; 1348 struct dentry *dentry = filp->f_path.dentry; 1349 struct inode *inode = dentry->d_inode; 1350 int error, rdlease_count = 0, wrlease_count = 0; 1351 1352 time_out_leases(inode); 1353 1354 error = -EINVAL; 1355 if (!flp || !(*flp) || !(*flp)->fl_lmops || !(*flp)->fl_lmops->fl_break) 1356 goto out; 1357 1358 lease = *flp; 1359 1360 error = -EAGAIN; 1361 if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0)) 1362 goto out; 1363 if ((arg == F_WRLCK) 1364 && ((atomic_read(&dentry->d_count) > 1) 1365 || (atomic_read(&inode->i_count) > 1))) 1366 goto out; 1367 1368 /* 1369 * At this point, we know that if there is an exclusive 1370 * lease on this file, then we hold it on this filp 1371 * (otherwise our open of this file would have blocked). 1372 * And if we are trying to acquire an exclusive lease, 1373 * then the file is not open by anyone (including us) 1374 * except for this filp. 1375 */ 1376 for (before = &inode->i_flock; 1377 ((fl = *before) != NULL) && IS_LEASE(fl); 1378 before = &fl->fl_next) { 1379 if (lease->fl_lmops->fl_mylease(fl, lease)) 1380 my_before = before; 1381 else if (fl->fl_type == (F_INPROGRESS | F_UNLCK)) 1382 /* 1383 * Someone is in the process of opening this 1384 * file for writing so we may not take an 1385 * exclusive lease on it. 1386 */ 1387 wrlease_count++; 1388 else 1389 rdlease_count++; 1390 } 1391 1392 if ((arg == F_RDLCK && (wrlease_count > 0)) || 1393 (arg == F_WRLCK && ((rdlease_count + wrlease_count) > 0))) 1394 goto out; 1395 1396 if (my_before != NULL) { 1397 *flp = *my_before; 1398 error = lease->fl_lmops->fl_change(my_before, arg); 1399 goto out; 1400 } 1401 1402 error = 0; 1403 if (arg == F_UNLCK) 1404 goto out; 1405 1406 error = -EINVAL; 1407 if (!leases_enable) 1408 goto out; 1409 1410 error = -ENOMEM; 1411 fl = locks_alloc_lock(); 1412 if (fl == NULL) 1413 goto out; 1414 1415 locks_copy_lock(fl, lease); 1416 1417 locks_insert_lock(before, fl); 1418 1419 *flp = fl; 1420 error = 0; 1421 out: 1422 return error; 1423 } 1424 1425 /** 1426 * setlease - sets a lease on an open file 1427 * @filp: file pointer 1428 * @arg: type of lease to obtain 1429 * @lease: file_lock to use 1430 * 1431 * Call this to establish a lease on the file. 1432 * The fl_lmops fl_break function is required by break_lease 1433 */ 1434 1435 int setlease(struct file *filp, long arg, struct file_lock **lease) 1436 { 1437 struct dentry *dentry = filp->f_path.dentry; 1438 struct inode *inode = dentry->d_inode; 1439 int error; 1440 1441 if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE)) 1442 return -EACCES; 1443 if (!S_ISREG(inode->i_mode)) 1444 return -EINVAL; 1445 error = security_file_lock(filp, arg); 1446 if (error) 1447 return error; 1448 1449 lock_kernel(); 1450 error = __setlease(filp, arg, lease); 1451 unlock_kernel(); 1452 1453 return error; 1454 } 1455 1456 EXPORT_SYMBOL(setlease); 1457 1458 /** 1459 * fcntl_setlease - sets a lease on an open file 1460 * @fd: open file descriptor 1461 * @filp: file pointer 1462 * @arg: type of lease to obtain 1463 * 1464 * Call this fcntl to establish a lease on the file. 1465 * Note that you also need to call %F_SETSIG to 1466 * receive a signal when the lease is broken. 1467 */ 1468 int fcntl_setlease(unsigned int fd, struct file *filp, long arg) 1469 { 1470 struct file_lock fl, *flp = &fl; 1471 struct dentry *dentry = filp->f_path.dentry; 1472 struct inode *inode = dentry->d_inode; 1473 int error; 1474 1475 if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE)) 1476 return -EACCES; 1477 if (!S_ISREG(inode->i_mode)) 1478 return -EINVAL; 1479 error = security_file_lock(filp, arg); 1480 if (error) 1481 return error; 1482 1483 locks_init_lock(&fl); 1484 error = lease_init(filp, arg, &fl); 1485 if (error) 1486 return error; 1487 1488 lock_kernel(); 1489 1490 error = __setlease(filp, arg, &flp); 1491 if (error || arg == F_UNLCK) 1492 goto out_unlock; 1493 1494 error = fasync_helper(fd, filp, 1, &flp->fl_fasync); 1495 if (error < 0) { 1496 /* remove lease just inserted by __setlease */ 1497 flp->fl_type = F_UNLCK | F_INPROGRESS; 1498 flp->fl_break_time = jiffies- 10; 1499 time_out_leases(inode); 1500 goto out_unlock; 1501 } 1502 1503 error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0); 1504 out_unlock: 1505 unlock_kernel(); 1506 return error; 1507 } 1508 1509 /** 1510 * flock_lock_file_wait - Apply a FLOCK-style lock to a file 1511 * @filp: The file to apply the lock to 1512 * @fl: The lock to be applied 1513 * 1514 * Add a FLOCK style lock to a file. 1515 */ 1516 int flock_lock_file_wait(struct file *filp, struct file_lock *fl) 1517 { 1518 int error; 1519 might_sleep(); 1520 for (;;) { 1521 error = flock_lock_file(filp, fl); 1522 if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP)) 1523 break; 1524 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 1525 if (!error) 1526 continue; 1527 1528 locks_delete_block(fl); 1529 break; 1530 } 1531 return error; 1532 } 1533 1534 EXPORT_SYMBOL(flock_lock_file_wait); 1535 1536 /** 1537 * sys_flock: - flock() system call. 1538 * @fd: the file descriptor to lock. 1539 * @cmd: the type of lock to apply. 1540 * 1541 * Apply a %FL_FLOCK style lock to an open file descriptor. 1542 * The @cmd can be one of 1543 * 1544 * %LOCK_SH -- a shared lock. 1545 * 1546 * %LOCK_EX -- an exclusive lock. 1547 * 1548 * %LOCK_UN -- remove an existing lock. 1549 * 1550 * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes. 1551 * 1552 * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other 1553 * processes read and write access respectively. 1554 */ 1555 asmlinkage long sys_flock(unsigned int fd, unsigned int cmd) 1556 { 1557 struct file *filp; 1558 struct file_lock *lock; 1559 int can_sleep, unlock; 1560 int error; 1561 1562 error = -EBADF; 1563 filp = fget(fd); 1564 if (!filp) 1565 goto out; 1566 1567 can_sleep = !(cmd & LOCK_NB); 1568 cmd &= ~LOCK_NB; 1569 unlock = (cmd == LOCK_UN); 1570 1571 if (!unlock && !(cmd & LOCK_MAND) && !(filp->f_mode & 3)) 1572 goto out_putf; 1573 1574 error = flock_make_lock(filp, &lock, cmd); 1575 if (error) 1576 goto out_putf; 1577 if (can_sleep) 1578 lock->fl_flags |= FL_SLEEP; 1579 1580 error = security_file_lock(filp, cmd); 1581 if (error) 1582 goto out_free; 1583 1584 if (filp->f_op && filp->f_op->flock) 1585 error = filp->f_op->flock(filp, 1586 (can_sleep) ? F_SETLKW : F_SETLK, 1587 lock); 1588 else 1589 error = flock_lock_file_wait(filp, lock); 1590 1591 out_free: 1592 locks_free_lock(lock); 1593 1594 out_putf: 1595 fput(filp); 1596 out: 1597 return error; 1598 } 1599 1600 /** 1601 * vfs_test_lock - test file byte range lock 1602 * @filp: The file to test lock for 1603 * @fl: The lock to test 1604 * @conf: Place to return a copy of the conflicting lock, if found 1605 * 1606 * Returns -ERRNO on failure. Indicates presence of conflicting lock by 1607 * setting conf->fl_type to something other than F_UNLCK. 1608 */ 1609 int vfs_test_lock(struct file *filp, struct file_lock *fl) 1610 { 1611 if (filp->f_op && filp->f_op->lock) 1612 return filp->f_op->lock(filp, F_GETLK, fl); 1613 posix_test_lock(filp, fl); 1614 return 0; 1615 } 1616 EXPORT_SYMBOL_GPL(vfs_test_lock); 1617 1618 static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) 1619 { 1620 flock->l_pid = fl->fl_pid; 1621 #if BITS_PER_LONG == 32 1622 /* 1623 * Make sure we can represent the posix lock via 1624 * legacy 32bit flock. 1625 */ 1626 if (fl->fl_start > OFFT_OFFSET_MAX) 1627 return -EOVERFLOW; 1628 if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX) 1629 return -EOVERFLOW; 1630 #endif 1631 flock->l_start = fl->fl_start; 1632 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1633 fl->fl_end - fl->fl_start + 1; 1634 flock->l_whence = 0; 1635 flock->l_type = fl->fl_type; 1636 return 0; 1637 } 1638 1639 #if BITS_PER_LONG == 32 1640 static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) 1641 { 1642 flock->l_pid = fl->fl_pid; 1643 flock->l_start = fl->fl_start; 1644 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1645 fl->fl_end - fl->fl_start + 1; 1646 flock->l_whence = 0; 1647 flock->l_type = fl->fl_type; 1648 } 1649 #endif 1650 1651 /* Report the first existing lock that would conflict with l. 1652 * This implements the F_GETLK command of fcntl(). 1653 */ 1654 int fcntl_getlk(struct file *filp, struct flock __user *l) 1655 { 1656 struct file_lock file_lock; 1657 struct flock flock; 1658 int error; 1659 1660 error = -EFAULT; 1661 if (copy_from_user(&flock, l, sizeof(flock))) 1662 goto out; 1663 error = -EINVAL; 1664 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 1665 goto out; 1666 1667 error = flock_to_posix_lock(filp, &file_lock, &flock); 1668 if (error) 1669 goto out; 1670 1671 error = vfs_test_lock(filp, &file_lock); 1672 if (error) 1673 goto out; 1674 1675 flock.l_type = file_lock.fl_type; 1676 if (file_lock.fl_type != F_UNLCK) { 1677 error = posix_lock_to_flock(&flock, &file_lock); 1678 if (error) 1679 goto out; 1680 } 1681 error = -EFAULT; 1682 if (!copy_to_user(l, &flock, sizeof(flock))) 1683 error = 0; 1684 out: 1685 return error; 1686 } 1687 1688 /** 1689 * vfs_lock_file - file byte range lock 1690 * @filp: The file to apply the lock to 1691 * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.) 1692 * @fl: The lock to be applied 1693 * @conf: Place to return a copy of the conflicting lock, if found. 1694 * 1695 * A caller that doesn't care about the conflicting lock may pass NULL 1696 * as the final argument. 1697 * 1698 * If the filesystem defines a private ->lock() method, then @conf will 1699 * be left unchanged; so a caller that cares should initialize it to 1700 * some acceptable default. 1701 * 1702 * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX 1703 * locks, the ->lock() interface may return asynchronously, before the lock has 1704 * been granted or denied by the underlying filesystem, if (and only if) 1705 * fl_grant is set. Callers expecting ->lock() to return asynchronously 1706 * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if) 1707 * the request is for a blocking lock. When ->lock() does return asynchronously, 1708 * it must return -EINPROGRESS, and call ->fl_grant() when the lock 1709 * request completes. 1710 * If the request is for non-blocking lock the file system should return 1711 * -EINPROGRESS then try to get the lock and call the callback routine with 1712 * the result. If the request timed out the callback routine will return a 1713 * nonzero return code and the file system should release the lock. The file 1714 * system is also responsible to keep a corresponding posix lock when it 1715 * grants a lock so the VFS can find out which locks are locally held and do 1716 * the correct lock cleanup when required. 1717 * The underlying filesystem must not drop the kernel lock or call 1718 * ->fl_grant() before returning to the caller with a -EINPROGRESS 1719 * return code. 1720 */ 1721 int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) 1722 { 1723 if (filp->f_op && filp->f_op->lock) 1724 return filp->f_op->lock(filp, cmd, fl); 1725 else 1726 return posix_lock_file(filp, fl, conf); 1727 } 1728 EXPORT_SYMBOL_GPL(vfs_lock_file); 1729 1730 /* Apply the lock described by l to an open file descriptor. 1731 * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 1732 */ 1733 int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, 1734 struct flock __user *l) 1735 { 1736 struct file_lock *file_lock = locks_alloc_lock(); 1737 struct flock flock; 1738 struct inode *inode; 1739 int error; 1740 1741 if (file_lock == NULL) 1742 return -ENOLCK; 1743 1744 /* 1745 * This might block, so we do it before checking the inode. 1746 */ 1747 error = -EFAULT; 1748 if (copy_from_user(&flock, l, sizeof(flock))) 1749 goto out; 1750 1751 inode = filp->f_path.dentry->d_inode; 1752 1753 /* Don't allow mandatory locks on files that may be memory mapped 1754 * and shared. 1755 */ 1756 if (IS_MANDLOCK(inode) && 1757 (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID && 1758 mapping_writably_mapped(filp->f_mapping)) { 1759 error = -EAGAIN; 1760 goto out; 1761 } 1762 1763 again: 1764 error = flock_to_posix_lock(filp, file_lock, &flock); 1765 if (error) 1766 goto out; 1767 if (cmd == F_SETLKW) { 1768 file_lock->fl_flags |= FL_SLEEP; 1769 } 1770 1771 error = -EBADF; 1772 switch (flock.l_type) { 1773 case F_RDLCK: 1774 if (!(filp->f_mode & FMODE_READ)) 1775 goto out; 1776 break; 1777 case F_WRLCK: 1778 if (!(filp->f_mode & FMODE_WRITE)) 1779 goto out; 1780 break; 1781 case F_UNLCK: 1782 break; 1783 default: 1784 error = -EINVAL; 1785 goto out; 1786 } 1787 1788 error = security_file_lock(filp, file_lock->fl_type); 1789 if (error) 1790 goto out; 1791 1792 for (;;) { 1793 error = vfs_lock_file(filp, cmd, file_lock, NULL); 1794 if (error != -EAGAIN || cmd == F_SETLK) 1795 break; 1796 error = wait_event_interruptible(file_lock->fl_wait, 1797 !file_lock->fl_next); 1798 if (!error) 1799 continue; 1800 1801 locks_delete_block(file_lock); 1802 break; 1803 } 1804 1805 /* 1806 * Attempt to detect a close/fcntl race and recover by 1807 * releasing the lock that was just acquired. 1808 */ 1809 if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) { 1810 flock.l_type = F_UNLCK; 1811 goto again; 1812 } 1813 1814 out: 1815 locks_free_lock(file_lock); 1816 return error; 1817 } 1818 1819 #if BITS_PER_LONG == 32 1820 /* Report the first existing lock that would conflict with l. 1821 * This implements the F_GETLK command of fcntl(). 1822 */ 1823 int fcntl_getlk64(struct file *filp, struct flock64 __user *l) 1824 { 1825 struct file_lock file_lock; 1826 struct flock64 flock; 1827 int error; 1828 1829 error = -EFAULT; 1830 if (copy_from_user(&flock, l, sizeof(flock))) 1831 goto out; 1832 error = -EINVAL; 1833 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 1834 goto out; 1835 1836 error = flock64_to_posix_lock(filp, &file_lock, &flock); 1837 if (error) 1838 goto out; 1839 1840 error = vfs_test_lock(filp, &file_lock); 1841 if (error) 1842 goto out; 1843 1844 flock.l_type = file_lock.fl_type; 1845 if (file_lock.fl_type != F_UNLCK) 1846 posix_lock_to_flock64(&flock, &file_lock); 1847 1848 error = -EFAULT; 1849 if (!copy_to_user(l, &flock, sizeof(flock))) 1850 error = 0; 1851 1852 out: 1853 return error; 1854 } 1855 1856 /* Apply the lock described by l to an open file descriptor. 1857 * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 1858 */ 1859 int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, 1860 struct flock64 __user *l) 1861 { 1862 struct file_lock *file_lock = locks_alloc_lock(); 1863 struct flock64 flock; 1864 struct inode *inode; 1865 int error; 1866 1867 if (file_lock == NULL) 1868 return -ENOLCK; 1869 1870 /* 1871 * This might block, so we do it before checking the inode. 1872 */ 1873 error = -EFAULT; 1874 if (copy_from_user(&flock, l, sizeof(flock))) 1875 goto out; 1876 1877 inode = filp->f_path.dentry->d_inode; 1878 1879 /* Don't allow mandatory locks on files that may be memory mapped 1880 * and shared. 1881 */ 1882 if (IS_MANDLOCK(inode) && 1883 (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID && 1884 mapping_writably_mapped(filp->f_mapping)) { 1885 error = -EAGAIN; 1886 goto out; 1887 } 1888 1889 again: 1890 error = flock64_to_posix_lock(filp, file_lock, &flock); 1891 if (error) 1892 goto out; 1893 if (cmd == F_SETLKW64) { 1894 file_lock->fl_flags |= FL_SLEEP; 1895 } 1896 1897 error = -EBADF; 1898 switch (flock.l_type) { 1899 case F_RDLCK: 1900 if (!(filp->f_mode & FMODE_READ)) 1901 goto out; 1902 break; 1903 case F_WRLCK: 1904 if (!(filp->f_mode & FMODE_WRITE)) 1905 goto out; 1906 break; 1907 case F_UNLCK: 1908 break; 1909 default: 1910 error = -EINVAL; 1911 goto out; 1912 } 1913 1914 error = security_file_lock(filp, file_lock->fl_type); 1915 if (error) 1916 goto out; 1917 1918 for (;;) { 1919 error = vfs_lock_file(filp, cmd, file_lock, NULL); 1920 if (error != -EAGAIN || cmd == F_SETLK64) 1921 break; 1922 error = wait_event_interruptible(file_lock->fl_wait, 1923 !file_lock->fl_next); 1924 if (!error) 1925 continue; 1926 1927 locks_delete_block(file_lock); 1928 break; 1929 } 1930 1931 /* 1932 * Attempt to detect a close/fcntl race and recover by 1933 * releasing the lock that was just acquired. 1934 */ 1935 if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) { 1936 flock.l_type = F_UNLCK; 1937 goto again; 1938 } 1939 1940 out: 1941 locks_free_lock(file_lock); 1942 return error; 1943 } 1944 #endif /* BITS_PER_LONG == 32 */ 1945 1946 /* 1947 * This function is called when the file is being removed 1948 * from the task's fd array. POSIX locks belonging to this task 1949 * are deleted at this time. 1950 */ 1951 void locks_remove_posix(struct file *filp, fl_owner_t owner) 1952 { 1953 struct file_lock lock; 1954 1955 /* 1956 * If there are no locks held on this file, we don't need to call 1957 * posix_lock_file(). Another process could be setting a lock on this 1958 * file at the same time, but we wouldn't remove that lock anyway. 1959 */ 1960 if (!filp->f_path.dentry->d_inode->i_flock) 1961 return; 1962 1963 lock.fl_type = F_UNLCK; 1964 lock.fl_flags = FL_POSIX | FL_CLOSE; 1965 lock.fl_start = 0; 1966 lock.fl_end = OFFSET_MAX; 1967 lock.fl_owner = owner; 1968 lock.fl_pid = current->tgid; 1969 lock.fl_file = filp; 1970 lock.fl_ops = NULL; 1971 lock.fl_lmops = NULL; 1972 1973 vfs_lock_file(filp, F_SETLK, &lock, NULL); 1974 1975 if (lock.fl_ops && lock.fl_ops->fl_release_private) 1976 lock.fl_ops->fl_release_private(&lock); 1977 } 1978 1979 EXPORT_SYMBOL(locks_remove_posix); 1980 1981 /* 1982 * This function is called on the last close of an open file. 1983 */ 1984 void locks_remove_flock(struct file *filp) 1985 { 1986 struct inode * inode = filp->f_path.dentry->d_inode; 1987 struct file_lock *fl; 1988 struct file_lock **before; 1989 1990 if (!inode->i_flock) 1991 return; 1992 1993 if (filp->f_op && filp->f_op->flock) { 1994 struct file_lock fl = { 1995 .fl_pid = current->tgid, 1996 .fl_file = filp, 1997 .fl_flags = FL_FLOCK, 1998 .fl_type = F_UNLCK, 1999 .fl_end = OFFSET_MAX, 2000 }; 2001 filp->f_op->flock(filp, F_SETLKW, &fl); 2002 if (fl.fl_ops && fl.fl_ops->fl_release_private) 2003 fl.fl_ops->fl_release_private(&fl); 2004 } 2005 2006 lock_kernel(); 2007 before = &inode->i_flock; 2008 2009 while ((fl = *before) != NULL) { 2010 if (fl->fl_file == filp) { 2011 if (IS_FLOCK(fl)) { 2012 locks_delete_lock(before); 2013 continue; 2014 } 2015 if (IS_LEASE(fl)) { 2016 lease_modify(before, F_UNLCK); 2017 continue; 2018 } 2019 /* What? */ 2020 BUG(); 2021 } 2022 before = &fl->fl_next; 2023 } 2024 unlock_kernel(); 2025 } 2026 2027 /** 2028 * posix_unblock_lock - stop waiting for a file lock 2029 * @filp: how the file was opened 2030 * @waiter: the lock which was waiting 2031 * 2032 * lockd needs to block waiting for locks. 2033 */ 2034 int 2035 posix_unblock_lock(struct file *filp, struct file_lock *waiter) 2036 { 2037 int status = 0; 2038 2039 lock_kernel(); 2040 if (waiter->fl_next) 2041 __locks_delete_block(waiter); 2042 else 2043 status = -ENOENT; 2044 unlock_kernel(); 2045 return status; 2046 } 2047 2048 EXPORT_SYMBOL(posix_unblock_lock); 2049 2050 /** 2051 * vfs_cancel_lock - file byte range unblock lock 2052 * @filp: The file to apply the unblock to 2053 * @fl: The lock to be unblocked 2054 * 2055 * Used by lock managers to cancel blocked requests 2056 */ 2057 int vfs_cancel_lock(struct file *filp, struct file_lock *fl) 2058 { 2059 if (filp->f_op && filp->f_op->lock) 2060 return filp->f_op->lock(filp, F_CANCELLK, fl); 2061 return 0; 2062 } 2063 2064 EXPORT_SYMBOL_GPL(vfs_cancel_lock); 2065 2066 static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx) 2067 { 2068 struct inode *inode = NULL; 2069 2070 if (fl->fl_file != NULL) 2071 inode = fl->fl_file->f_path.dentry->d_inode; 2072 2073 out += sprintf(out, "%d:%s ", id, pfx); 2074 if (IS_POSIX(fl)) { 2075 out += sprintf(out, "%6s %s ", 2076 (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ", 2077 (inode == NULL) ? "*NOINODE*" : 2078 (IS_MANDLOCK(inode) && 2079 (inode->i_mode & (S_IXGRP | S_ISGID)) == S_ISGID) ? 2080 "MANDATORY" : "ADVISORY "); 2081 } else if (IS_FLOCK(fl)) { 2082 if (fl->fl_type & LOCK_MAND) { 2083 out += sprintf(out, "FLOCK MSNFS "); 2084 } else { 2085 out += sprintf(out, "FLOCK ADVISORY "); 2086 } 2087 } else if (IS_LEASE(fl)) { 2088 out += sprintf(out, "LEASE "); 2089 if (fl->fl_type & F_INPROGRESS) 2090 out += sprintf(out, "BREAKING "); 2091 else if (fl->fl_file) 2092 out += sprintf(out, "ACTIVE "); 2093 else 2094 out += sprintf(out, "BREAKER "); 2095 } else { 2096 out += sprintf(out, "UNKNOWN UNKNOWN "); 2097 } 2098 if (fl->fl_type & LOCK_MAND) { 2099 out += sprintf(out, "%s ", 2100 (fl->fl_type & LOCK_READ) 2101 ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ " 2102 : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE "); 2103 } else { 2104 out += sprintf(out, "%s ", 2105 (fl->fl_type & F_INPROGRESS) 2106 ? (fl->fl_type & F_UNLCK) ? "UNLCK" : "READ " 2107 : (fl->fl_type & F_WRLCK) ? "WRITE" : "READ "); 2108 } 2109 if (inode) { 2110 #ifdef WE_CAN_BREAK_LSLK_NOW 2111 out += sprintf(out, "%d %s:%ld ", fl->fl_pid, 2112 inode->i_sb->s_id, inode->i_ino); 2113 #else 2114 /* userspace relies on this representation of dev_t ;-( */ 2115 out += sprintf(out, "%d %02x:%02x:%ld ", fl->fl_pid, 2116 MAJOR(inode->i_sb->s_dev), 2117 MINOR(inode->i_sb->s_dev), inode->i_ino); 2118 #endif 2119 } else { 2120 out += sprintf(out, "%d <none>:0 ", fl->fl_pid); 2121 } 2122 if (IS_POSIX(fl)) { 2123 if (fl->fl_end == OFFSET_MAX) 2124 out += sprintf(out, "%Ld EOF\n", fl->fl_start); 2125 else 2126 out += sprintf(out, "%Ld %Ld\n", fl->fl_start, 2127 fl->fl_end); 2128 } else { 2129 out += sprintf(out, "0 EOF\n"); 2130 } 2131 } 2132 2133 static void move_lock_status(char **p, off_t* pos, off_t offset) 2134 { 2135 int len; 2136 len = strlen(*p); 2137 if(*pos >= offset) { 2138 /* the complete line is valid */ 2139 *p += len; 2140 *pos += len; 2141 return; 2142 } 2143 if(*pos+len > offset) { 2144 /* use the second part of the line */ 2145 int i = offset-*pos; 2146 memmove(*p,*p+i,len-i); 2147 *p += len-i; 2148 *pos += len; 2149 return; 2150 } 2151 /* discard the complete line */ 2152 *pos += len; 2153 } 2154 2155 /** 2156 * get_locks_status - reports lock usage in /proc/locks 2157 * @buffer: address in userspace to write into 2158 * @start: ? 2159 * @offset: how far we are through the buffer 2160 * @length: how much to read 2161 */ 2162 2163 int get_locks_status(char *buffer, char **start, off_t offset, int length) 2164 { 2165 struct list_head *tmp; 2166 char *q = buffer; 2167 off_t pos = 0; 2168 int i = 0; 2169 2170 lock_kernel(); 2171 list_for_each(tmp, &file_lock_list) { 2172 struct list_head *btmp; 2173 struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link); 2174 lock_get_status(q, fl, ++i, ""); 2175 move_lock_status(&q, &pos, offset); 2176 2177 if(pos >= offset+length) 2178 goto done; 2179 2180 list_for_each(btmp, &fl->fl_block) { 2181 struct file_lock *bfl = list_entry(btmp, 2182 struct file_lock, fl_block); 2183 lock_get_status(q, bfl, i, " ->"); 2184 move_lock_status(&q, &pos, offset); 2185 2186 if(pos >= offset+length) 2187 goto done; 2188 } 2189 } 2190 done: 2191 unlock_kernel(); 2192 *start = buffer; 2193 if(q-buffer < length) 2194 return (q-buffer); 2195 return length; 2196 } 2197 2198 /** 2199 * lock_may_read - checks that the region is free of locks 2200 * @inode: the inode that is being read 2201 * @start: the first byte to read 2202 * @len: the number of bytes to read 2203 * 2204 * Emulates Windows locking requirements. Whole-file 2205 * mandatory locks (share modes) can prohibit a read and 2206 * byte-range POSIX locks can prohibit a read if they overlap. 2207 * 2208 * N.B. this function is only ever called 2209 * from knfsd and ownership of locks is never checked. 2210 */ 2211 int lock_may_read(struct inode *inode, loff_t start, unsigned long len) 2212 { 2213 struct file_lock *fl; 2214 int result = 1; 2215 lock_kernel(); 2216 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 2217 if (IS_POSIX(fl)) { 2218 if (fl->fl_type == F_RDLCK) 2219 continue; 2220 if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 2221 continue; 2222 } else if (IS_FLOCK(fl)) { 2223 if (!(fl->fl_type & LOCK_MAND)) 2224 continue; 2225 if (fl->fl_type & LOCK_READ) 2226 continue; 2227 } else 2228 continue; 2229 result = 0; 2230 break; 2231 } 2232 unlock_kernel(); 2233 return result; 2234 } 2235 2236 EXPORT_SYMBOL(lock_may_read); 2237 2238 /** 2239 * lock_may_write - checks that the region is free of locks 2240 * @inode: the inode that is being written 2241 * @start: the first byte to write 2242 * @len: the number of bytes to write 2243 * 2244 * Emulates Windows locking requirements. Whole-file 2245 * mandatory locks (share modes) can prohibit a write and 2246 * byte-range POSIX locks can prohibit a write if they overlap. 2247 * 2248 * N.B. this function is only ever called 2249 * from knfsd and ownership of locks is never checked. 2250 */ 2251 int lock_may_write(struct inode *inode, loff_t start, unsigned long len) 2252 { 2253 struct file_lock *fl; 2254 int result = 1; 2255 lock_kernel(); 2256 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 2257 if (IS_POSIX(fl)) { 2258 if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 2259 continue; 2260 } else if (IS_FLOCK(fl)) { 2261 if (!(fl->fl_type & LOCK_MAND)) 2262 continue; 2263 if (fl->fl_type & LOCK_WRITE) 2264 continue; 2265 } else 2266 continue; 2267 result = 0; 2268 break; 2269 } 2270 unlock_kernel(); 2271 return result; 2272 } 2273 2274 EXPORT_SYMBOL(lock_may_write); 2275 2276 static int __init filelock_init(void) 2277 { 2278 filelock_cache = kmem_cache_create("file_lock_cache", 2279 sizeof(struct file_lock), 0, SLAB_PANIC, 2280 init_once, NULL); 2281 return 0; 2282 } 2283 2284 core_initcall(filelock_init); 2285