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/filesystems/mandatory-locking.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/fdtable.h> 120 #include <linux/fs.h> 121 #include <linux/init.h> 122 #include <linux/module.h> 123 #include <linux/security.h> 124 #include <linux/slab.h> 125 #include <linux/syscalls.h> 126 #include <linux/time.h> 127 #include <linux/rcupdate.h> 128 #include <linux/pid_namespace.h> 129 #include <linux/hashtable.h> 130 #include <linux/percpu.h> 131 #include <linux/lglock.h> 132 133 #include <asm/uaccess.h> 134 135 #define IS_POSIX(fl) (fl->fl_flags & FL_POSIX) 136 #define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK) 137 #define IS_LEASE(fl) (fl->fl_flags & (FL_LEASE|FL_DELEG)) 138 #define IS_OFDLCK(fl) (fl->fl_flags & FL_OFDLCK) 139 140 static bool lease_breaking(struct file_lock *fl) 141 { 142 return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING); 143 } 144 145 static int target_leasetype(struct file_lock *fl) 146 { 147 if (fl->fl_flags & FL_UNLOCK_PENDING) 148 return F_UNLCK; 149 if (fl->fl_flags & FL_DOWNGRADE_PENDING) 150 return F_RDLCK; 151 return fl->fl_type; 152 } 153 154 int leases_enable = 1; 155 int lease_break_time = 45; 156 157 #define for_each_lock(inode, lockp) \ 158 for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next) 159 160 /* 161 * The global file_lock_list is only used for displaying /proc/locks, so we 162 * keep a list on each CPU, with each list protected by its own spinlock via 163 * the file_lock_lglock. Note that alterations to the list also require that 164 * the relevant i_lock is held. 165 */ 166 DEFINE_STATIC_LGLOCK(file_lock_lglock); 167 static DEFINE_PER_CPU(struct hlist_head, file_lock_list); 168 169 /* 170 * The blocked_hash is used to find POSIX lock loops for deadlock detection. 171 * It is protected by blocked_lock_lock. 172 * 173 * We hash locks by lockowner in order to optimize searching for the lock a 174 * particular lockowner is waiting on. 175 * 176 * FIXME: make this value scale via some heuristic? We generally will want more 177 * buckets when we have more lockowners holding locks, but that's a little 178 * difficult to determine without knowing what the workload will look like. 179 */ 180 #define BLOCKED_HASH_BITS 7 181 static DEFINE_HASHTABLE(blocked_hash, BLOCKED_HASH_BITS); 182 183 /* 184 * This lock protects the blocked_hash. Generally, if you're accessing it, you 185 * want to be holding this lock. 186 * 187 * In addition, it also protects the fl->fl_block list, and the fl->fl_next 188 * pointer for file_lock structures that are acting as lock requests (in 189 * contrast to those that are acting as records of acquired locks). 190 * 191 * Note that when we acquire this lock in order to change the above fields, 192 * we often hold the i_lock as well. In certain cases, when reading the fields 193 * protected by this lock, we can skip acquiring it iff we already hold the 194 * i_lock. 195 * 196 * In particular, adding an entry to the fl_block list requires that you hold 197 * both the i_lock and the blocked_lock_lock (acquired in that order). Deleting 198 * an entry from the list however only requires the file_lock_lock. 199 */ 200 static DEFINE_SPINLOCK(blocked_lock_lock); 201 202 static struct kmem_cache *filelock_cache __read_mostly; 203 204 static void locks_init_lock_heads(struct file_lock *fl) 205 { 206 INIT_HLIST_NODE(&fl->fl_link); 207 INIT_LIST_HEAD(&fl->fl_block); 208 init_waitqueue_head(&fl->fl_wait); 209 } 210 211 /* Allocate an empty lock structure. */ 212 struct file_lock *locks_alloc_lock(void) 213 { 214 struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL); 215 216 if (fl) 217 locks_init_lock_heads(fl); 218 219 return fl; 220 } 221 EXPORT_SYMBOL_GPL(locks_alloc_lock); 222 223 void locks_release_private(struct file_lock *fl) 224 { 225 if (fl->fl_ops) { 226 if (fl->fl_ops->fl_release_private) 227 fl->fl_ops->fl_release_private(fl); 228 fl->fl_ops = NULL; 229 } 230 fl->fl_lmops = NULL; 231 232 } 233 EXPORT_SYMBOL_GPL(locks_release_private); 234 235 /* Free a lock which is not in use. */ 236 void locks_free_lock(struct file_lock *fl) 237 { 238 BUG_ON(waitqueue_active(&fl->fl_wait)); 239 BUG_ON(!list_empty(&fl->fl_block)); 240 BUG_ON(!hlist_unhashed(&fl->fl_link)); 241 242 locks_release_private(fl); 243 kmem_cache_free(filelock_cache, fl); 244 } 245 EXPORT_SYMBOL(locks_free_lock); 246 247 void locks_init_lock(struct file_lock *fl) 248 { 249 memset(fl, 0, sizeof(struct file_lock)); 250 locks_init_lock_heads(fl); 251 } 252 253 EXPORT_SYMBOL(locks_init_lock); 254 255 static void locks_copy_private(struct file_lock *new, struct file_lock *fl) 256 { 257 if (fl->fl_ops) { 258 if (fl->fl_ops->fl_copy_lock) 259 fl->fl_ops->fl_copy_lock(new, fl); 260 new->fl_ops = fl->fl_ops; 261 } 262 if (fl->fl_lmops) 263 new->fl_lmops = fl->fl_lmops; 264 } 265 266 /* 267 * Initialize a new lock from an existing file_lock structure. 268 */ 269 void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl) 270 { 271 new->fl_owner = fl->fl_owner; 272 new->fl_pid = fl->fl_pid; 273 new->fl_file = NULL; 274 new->fl_flags = fl->fl_flags; 275 new->fl_type = fl->fl_type; 276 new->fl_start = fl->fl_start; 277 new->fl_end = fl->fl_end; 278 new->fl_ops = NULL; 279 new->fl_lmops = NULL; 280 } 281 EXPORT_SYMBOL(__locks_copy_lock); 282 283 void locks_copy_lock(struct file_lock *new, struct file_lock *fl) 284 { 285 locks_release_private(new); 286 287 __locks_copy_lock(new, fl); 288 new->fl_file = fl->fl_file; 289 new->fl_ops = fl->fl_ops; 290 new->fl_lmops = fl->fl_lmops; 291 292 locks_copy_private(new, fl); 293 } 294 295 EXPORT_SYMBOL(locks_copy_lock); 296 297 static inline int flock_translate_cmd(int cmd) { 298 if (cmd & LOCK_MAND) 299 return cmd & (LOCK_MAND | LOCK_RW); 300 switch (cmd) { 301 case LOCK_SH: 302 return F_RDLCK; 303 case LOCK_EX: 304 return F_WRLCK; 305 case LOCK_UN: 306 return F_UNLCK; 307 } 308 return -EINVAL; 309 } 310 311 /* Fill in a file_lock structure with an appropriate FLOCK lock. */ 312 static int flock_make_lock(struct file *filp, struct file_lock **lock, 313 unsigned int cmd) 314 { 315 struct file_lock *fl; 316 int type = flock_translate_cmd(cmd); 317 if (type < 0) 318 return type; 319 320 fl = locks_alloc_lock(); 321 if (fl == NULL) 322 return -ENOMEM; 323 324 fl->fl_file = filp; 325 fl->fl_pid = current->tgid; 326 fl->fl_flags = FL_FLOCK; 327 fl->fl_type = type; 328 fl->fl_end = OFFSET_MAX; 329 330 *lock = fl; 331 return 0; 332 } 333 334 static int assign_type(struct file_lock *fl, long type) 335 { 336 switch (type) { 337 case F_RDLCK: 338 case F_WRLCK: 339 case F_UNLCK: 340 fl->fl_type = type; 341 break; 342 default: 343 return -EINVAL; 344 } 345 return 0; 346 } 347 348 static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, 349 struct flock64 *l) 350 { 351 switch (l->l_whence) { 352 case SEEK_SET: 353 fl->fl_start = 0; 354 break; 355 case SEEK_CUR: 356 fl->fl_start = filp->f_pos; 357 break; 358 case SEEK_END: 359 fl->fl_start = i_size_read(file_inode(filp)); 360 break; 361 default: 362 return -EINVAL; 363 } 364 if (l->l_start > OFFSET_MAX - fl->fl_start) 365 return -EOVERFLOW; 366 fl->fl_start += l->l_start; 367 if (fl->fl_start < 0) 368 return -EINVAL; 369 370 /* POSIX-1996 leaves the case l->l_len < 0 undefined; 371 POSIX-2001 defines it. */ 372 if (l->l_len > 0) { 373 if (l->l_len - 1 > OFFSET_MAX - fl->fl_start) 374 return -EOVERFLOW; 375 fl->fl_end = fl->fl_start + l->l_len - 1; 376 377 } else if (l->l_len < 0) { 378 if (fl->fl_start + l->l_len < 0) 379 return -EINVAL; 380 fl->fl_end = fl->fl_start - 1; 381 fl->fl_start += l->l_len; 382 } else 383 fl->fl_end = OFFSET_MAX; 384 385 fl->fl_owner = current->files; 386 fl->fl_pid = current->tgid; 387 fl->fl_file = filp; 388 fl->fl_flags = FL_POSIX; 389 fl->fl_ops = NULL; 390 fl->fl_lmops = NULL; 391 392 return assign_type(fl, l->l_type); 393 } 394 395 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX 396 * style lock. 397 */ 398 static int flock_to_posix_lock(struct file *filp, struct file_lock *fl, 399 struct flock *l) 400 { 401 struct flock64 ll = { 402 .l_type = l->l_type, 403 .l_whence = l->l_whence, 404 .l_start = l->l_start, 405 .l_len = l->l_len, 406 }; 407 408 return flock64_to_posix_lock(filp, fl, &ll); 409 } 410 411 /* default lease lock manager operations */ 412 static void lease_break_callback(struct file_lock *fl) 413 { 414 kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG); 415 } 416 417 static const struct lock_manager_operations lease_manager_ops = { 418 .lm_break = lease_break_callback, 419 .lm_change = lease_modify, 420 }; 421 422 /* 423 * Initialize a lease, use the default lock manager operations 424 */ 425 static int lease_init(struct file *filp, long type, struct file_lock *fl) 426 { 427 if (assign_type(fl, type) != 0) 428 return -EINVAL; 429 430 fl->fl_owner = current->files; 431 fl->fl_pid = current->tgid; 432 433 fl->fl_file = filp; 434 fl->fl_flags = FL_LEASE; 435 fl->fl_start = 0; 436 fl->fl_end = OFFSET_MAX; 437 fl->fl_ops = NULL; 438 fl->fl_lmops = &lease_manager_ops; 439 return 0; 440 } 441 442 /* Allocate a file_lock initialised to this type of lease */ 443 static struct file_lock *lease_alloc(struct file *filp, long type) 444 { 445 struct file_lock *fl = locks_alloc_lock(); 446 int error = -ENOMEM; 447 448 if (fl == NULL) 449 return ERR_PTR(error); 450 451 error = lease_init(filp, type, fl); 452 if (error) { 453 locks_free_lock(fl); 454 return ERR_PTR(error); 455 } 456 return fl; 457 } 458 459 /* Check if two locks overlap each other. 460 */ 461 static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) 462 { 463 return ((fl1->fl_end >= fl2->fl_start) && 464 (fl2->fl_end >= fl1->fl_start)); 465 } 466 467 /* 468 * Check whether two locks have the same owner. 469 */ 470 static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2) 471 { 472 if (fl1->fl_lmops && fl1->fl_lmops->lm_compare_owner) 473 return fl2->fl_lmops == fl1->fl_lmops && 474 fl1->fl_lmops->lm_compare_owner(fl1, fl2); 475 return fl1->fl_owner == fl2->fl_owner; 476 } 477 478 /* Must be called with the i_lock held! */ 479 static void locks_insert_global_locks(struct file_lock *fl) 480 { 481 lg_local_lock(&file_lock_lglock); 482 fl->fl_link_cpu = smp_processor_id(); 483 hlist_add_head(&fl->fl_link, this_cpu_ptr(&file_lock_list)); 484 lg_local_unlock(&file_lock_lglock); 485 } 486 487 /* Must be called with the i_lock held! */ 488 static void locks_delete_global_locks(struct file_lock *fl) 489 { 490 /* 491 * Avoid taking lock if already unhashed. This is safe since this check 492 * is done while holding the i_lock, and new insertions into the list 493 * also require that it be held. 494 */ 495 if (hlist_unhashed(&fl->fl_link)) 496 return; 497 lg_local_lock_cpu(&file_lock_lglock, fl->fl_link_cpu); 498 hlist_del_init(&fl->fl_link); 499 lg_local_unlock_cpu(&file_lock_lglock, fl->fl_link_cpu); 500 } 501 502 static unsigned long 503 posix_owner_key(struct file_lock *fl) 504 { 505 if (fl->fl_lmops && fl->fl_lmops->lm_owner_key) 506 return fl->fl_lmops->lm_owner_key(fl); 507 return (unsigned long)fl->fl_owner; 508 } 509 510 static void locks_insert_global_blocked(struct file_lock *waiter) 511 { 512 hash_add(blocked_hash, &waiter->fl_link, posix_owner_key(waiter)); 513 } 514 515 static void locks_delete_global_blocked(struct file_lock *waiter) 516 { 517 hash_del(&waiter->fl_link); 518 } 519 520 /* Remove waiter from blocker's block list. 521 * When blocker ends up pointing to itself then the list is empty. 522 * 523 * Must be called with blocked_lock_lock held. 524 */ 525 static void __locks_delete_block(struct file_lock *waiter) 526 { 527 locks_delete_global_blocked(waiter); 528 list_del_init(&waiter->fl_block); 529 waiter->fl_next = NULL; 530 } 531 532 static void locks_delete_block(struct file_lock *waiter) 533 { 534 spin_lock(&blocked_lock_lock); 535 __locks_delete_block(waiter); 536 spin_unlock(&blocked_lock_lock); 537 } 538 539 /* Insert waiter into blocker's block list. 540 * We use a circular list so that processes can be easily woken up in 541 * the order they blocked. The documentation doesn't require this but 542 * it seems like the reasonable thing to do. 543 * 544 * Must be called with both the i_lock and blocked_lock_lock held. The fl_block 545 * list itself is protected by the blocked_lock_lock, but by ensuring that the 546 * i_lock is also held on insertions we can avoid taking the blocked_lock_lock 547 * in some cases when we see that the fl_block list is empty. 548 */ 549 static void __locks_insert_block(struct file_lock *blocker, 550 struct file_lock *waiter) 551 { 552 BUG_ON(!list_empty(&waiter->fl_block)); 553 waiter->fl_next = blocker; 554 list_add_tail(&waiter->fl_block, &blocker->fl_block); 555 if (IS_POSIX(blocker) && !IS_OFDLCK(blocker)) 556 locks_insert_global_blocked(waiter); 557 } 558 559 /* Must be called with i_lock held. */ 560 static void locks_insert_block(struct file_lock *blocker, 561 struct file_lock *waiter) 562 { 563 spin_lock(&blocked_lock_lock); 564 __locks_insert_block(blocker, waiter); 565 spin_unlock(&blocked_lock_lock); 566 } 567 568 /* 569 * Wake up processes blocked waiting for blocker. 570 * 571 * Must be called with the inode->i_lock held! 572 */ 573 static void locks_wake_up_blocks(struct file_lock *blocker) 574 { 575 /* 576 * Avoid taking global lock if list is empty. This is safe since new 577 * blocked requests are only added to the list under the i_lock, and 578 * the i_lock is always held here. Note that removal from the fl_block 579 * list does not require the i_lock, so we must recheck list_empty() 580 * after acquiring the blocked_lock_lock. 581 */ 582 if (list_empty(&blocker->fl_block)) 583 return; 584 585 spin_lock(&blocked_lock_lock); 586 while (!list_empty(&blocker->fl_block)) { 587 struct file_lock *waiter; 588 589 waiter = list_first_entry(&blocker->fl_block, 590 struct file_lock, fl_block); 591 __locks_delete_block(waiter); 592 if (waiter->fl_lmops && waiter->fl_lmops->lm_notify) 593 waiter->fl_lmops->lm_notify(waiter); 594 else 595 wake_up(&waiter->fl_wait); 596 } 597 spin_unlock(&blocked_lock_lock); 598 } 599 600 /* Insert file lock fl into an inode's lock list at the position indicated 601 * by pos. At the same time add the lock to the global file lock list. 602 * 603 * Must be called with the i_lock held! 604 */ 605 static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl) 606 { 607 fl->fl_nspid = get_pid(task_tgid(current)); 608 609 /* insert into file's list */ 610 fl->fl_next = *pos; 611 *pos = fl; 612 613 locks_insert_global_locks(fl); 614 } 615 616 /** 617 * locks_delete_lock - Delete a lock and then free it. 618 * @thisfl_p: pointer that points to the fl_next field of the previous 619 * inode->i_flock list entry 620 * 621 * Unlink a lock from all lists and free the namespace reference, but don't 622 * free it yet. Wake up processes that are blocked waiting for this lock and 623 * notify the FS that the lock has been cleared. 624 * 625 * Must be called with the i_lock held! 626 */ 627 static void locks_unlink_lock(struct file_lock **thisfl_p) 628 { 629 struct file_lock *fl = *thisfl_p; 630 631 locks_delete_global_locks(fl); 632 633 *thisfl_p = fl->fl_next; 634 fl->fl_next = NULL; 635 636 if (fl->fl_nspid) { 637 put_pid(fl->fl_nspid); 638 fl->fl_nspid = NULL; 639 } 640 641 locks_wake_up_blocks(fl); 642 } 643 644 /* 645 * Unlink a lock from all lists and free it. 646 * 647 * Must be called with i_lock held! 648 */ 649 static void locks_delete_lock(struct file_lock **thisfl_p) 650 { 651 struct file_lock *fl = *thisfl_p; 652 653 locks_unlink_lock(thisfl_p); 654 locks_free_lock(fl); 655 } 656 657 /* Determine if lock sys_fl blocks lock caller_fl. Common functionality 658 * checks for shared/exclusive status of overlapping locks. 659 */ 660 static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 661 { 662 if (sys_fl->fl_type == F_WRLCK) 663 return 1; 664 if (caller_fl->fl_type == F_WRLCK) 665 return 1; 666 return 0; 667 } 668 669 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific 670 * checking before calling the locks_conflict(). 671 */ 672 static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 673 { 674 /* POSIX locks owned by the same process do not conflict with 675 * each other. 676 */ 677 if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl)) 678 return (0); 679 680 /* Check whether they overlap */ 681 if (!locks_overlap(caller_fl, sys_fl)) 682 return 0; 683 684 return (locks_conflict(caller_fl, sys_fl)); 685 } 686 687 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific 688 * checking before calling the locks_conflict(). 689 */ 690 static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 691 { 692 /* FLOCK locks referring to the same filp do not conflict with 693 * each other. 694 */ 695 if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file)) 696 return (0); 697 if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND)) 698 return 0; 699 700 return (locks_conflict(caller_fl, sys_fl)); 701 } 702 703 void 704 posix_test_lock(struct file *filp, struct file_lock *fl) 705 { 706 struct file_lock *cfl; 707 struct inode *inode = file_inode(filp); 708 709 spin_lock(&inode->i_lock); 710 for (cfl = file_inode(filp)->i_flock; cfl; cfl = cfl->fl_next) { 711 if (!IS_POSIX(cfl)) 712 continue; 713 if (posix_locks_conflict(fl, cfl)) 714 break; 715 } 716 if (cfl) { 717 __locks_copy_lock(fl, cfl); 718 if (cfl->fl_nspid) 719 fl->fl_pid = pid_vnr(cfl->fl_nspid); 720 } else 721 fl->fl_type = F_UNLCK; 722 spin_unlock(&inode->i_lock); 723 return; 724 } 725 EXPORT_SYMBOL(posix_test_lock); 726 727 /* 728 * Deadlock detection: 729 * 730 * We attempt to detect deadlocks that are due purely to posix file 731 * locks. 732 * 733 * We assume that a task can be waiting for at most one lock at a time. 734 * So for any acquired lock, the process holding that lock may be 735 * waiting on at most one other lock. That lock in turns may be held by 736 * someone waiting for at most one other lock. Given a requested lock 737 * caller_fl which is about to wait for a conflicting lock block_fl, we 738 * follow this chain of waiters to ensure we are not about to create a 739 * cycle. 740 * 741 * Since we do this before we ever put a process to sleep on a lock, we 742 * are ensured that there is never a cycle; that is what guarantees that 743 * the while() loop in posix_locks_deadlock() eventually completes. 744 * 745 * Note: the above assumption may not be true when handling lock 746 * requests from a broken NFS client. It may also fail in the presence 747 * of tasks (such as posix threads) sharing the same open file table. 748 * To handle those cases, we just bail out after a few iterations. 749 * 750 * For FL_OFDLCK locks, the owner is the filp, not the files_struct. 751 * Because the owner is not even nominally tied to a thread of 752 * execution, the deadlock detection below can't reasonably work well. Just 753 * skip it for those. 754 * 755 * In principle, we could do a more limited deadlock detection on FL_OFDLCK 756 * locks that just checks for the case where two tasks are attempting to 757 * upgrade from read to write locks on the same inode. 758 */ 759 760 #define MAX_DEADLK_ITERATIONS 10 761 762 /* Find a lock that the owner of the given block_fl is blocking on. */ 763 static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl) 764 { 765 struct file_lock *fl; 766 767 hash_for_each_possible(blocked_hash, fl, fl_link, posix_owner_key(block_fl)) { 768 if (posix_same_owner(fl, block_fl)) 769 return fl->fl_next; 770 } 771 return NULL; 772 } 773 774 /* Must be called with the blocked_lock_lock held! */ 775 static int posix_locks_deadlock(struct file_lock *caller_fl, 776 struct file_lock *block_fl) 777 { 778 int i = 0; 779 780 /* 781 * This deadlock detector can't reasonably detect deadlocks with 782 * FL_OFDLCK locks, since they aren't owned by a process, per-se. 783 */ 784 if (IS_OFDLCK(caller_fl)) 785 return 0; 786 787 while ((block_fl = what_owner_is_waiting_for(block_fl))) { 788 if (i++ > MAX_DEADLK_ITERATIONS) 789 return 0; 790 if (posix_same_owner(caller_fl, block_fl)) 791 return 1; 792 } 793 return 0; 794 } 795 796 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks 797 * after any leases, but before any posix locks. 798 * 799 * Note that if called with an FL_EXISTS argument, the caller may determine 800 * whether or not a lock was successfully freed by testing the return 801 * value for -ENOENT. 802 */ 803 static int flock_lock_file(struct file *filp, struct file_lock *request) 804 { 805 struct file_lock *new_fl = NULL; 806 struct file_lock **before; 807 struct inode * inode = file_inode(filp); 808 int error = 0; 809 int found = 0; 810 811 if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) { 812 new_fl = locks_alloc_lock(); 813 if (!new_fl) 814 return -ENOMEM; 815 } 816 817 spin_lock(&inode->i_lock); 818 if (request->fl_flags & FL_ACCESS) 819 goto find_conflict; 820 821 for_each_lock(inode, before) { 822 struct file_lock *fl = *before; 823 if (IS_POSIX(fl)) 824 break; 825 if (IS_LEASE(fl)) 826 continue; 827 if (filp != fl->fl_file) 828 continue; 829 if (request->fl_type == fl->fl_type) 830 goto out; 831 found = 1; 832 locks_delete_lock(before); 833 break; 834 } 835 836 if (request->fl_type == F_UNLCK) { 837 if ((request->fl_flags & FL_EXISTS) && !found) 838 error = -ENOENT; 839 goto out; 840 } 841 842 /* 843 * If a higher-priority process was blocked on the old file lock, 844 * give it the opportunity to lock the file. 845 */ 846 if (found) { 847 spin_unlock(&inode->i_lock); 848 cond_resched(); 849 spin_lock(&inode->i_lock); 850 } 851 852 find_conflict: 853 for_each_lock(inode, before) { 854 struct file_lock *fl = *before; 855 if (IS_POSIX(fl)) 856 break; 857 if (IS_LEASE(fl)) 858 continue; 859 if (!flock_locks_conflict(request, fl)) 860 continue; 861 error = -EAGAIN; 862 if (!(request->fl_flags & FL_SLEEP)) 863 goto out; 864 error = FILE_LOCK_DEFERRED; 865 locks_insert_block(fl, request); 866 goto out; 867 } 868 if (request->fl_flags & FL_ACCESS) 869 goto out; 870 locks_copy_lock(new_fl, request); 871 locks_insert_lock(before, new_fl); 872 new_fl = NULL; 873 error = 0; 874 875 out: 876 spin_unlock(&inode->i_lock); 877 if (new_fl) 878 locks_free_lock(new_fl); 879 return error; 880 } 881 882 static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock) 883 { 884 struct file_lock *fl; 885 struct file_lock *new_fl = NULL; 886 struct file_lock *new_fl2 = NULL; 887 struct file_lock *left = NULL; 888 struct file_lock *right = NULL; 889 struct file_lock **before; 890 int error; 891 bool added = false; 892 893 /* 894 * We may need two file_lock structures for this operation, 895 * so we get them in advance to avoid races. 896 * 897 * In some cases we can be sure, that no new locks will be needed 898 */ 899 if (!(request->fl_flags & FL_ACCESS) && 900 (request->fl_type != F_UNLCK || 901 request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { 902 new_fl = locks_alloc_lock(); 903 new_fl2 = locks_alloc_lock(); 904 } 905 906 spin_lock(&inode->i_lock); 907 /* 908 * New lock request. Walk all POSIX locks and look for conflicts. If 909 * there are any, either return error or put the request on the 910 * blocker's list of waiters and the global blocked_hash. 911 */ 912 if (request->fl_type != F_UNLCK) { 913 for_each_lock(inode, before) { 914 fl = *before; 915 if (!IS_POSIX(fl)) 916 continue; 917 if (!posix_locks_conflict(request, fl)) 918 continue; 919 if (conflock) 920 __locks_copy_lock(conflock, fl); 921 error = -EAGAIN; 922 if (!(request->fl_flags & FL_SLEEP)) 923 goto out; 924 /* 925 * Deadlock detection and insertion into the blocked 926 * locks list must be done while holding the same lock! 927 */ 928 error = -EDEADLK; 929 spin_lock(&blocked_lock_lock); 930 if (likely(!posix_locks_deadlock(request, fl))) { 931 error = FILE_LOCK_DEFERRED; 932 __locks_insert_block(fl, request); 933 } 934 spin_unlock(&blocked_lock_lock); 935 goto out; 936 } 937 } 938 939 /* If we're just looking for a conflict, we're done. */ 940 error = 0; 941 if (request->fl_flags & FL_ACCESS) 942 goto out; 943 944 /* 945 * Find the first old lock with the same owner as the new lock. 946 */ 947 948 before = &inode->i_flock; 949 950 /* First skip locks owned by other processes. */ 951 while ((fl = *before) && (!IS_POSIX(fl) || 952 !posix_same_owner(request, fl))) { 953 before = &fl->fl_next; 954 } 955 956 /* Process locks with this owner. */ 957 while ((fl = *before) && posix_same_owner(request, fl)) { 958 /* Detect adjacent or overlapping regions (if same lock type) 959 */ 960 if (request->fl_type == fl->fl_type) { 961 /* In all comparisons of start vs end, use 962 * "start - 1" rather than "end + 1". If end 963 * is OFFSET_MAX, end + 1 will become negative. 964 */ 965 if (fl->fl_end < request->fl_start - 1) 966 goto next_lock; 967 /* If the next lock in the list has entirely bigger 968 * addresses than the new one, insert the lock here. 969 */ 970 if (fl->fl_start - 1 > request->fl_end) 971 break; 972 973 /* If we come here, the new and old lock are of the 974 * same type and adjacent or overlapping. Make one 975 * lock yielding from the lower start address of both 976 * locks to the higher end address. 977 */ 978 if (fl->fl_start > request->fl_start) 979 fl->fl_start = request->fl_start; 980 else 981 request->fl_start = fl->fl_start; 982 if (fl->fl_end < request->fl_end) 983 fl->fl_end = request->fl_end; 984 else 985 request->fl_end = fl->fl_end; 986 if (added) { 987 locks_delete_lock(before); 988 continue; 989 } 990 request = fl; 991 added = true; 992 } 993 else { 994 /* Processing for different lock types is a bit 995 * more complex. 996 */ 997 if (fl->fl_end < request->fl_start) 998 goto next_lock; 999 if (fl->fl_start > request->fl_end) 1000 break; 1001 if (request->fl_type == F_UNLCK) 1002 added = true; 1003 if (fl->fl_start < request->fl_start) 1004 left = fl; 1005 /* If the next lock in the list has a higher end 1006 * address than the new one, insert the new one here. 1007 */ 1008 if (fl->fl_end > request->fl_end) { 1009 right = fl; 1010 break; 1011 } 1012 if (fl->fl_start >= request->fl_start) { 1013 /* The new lock completely replaces an old 1014 * one (This may happen several times). 1015 */ 1016 if (added) { 1017 locks_delete_lock(before); 1018 continue; 1019 } 1020 /* Replace the old lock with the new one. 1021 * Wake up anybody waiting for the old one, 1022 * as the change in lock type might satisfy 1023 * their needs. 1024 */ 1025 locks_wake_up_blocks(fl); 1026 fl->fl_start = request->fl_start; 1027 fl->fl_end = request->fl_end; 1028 fl->fl_type = request->fl_type; 1029 locks_release_private(fl); 1030 locks_copy_private(fl, request); 1031 request = fl; 1032 added = true; 1033 } 1034 } 1035 /* Go on to next lock. 1036 */ 1037 next_lock: 1038 before = &fl->fl_next; 1039 } 1040 1041 /* 1042 * The above code only modifies existing locks in case of merging or 1043 * replacing. If new lock(s) need to be inserted all modifications are 1044 * done below this, so it's safe yet to bail out. 1045 */ 1046 error = -ENOLCK; /* "no luck" */ 1047 if (right && left == right && !new_fl2) 1048 goto out; 1049 1050 error = 0; 1051 if (!added) { 1052 if (request->fl_type == F_UNLCK) { 1053 if (request->fl_flags & FL_EXISTS) 1054 error = -ENOENT; 1055 goto out; 1056 } 1057 1058 if (!new_fl) { 1059 error = -ENOLCK; 1060 goto out; 1061 } 1062 locks_copy_lock(new_fl, request); 1063 locks_insert_lock(before, new_fl); 1064 new_fl = NULL; 1065 } 1066 if (right) { 1067 if (left == right) { 1068 /* The new lock breaks the old one in two pieces, 1069 * so we have to use the second new lock. 1070 */ 1071 left = new_fl2; 1072 new_fl2 = NULL; 1073 locks_copy_lock(left, right); 1074 locks_insert_lock(before, left); 1075 } 1076 right->fl_start = request->fl_end + 1; 1077 locks_wake_up_blocks(right); 1078 } 1079 if (left) { 1080 left->fl_end = request->fl_start - 1; 1081 locks_wake_up_blocks(left); 1082 } 1083 out: 1084 spin_unlock(&inode->i_lock); 1085 /* 1086 * Free any unused locks. 1087 */ 1088 if (new_fl) 1089 locks_free_lock(new_fl); 1090 if (new_fl2) 1091 locks_free_lock(new_fl2); 1092 return error; 1093 } 1094 1095 /** 1096 * posix_lock_file - Apply a POSIX-style lock to a file 1097 * @filp: The file to apply the lock to 1098 * @fl: The lock to be applied 1099 * @conflock: Place to return a copy of the conflicting lock, if found. 1100 * 1101 * Add a POSIX style lock to a file. 1102 * We merge adjacent & overlapping locks whenever possible. 1103 * POSIX locks are sorted by owner task, then by starting address 1104 * 1105 * Note that if called with an FL_EXISTS argument, the caller may determine 1106 * whether or not a lock was successfully freed by testing the return 1107 * value for -ENOENT. 1108 */ 1109 int posix_lock_file(struct file *filp, struct file_lock *fl, 1110 struct file_lock *conflock) 1111 { 1112 return __posix_lock_file(file_inode(filp), fl, conflock); 1113 } 1114 EXPORT_SYMBOL(posix_lock_file); 1115 1116 /** 1117 * posix_lock_file_wait - Apply a POSIX-style lock to a file 1118 * @filp: The file to apply the lock to 1119 * @fl: The lock to be applied 1120 * 1121 * Add a POSIX style lock to a file. 1122 * We merge adjacent & overlapping locks whenever possible. 1123 * POSIX locks are sorted by owner task, then by starting address 1124 */ 1125 int posix_lock_file_wait(struct file *filp, struct file_lock *fl) 1126 { 1127 int error; 1128 might_sleep (); 1129 for (;;) { 1130 error = posix_lock_file(filp, fl, NULL); 1131 if (error != FILE_LOCK_DEFERRED) 1132 break; 1133 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 1134 if (!error) 1135 continue; 1136 1137 locks_delete_block(fl); 1138 break; 1139 } 1140 return error; 1141 } 1142 EXPORT_SYMBOL(posix_lock_file_wait); 1143 1144 /** 1145 * locks_mandatory_locked - Check for an active lock 1146 * @file: the file to check 1147 * 1148 * Searches the inode's list of locks to find any POSIX locks which conflict. 1149 * This function is called from locks_verify_locked() only. 1150 */ 1151 int locks_mandatory_locked(struct file *file) 1152 { 1153 struct inode *inode = file_inode(file); 1154 fl_owner_t owner = current->files; 1155 struct file_lock *fl; 1156 1157 /* 1158 * Search the lock list for this inode for any POSIX locks. 1159 */ 1160 spin_lock(&inode->i_lock); 1161 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 1162 if (!IS_POSIX(fl)) 1163 continue; 1164 if (fl->fl_owner != owner && fl->fl_owner != (fl_owner_t)file) 1165 break; 1166 } 1167 spin_unlock(&inode->i_lock); 1168 return fl ? -EAGAIN : 0; 1169 } 1170 1171 /** 1172 * locks_mandatory_area - Check for a conflicting lock 1173 * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ 1174 * for shared 1175 * @inode: the file to check 1176 * @filp: how the file was opened (if it was) 1177 * @offset: start of area to check 1178 * @count: length of area to check 1179 * 1180 * Searches the inode's list of locks to find any POSIX locks which conflict. 1181 * This function is called from rw_verify_area() and 1182 * locks_verify_truncate(). 1183 */ 1184 int locks_mandatory_area(int read_write, struct inode *inode, 1185 struct file *filp, loff_t offset, 1186 size_t count) 1187 { 1188 struct file_lock fl; 1189 int error; 1190 bool sleep = false; 1191 1192 locks_init_lock(&fl); 1193 fl.fl_pid = current->tgid; 1194 fl.fl_file = filp; 1195 fl.fl_flags = FL_POSIX | FL_ACCESS; 1196 if (filp && !(filp->f_flags & O_NONBLOCK)) 1197 sleep = true; 1198 fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK; 1199 fl.fl_start = offset; 1200 fl.fl_end = offset + count - 1; 1201 1202 for (;;) { 1203 if (filp) { 1204 fl.fl_owner = (fl_owner_t)filp; 1205 fl.fl_flags &= ~FL_SLEEP; 1206 error = __posix_lock_file(inode, &fl, NULL); 1207 if (!error) 1208 break; 1209 } 1210 1211 if (sleep) 1212 fl.fl_flags |= FL_SLEEP; 1213 fl.fl_owner = current->files; 1214 error = __posix_lock_file(inode, &fl, NULL); 1215 if (error != FILE_LOCK_DEFERRED) 1216 break; 1217 error = wait_event_interruptible(fl.fl_wait, !fl.fl_next); 1218 if (!error) { 1219 /* 1220 * If we've been sleeping someone might have 1221 * changed the permissions behind our back. 1222 */ 1223 if (__mandatory_lock(inode)) 1224 continue; 1225 } 1226 1227 locks_delete_block(&fl); 1228 break; 1229 } 1230 1231 return error; 1232 } 1233 1234 EXPORT_SYMBOL(locks_mandatory_area); 1235 1236 static void lease_clear_pending(struct file_lock *fl, int arg) 1237 { 1238 switch (arg) { 1239 case F_UNLCK: 1240 fl->fl_flags &= ~FL_UNLOCK_PENDING; 1241 /* fall through: */ 1242 case F_RDLCK: 1243 fl->fl_flags &= ~FL_DOWNGRADE_PENDING; 1244 } 1245 } 1246 1247 /* We already had a lease on this file; just change its type */ 1248 int lease_modify(struct file_lock **before, int arg) 1249 { 1250 struct file_lock *fl = *before; 1251 int error = assign_type(fl, arg); 1252 1253 if (error) 1254 return error; 1255 lease_clear_pending(fl, arg); 1256 locks_wake_up_blocks(fl); 1257 if (arg == F_UNLCK) { 1258 struct file *filp = fl->fl_file; 1259 1260 f_delown(filp); 1261 filp->f_owner.signum = 0; 1262 fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); 1263 if (fl->fl_fasync != NULL) { 1264 printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync); 1265 fl->fl_fasync = NULL; 1266 } 1267 locks_delete_lock(before); 1268 } 1269 return 0; 1270 } 1271 1272 EXPORT_SYMBOL(lease_modify); 1273 1274 static bool past_time(unsigned long then) 1275 { 1276 if (!then) 1277 /* 0 is a special value meaning "this never expires": */ 1278 return false; 1279 return time_after(jiffies, then); 1280 } 1281 1282 static void time_out_leases(struct inode *inode) 1283 { 1284 struct file_lock **before; 1285 struct file_lock *fl; 1286 1287 before = &inode->i_flock; 1288 while ((fl = *before) && IS_LEASE(fl) && lease_breaking(fl)) { 1289 if (past_time(fl->fl_downgrade_time)) 1290 lease_modify(before, F_RDLCK); 1291 if (past_time(fl->fl_break_time)) 1292 lease_modify(before, F_UNLCK); 1293 if (fl == *before) /* lease_modify may have freed fl */ 1294 before = &fl->fl_next; 1295 } 1296 } 1297 1298 static bool leases_conflict(struct file_lock *lease, struct file_lock *breaker) 1299 { 1300 if ((breaker->fl_flags & FL_DELEG) && (lease->fl_flags & FL_LEASE)) 1301 return false; 1302 return locks_conflict(breaker, lease); 1303 } 1304 1305 /** 1306 * __break_lease - revoke all outstanding leases on file 1307 * @inode: the inode of the file to return 1308 * @mode: O_RDONLY: break only write leases; O_WRONLY or O_RDWR: 1309 * break all leases 1310 * @type: FL_LEASE: break leases and delegations; FL_DELEG: break 1311 * only delegations 1312 * 1313 * break_lease (inlined for speed) has checked there already is at least 1314 * some kind of lock (maybe a lease) on this file. Leases are broken on 1315 * a call to open() or truncate(). This function can sleep unless you 1316 * specified %O_NONBLOCK to your open(). 1317 */ 1318 int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) 1319 { 1320 int error = 0; 1321 struct file_lock *new_fl, *flock; 1322 struct file_lock *fl; 1323 unsigned long break_time; 1324 int i_have_this_lease = 0; 1325 bool lease_conflict = false; 1326 int want_write = (mode & O_ACCMODE) != O_RDONLY; 1327 1328 new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK); 1329 if (IS_ERR(new_fl)) 1330 return PTR_ERR(new_fl); 1331 new_fl->fl_flags = type; 1332 1333 spin_lock(&inode->i_lock); 1334 1335 time_out_leases(inode); 1336 1337 flock = inode->i_flock; 1338 if ((flock == NULL) || !IS_LEASE(flock)) 1339 goto out; 1340 1341 for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) { 1342 if (leases_conflict(fl, new_fl)) { 1343 lease_conflict = true; 1344 if (fl->fl_owner == current->files) 1345 i_have_this_lease = 1; 1346 } 1347 } 1348 if (!lease_conflict) 1349 goto out; 1350 1351 break_time = 0; 1352 if (lease_break_time > 0) { 1353 break_time = jiffies + lease_break_time * HZ; 1354 if (break_time == 0) 1355 break_time++; /* so that 0 means no break time */ 1356 } 1357 1358 for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) { 1359 if (!leases_conflict(fl, new_fl)) 1360 continue; 1361 if (want_write) { 1362 if (fl->fl_flags & FL_UNLOCK_PENDING) 1363 continue; 1364 fl->fl_flags |= FL_UNLOCK_PENDING; 1365 fl->fl_break_time = break_time; 1366 } else { 1367 if (lease_breaking(flock)) 1368 continue; 1369 fl->fl_flags |= FL_DOWNGRADE_PENDING; 1370 fl->fl_downgrade_time = break_time; 1371 } 1372 fl->fl_lmops->lm_break(fl); 1373 } 1374 1375 if (i_have_this_lease || (mode & O_NONBLOCK)) { 1376 error = -EWOULDBLOCK; 1377 goto out; 1378 } 1379 1380 restart: 1381 break_time = flock->fl_break_time; 1382 if (break_time != 0) 1383 break_time -= jiffies; 1384 if (break_time == 0) 1385 break_time++; 1386 locks_insert_block(flock, new_fl); 1387 spin_unlock(&inode->i_lock); 1388 error = wait_event_interruptible_timeout(new_fl->fl_wait, 1389 !new_fl->fl_next, break_time); 1390 spin_lock(&inode->i_lock); 1391 locks_delete_block(new_fl); 1392 if (error >= 0) { 1393 if (error == 0) 1394 time_out_leases(inode); 1395 /* 1396 * Wait for the next conflicting lease that has not been 1397 * broken yet 1398 */ 1399 for (flock = inode->i_flock; flock && IS_LEASE(flock); 1400 flock = flock->fl_next) { 1401 if (leases_conflict(new_fl, flock)) 1402 goto restart; 1403 } 1404 error = 0; 1405 } 1406 1407 out: 1408 spin_unlock(&inode->i_lock); 1409 locks_free_lock(new_fl); 1410 return error; 1411 } 1412 1413 EXPORT_SYMBOL(__break_lease); 1414 1415 /** 1416 * lease_get_mtime - get the last modified time of an inode 1417 * @inode: the inode 1418 * @time: pointer to a timespec which will contain the last modified time 1419 * 1420 * This is to force NFS clients to flush their caches for files with 1421 * exclusive leases. The justification is that if someone has an 1422 * exclusive lease, then they could be modifying it. 1423 */ 1424 void lease_get_mtime(struct inode *inode, struct timespec *time) 1425 { 1426 struct file_lock *flock = inode->i_flock; 1427 if (flock && IS_LEASE(flock) && (flock->fl_type == F_WRLCK)) 1428 *time = current_fs_time(inode->i_sb); 1429 else 1430 *time = inode->i_mtime; 1431 } 1432 1433 EXPORT_SYMBOL(lease_get_mtime); 1434 1435 /** 1436 * fcntl_getlease - Enquire what lease is currently active 1437 * @filp: the file 1438 * 1439 * The value returned by this function will be one of 1440 * (if no lease break is pending): 1441 * 1442 * %F_RDLCK to indicate a shared lease is held. 1443 * 1444 * %F_WRLCK to indicate an exclusive lease is held. 1445 * 1446 * %F_UNLCK to indicate no lease is held. 1447 * 1448 * (if a lease break is pending): 1449 * 1450 * %F_RDLCK to indicate an exclusive lease needs to be 1451 * changed to a shared lease (or removed). 1452 * 1453 * %F_UNLCK to indicate the lease needs to be removed. 1454 * 1455 * XXX: sfr & willy disagree over whether F_INPROGRESS 1456 * should be returned to userspace. 1457 */ 1458 int fcntl_getlease(struct file *filp) 1459 { 1460 struct file_lock *fl; 1461 struct inode *inode = file_inode(filp); 1462 int type = F_UNLCK; 1463 1464 spin_lock(&inode->i_lock); 1465 time_out_leases(file_inode(filp)); 1466 for (fl = file_inode(filp)->i_flock; fl && IS_LEASE(fl); 1467 fl = fl->fl_next) { 1468 if (fl->fl_file == filp) { 1469 type = target_leasetype(fl); 1470 break; 1471 } 1472 } 1473 spin_unlock(&inode->i_lock); 1474 return type; 1475 } 1476 1477 /** 1478 * check_conflicting_open - see if the given dentry points to a file that has 1479 * an existing open that would conflict with the 1480 * desired lease. 1481 * @dentry: dentry to check 1482 * @arg: type of lease that we're trying to acquire 1483 * 1484 * Check to see if there's an existing open fd on this file that would 1485 * conflict with the lease we're trying to set. 1486 */ 1487 static int 1488 check_conflicting_open(const struct dentry *dentry, const long arg) 1489 { 1490 int ret = 0; 1491 struct inode *inode = dentry->d_inode; 1492 1493 if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0)) 1494 return -EAGAIN; 1495 1496 if ((arg == F_WRLCK) && ((d_count(dentry) > 1) || 1497 (atomic_read(&inode->i_count) > 1))) 1498 ret = -EAGAIN; 1499 1500 return ret; 1501 } 1502 1503 static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp) 1504 { 1505 struct file_lock *fl, **before, **my_before = NULL, *lease; 1506 struct dentry *dentry = filp->f_path.dentry; 1507 struct inode *inode = dentry->d_inode; 1508 bool is_deleg = (*flp)->fl_flags & FL_DELEG; 1509 int error; 1510 1511 lease = *flp; 1512 /* 1513 * In the delegation case we need mutual exclusion with 1514 * a number of operations that take the i_mutex. We trylock 1515 * because delegations are an optional optimization, and if 1516 * there's some chance of a conflict--we'd rather not 1517 * bother, maybe that's a sign this just isn't a good file to 1518 * hand out a delegation on. 1519 */ 1520 if (is_deleg && !mutex_trylock(&inode->i_mutex)) 1521 return -EAGAIN; 1522 1523 if (is_deleg && arg == F_WRLCK) { 1524 /* Write delegations are not currently supported: */ 1525 mutex_unlock(&inode->i_mutex); 1526 WARN_ON_ONCE(1); 1527 return -EINVAL; 1528 } 1529 1530 error = check_conflicting_open(dentry, arg); 1531 if (error) 1532 goto out; 1533 1534 /* 1535 * At this point, we know that if there is an exclusive 1536 * lease on this file, then we hold it on this filp 1537 * (otherwise our open of this file would have blocked). 1538 * And if we are trying to acquire an exclusive lease, 1539 * then the file is not open by anyone (including us) 1540 * except for this filp. 1541 */ 1542 error = -EAGAIN; 1543 for (before = &inode->i_flock; 1544 ((fl = *before) != NULL) && IS_LEASE(fl); 1545 before = &fl->fl_next) { 1546 if (fl->fl_file == filp) { 1547 my_before = before; 1548 continue; 1549 } 1550 /* 1551 * No exclusive leases if someone else has a lease on 1552 * this file: 1553 */ 1554 if (arg == F_WRLCK) 1555 goto out; 1556 /* 1557 * Modifying our existing lease is OK, but no getting a 1558 * new lease if someone else is opening for write: 1559 */ 1560 if (fl->fl_flags & FL_UNLOCK_PENDING) 1561 goto out; 1562 } 1563 1564 if (my_before != NULL) { 1565 error = lease->fl_lmops->lm_change(my_before, arg); 1566 if (!error) 1567 *flp = *my_before; 1568 goto out; 1569 } 1570 1571 error = -EINVAL; 1572 if (!leases_enable) 1573 goto out; 1574 1575 locks_insert_lock(before, lease); 1576 /* 1577 * The check in break_lease() is lockless. It's possible for another 1578 * open to race in after we did the earlier check for a conflicting 1579 * open but before the lease was inserted. Check again for a 1580 * conflicting open and cancel the lease if there is one. 1581 * 1582 * We also add a barrier here to ensure that the insertion of the lock 1583 * precedes these checks. 1584 */ 1585 smp_mb(); 1586 error = check_conflicting_open(dentry, arg); 1587 if (error) 1588 locks_unlink_lock(flp); 1589 out: 1590 if (is_deleg) 1591 mutex_unlock(&inode->i_mutex); 1592 return error; 1593 } 1594 1595 static int generic_delete_lease(struct file *filp, struct file_lock **flp) 1596 { 1597 struct file_lock *fl, **before; 1598 struct dentry *dentry = filp->f_path.dentry; 1599 struct inode *inode = dentry->d_inode; 1600 1601 for (before = &inode->i_flock; 1602 ((fl = *before) != NULL) && IS_LEASE(fl); 1603 before = &fl->fl_next) { 1604 if (fl->fl_file != filp) 1605 continue; 1606 return (*flp)->fl_lmops->lm_change(before, F_UNLCK); 1607 } 1608 return -EAGAIN; 1609 } 1610 1611 /** 1612 * generic_setlease - sets a lease on an open file 1613 * @filp: file pointer 1614 * @arg: type of lease to obtain 1615 * @flp: input - file_lock to use, output - file_lock inserted 1616 * 1617 * The (input) flp->fl_lmops->lm_break function is required 1618 * by break_lease(). 1619 * 1620 * Called with inode->i_lock held. 1621 */ 1622 int generic_setlease(struct file *filp, long arg, struct file_lock **flp) 1623 { 1624 struct dentry *dentry = filp->f_path.dentry; 1625 struct inode *inode = dentry->d_inode; 1626 int error; 1627 1628 if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE)) 1629 return -EACCES; 1630 if (!S_ISREG(inode->i_mode)) 1631 return -EINVAL; 1632 error = security_file_lock(filp, arg); 1633 if (error) 1634 return error; 1635 1636 time_out_leases(inode); 1637 1638 BUG_ON(!(*flp)->fl_lmops->lm_break); 1639 1640 switch (arg) { 1641 case F_UNLCK: 1642 return generic_delete_lease(filp, flp); 1643 case F_RDLCK: 1644 case F_WRLCK: 1645 return generic_add_lease(filp, arg, flp); 1646 default: 1647 return -EINVAL; 1648 } 1649 } 1650 EXPORT_SYMBOL(generic_setlease); 1651 1652 static int __vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 1653 { 1654 if (filp->f_op->setlease) 1655 return filp->f_op->setlease(filp, arg, lease); 1656 else 1657 return generic_setlease(filp, arg, lease); 1658 } 1659 1660 /** 1661 * vfs_setlease - sets a lease on an open file 1662 * @filp: file pointer 1663 * @arg: type of lease to obtain 1664 * @lease: file_lock to use 1665 * 1666 * Call this to establish a lease on the file. 1667 * The (*lease)->fl_lmops->lm_break operation must be set; if not, 1668 * break_lease will oops! 1669 * 1670 * This will call the filesystem's setlease file method, if 1671 * defined. Note that there is no getlease method; instead, the 1672 * filesystem setlease method should call back to setlease() to 1673 * add a lease to the inode's lease list, where fcntl_getlease() can 1674 * find it. Since fcntl_getlease() only reports whether the current 1675 * task holds a lease, a cluster filesystem need only do this for 1676 * leases held by processes on this node. 1677 * 1678 * There is also no break_lease method; filesystems that 1679 * handle their own leases should break leases themselves from the 1680 * filesystem's open, create, and (on truncate) setattr methods. 1681 * 1682 * Warning: the only current setlease methods exist only to disable 1683 * leases in certain cases. More vfs changes may be required to 1684 * allow a full filesystem lease implementation. 1685 */ 1686 1687 int vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 1688 { 1689 struct inode *inode = file_inode(filp); 1690 int error; 1691 1692 spin_lock(&inode->i_lock); 1693 error = __vfs_setlease(filp, arg, lease); 1694 spin_unlock(&inode->i_lock); 1695 1696 return error; 1697 } 1698 EXPORT_SYMBOL_GPL(vfs_setlease); 1699 1700 static int do_fcntl_delete_lease(struct file *filp) 1701 { 1702 struct file_lock fl, *flp = &fl; 1703 1704 lease_init(filp, F_UNLCK, flp); 1705 1706 return vfs_setlease(filp, F_UNLCK, &flp); 1707 } 1708 1709 static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg) 1710 { 1711 struct file_lock *fl, *ret; 1712 struct inode *inode = file_inode(filp); 1713 struct fasync_struct *new; 1714 int error; 1715 1716 fl = lease_alloc(filp, arg); 1717 if (IS_ERR(fl)) 1718 return PTR_ERR(fl); 1719 1720 new = fasync_alloc(); 1721 if (!new) { 1722 locks_free_lock(fl); 1723 return -ENOMEM; 1724 } 1725 ret = fl; 1726 spin_lock(&inode->i_lock); 1727 error = __vfs_setlease(filp, arg, &ret); 1728 if (error) { 1729 spin_unlock(&inode->i_lock); 1730 locks_free_lock(fl); 1731 goto out_free_fasync; 1732 } 1733 if (ret != fl) 1734 locks_free_lock(fl); 1735 1736 /* 1737 * fasync_insert_entry() returns the old entry if any. 1738 * If there was no old entry, then it used 'new' and 1739 * inserted it into the fasync list. Clear new so that 1740 * we don't release it here. 1741 */ 1742 if (!fasync_insert_entry(fd, filp, &ret->fl_fasync, new)) 1743 new = NULL; 1744 1745 error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0); 1746 spin_unlock(&inode->i_lock); 1747 1748 out_free_fasync: 1749 if (new) 1750 fasync_free(new); 1751 return error; 1752 } 1753 1754 /** 1755 * fcntl_setlease - sets a lease on an open file 1756 * @fd: open file descriptor 1757 * @filp: file pointer 1758 * @arg: type of lease to obtain 1759 * 1760 * Call this fcntl to establish a lease on the file. 1761 * Note that you also need to call %F_SETSIG to 1762 * receive a signal when the lease is broken. 1763 */ 1764 int fcntl_setlease(unsigned int fd, struct file *filp, long arg) 1765 { 1766 if (arg == F_UNLCK) 1767 return do_fcntl_delete_lease(filp); 1768 return do_fcntl_add_lease(fd, filp, arg); 1769 } 1770 1771 /** 1772 * flock_lock_file_wait - Apply a FLOCK-style lock to a file 1773 * @filp: The file to apply the lock to 1774 * @fl: The lock to be applied 1775 * 1776 * Add a FLOCK style lock to a file. 1777 */ 1778 int flock_lock_file_wait(struct file *filp, struct file_lock *fl) 1779 { 1780 int error; 1781 might_sleep(); 1782 for (;;) { 1783 error = flock_lock_file(filp, fl); 1784 if (error != FILE_LOCK_DEFERRED) 1785 break; 1786 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 1787 if (!error) 1788 continue; 1789 1790 locks_delete_block(fl); 1791 break; 1792 } 1793 return error; 1794 } 1795 1796 EXPORT_SYMBOL(flock_lock_file_wait); 1797 1798 /** 1799 * sys_flock: - flock() system call. 1800 * @fd: the file descriptor to lock. 1801 * @cmd: the type of lock to apply. 1802 * 1803 * Apply a %FL_FLOCK style lock to an open file descriptor. 1804 * The @cmd can be one of 1805 * 1806 * %LOCK_SH -- a shared lock. 1807 * 1808 * %LOCK_EX -- an exclusive lock. 1809 * 1810 * %LOCK_UN -- remove an existing lock. 1811 * 1812 * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes. 1813 * 1814 * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other 1815 * processes read and write access respectively. 1816 */ 1817 SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) 1818 { 1819 struct fd f = fdget(fd); 1820 struct file_lock *lock; 1821 int can_sleep, unlock; 1822 int error; 1823 1824 error = -EBADF; 1825 if (!f.file) 1826 goto out; 1827 1828 can_sleep = !(cmd & LOCK_NB); 1829 cmd &= ~LOCK_NB; 1830 unlock = (cmd == LOCK_UN); 1831 1832 if (!unlock && !(cmd & LOCK_MAND) && 1833 !(f.file->f_mode & (FMODE_READ|FMODE_WRITE))) 1834 goto out_putf; 1835 1836 error = flock_make_lock(f.file, &lock, cmd); 1837 if (error) 1838 goto out_putf; 1839 if (can_sleep) 1840 lock->fl_flags |= FL_SLEEP; 1841 1842 error = security_file_lock(f.file, lock->fl_type); 1843 if (error) 1844 goto out_free; 1845 1846 if (f.file->f_op->flock) 1847 error = f.file->f_op->flock(f.file, 1848 (can_sleep) ? F_SETLKW : F_SETLK, 1849 lock); 1850 else 1851 error = flock_lock_file_wait(f.file, lock); 1852 1853 out_free: 1854 locks_free_lock(lock); 1855 1856 out_putf: 1857 fdput(f); 1858 out: 1859 return error; 1860 } 1861 1862 /** 1863 * vfs_test_lock - test file byte range lock 1864 * @filp: The file to test lock for 1865 * @fl: The lock to test; also used to hold result 1866 * 1867 * Returns -ERRNO on failure. Indicates presence of conflicting lock by 1868 * setting conf->fl_type to something other than F_UNLCK. 1869 */ 1870 int vfs_test_lock(struct file *filp, struct file_lock *fl) 1871 { 1872 if (filp->f_op->lock) 1873 return filp->f_op->lock(filp, F_GETLK, fl); 1874 posix_test_lock(filp, fl); 1875 return 0; 1876 } 1877 EXPORT_SYMBOL_GPL(vfs_test_lock); 1878 1879 static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) 1880 { 1881 flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid; 1882 #if BITS_PER_LONG == 32 1883 /* 1884 * Make sure we can represent the posix lock via 1885 * legacy 32bit flock. 1886 */ 1887 if (fl->fl_start > OFFT_OFFSET_MAX) 1888 return -EOVERFLOW; 1889 if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX) 1890 return -EOVERFLOW; 1891 #endif 1892 flock->l_start = fl->fl_start; 1893 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1894 fl->fl_end - fl->fl_start + 1; 1895 flock->l_whence = 0; 1896 flock->l_type = fl->fl_type; 1897 return 0; 1898 } 1899 1900 #if BITS_PER_LONG == 32 1901 static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) 1902 { 1903 flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid; 1904 flock->l_start = fl->fl_start; 1905 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1906 fl->fl_end - fl->fl_start + 1; 1907 flock->l_whence = 0; 1908 flock->l_type = fl->fl_type; 1909 } 1910 #endif 1911 1912 /* Report the first existing lock that would conflict with l. 1913 * This implements the F_GETLK command of fcntl(). 1914 */ 1915 int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock __user *l) 1916 { 1917 struct file_lock file_lock; 1918 struct flock flock; 1919 int error; 1920 1921 error = -EFAULT; 1922 if (copy_from_user(&flock, l, sizeof(flock))) 1923 goto out; 1924 error = -EINVAL; 1925 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 1926 goto out; 1927 1928 error = flock_to_posix_lock(filp, &file_lock, &flock); 1929 if (error) 1930 goto out; 1931 1932 if (cmd == F_OFD_GETLK) { 1933 error = -EINVAL; 1934 if (flock.l_pid != 0) 1935 goto out; 1936 1937 cmd = F_GETLK; 1938 file_lock.fl_flags |= FL_OFDLCK; 1939 file_lock.fl_owner = (fl_owner_t)filp; 1940 } 1941 1942 error = vfs_test_lock(filp, &file_lock); 1943 if (error) 1944 goto out; 1945 1946 flock.l_type = file_lock.fl_type; 1947 if (file_lock.fl_type != F_UNLCK) { 1948 error = posix_lock_to_flock(&flock, &file_lock); 1949 if (error) 1950 goto out; 1951 } 1952 error = -EFAULT; 1953 if (!copy_to_user(l, &flock, sizeof(flock))) 1954 error = 0; 1955 out: 1956 return error; 1957 } 1958 1959 /** 1960 * vfs_lock_file - file byte range lock 1961 * @filp: The file to apply the lock to 1962 * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.) 1963 * @fl: The lock to be applied 1964 * @conf: Place to return a copy of the conflicting lock, if found. 1965 * 1966 * A caller that doesn't care about the conflicting lock may pass NULL 1967 * as the final argument. 1968 * 1969 * If the filesystem defines a private ->lock() method, then @conf will 1970 * be left unchanged; so a caller that cares should initialize it to 1971 * some acceptable default. 1972 * 1973 * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX 1974 * locks, the ->lock() interface may return asynchronously, before the lock has 1975 * been granted or denied by the underlying filesystem, if (and only if) 1976 * lm_grant is set. Callers expecting ->lock() to return asynchronously 1977 * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if) 1978 * the request is for a blocking lock. When ->lock() does return asynchronously, 1979 * it must return FILE_LOCK_DEFERRED, and call ->lm_grant() when the lock 1980 * request completes. 1981 * If the request is for non-blocking lock the file system should return 1982 * FILE_LOCK_DEFERRED then try to get the lock and call the callback routine 1983 * with the result. If the request timed out the callback routine will return a 1984 * nonzero return code and the file system should release the lock. The file 1985 * system is also responsible to keep a corresponding posix lock when it 1986 * grants a lock so the VFS can find out which locks are locally held and do 1987 * the correct lock cleanup when required. 1988 * The underlying filesystem must not drop the kernel lock or call 1989 * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED 1990 * return code. 1991 */ 1992 int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) 1993 { 1994 if (filp->f_op->lock) 1995 return filp->f_op->lock(filp, cmd, fl); 1996 else 1997 return posix_lock_file(filp, fl, conf); 1998 } 1999 EXPORT_SYMBOL_GPL(vfs_lock_file); 2000 2001 static int do_lock_file_wait(struct file *filp, unsigned int cmd, 2002 struct file_lock *fl) 2003 { 2004 int error; 2005 2006 error = security_file_lock(filp, fl->fl_type); 2007 if (error) 2008 return error; 2009 2010 for (;;) { 2011 error = vfs_lock_file(filp, cmd, fl, NULL); 2012 if (error != FILE_LOCK_DEFERRED) 2013 break; 2014 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 2015 if (!error) 2016 continue; 2017 2018 locks_delete_block(fl); 2019 break; 2020 } 2021 2022 return error; 2023 } 2024 2025 /* Ensure that fl->fl_filp has compatible f_mode for F_SETLK calls */ 2026 static int 2027 check_fmode_for_setlk(struct file_lock *fl) 2028 { 2029 switch (fl->fl_type) { 2030 case F_RDLCK: 2031 if (!(fl->fl_file->f_mode & FMODE_READ)) 2032 return -EBADF; 2033 break; 2034 case F_WRLCK: 2035 if (!(fl->fl_file->f_mode & FMODE_WRITE)) 2036 return -EBADF; 2037 } 2038 return 0; 2039 } 2040 2041 /* Apply the lock described by l to an open file descriptor. 2042 * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 2043 */ 2044 int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, 2045 struct flock __user *l) 2046 { 2047 struct file_lock *file_lock = locks_alloc_lock(); 2048 struct flock flock; 2049 struct inode *inode; 2050 struct file *f; 2051 int error; 2052 2053 if (file_lock == NULL) 2054 return -ENOLCK; 2055 2056 /* 2057 * This might block, so we do it before checking the inode. 2058 */ 2059 error = -EFAULT; 2060 if (copy_from_user(&flock, l, sizeof(flock))) 2061 goto out; 2062 2063 inode = file_inode(filp); 2064 2065 /* Don't allow mandatory locks on files that may be memory mapped 2066 * and shared. 2067 */ 2068 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 2069 error = -EAGAIN; 2070 goto out; 2071 } 2072 2073 again: 2074 error = flock_to_posix_lock(filp, file_lock, &flock); 2075 if (error) 2076 goto out; 2077 2078 error = check_fmode_for_setlk(file_lock); 2079 if (error) 2080 goto out; 2081 2082 /* 2083 * If the cmd is requesting file-private locks, then set the 2084 * FL_OFDLCK flag and override the owner. 2085 */ 2086 switch (cmd) { 2087 case F_OFD_SETLK: 2088 error = -EINVAL; 2089 if (flock.l_pid != 0) 2090 goto out; 2091 2092 cmd = F_SETLK; 2093 file_lock->fl_flags |= FL_OFDLCK; 2094 file_lock->fl_owner = (fl_owner_t)filp; 2095 break; 2096 case F_OFD_SETLKW: 2097 error = -EINVAL; 2098 if (flock.l_pid != 0) 2099 goto out; 2100 2101 cmd = F_SETLKW; 2102 file_lock->fl_flags |= FL_OFDLCK; 2103 file_lock->fl_owner = (fl_owner_t)filp; 2104 /* Fallthrough */ 2105 case F_SETLKW: 2106 file_lock->fl_flags |= FL_SLEEP; 2107 } 2108 2109 error = do_lock_file_wait(filp, cmd, file_lock); 2110 2111 /* 2112 * Attempt to detect a close/fcntl race and recover by 2113 * releasing the lock that was just acquired. 2114 */ 2115 /* 2116 * we need that spin_lock here - it prevents reordering between 2117 * update of inode->i_flock and check for it done in close(). 2118 * rcu_read_lock() wouldn't do. 2119 */ 2120 spin_lock(¤t->files->file_lock); 2121 f = fcheck(fd); 2122 spin_unlock(¤t->files->file_lock); 2123 if (!error && f != filp && flock.l_type != F_UNLCK) { 2124 flock.l_type = F_UNLCK; 2125 goto again; 2126 } 2127 2128 out: 2129 locks_free_lock(file_lock); 2130 return error; 2131 } 2132 2133 #if BITS_PER_LONG == 32 2134 /* Report the first existing lock that would conflict with l. 2135 * This implements the F_GETLK command of fcntl(). 2136 */ 2137 int fcntl_getlk64(struct file *filp, unsigned int cmd, struct flock64 __user *l) 2138 { 2139 struct file_lock file_lock; 2140 struct flock64 flock; 2141 int error; 2142 2143 error = -EFAULT; 2144 if (copy_from_user(&flock, l, sizeof(flock))) 2145 goto out; 2146 error = -EINVAL; 2147 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 2148 goto out; 2149 2150 error = flock64_to_posix_lock(filp, &file_lock, &flock); 2151 if (error) 2152 goto out; 2153 2154 if (cmd == F_OFD_GETLK) { 2155 error = -EINVAL; 2156 if (flock.l_pid != 0) 2157 goto out; 2158 2159 cmd = F_GETLK64; 2160 file_lock.fl_flags |= FL_OFDLCK; 2161 file_lock.fl_owner = (fl_owner_t)filp; 2162 } 2163 2164 error = vfs_test_lock(filp, &file_lock); 2165 if (error) 2166 goto out; 2167 2168 flock.l_type = file_lock.fl_type; 2169 if (file_lock.fl_type != F_UNLCK) 2170 posix_lock_to_flock64(&flock, &file_lock); 2171 2172 error = -EFAULT; 2173 if (!copy_to_user(l, &flock, sizeof(flock))) 2174 error = 0; 2175 2176 out: 2177 return error; 2178 } 2179 2180 /* Apply the lock described by l to an open file descriptor. 2181 * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 2182 */ 2183 int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, 2184 struct flock64 __user *l) 2185 { 2186 struct file_lock *file_lock = locks_alloc_lock(); 2187 struct flock64 flock; 2188 struct inode *inode; 2189 struct file *f; 2190 int error; 2191 2192 if (file_lock == NULL) 2193 return -ENOLCK; 2194 2195 /* 2196 * This might block, so we do it before checking the inode. 2197 */ 2198 error = -EFAULT; 2199 if (copy_from_user(&flock, l, sizeof(flock))) 2200 goto out; 2201 2202 inode = file_inode(filp); 2203 2204 /* Don't allow mandatory locks on files that may be memory mapped 2205 * and shared. 2206 */ 2207 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 2208 error = -EAGAIN; 2209 goto out; 2210 } 2211 2212 again: 2213 error = flock64_to_posix_lock(filp, file_lock, &flock); 2214 if (error) 2215 goto out; 2216 2217 error = check_fmode_for_setlk(file_lock); 2218 if (error) 2219 goto out; 2220 2221 /* 2222 * If the cmd is requesting file-private locks, then set the 2223 * FL_OFDLCK flag and override the owner. 2224 */ 2225 switch (cmd) { 2226 case F_OFD_SETLK: 2227 error = -EINVAL; 2228 if (flock.l_pid != 0) 2229 goto out; 2230 2231 cmd = F_SETLK64; 2232 file_lock->fl_flags |= FL_OFDLCK; 2233 file_lock->fl_owner = (fl_owner_t)filp; 2234 break; 2235 case F_OFD_SETLKW: 2236 error = -EINVAL; 2237 if (flock.l_pid != 0) 2238 goto out; 2239 2240 cmd = F_SETLKW64; 2241 file_lock->fl_flags |= FL_OFDLCK; 2242 file_lock->fl_owner = (fl_owner_t)filp; 2243 /* Fallthrough */ 2244 case F_SETLKW64: 2245 file_lock->fl_flags |= FL_SLEEP; 2246 } 2247 2248 error = do_lock_file_wait(filp, cmd, file_lock); 2249 2250 /* 2251 * Attempt to detect a close/fcntl race and recover by 2252 * releasing the lock that was just acquired. 2253 */ 2254 spin_lock(¤t->files->file_lock); 2255 f = fcheck(fd); 2256 spin_unlock(¤t->files->file_lock); 2257 if (!error && f != filp && flock.l_type != F_UNLCK) { 2258 flock.l_type = F_UNLCK; 2259 goto again; 2260 } 2261 2262 out: 2263 locks_free_lock(file_lock); 2264 return error; 2265 } 2266 #endif /* BITS_PER_LONG == 32 */ 2267 2268 /* 2269 * This function is called when the file is being removed 2270 * from the task's fd array. POSIX locks belonging to this task 2271 * are deleted at this time. 2272 */ 2273 void locks_remove_posix(struct file *filp, fl_owner_t owner) 2274 { 2275 struct file_lock lock; 2276 2277 /* 2278 * If there are no locks held on this file, we don't need to call 2279 * posix_lock_file(). Another process could be setting a lock on this 2280 * file at the same time, but we wouldn't remove that lock anyway. 2281 */ 2282 if (!file_inode(filp)->i_flock) 2283 return; 2284 2285 lock.fl_type = F_UNLCK; 2286 lock.fl_flags = FL_POSIX | FL_CLOSE; 2287 lock.fl_start = 0; 2288 lock.fl_end = OFFSET_MAX; 2289 lock.fl_owner = owner; 2290 lock.fl_pid = current->tgid; 2291 lock.fl_file = filp; 2292 lock.fl_ops = NULL; 2293 lock.fl_lmops = NULL; 2294 2295 vfs_lock_file(filp, F_SETLK, &lock, NULL); 2296 2297 if (lock.fl_ops && lock.fl_ops->fl_release_private) 2298 lock.fl_ops->fl_release_private(&lock); 2299 } 2300 2301 EXPORT_SYMBOL(locks_remove_posix); 2302 2303 /* 2304 * This function is called on the last close of an open file. 2305 */ 2306 void locks_remove_file(struct file *filp) 2307 { 2308 struct inode * inode = file_inode(filp); 2309 struct file_lock *fl; 2310 struct file_lock **before; 2311 2312 if (!inode->i_flock) 2313 return; 2314 2315 locks_remove_posix(filp, (fl_owner_t)filp); 2316 2317 if (filp->f_op->flock) { 2318 struct file_lock fl = { 2319 .fl_pid = current->tgid, 2320 .fl_file = filp, 2321 .fl_flags = FL_FLOCK, 2322 .fl_type = F_UNLCK, 2323 .fl_end = OFFSET_MAX, 2324 }; 2325 filp->f_op->flock(filp, F_SETLKW, &fl); 2326 if (fl.fl_ops && fl.fl_ops->fl_release_private) 2327 fl.fl_ops->fl_release_private(&fl); 2328 } 2329 2330 spin_lock(&inode->i_lock); 2331 before = &inode->i_flock; 2332 2333 while ((fl = *before) != NULL) { 2334 if (fl->fl_file == filp) { 2335 if (IS_LEASE(fl)) { 2336 lease_modify(before, F_UNLCK); 2337 continue; 2338 } 2339 2340 /* 2341 * There's a leftover lock on the list of a type that 2342 * we didn't expect to see. Most likely a classic 2343 * POSIX lock that ended up not getting released 2344 * properly, or that raced onto the list somehow. Log 2345 * some info about it and then just remove it from 2346 * the list. 2347 */ 2348 WARN(!IS_FLOCK(fl), 2349 "leftover lock: dev=%u:%u ino=%lu type=%hhd flags=0x%x start=%lld end=%lld\n", 2350 MAJOR(inode->i_sb->s_dev), 2351 MINOR(inode->i_sb->s_dev), inode->i_ino, 2352 fl->fl_type, fl->fl_flags, 2353 fl->fl_start, fl->fl_end); 2354 2355 locks_delete_lock(before); 2356 continue; 2357 } 2358 before = &fl->fl_next; 2359 } 2360 spin_unlock(&inode->i_lock); 2361 } 2362 2363 /** 2364 * posix_unblock_lock - stop waiting for a file lock 2365 * @waiter: the lock which was waiting 2366 * 2367 * lockd needs to block waiting for locks. 2368 */ 2369 int 2370 posix_unblock_lock(struct file_lock *waiter) 2371 { 2372 int status = 0; 2373 2374 spin_lock(&blocked_lock_lock); 2375 if (waiter->fl_next) 2376 __locks_delete_block(waiter); 2377 else 2378 status = -ENOENT; 2379 spin_unlock(&blocked_lock_lock); 2380 return status; 2381 } 2382 EXPORT_SYMBOL(posix_unblock_lock); 2383 2384 /** 2385 * vfs_cancel_lock - file byte range unblock lock 2386 * @filp: The file to apply the unblock to 2387 * @fl: The lock to be unblocked 2388 * 2389 * Used by lock managers to cancel blocked requests 2390 */ 2391 int vfs_cancel_lock(struct file *filp, struct file_lock *fl) 2392 { 2393 if (filp->f_op->lock) 2394 return filp->f_op->lock(filp, F_CANCELLK, fl); 2395 return 0; 2396 } 2397 2398 EXPORT_SYMBOL_GPL(vfs_cancel_lock); 2399 2400 #ifdef CONFIG_PROC_FS 2401 #include <linux/proc_fs.h> 2402 #include <linux/seq_file.h> 2403 2404 struct locks_iterator { 2405 int li_cpu; 2406 loff_t li_pos; 2407 }; 2408 2409 static void lock_get_status(struct seq_file *f, struct file_lock *fl, 2410 loff_t id, char *pfx) 2411 { 2412 struct inode *inode = NULL; 2413 unsigned int fl_pid; 2414 2415 if (fl->fl_nspid) 2416 fl_pid = pid_vnr(fl->fl_nspid); 2417 else 2418 fl_pid = fl->fl_pid; 2419 2420 if (fl->fl_file != NULL) 2421 inode = file_inode(fl->fl_file); 2422 2423 seq_printf(f, "%lld:%s ", id, pfx); 2424 if (IS_POSIX(fl)) { 2425 if (fl->fl_flags & FL_ACCESS) 2426 seq_printf(f, "ACCESS"); 2427 else if (IS_OFDLCK(fl)) 2428 seq_printf(f, "OFDLCK"); 2429 else 2430 seq_printf(f, "POSIX "); 2431 2432 seq_printf(f, " %s ", 2433 (inode == NULL) ? "*NOINODE*" : 2434 mandatory_lock(inode) ? "MANDATORY" : "ADVISORY "); 2435 } else if (IS_FLOCK(fl)) { 2436 if (fl->fl_type & LOCK_MAND) { 2437 seq_printf(f, "FLOCK MSNFS "); 2438 } else { 2439 seq_printf(f, "FLOCK ADVISORY "); 2440 } 2441 } else if (IS_LEASE(fl)) { 2442 seq_printf(f, "LEASE "); 2443 if (lease_breaking(fl)) 2444 seq_printf(f, "BREAKING "); 2445 else if (fl->fl_file) 2446 seq_printf(f, "ACTIVE "); 2447 else 2448 seq_printf(f, "BREAKER "); 2449 } else { 2450 seq_printf(f, "UNKNOWN UNKNOWN "); 2451 } 2452 if (fl->fl_type & LOCK_MAND) { 2453 seq_printf(f, "%s ", 2454 (fl->fl_type & LOCK_READ) 2455 ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ " 2456 : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE "); 2457 } else { 2458 seq_printf(f, "%s ", 2459 (lease_breaking(fl)) 2460 ? (fl->fl_type == F_UNLCK) ? "UNLCK" : "READ " 2461 : (fl->fl_type == F_WRLCK) ? "WRITE" : "READ "); 2462 } 2463 if (inode) { 2464 #ifdef WE_CAN_BREAK_LSLK_NOW 2465 seq_printf(f, "%d %s:%ld ", fl_pid, 2466 inode->i_sb->s_id, inode->i_ino); 2467 #else 2468 /* userspace relies on this representation of dev_t ;-( */ 2469 seq_printf(f, "%d %02x:%02x:%ld ", fl_pid, 2470 MAJOR(inode->i_sb->s_dev), 2471 MINOR(inode->i_sb->s_dev), inode->i_ino); 2472 #endif 2473 } else { 2474 seq_printf(f, "%d <none>:0 ", fl_pid); 2475 } 2476 if (IS_POSIX(fl)) { 2477 if (fl->fl_end == OFFSET_MAX) 2478 seq_printf(f, "%Ld EOF\n", fl->fl_start); 2479 else 2480 seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end); 2481 } else { 2482 seq_printf(f, "0 EOF\n"); 2483 } 2484 } 2485 2486 static int locks_show(struct seq_file *f, void *v) 2487 { 2488 struct locks_iterator *iter = f->private; 2489 struct file_lock *fl, *bfl; 2490 2491 fl = hlist_entry(v, struct file_lock, fl_link); 2492 2493 lock_get_status(f, fl, iter->li_pos, ""); 2494 2495 list_for_each_entry(bfl, &fl->fl_block, fl_block) 2496 lock_get_status(f, bfl, iter->li_pos, " ->"); 2497 2498 return 0; 2499 } 2500 2501 static void *locks_start(struct seq_file *f, loff_t *pos) 2502 __acquires(&blocked_lock_lock) 2503 { 2504 struct locks_iterator *iter = f->private; 2505 2506 iter->li_pos = *pos + 1; 2507 lg_global_lock(&file_lock_lglock); 2508 spin_lock(&blocked_lock_lock); 2509 return seq_hlist_start_percpu(&file_lock_list, &iter->li_cpu, *pos); 2510 } 2511 2512 static void *locks_next(struct seq_file *f, void *v, loff_t *pos) 2513 { 2514 struct locks_iterator *iter = f->private; 2515 2516 ++iter->li_pos; 2517 return seq_hlist_next_percpu(v, &file_lock_list, &iter->li_cpu, pos); 2518 } 2519 2520 static void locks_stop(struct seq_file *f, void *v) 2521 __releases(&blocked_lock_lock) 2522 { 2523 spin_unlock(&blocked_lock_lock); 2524 lg_global_unlock(&file_lock_lglock); 2525 } 2526 2527 static const struct seq_operations locks_seq_operations = { 2528 .start = locks_start, 2529 .next = locks_next, 2530 .stop = locks_stop, 2531 .show = locks_show, 2532 }; 2533 2534 static int locks_open(struct inode *inode, struct file *filp) 2535 { 2536 return seq_open_private(filp, &locks_seq_operations, 2537 sizeof(struct locks_iterator)); 2538 } 2539 2540 static const struct file_operations proc_locks_operations = { 2541 .open = locks_open, 2542 .read = seq_read, 2543 .llseek = seq_lseek, 2544 .release = seq_release_private, 2545 }; 2546 2547 static int __init proc_locks_init(void) 2548 { 2549 proc_create("locks", 0, NULL, &proc_locks_operations); 2550 return 0; 2551 } 2552 module_init(proc_locks_init); 2553 #endif 2554 2555 /** 2556 * lock_may_read - checks that the region is free of locks 2557 * @inode: the inode that is being read 2558 * @start: the first byte to read 2559 * @len: the number of bytes to read 2560 * 2561 * Emulates Windows locking requirements. Whole-file 2562 * mandatory locks (share modes) can prohibit a read and 2563 * byte-range POSIX locks can prohibit a read if they overlap. 2564 * 2565 * N.B. this function is only ever called 2566 * from knfsd and ownership of locks is never checked. 2567 */ 2568 int lock_may_read(struct inode *inode, loff_t start, unsigned long len) 2569 { 2570 struct file_lock *fl; 2571 int result = 1; 2572 2573 spin_lock(&inode->i_lock); 2574 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 2575 if (IS_POSIX(fl)) { 2576 if (fl->fl_type == F_RDLCK) 2577 continue; 2578 if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 2579 continue; 2580 } else if (IS_FLOCK(fl)) { 2581 if (!(fl->fl_type & LOCK_MAND)) 2582 continue; 2583 if (fl->fl_type & LOCK_READ) 2584 continue; 2585 } else 2586 continue; 2587 result = 0; 2588 break; 2589 } 2590 spin_unlock(&inode->i_lock); 2591 return result; 2592 } 2593 2594 EXPORT_SYMBOL(lock_may_read); 2595 2596 /** 2597 * lock_may_write - checks that the region is free of locks 2598 * @inode: the inode that is being written 2599 * @start: the first byte to write 2600 * @len: the number of bytes to write 2601 * 2602 * Emulates Windows locking requirements. Whole-file 2603 * mandatory locks (share modes) can prohibit a write and 2604 * byte-range POSIX locks can prohibit a write if they overlap. 2605 * 2606 * N.B. this function is only ever called 2607 * from knfsd and ownership of locks is never checked. 2608 */ 2609 int lock_may_write(struct inode *inode, loff_t start, unsigned long len) 2610 { 2611 struct file_lock *fl; 2612 int result = 1; 2613 2614 spin_lock(&inode->i_lock); 2615 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 2616 if (IS_POSIX(fl)) { 2617 if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 2618 continue; 2619 } else if (IS_FLOCK(fl)) { 2620 if (!(fl->fl_type & LOCK_MAND)) 2621 continue; 2622 if (fl->fl_type & LOCK_WRITE) 2623 continue; 2624 } else 2625 continue; 2626 result = 0; 2627 break; 2628 } 2629 spin_unlock(&inode->i_lock); 2630 return result; 2631 } 2632 2633 EXPORT_SYMBOL(lock_may_write); 2634 2635 static int __init filelock_init(void) 2636 { 2637 int i; 2638 2639 filelock_cache = kmem_cache_create("file_lock_cache", 2640 sizeof(struct file_lock), 0, SLAB_PANIC, NULL); 2641 2642 lg_lock_init(&file_lock_lglock, "file_lock_lglock"); 2643 2644 for_each_possible_cpu(i) 2645 INIT_HLIST_HEAD(per_cpu_ptr(&file_lock_list, i)); 2646 2647 return 0; 2648 } 2649 2650 core_initcall(filelock_init); 2651