1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/fs/locks.c 4 * 5 * Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls. 6 * Doug Evans (dje@spiff.uucp), August 07, 1992 7 * 8 * Deadlock detection added. 9 * FIXME: one thing isn't handled yet: 10 * - mandatory locks (requires lots of changes elsewhere) 11 * Kelly Carmichael (kelly@[142.24.8.65]), September 17, 1994. 12 * 13 * Miscellaneous edits, and a total rewrite of posix_lock_file() code. 14 * Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994 15 * 16 * Converted file_lock_table to a linked list from an array, which eliminates 17 * the limits on how many active file locks are open. 18 * Chad Page (pageone@netcom.com), November 27, 1994 19 * 20 * Removed dependency on file descriptors. dup()'ed file descriptors now 21 * get the same locks as the original file descriptors, and a close() on 22 * any file descriptor removes ALL the locks on the file for the current 23 * process. Since locks still depend on the process id, locks are inherited 24 * after an exec() but not after a fork(). This agrees with POSIX, and both 25 * BSD and SVR4 practice. 26 * Andy Walker (andy@lysaker.kvaerner.no), February 14, 1995 27 * 28 * Scrapped free list which is redundant now that we allocate locks 29 * dynamically with kmalloc()/kfree(). 30 * Andy Walker (andy@lysaker.kvaerner.no), February 21, 1995 31 * 32 * Implemented two lock personalities - FL_FLOCK and FL_POSIX. 33 * 34 * FL_POSIX locks are created with calls to fcntl() and lockf() through the 35 * fcntl() system call. They have the semantics described above. 36 * 37 * FL_FLOCK locks are created with calls to flock(), through the flock() 38 * system call, which is new. Old C libraries implement flock() via fcntl() 39 * and will continue to use the old, broken implementation. 40 * 41 * FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated 42 * with a file pointer (filp). As a result they can be shared by a parent 43 * process and its children after a fork(). They are removed when the last 44 * file descriptor referring to the file pointer is closed (unless explicitly 45 * unlocked). 46 * 47 * FL_FLOCK locks never deadlock, an existing lock is always removed before 48 * upgrading from shared to exclusive (or vice versa). When this happens 49 * any processes blocked by the current lock are woken up and allowed to 50 * run before the new lock is applied. 51 * Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995 52 * 53 * Removed some race conditions in flock_lock_file(), marked other possible 54 * races. Just grep for FIXME to see them. 55 * Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996. 56 * 57 * Addressed Dmitry's concerns. Deadlock checking no longer recursive. 58 * Lock allocation changed to GFP_ATOMIC as we can't afford to sleep 59 * once we've checked for blocking and deadlocking. 60 * Andy Walker (andy@lysaker.kvaerner.no), April 03, 1996. 61 * 62 * Initial implementation of mandatory locks. SunOS turned out to be 63 * a rotten model, so I implemented the "obvious" semantics. 64 * See 'Documentation/filesystems/mandatory-locking.txt' for details. 65 * Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996. 66 * 67 * Don't allow mandatory locks on mmap()'ed files. Added simple functions to 68 * check if a file has mandatory locks, used by mmap(), open() and creat() to 69 * see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference 70 * Manual, Section 2. 71 * Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996. 72 * 73 * Tidied up block list handling. Added '/proc/locks' interface. 74 * Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996. 75 * 76 * Fixed deadlock condition for pathological code that mixes calls to 77 * flock() and fcntl(). 78 * Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996. 79 * 80 * Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use 81 * for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to 82 * guarantee sensible behaviour in the case where file system modules might 83 * be compiled with different options than the kernel itself. 84 * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996. 85 * 86 * Added a couple of missing wake_up() calls. Thanks to Thomas Meckel 87 * (Thomas.Meckel@mni.fh-giessen.de) for spotting this. 88 * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996. 89 * 90 * Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK 91 * locks. Changed process synchronisation to avoid dereferencing locks that 92 * have already been freed. 93 * Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996. 94 * 95 * Made the block list a circular list to minimise searching in the list. 96 * Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996. 97 * 98 * Made mandatory locking a mount option. Default is not to allow mandatory 99 * locking. 100 * Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996. 101 * 102 * Some adaptations for NFS support. 103 * Olaf Kirch (okir@monad.swb.de), Dec 1996, 104 * 105 * Fixed /proc/locks interface so that we can't overrun the buffer we are handed. 106 * Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997. 107 * 108 * Use slab allocator instead of kmalloc/kfree. 109 * Use generic list implementation from <linux/list.h>. 110 * Sped up posix_locks_deadlock by only considering blocked locks. 111 * Matthew Wilcox <willy@debian.org>, March, 2000. 112 * 113 * Leases and LOCK_MAND 114 * Matthew Wilcox <willy@debian.org>, June, 2000. 115 * Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000. 116 * 117 * Locking conflicts and dependencies: 118 * If multiple threads attempt to lock the same byte (or flock the same file) 119 * only one can be granted the lock, and other must wait their turn. 120 * The first lock has been "applied" or "granted", the others are "waiting" 121 * and are "blocked" by the "applied" lock.. 122 * 123 * Waiting and applied locks are all kept in trees whose properties are: 124 * 125 * - the root of a tree may be an applied or waiting lock. 126 * - every other node in the tree is a waiting lock that 127 * conflicts with every ancestor of that node. 128 * 129 * Every such tree begins life as a waiting singleton which obviously 130 * satisfies the above properties. 131 * 132 * The only ways we modify trees preserve these properties: 133 * 134 * 1. We may add a new leaf node, but only after first verifying that it 135 * conflicts with all of its ancestors. 136 * 2. We may remove the root of a tree, creating a new singleton 137 * tree from the root and N new trees rooted in the immediate 138 * children. 139 * 3. If the root of a tree is not currently an applied lock, we may 140 * apply it (if possible). 141 * 4. We may upgrade the root of the tree (either extend its range, 142 * or upgrade its entire range from read to write). 143 * 144 * When an applied lock is modified in a way that reduces or downgrades any 145 * part of its range, we remove all its children (2 above). This particularly 146 * happens when a lock is unlocked. 147 * 148 * For each of those child trees we "wake up" the thread which is 149 * waiting for the lock so it can continue handling as follows: if the 150 * root of the tree applies, we do so (3). If it doesn't, it must 151 * conflict with some applied lock. We remove (wake up) all of its children 152 * (2), and add it is a new leaf to the tree rooted in the applied 153 * lock (1). We then repeat the process recursively with those 154 * children. 155 * 156 */ 157 158 #include <linux/capability.h> 159 #include <linux/file.h> 160 #include <linux/fdtable.h> 161 #include <linux/fs.h> 162 #include <linux/init.h> 163 #include <linux/security.h> 164 #include <linux/slab.h> 165 #include <linux/syscalls.h> 166 #include <linux/time.h> 167 #include <linux/rcupdate.h> 168 #include <linux/pid_namespace.h> 169 #include <linux/hashtable.h> 170 #include <linux/percpu.h> 171 172 #define CREATE_TRACE_POINTS 173 #include <trace/events/filelock.h> 174 175 #include <linux/uaccess.h> 176 177 #define IS_POSIX(fl) (fl->fl_flags & FL_POSIX) 178 #define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK) 179 #define IS_LEASE(fl) (fl->fl_flags & (FL_LEASE|FL_DELEG|FL_LAYOUT)) 180 #define IS_OFDLCK(fl) (fl->fl_flags & FL_OFDLCK) 181 #define IS_REMOTELCK(fl) (fl->fl_pid <= 0) 182 183 static bool lease_breaking(struct file_lock *fl) 184 { 185 return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING); 186 } 187 188 static int target_leasetype(struct file_lock *fl) 189 { 190 if (fl->fl_flags & FL_UNLOCK_PENDING) 191 return F_UNLCK; 192 if (fl->fl_flags & FL_DOWNGRADE_PENDING) 193 return F_RDLCK; 194 return fl->fl_type; 195 } 196 197 int leases_enable = 1; 198 int lease_break_time = 45; 199 200 /* 201 * The global file_lock_list is only used for displaying /proc/locks, so we 202 * keep a list on each CPU, with each list protected by its own spinlock. 203 * Global serialization is done using file_rwsem. 204 * 205 * Note that alterations to the list also require that the relevant flc_lock is 206 * held. 207 */ 208 struct file_lock_list_struct { 209 spinlock_t lock; 210 struct hlist_head hlist; 211 }; 212 static DEFINE_PER_CPU(struct file_lock_list_struct, file_lock_list); 213 DEFINE_STATIC_PERCPU_RWSEM(file_rwsem); 214 215 216 /* 217 * The blocked_hash is used to find POSIX lock loops for deadlock detection. 218 * It is protected by blocked_lock_lock. 219 * 220 * We hash locks by lockowner in order to optimize searching for the lock a 221 * particular lockowner is waiting on. 222 * 223 * FIXME: make this value scale via some heuristic? We generally will want more 224 * buckets when we have more lockowners holding locks, but that's a little 225 * difficult to determine without knowing what the workload will look like. 226 */ 227 #define BLOCKED_HASH_BITS 7 228 static DEFINE_HASHTABLE(blocked_hash, BLOCKED_HASH_BITS); 229 230 /* 231 * This lock protects the blocked_hash. Generally, if you're accessing it, you 232 * want to be holding this lock. 233 * 234 * In addition, it also protects the fl->fl_blocked_requests list, and the 235 * fl->fl_blocker pointer for file_lock structures that are acting as lock 236 * requests (in contrast to those that are acting as records of acquired locks). 237 * 238 * Note that when we acquire this lock in order to change the above fields, 239 * we often hold the flc_lock as well. In certain cases, when reading the fields 240 * protected by this lock, we can skip acquiring it iff we already hold the 241 * flc_lock. 242 */ 243 static DEFINE_SPINLOCK(blocked_lock_lock); 244 245 static struct kmem_cache *flctx_cache __read_mostly; 246 static struct kmem_cache *filelock_cache __read_mostly; 247 248 static struct file_lock_context * 249 locks_get_lock_context(struct inode *inode, int type) 250 { 251 struct file_lock_context *ctx; 252 253 /* paired with cmpxchg() below */ 254 ctx = smp_load_acquire(&inode->i_flctx); 255 if (likely(ctx) || type == F_UNLCK) 256 goto out; 257 258 ctx = kmem_cache_alloc(flctx_cache, GFP_KERNEL); 259 if (!ctx) 260 goto out; 261 262 spin_lock_init(&ctx->flc_lock); 263 INIT_LIST_HEAD(&ctx->flc_flock); 264 INIT_LIST_HEAD(&ctx->flc_posix); 265 INIT_LIST_HEAD(&ctx->flc_lease); 266 267 /* 268 * Assign the pointer if it's not already assigned. If it is, then 269 * free the context we just allocated. 270 */ 271 if (cmpxchg(&inode->i_flctx, NULL, ctx)) { 272 kmem_cache_free(flctx_cache, ctx); 273 ctx = smp_load_acquire(&inode->i_flctx); 274 } 275 out: 276 trace_locks_get_lock_context(inode, type, ctx); 277 return ctx; 278 } 279 280 static void 281 locks_dump_ctx_list(struct list_head *list, char *list_type) 282 { 283 struct file_lock *fl; 284 285 list_for_each_entry(fl, list, fl_list) { 286 pr_warn("%s: fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n", list_type, fl->fl_owner, fl->fl_flags, fl->fl_type, fl->fl_pid); 287 } 288 } 289 290 static void 291 locks_check_ctx_lists(struct inode *inode) 292 { 293 struct file_lock_context *ctx = inode->i_flctx; 294 295 if (unlikely(!list_empty(&ctx->flc_flock) || 296 !list_empty(&ctx->flc_posix) || 297 !list_empty(&ctx->flc_lease))) { 298 pr_warn("Leaked locks on dev=0x%x:0x%x ino=0x%lx:\n", 299 MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev), 300 inode->i_ino); 301 locks_dump_ctx_list(&ctx->flc_flock, "FLOCK"); 302 locks_dump_ctx_list(&ctx->flc_posix, "POSIX"); 303 locks_dump_ctx_list(&ctx->flc_lease, "LEASE"); 304 } 305 } 306 307 static void 308 locks_check_ctx_file_list(struct file *filp, struct list_head *list, 309 char *list_type) 310 { 311 struct file_lock *fl; 312 struct inode *inode = locks_inode(filp); 313 314 list_for_each_entry(fl, list, fl_list) 315 if (fl->fl_file == filp) 316 pr_warn("Leaked %s lock on dev=0x%x:0x%x ino=0x%lx " 317 " fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n", 318 list_type, MAJOR(inode->i_sb->s_dev), 319 MINOR(inode->i_sb->s_dev), inode->i_ino, 320 fl->fl_owner, fl->fl_flags, fl->fl_type, fl->fl_pid); 321 } 322 323 void 324 locks_free_lock_context(struct inode *inode) 325 { 326 struct file_lock_context *ctx = inode->i_flctx; 327 328 if (unlikely(ctx)) { 329 locks_check_ctx_lists(inode); 330 kmem_cache_free(flctx_cache, ctx); 331 } 332 } 333 334 static void locks_init_lock_heads(struct file_lock *fl) 335 { 336 INIT_HLIST_NODE(&fl->fl_link); 337 INIT_LIST_HEAD(&fl->fl_list); 338 INIT_LIST_HEAD(&fl->fl_blocked_requests); 339 INIT_LIST_HEAD(&fl->fl_blocked_member); 340 init_waitqueue_head(&fl->fl_wait); 341 } 342 343 /* Allocate an empty lock structure. */ 344 struct file_lock *locks_alloc_lock(void) 345 { 346 struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL); 347 348 if (fl) 349 locks_init_lock_heads(fl); 350 351 return fl; 352 } 353 EXPORT_SYMBOL_GPL(locks_alloc_lock); 354 355 void locks_release_private(struct file_lock *fl) 356 { 357 BUG_ON(waitqueue_active(&fl->fl_wait)); 358 BUG_ON(!list_empty(&fl->fl_list)); 359 BUG_ON(!list_empty(&fl->fl_blocked_requests)); 360 BUG_ON(!list_empty(&fl->fl_blocked_member)); 361 BUG_ON(!hlist_unhashed(&fl->fl_link)); 362 363 if (fl->fl_ops) { 364 if (fl->fl_ops->fl_release_private) 365 fl->fl_ops->fl_release_private(fl); 366 fl->fl_ops = NULL; 367 } 368 369 if (fl->fl_lmops) { 370 if (fl->fl_lmops->lm_put_owner) { 371 fl->fl_lmops->lm_put_owner(fl->fl_owner); 372 fl->fl_owner = NULL; 373 } 374 fl->fl_lmops = NULL; 375 } 376 } 377 EXPORT_SYMBOL_GPL(locks_release_private); 378 379 /* Free a lock which is not in use. */ 380 void locks_free_lock(struct file_lock *fl) 381 { 382 locks_release_private(fl); 383 kmem_cache_free(filelock_cache, fl); 384 } 385 EXPORT_SYMBOL(locks_free_lock); 386 387 static void 388 locks_dispose_list(struct list_head *dispose) 389 { 390 struct file_lock *fl; 391 392 while (!list_empty(dispose)) { 393 fl = list_first_entry(dispose, struct file_lock, fl_list); 394 list_del_init(&fl->fl_list); 395 locks_free_lock(fl); 396 } 397 } 398 399 void locks_init_lock(struct file_lock *fl) 400 { 401 memset(fl, 0, sizeof(struct file_lock)); 402 locks_init_lock_heads(fl); 403 } 404 EXPORT_SYMBOL(locks_init_lock); 405 406 /* 407 * Initialize a new lock from an existing file_lock structure. 408 */ 409 void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) 410 { 411 new->fl_owner = fl->fl_owner; 412 new->fl_pid = fl->fl_pid; 413 new->fl_file = NULL; 414 new->fl_flags = fl->fl_flags; 415 new->fl_type = fl->fl_type; 416 new->fl_start = fl->fl_start; 417 new->fl_end = fl->fl_end; 418 new->fl_lmops = fl->fl_lmops; 419 new->fl_ops = NULL; 420 421 if (fl->fl_lmops) { 422 if (fl->fl_lmops->lm_get_owner) 423 fl->fl_lmops->lm_get_owner(fl->fl_owner); 424 } 425 } 426 EXPORT_SYMBOL(locks_copy_conflock); 427 428 void locks_copy_lock(struct file_lock *new, struct file_lock *fl) 429 { 430 /* "new" must be a freshly-initialized lock */ 431 WARN_ON_ONCE(new->fl_ops); 432 433 locks_copy_conflock(new, fl); 434 435 new->fl_file = fl->fl_file; 436 new->fl_ops = fl->fl_ops; 437 438 if (fl->fl_ops) { 439 if (fl->fl_ops->fl_copy_lock) 440 fl->fl_ops->fl_copy_lock(new, fl); 441 } 442 } 443 EXPORT_SYMBOL(locks_copy_lock); 444 445 static void locks_move_blocks(struct file_lock *new, struct file_lock *fl) 446 { 447 struct file_lock *f; 448 449 /* 450 * As ctx->flc_lock is held, new requests cannot be added to 451 * ->fl_blocked_requests, so we don't need a lock to check if it 452 * is empty. 453 */ 454 if (list_empty(&fl->fl_blocked_requests)) 455 return; 456 spin_lock(&blocked_lock_lock); 457 list_splice_init(&fl->fl_blocked_requests, &new->fl_blocked_requests); 458 list_for_each_entry(f, &new->fl_blocked_requests, fl_blocked_member) 459 f->fl_blocker = new; 460 spin_unlock(&blocked_lock_lock); 461 } 462 463 static inline int flock_translate_cmd(int cmd) { 464 if (cmd & LOCK_MAND) 465 return cmd & (LOCK_MAND | LOCK_RW); 466 switch (cmd) { 467 case LOCK_SH: 468 return F_RDLCK; 469 case LOCK_EX: 470 return F_WRLCK; 471 case LOCK_UN: 472 return F_UNLCK; 473 } 474 return -EINVAL; 475 } 476 477 /* Fill in a file_lock structure with an appropriate FLOCK lock. */ 478 static struct file_lock * 479 flock_make_lock(struct file *filp, unsigned int cmd, struct file_lock *fl) 480 { 481 int type = flock_translate_cmd(cmd); 482 483 if (type < 0) 484 return ERR_PTR(type); 485 486 if (fl == NULL) { 487 fl = locks_alloc_lock(); 488 if (fl == NULL) 489 return ERR_PTR(-ENOMEM); 490 } else { 491 locks_init_lock(fl); 492 } 493 494 fl->fl_file = filp; 495 fl->fl_owner = filp; 496 fl->fl_pid = current->tgid; 497 fl->fl_flags = FL_FLOCK; 498 fl->fl_type = type; 499 fl->fl_end = OFFSET_MAX; 500 501 return fl; 502 } 503 504 static int assign_type(struct file_lock *fl, long type) 505 { 506 switch (type) { 507 case F_RDLCK: 508 case F_WRLCK: 509 case F_UNLCK: 510 fl->fl_type = type; 511 break; 512 default: 513 return -EINVAL; 514 } 515 return 0; 516 } 517 518 static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, 519 struct flock64 *l) 520 { 521 switch (l->l_whence) { 522 case SEEK_SET: 523 fl->fl_start = 0; 524 break; 525 case SEEK_CUR: 526 fl->fl_start = filp->f_pos; 527 break; 528 case SEEK_END: 529 fl->fl_start = i_size_read(file_inode(filp)); 530 break; 531 default: 532 return -EINVAL; 533 } 534 if (l->l_start > OFFSET_MAX - fl->fl_start) 535 return -EOVERFLOW; 536 fl->fl_start += l->l_start; 537 if (fl->fl_start < 0) 538 return -EINVAL; 539 540 /* POSIX-1996 leaves the case l->l_len < 0 undefined; 541 POSIX-2001 defines it. */ 542 if (l->l_len > 0) { 543 if (l->l_len - 1 > OFFSET_MAX - fl->fl_start) 544 return -EOVERFLOW; 545 fl->fl_end = fl->fl_start + l->l_len - 1; 546 547 } else if (l->l_len < 0) { 548 if (fl->fl_start + l->l_len < 0) 549 return -EINVAL; 550 fl->fl_end = fl->fl_start - 1; 551 fl->fl_start += l->l_len; 552 } else 553 fl->fl_end = OFFSET_MAX; 554 555 fl->fl_owner = current->files; 556 fl->fl_pid = current->tgid; 557 fl->fl_file = filp; 558 fl->fl_flags = FL_POSIX; 559 fl->fl_ops = NULL; 560 fl->fl_lmops = NULL; 561 562 return assign_type(fl, l->l_type); 563 } 564 565 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX 566 * style lock. 567 */ 568 static int flock_to_posix_lock(struct file *filp, struct file_lock *fl, 569 struct flock *l) 570 { 571 struct flock64 ll = { 572 .l_type = l->l_type, 573 .l_whence = l->l_whence, 574 .l_start = l->l_start, 575 .l_len = l->l_len, 576 }; 577 578 return flock64_to_posix_lock(filp, fl, &ll); 579 } 580 581 /* default lease lock manager operations */ 582 static bool 583 lease_break_callback(struct file_lock *fl) 584 { 585 kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG); 586 return false; 587 } 588 589 static void 590 lease_setup(struct file_lock *fl, void **priv) 591 { 592 struct file *filp = fl->fl_file; 593 struct fasync_struct *fa = *priv; 594 595 /* 596 * fasync_insert_entry() returns the old entry if any. If there was no 597 * old entry, then it used "priv" and inserted it into the fasync list. 598 * Clear the pointer to indicate that it shouldn't be freed. 599 */ 600 if (!fasync_insert_entry(fa->fa_fd, filp, &fl->fl_fasync, fa)) 601 *priv = NULL; 602 603 __f_setown(filp, task_pid(current), PIDTYPE_TGID, 0); 604 } 605 606 static const struct lock_manager_operations lease_manager_ops = { 607 .lm_break = lease_break_callback, 608 .lm_change = lease_modify, 609 .lm_setup = lease_setup, 610 }; 611 612 /* 613 * Initialize a lease, use the default lock manager operations 614 */ 615 static int lease_init(struct file *filp, long type, struct file_lock *fl) 616 { 617 if (assign_type(fl, type) != 0) 618 return -EINVAL; 619 620 fl->fl_owner = filp; 621 fl->fl_pid = current->tgid; 622 623 fl->fl_file = filp; 624 fl->fl_flags = FL_LEASE; 625 fl->fl_start = 0; 626 fl->fl_end = OFFSET_MAX; 627 fl->fl_ops = NULL; 628 fl->fl_lmops = &lease_manager_ops; 629 return 0; 630 } 631 632 /* Allocate a file_lock initialised to this type of lease */ 633 static struct file_lock *lease_alloc(struct file *filp, long type) 634 { 635 struct file_lock *fl = locks_alloc_lock(); 636 int error = -ENOMEM; 637 638 if (fl == NULL) 639 return ERR_PTR(error); 640 641 error = lease_init(filp, type, fl); 642 if (error) { 643 locks_free_lock(fl); 644 return ERR_PTR(error); 645 } 646 return fl; 647 } 648 649 /* Check if two locks overlap each other. 650 */ 651 static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) 652 { 653 return ((fl1->fl_end >= fl2->fl_start) && 654 (fl2->fl_end >= fl1->fl_start)); 655 } 656 657 /* 658 * Check whether two locks have the same owner. 659 */ 660 static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2) 661 { 662 return fl1->fl_owner == fl2->fl_owner; 663 } 664 665 /* Must be called with the flc_lock held! */ 666 static void locks_insert_global_locks(struct file_lock *fl) 667 { 668 struct file_lock_list_struct *fll = this_cpu_ptr(&file_lock_list); 669 670 percpu_rwsem_assert_held(&file_rwsem); 671 672 spin_lock(&fll->lock); 673 fl->fl_link_cpu = smp_processor_id(); 674 hlist_add_head(&fl->fl_link, &fll->hlist); 675 spin_unlock(&fll->lock); 676 } 677 678 /* Must be called with the flc_lock held! */ 679 static void locks_delete_global_locks(struct file_lock *fl) 680 { 681 struct file_lock_list_struct *fll; 682 683 percpu_rwsem_assert_held(&file_rwsem); 684 685 /* 686 * Avoid taking lock if already unhashed. This is safe since this check 687 * is done while holding the flc_lock, and new insertions into the list 688 * also require that it be held. 689 */ 690 if (hlist_unhashed(&fl->fl_link)) 691 return; 692 693 fll = per_cpu_ptr(&file_lock_list, fl->fl_link_cpu); 694 spin_lock(&fll->lock); 695 hlist_del_init(&fl->fl_link); 696 spin_unlock(&fll->lock); 697 } 698 699 static unsigned long 700 posix_owner_key(struct file_lock *fl) 701 { 702 return (unsigned long)fl->fl_owner; 703 } 704 705 static void locks_insert_global_blocked(struct file_lock *waiter) 706 { 707 lockdep_assert_held(&blocked_lock_lock); 708 709 hash_add(blocked_hash, &waiter->fl_link, posix_owner_key(waiter)); 710 } 711 712 static void locks_delete_global_blocked(struct file_lock *waiter) 713 { 714 lockdep_assert_held(&blocked_lock_lock); 715 716 hash_del(&waiter->fl_link); 717 } 718 719 /* Remove waiter from blocker's block list. 720 * When blocker ends up pointing to itself then the list is empty. 721 * 722 * Must be called with blocked_lock_lock held. 723 */ 724 static void __locks_delete_block(struct file_lock *waiter) 725 { 726 locks_delete_global_blocked(waiter); 727 list_del_init(&waiter->fl_blocked_member); 728 waiter->fl_blocker = NULL; 729 } 730 731 static void __locks_wake_up_blocks(struct file_lock *blocker) 732 { 733 while (!list_empty(&blocker->fl_blocked_requests)) { 734 struct file_lock *waiter; 735 736 waiter = list_first_entry(&blocker->fl_blocked_requests, 737 struct file_lock, fl_blocked_member); 738 __locks_delete_block(waiter); 739 if (waiter->fl_lmops && waiter->fl_lmops->lm_notify) 740 waiter->fl_lmops->lm_notify(waiter); 741 else 742 wake_up(&waiter->fl_wait); 743 } 744 } 745 746 /** 747 * locks_delete_lock - stop waiting for a file lock 748 * @waiter: the lock which was waiting 749 * 750 * lockd/nfsd need to disconnect the lock while working on it. 751 */ 752 int locks_delete_block(struct file_lock *waiter) 753 { 754 int status = -ENOENT; 755 756 spin_lock(&blocked_lock_lock); 757 if (waiter->fl_blocker) 758 status = 0; 759 __locks_wake_up_blocks(waiter); 760 __locks_delete_block(waiter); 761 spin_unlock(&blocked_lock_lock); 762 return status; 763 } 764 EXPORT_SYMBOL(locks_delete_block); 765 766 /* Insert waiter into blocker's block list. 767 * We use a circular list so that processes can be easily woken up in 768 * the order they blocked. The documentation doesn't require this but 769 * it seems like the reasonable thing to do. 770 * 771 * Must be called with both the flc_lock and blocked_lock_lock held. The 772 * fl_blocked_requests list itself is protected by the blocked_lock_lock, 773 * but by ensuring that the flc_lock is also held on insertions we can avoid 774 * taking the blocked_lock_lock in some cases when we see that the 775 * fl_blocked_requests list is empty. 776 * 777 * Rather than just adding to the list, we check for conflicts with any existing 778 * waiters, and add beneath any waiter that blocks the new waiter. 779 * Thus wakeups don't happen until needed. 780 */ 781 static void __locks_insert_block(struct file_lock *blocker, 782 struct file_lock *waiter, 783 bool conflict(struct file_lock *, 784 struct file_lock *)) 785 { 786 struct file_lock *fl; 787 BUG_ON(!list_empty(&waiter->fl_blocked_member)); 788 789 new_blocker: 790 list_for_each_entry(fl, &blocker->fl_blocked_requests, fl_blocked_member) 791 if (conflict(fl, waiter)) { 792 blocker = fl; 793 goto new_blocker; 794 } 795 waiter->fl_blocker = blocker; 796 list_add_tail(&waiter->fl_blocked_member, &blocker->fl_blocked_requests); 797 if (IS_POSIX(blocker) && !IS_OFDLCK(blocker)) 798 locks_insert_global_blocked(waiter); 799 800 /* The requests in waiter->fl_blocked are known to conflict with 801 * waiter, but might not conflict with blocker, or the requests 802 * and lock which block it. So they all need to be woken. 803 */ 804 __locks_wake_up_blocks(waiter); 805 } 806 807 /* Must be called with flc_lock held. */ 808 static void locks_insert_block(struct file_lock *blocker, 809 struct file_lock *waiter, 810 bool conflict(struct file_lock *, 811 struct file_lock *)) 812 { 813 spin_lock(&blocked_lock_lock); 814 __locks_insert_block(blocker, waiter, conflict); 815 spin_unlock(&blocked_lock_lock); 816 } 817 818 /* 819 * Wake up processes blocked waiting for blocker. 820 * 821 * Must be called with the inode->flc_lock held! 822 */ 823 static void locks_wake_up_blocks(struct file_lock *blocker) 824 { 825 /* 826 * Avoid taking global lock if list is empty. This is safe since new 827 * blocked requests are only added to the list under the flc_lock, and 828 * the flc_lock is always held here. Note that removal from the 829 * fl_blocked_requests list does not require the flc_lock, so we must 830 * recheck list_empty() after acquiring the blocked_lock_lock. 831 */ 832 if (list_empty(&blocker->fl_blocked_requests)) 833 return; 834 835 spin_lock(&blocked_lock_lock); 836 __locks_wake_up_blocks(blocker); 837 spin_unlock(&blocked_lock_lock); 838 } 839 840 static void 841 locks_insert_lock_ctx(struct file_lock *fl, struct list_head *before) 842 { 843 list_add_tail(&fl->fl_list, before); 844 locks_insert_global_locks(fl); 845 } 846 847 static void 848 locks_unlink_lock_ctx(struct file_lock *fl) 849 { 850 locks_delete_global_locks(fl); 851 list_del_init(&fl->fl_list); 852 locks_wake_up_blocks(fl); 853 } 854 855 static void 856 locks_delete_lock_ctx(struct file_lock *fl, struct list_head *dispose) 857 { 858 locks_unlink_lock_ctx(fl); 859 if (dispose) 860 list_add(&fl->fl_list, dispose); 861 else 862 locks_free_lock(fl); 863 } 864 865 /* Determine if lock sys_fl blocks lock caller_fl. Common functionality 866 * checks for shared/exclusive status of overlapping locks. 867 */ 868 static bool locks_conflict(struct file_lock *caller_fl, 869 struct file_lock *sys_fl) 870 { 871 if (sys_fl->fl_type == F_WRLCK) 872 return true; 873 if (caller_fl->fl_type == F_WRLCK) 874 return true; 875 return false; 876 } 877 878 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific 879 * checking before calling the locks_conflict(). 880 */ 881 static bool posix_locks_conflict(struct file_lock *caller_fl, 882 struct file_lock *sys_fl) 883 { 884 /* POSIX locks owned by the same process do not conflict with 885 * each other. 886 */ 887 if (posix_same_owner(caller_fl, sys_fl)) 888 return false; 889 890 /* Check whether they overlap */ 891 if (!locks_overlap(caller_fl, sys_fl)) 892 return false; 893 894 return locks_conflict(caller_fl, sys_fl); 895 } 896 897 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific 898 * checking before calling the locks_conflict(). 899 */ 900 static bool flock_locks_conflict(struct file_lock *caller_fl, 901 struct file_lock *sys_fl) 902 { 903 /* FLOCK locks referring to the same filp do not conflict with 904 * each other. 905 */ 906 if (caller_fl->fl_file == sys_fl->fl_file) 907 return false; 908 if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND)) 909 return false; 910 911 return locks_conflict(caller_fl, sys_fl); 912 } 913 914 void 915 posix_test_lock(struct file *filp, struct file_lock *fl) 916 { 917 struct file_lock *cfl; 918 struct file_lock_context *ctx; 919 struct inode *inode = locks_inode(filp); 920 921 ctx = smp_load_acquire(&inode->i_flctx); 922 if (!ctx || list_empty_careful(&ctx->flc_posix)) { 923 fl->fl_type = F_UNLCK; 924 return; 925 } 926 927 spin_lock(&ctx->flc_lock); 928 list_for_each_entry(cfl, &ctx->flc_posix, fl_list) { 929 if (posix_locks_conflict(fl, cfl)) { 930 locks_copy_conflock(fl, cfl); 931 goto out; 932 } 933 } 934 fl->fl_type = F_UNLCK; 935 out: 936 spin_unlock(&ctx->flc_lock); 937 return; 938 } 939 EXPORT_SYMBOL(posix_test_lock); 940 941 /* 942 * Deadlock detection: 943 * 944 * We attempt to detect deadlocks that are due purely to posix file 945 * locks. 946 * 947 * We assume that a task can be waiting for at most one lock at a time. 948 * So for any acquired lock, the process holding that lock may be 949 * waiting on at most one other lock. That lock in turns may be held by 950 * someone waiting for at most one other lock. Given a requested lock 951 * caller_fl which is about to wait for a conflicting lock block_fl, we 952 * follow this chain of waiters to ensure we are not about to create a 953 * cycle. 954 * 955 * Since we do this before we ever put a process to sleep on a lock, we 956 * are ensured that there is never a cycle; that is what guarantees that 957 * the while() loop in posix_locks_deadlock() eventually completes. 958 * 959 * Note: the above assumption may not be true when handling lock 960 * requests from a broken NFS client. It may also fail in the presence 961 * of tasks (such as posix threads) sharing the same open file table. 962 * To handle those cases, we just bail out after a few iterations. 963 * 964 * For FL_OFDLCK locks, the owner is the filp, not the files_struct. 965 * Because the owner is not even nominally tied to a thread of 966 * execution, the deadlock detection below can't reasonably work well. Just 967 * skip it for those. 968 * 969 * In principle, we could do a more limited deadlock detection on FL_OFDLCK 970 * locks that just checks for the case where two tasks are attempting to 971 * upgrade from read to write locks on the same inode. 972 */ 973 974 #define MAX_DEADLK_ITERATIONS 10 975 976 /* Find a lock that the owner of the given block_fl is blocking on. */ 977 static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl) 978 { 979 struct file_lock *fl; 980 981 hash_for_each_possible(blocked_hash, fl, fl_link, posix_owner_key(block_fl)) { 982 if (posix_same_owner(fl, block_fl)) { 983 while (fl->fl_blocker) 984 fl = fl->fl_blocker; 985 return fl; 986 } 987 } 988 return NULL; 989 } 990 991 /* Must be called with the blocked_lock_lock held! */ 992 static int posix_locks_deadlock(struct file_lock *caller_fl, 993 struct file_lock *block_fl) 994 { 995 int i = 0; 996 997 lockdep_assert_held(&blocked_lock_lock); 998 999 /* 1000 * This deadlock detector can't reasonably detect deadlocks with 1001 * FL_OFDLCK locks, since they aren't owned by a process, per-se. 1002 */ 1003 if (IS_OFDLCK(caller_fl)) 1004 return 0; 1005 1006 while ((block_fl = what_owner_is_waiting_for(block_fl))) { 1007 if (i++ > MAX_DEADLK_ITERATIONS) 1008 return 0; 1009 if (posix_same_owner(caller_fl, block_fl)) 1010 return 1; 1011 } 1012 return 0; 1013 } 1014 1015 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks 1016 * after any leases, but before any posix locks. 1017 * 1018 * Note that if called with an FL_EXISTS argument, the caller may determine 1019 * whether or not a lock was successfully freed by testing the return 1020 * value for -ENOENT. 1021 */ 1022 static int flock_lock_inode(struct inode *inode, struct file_lock *request) 1023 { 1024 struct file_lock *new_fl = NULL; 1025 struct file_lock *fl; 1026 struct file_lock_context *ctx; 1027 int error = 0; 1028 bool found = false; 1029 LIST_HEAD(dispose); 1030 1031 ctx = locks_get_lock_context(inode, request->fl_type); 1032 if (!ctx) { 1033 if (request->fl_type != F_UNLCK) 1034 return -ENOMEM; 1035 return (request->fl_flags & FL_EXISTS) ? -ENOENT : 0; 1036 } 1037 1038 if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) { 1039 new_fl = locks_alloc_lock(); 1040 if (!new_fl) 1041 return -ENOMEM; 1042 } 1043 1044 percpu_down_read(&file_rwsem); 1045 spin_lock(&ctx->flc_lock); 1046 if (request->fl_flags & FL_ACCESS) 1047 goto find_conflict; 1048 1049 list_for_each_entry(fl, &ctx->flc_flock, fl_list) { 1050 if (request->fl_file != fl->fl_file) 1051 continue; 1052 if (request->fl_type == fl->fl_type) 1053 goto out; 1054 found = true; 1055 locks_delete_lock_ctx(fl, &dispose); 1056 break; 1057 } 1058 1059 if (request->fl_type == F_UNLCK) { 1060 if ((request->fl_flags & FL_EXISTS) && !found) 1061 error = -ENOENT; 1062 goto out; 1063 } 1064 1065 find_conflict: 1066 list_for_each_entry(fl, &ctx->flc_flock, fl_list) { 1067 if (!flock_locks_conflict(request, fl)) 1068 continue; 1069 error = -EAGAIN; 1070 if (!(request->fl_flags & FL_SLEEP)) 1071 goto out; 1072 error = FILE_LOCK_DEFERRED; 1073 locks_insert_block(fl, request, flock_locks_conflict); 1074 goto out; 1075 } 1076 if (request->fl_flags & FL_ACCESS) 1077 goto out; 1078 locks_copy_lock(new_fl, request); 1079 locks_move_blocks(new_fl, request); 1080 locks_insert_lock_ctx(new_fl, &ctx->flc_flock); 1081 new_fl = NULL; 1082 error = 0; 1083 1084 out: 1085 spin_unlock(&ctx->flc_lock); 1086 percpu_up_read(&file_rwsem); 1087 if (new_fl) 1088 locks_free_lock(new_fl); 1089 locks_dispose_list(&dispose); 1090 trace_flock_lock_inode(inode, request, error); 1091 return error; 1092 } 1093 1094 static int posix_lock_inode(struct inode *inode, struct file_lock *request, 1095 struct file_lock *conflock) 1096 { 1097 struct file_lock *fl, *tmp; 1098 struct file_lock *new_fl = NULL; 1099 struct file_lock *new_fl2 = NULL; 1100 struct file_lock *left = NULL; 1101 struct file_lock *right = NULL; 1102 struct file_lock_context *ctx; 1103 int error; 1104 bool added = false; 1105 LIST_HEAD(dispose); 1106 1107 ctx = locks_get_lock_context(inode, request->fl_type); 1108 if (!ctx) 1109 return (request->fl_type == F_UNLCK) ? 0 : -ENOMEM; 1110 1111 /* 1112 * We may need two file_lock structures for this operation, 1113 * so we get them in advance to avoid races. 1114 * 1115 * In some cases we can be sure, that no new locks will be needed 1116 */ 1117 if (!(request->fl_flags & FL_ACCESS) && 1118 (request->fl_type != F_UNLCK || 1119 request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { 1120 new_fl = locks_alloc_lock(); 1121 new_fl2 = locks_alloc_lock(); 1122 } 1123 1124 percpu_down_read(&file_rwsem); 1125 spin_lock(&ctx->flc_lock); 1126 /* 1127 * New lock request. Walk all POSIX locks and look for conflicts. If 1128 * there are any, either return error or put the request on the 1129 * blocker's list of waiters and the global blocked_hash. 1130 */ 1131 if (request->fl_type != F_UNLCK) { 1132 list_for_each_entry(fl, &ctx->flc_posix, fl_list) { 1133 if (!posix_locks_conflict(request, fl)) 1134 continue; 1135 if (conflock) 1136 locks_copy_conflock(conflock, fl); 1137 error = -EAGAIN; 1138 if (!(request->fl_flags & FL_SLEEP)) 1139 goto out; 1140 /* 1141 * Deadlock detection and insertion into the blocked 1142 * locks list must be done while holding the same lock! 1143 */ 1144 error = -EDEADLK; 1145 spin_lock(&blocked_lock_lock); 1146 /* 1147 * Ensure that we don't find any locks blocked on this 1148 * request during deadlock detection. 1149 */ 1150 __locks_wake_up_blocks(request); 1151 if (likely(!posix_locks_deadlock(request, fl))) { 1152 error = FILE_LOCK_DEFERRED; 1153 __locks_insert_block(fl, request, 1154 posix_locks_conflict); 1155 } 1156 spin_unlock(&blocked_lock_lock); 1157 goto out; 1158 } 1159 } 1160 1161 /* If we're just looking for a conflict, we're done. */ 1162 error = 0; 1163 if (request->fl_flags & FL_ACCESS) 1164 goto out; 1165 1166 /* Find the first old lock with the same owner as the new lock */ 1167 list_for_each_entry(fl, &ctx->flc_posix, fl_list) { 1168 if (posix_same_owner(request, fl)) 1169 break; 1170 } 1171 1172 /* Process locks with this owner. */ 1173 list_for_each_entry_safe_from(fl, tmp, &ctx->flc_posix, fl_list) { 1174 if (!posix_same_owner(request, fl)) 1175 break; 1176 1177 /* Detect adjacent or overlapping regions (if same lock type) */ 1178 if (request->fl_type == fl->fl_type) { 1179 /* In all comparisons of start vs end, use 1180 * "start - 1" rather than "end + 1". If end 1181 * is OFFSET_MAX, end + 1 will become negative. 1182 */ 1183 if (fl->fl_end < request->fl_start - 1) 1184 continue; 1185 /* If the next lock in the list has entirely bigger 1186 * addresses than the new one, insert the lock here. 1187 */ 1188 if (fl->fl_start - 1 > request->fl_end) 1189 break; 1190 1191 /* If we come here, the new and old lock are of the 1192 * same type and adjacent or overlapping. Make one 1193 * lock yielding from the lower start address of both 1194 * locks to the higher end address. 1195 */ 1196 if (fl->fl_start > request->fl_start) 1197 fl->fl_start = request->fl_start; 1198 else 1199 request->fl_start = fl->fl_start; 1200 if (fl->fl_end < request->fl_end) 1201 fl->fl_end = request->fl_end; 1202 else 1203 request->fl_end = fl->fl_end; 1204 if (added) { 1205 locks_delete_lock_ctx(fl, &dispose); 1206 continue; 1207 } 1208 request = fl; 1209 added = true; 1210 } else { 1211 /* Processing for different lock types is a bit 1212 * more complex. 1213 */ 1214 if (fl->fl_end < request->fl_start) 1215 continue; 1216 if (fl->fl_start > request->fl_end) 1217 break; 1218 if (request->fl_type == F_UNLCK) 1219 added = true; 1220 if (fl->fl_start < request->fl_start) 1221 left = fl; 1222 /* If the next lock in the list has a higher end 1223 * address than the new one, insert the new one here. 1224 */ 1225 if (fl->fl_end > request->fl_end) { 1226 right = fl; 1227 break; 1228 } 1229 if (fl->fl_start >= request->fl_start) { 1230 /* The new lock completely replaces an old 1231 * one (This may happen several times). 1232 */ 1233 if (added) { 1234 locks_delete_lock_ctx(fl, &dispose); 1235 continue; 1236 } 1237 /* 1238 * Replace the old lock with new_fl, and 1239 * remove the old one. It's safe to do the 1240 * insert here since we know that we won't be 1241 * using new_fl later, and that the lock is 1242 * just replacing an existing lock. 1243 */ 1244 error = -ENOLCK; 1245 if (!new_fl) 1246 goto out; 1247 locks_copy_lock(new_fl, request); 1248 request = new_fl; 1249 new_fl = NULL; 1250 locks_insert_lock_ctx(request, &fl->fl_list); 1251 locks_delete_lock_ctx(fl, &dispose); 1252 added = true; 1253 } 1254 } 1255 } 1256 1257 /* 1258 * The above code only modifies existing locks in case of merging or 1259 * replacing. If new lock(s) need to be inserted all modifications are 1260 * done below this, so it's safe yet to bail out. 1261 */ 1262 error = -ENOLCK; /* "no luck" */ 1263 if (right && left == right && !new_fl2) 1264 goto out; 1265 1266 error = 0; 1267 if (!added) { 1268 if (request->fl_type == F_UNLCK) { 1269 if (request->fl_flags & FL_EXISTS) 1270 error = -ENOENT; 1271 goto out; 1272 } 1273 1274 if (!new_fl) { 1275 error = -ENOLCK; 1276 goto out; 1277 } 1278 locks_copy_lock(new_fl, request); 1279 locks_move_blocks(new_fl, request); 1280 locks_insert_lock_ctx(new_fl, &fl->fl_list); 1281 fl = new_fl; 1282 new_fl = NULL; 1283 } 1284 if (right) { 1285 if (left == right) { 1286 /* The new lock breaks the old one in two pieces, 1287 * so we have to use the second new lock. 1288 */ 1289 left = new_fl2; 1290 new_fl2 = NULL; 1291 locks_copy_lock(left, right); 1292 locks_insert_lock_ctx(left, &fl->fl_list); 1293 } 1294 right->fl_start = request->fl_end + 1; 1295 locks_wake_up_blocks(right); 1296 } 1297 if (left) { 1298 left->fl_end = request->fl_start - 1; 1299 locks_wake_up_blocks(left); 1300 } 1301 out: 1302 spin_unlock(&ctx->flc_lock); 1303 percpu_up_read(&file_rwsem); 1304 /* 1305 * Free any unused locks. 1306 */ 1307 if (new_fl) 1308 locks_free_lock(new_fl); 1309 if (new_fl2) 1310 locks_free_lock(new_fl2); 1311 locks_dispose_list(&dispose); 1312 trace_posix_lock_inode(inode, request, error); 1313 1314 return error; 1315 } 1316 1317 /** 1318 * posix_lock_file - Apply a POSIX-style lock to a file 1319 * @filp: The file to apply the lock to 1320 * @fl: The lock to be applied 1321 * @conflock: Place to return a copy of the conflicting lock, if found. 1322 * 1323 * Add a POSIX style lock to a file. 1324 * We merge adjacent & overlapping locks whenever possible. 1325 * POSIX locks are sorted by owner task, then by starting address 1326 * 1327 * Note that if called with an FL_EXISTS argument, the caller may determine 1328 * whether or not a lock was successfully freed by testing the return 1329 * value for -ENOENT. 1330 */ 1331 int posix_lock_file(struct file *filp, struct file_lock *fl, 1332 struct file_lock *conflock) 1333 { 1334 return posix_lock_inode(locks_inode(filp), fl, conflock); 1335 } 1336 EXPORT_SYMBOL(posix_lock_file); 1337 1338 /** 1339 * posix_lock_inode_wait - Apply a POSIX-style lock to a file 1340 * @inode: inode of file to which lock request should be applied 1341 * @fl: The lock to be applied 1342 * 1343 * Apply a POSIX style lock request to an inode. 1344 */ 1345 static int posix_lock_inode_wait(struct inode *inode, struct file_lock *fl) 1346 { 1347 int error; 1348 might_sleep (); 1349 for (;;) { 1350 error = posix_lock_inode(inode, fl, NULL); 1351 if (error != FILE_LOCK_DEFERRED) 1352 break; 1353 error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker); 1354 if (error) 1355 break; 1356 } 1357 locks_delete_block(fl); 1358 return error; 1359 } 1360 1361 #ifdef CONFIG_MANDATORY_FILE_LOCKING 1362 /** 1363 * locks_mandatory_locked - Check for an active lock 1364 * @file: the file to check 1365 * 1366 * Searches the inode's list of locks to find any POSIX locks which conflict. 1367 * This function is called from locks_verify_locked() only. 1368 */ 1369 int locks_mandatory_locked(struct file *file) 1370 { 1371 int ret; 1372 struct inode *inode = locks_inode(file); 1373 struct file_lock_context *ctx; 1374 struct file_lock *fl; 1375 1376 ctx = smp_load_acquire(&inode->i_flctx); 1377 if (!ctx || list_empty_careful(&ctx->flc_posix)) 1378 return 0; 1379 1380 /* 1381 * Search the lock list for this inode for any POSIX locks. 1382 */ 1383 spin_lock(&ctx->flc_lock); 1384 ret = 0; 1385 list_for_each_entry(fl, &ctx->flc_posix, fl_list) { 1386 if (fl->fl_owner != current->files && 1387 fl->fl_owner != file) { 1388 ret = -EAGAIN; 1389 break; 1390 } 1391 } 1392 spin_unlock(&ctx->flc_lock); 1393 return ret; 1394 } 1395 1396 /** 1397 * locks_mandatory_area - Check for a conflicting lock 1398 * @inode: the file to check 1399 * @filp: how the file was opened (if it was) 1400 * @start: first byte in the file to check 1401 * @end: lastbyte in the file to check 1402 * @type: %F_WRLCK for a write lock, else %F_RDLCK 1403 * 1404 * Searches the inode's list of locks to find any POSIX locks which conflict. 1405 */ 1406 int locks_mandatory_area(struct inode *inode, struct file *filp, loff_t start, 1407 loff_t end, unsigned char type) 1408 { 1409 struct file_lock fl; 1410 int error; 1411 bool sleep = false; 1412 1413 locks_init_lock(&fl); 1414 fl.fl_pid = current->tgid; 1415 fl.fl_file = filp; 1416 fl.fl_flags = FL_POSIX | FL_ACCESS; 1417 if (filp && !(filp->f_flags & O_NONBLOCK)) 1418 sleep = true; 1419 fl.fl_type = type; 1420 fl.fl_start = start; 1421 fl.fl_end = end; 1422 1423 for (;;) { 1424 if (filp) { 1425 fl.fl_owner = filp; 1426 fl.fl_flags &= ~FL_SLEEP; 1427 error = posix_lock_inode(inode, &fl, NULL); 1428 if (!error) 1429 break; 1430 } 1431 1432 if (sleep) 1433 fl.fl_flags |= FL_SLEEP; 1434 fl.fl_owner = current->files; 1435 error = posix_lock_inode(inode, &fl, NULL); 1436 if (error != FILE_LOCK_DEFERRED) 1437 break; 1438 error = wait_event_interruptible(fl.fl_wait, !fl.fl_blocker); 1439 if (!error) { 1440 /* 1441 * If we've been sleeping someone might have 1442 * changed the permissions behind our back. 1443 */ 1444 if (__mandatory_lock(inode)) 1445 continue; 1446 } 1447 1448 break; 1449 } 1450 locks_delete_block(&fl); 1451 1452 return error; 1453 } 1454 EXPORT_SYMBOL(locks_mandatory_area); 1455 #endif /* CONFIG_MANDATORY_FILE_LOCKING */ 1456 1457 static void lease_clear_pending(struct file_lock *fl, int arg) 1458 { 1459 switch (arg) { 1460 case F_UNLCK: 1461 fl->fl_flags &= ~FL_UNLOCK_PENDING; 1462 /* fall through */ 1463 case F_RDLCK: 1464 fl->fl_flags &= ~FL_DOWNGRADE_PENDING; 1465 } 1466 } 1467 1468 /* We already had a lease on this file; just change its type */ 1469 int lease_modify(struct file_lock *fl, int arg, struct list_head *dispose) 1470 { 1471 int error = assign_type(fl, arg); 1472 1473 if (error) 1474 return error; 1475 lease_clear_pending(fl, arg); 1476 locks_wake_up_blocks(fl); 1477 if (arg == F_UNLCK) { 1478 struct file *filp = fl->fl_file; 1479 1480 f_delown(filp); 1481 filp->f_owner.signum = 0; 1482 fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); 1483 if (fl->fl_fasync != NULL) { 1484 printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync); 1485 fl->fl_fasync = NULL; 1486 } 1487 locks_delete_lock_ctx(fl, dispose); 1488 } 1489 return 0; 1490 } 1491 EXPORT_SYMBOL(lease_modify); 1492 1493 static bool past_time(unsigned long then) 1494 { 1495 if (!then) 1496 /* 0 is a special value meaning "this never expires": */ 1497 return false; 1498 return time_after(jiffies, then); 1499 } 1500 1501 static void time_out_leases(struct inode *inode, struct list_head *dispose) 1502 { 1503 struct file_lock_context *ctx = inode->i_flctx; 1504 struct file_lock *fl, *tmp; 1505 1506 lockdep_assert_held(&ctx->flc_lock); 1507 1508 list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) { 1509 trace_time_out_leases(inode, fl); 1510 if (past_time(fl->fl_downgrade_time)) 1511 lease_modify(fl, F_RDLCK, dispose); 1512 if (past_time(fl->fl_break_time)) 1513 lease_modify(fl, F_UNLCK, dispose); 1514 } 1515 } 1516 1517 static bool leases_conflict(struct file_lock *lease, struct file_lock *breaker) 1518 { 1519 bool rc; 1520 1521 if ((breaker->fl_flags & FL_LAYOUT) != (lease->fl_flags & FL_LAYOUT)) { 1522 rc = false; 1523 goto trace; 1524 } 1525 if ((breaker->fl_flags & FL_DELEG) && (lease->fl_flags & FL_LEASE)) { 1526 rc = false; 1527 goto trace; 1528 } 1529 1530 rc = locks_conflict(breaker, lease); 1531 trace: 1532 trace_leases_conflict(rc, lease, breaker); 1533 return rc; 1534 } 1535 1536 static bool 1537 any_leases_conflict(struct inode *inode, struct file_lock *breaker) 1538 { 1539 struct file_lock_context *ctx = inode->i_flctx; 1540 struct file_lock *fl; 1541 1542 lockdep_assert_held(&ctx->flc_lock); 1543 1544 list_for_each_entry(fl, &ctx->flc_lease, fl_list) { 1545 if (leases_conflict(fl, breaker)) 1546 return true; 1547 } 1548 return false; 1549 } 1550 1551 /** 1552 * __break_lease - revoke all outstanding leases on file 1553 * @inode: the inode of the file to return 1554 * @mode: O_RDONLY: break only write leases; O_WRONLY or O_RDWR: 1555 * break all leases 1556 * @type: FL_LEASE: break leases and delegations; FL_DELEG: break 1557 * only delegations 1558 * 1559 * break_lease (inlined for speed) has checked there already is at least 1560 * some kind of lock (maybe a lease) on this file. Leases are broken on 1561 * a call to open() or truncate(). This function can sleep unless you 1562 * specified %O_NONBLOCK to your open(). 1563 */ 1564 int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) 1565 { 1566 int error = 0; 1567 struct file_lock_context *ctx; 1568 struct file_lock *new_fl, *fl, *tmp; 1569 unsigned long break_time; 1570 int want_write = (mode & O_ACCMODE) != O_RDONLY; 1571 LIST_HEAD(dispose); 1572 1573 new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK); 1574 if (IS_ERR(new_fl)) 1575 return PTR_ERR(new_fl); 1576 new_fl->fl_flags = type; 1577 1578 /* typically we will check that ctx is non-NULL before calling */ 1579 ctx = smp_load_acquire(&inode->i_flctx); 1580 if (!ctx) { 1581 WARN_ON_ONCE(1); 1582 goto free_lock; 1583 } 1584 1585 percpu_down_read(&file_rwsem); 1586 spin_lock(&ctx->flc_lock); 1587 1588 time_out_leases(inode, &dispose); 1589 1590 if (!any_leases_conflict(inode, new_fl)) 1591 goto out; 1592 1593 break_time = 0; 1594 if (lease_break_time > 0) { 1595 break_time = jiffies + lease_break_time * HZ; 1596 if (break_time == 0) 1597 break_time++; /* so that 0 means no break time */ 1598 } 1599 1600 list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) { 1601 if (!leases_conflict(fl, new_fl)) 1602 continue; 1603 if (want_write) { 1604 if (fl->fl_flags & FL_UNLOCK_PENDING) 1605 continue; 1606 fl->fl_flags |= FL_UNLOCK_PENDING; 1607 fl->fl_break_time = break_time; 1608 } else { 1609 if (lease_breaking(fl)) 1610 continue; 1611 fl->fl_flags |= FL_DOWNGRADE_PENDING; 1612 fl->fl_downgrade_time = break_time; 1613 } 1614 if (fl->fl_lmops->lm_break(fl)) 1615 locks_delete_lock_ctx(fl, &dispose); 1616 } 1617 1618 if (list_empty(&ctx->flc_lease)) 1619 goto out; 1620 1621 if (mode & O_NONBLOCK) { 1622 trace_break_lease_noblock(inode, new_fl); 1623 error = -EWOULDBLOCK; 1624 goto out; 1625 } 1626 1627 restart: 1628 fl = list_first_entry(&ctx->flc_lease, struct file_lock, fl_list); 1629 break_time = fl->fl_break_time; 1630 if (break_time != 0) 1631 break_time -= jiffies; 1632 if (break_time == 0) 1633 break_time++; 1634 locks_insert_block(fl, new_fl, leases_conflict); 1635 trace_break_lease_block(inode, new_fl); 1636 spin_unlock(&ctx->flc_lock); 1637 percpu_up_read(&file_rwsem); 1638 1639 locks_dispose_list(&dispose); 1640 error = wait_event_interruptible_timeout(new_fl->fl_wait, 1641 !new_fl->fl_blocker, break_time); 1642 1643 percpu_down_read(&file_rwsem); 1644 spin_lock(&ctx->flc_lock); 1645 trace_break_lease_unblock(inode, new_fl); 1646 locks_delete_block(new_fl); 1647 if (error >= 0) { 1648 /* 1649 * Wait for the next conflicting lease that has not been 1650 * broken yet 1651 */ 1652 if (error == 0) 1653 time_out_leases(inode, &dispose); 1654 if (any_leases_conflict(inode, new_fl)) 1655 goto restart; 1656 error = 0; 1657 } 1658 out: 1659 spin_unlock(&ctx->flc_lock); 1660 percpu_up_read(&file_rwsem); 1661 locks_dispose_list(&dispose); 1662 free_lock: 1663 locks_free_lock(new_fl); 1664 return error; 1665 } 1666 EXPORT_SYMBOL(__break_lease); 1667 1668 /** 1669 * lease_get_mtime - update modified time of an inode with exclusive lease 1670 * @inode: the inode 1671 * @time: pointer to a timespec which contains the last modified time 1672 * 1673 * This is to force NFS clients to flush their caches for files with 1674 * exclusive leases. The justification is that if someone has an 1675 * exclusive lease, then they could be modifying it. 1676 */ 1677 void lease_get_mtime(struct inode *inode, struct timespec64 *time) 1678 { 1679 bool has_lease = false; 1680 struct file_lock_context *ctx; 1681 struct file_lock *fl; 1682 1683 ctx = smp_load_acquire(&inode->i_flctx); 1684 if (ctx && !list_empty_careful(&ctx->flc_lease)) { 1685 spin_lock(&ctx->flc_lock); 1686 fl = list_first_entry_or_null(&ctx->flc_lease, 1687 struct file_lock, fl_list); 1688 if (fl && (fl->fl_type == F_WRLCK)) 1689 has_lease = true; 1690 spin_unlock(&ctx->flc_lock); 1691 } 1692 1693 if (has_lease) 1694 *time = current_time(inode); 1695 } 1696 EXPORT_SYMBOL(lease_get_mtime); 1697 1698 /** 1699 * fcntl_getlease - Enquire what lease is currently active 1700 * @filp: the file 1701 * 1702 * The value returned by this function will be one of 1703 * (if no lease break is pending): 1704 * 1705 * %F_RDLCK to indicate a shared lease is held. 1706 * 1707 * %F_WRLCK to indicate an exclusive lease is held. 1708 * 1709 * %F_UNLCK to indicate no lease is held. 1710 * 1711 * (if a lease break is pending): 1712 * 1713 * %F_RDLCK to indicate an exclusive lease needs to be 1714 * changed to a shared lease (or removed). 1715 * 1716 * %F_UNLCK to indicate the lease needs to be removed. 1717 * 1718 * XXX: sfr & willy disagree over whether F_INPROGRESS 1719 * should be returned to userspace. 1720 */ 1721 int fcntl_getlease(struct file *filp) 1722 { 1723 struct file_lock *fl; 1724 struct inode *inode = locks_inode(filp); 1725 struct file_lock_context *ctx; 1726 int type = F_UNLCK; 1727 LIST_HEAD(dispose); 1728 1729 ctx = smp_load_acquire(&inode->i_flctx); 1730 if (ctx && !list_empty_careful(&ctx->flc_lease)) { 1731 percpu_down_read(&file_rwsem); 1732 spin_lock(&ctx->flc_lock); 1733 time_out_leases(inode, &dispose); 1734 list_for_each_entry(fl, &ctx->flc_lease, fl_list) { 1735 if (fl->fl_file != filp) 1736 continue; 1737 type = target_leasetype(fl); 1738 break; 1739 } 1740 spin_unlock(&ctx->flc_lock); 1741 percpu_up_read(&file_rwsem); 1742 1743 locks_dispose_list(&dispose); 1744 } 1745 return type; 1746 } 1747 1748 /** 1749 * check_conflicting_open - see if the given file points to an inode that has 1750 * an existing open that would conflict with the 1751 * desired lease. 1752 * @filp: file to check 1753 * @arg: type of lease that we're trying to acquire 1754 * @flags: current lock flags 1755 * 1756 * Check to see if there's an existing open fd on this file that would 1757 * conflict with the lease we're trying to set. 1758 */ 1759 static int 1760 check_conflicting_open(struct file *filp, const long arg, int flags) 1761 { 1762 struct inode *inode = locks_inode(filp); 1763 int self_wcount = 0, self_rcount = 0; 1764 1765 if (flags & FL_LAYOUT) 1766 return 0; 1767 1768 if (arg == F_RDLCK) 1769 return inode_is_open_for_write(inode) ? -EAGAIN : 0; 1770 else if (arg != F_WRLCK) 1771 return 0; 1772 1773 /* 1774 * Make sure that only read/write count is from lease requestor. 1775 * Note that this will result in denying write leases when i_writecount 1776 * is negative, which is what we want. (We shouldn't grant write leases 1777 * on files open for execution.) 1778 */ 1779 if (filp->f_mode & FMODE_WRITE) 1780 self_wcount = 1; 1781 else if (filp->f_mode & FMODE_READ) 1782 self_rcount = 1; 1783 1784 if (atomic_read(&inode->i_writecount) != self_wcount || 1785 atomic_read(&inode->i_readcount) != self_rcount) 1786 return -EAGAIN; 1787 1788 return 0; 1789 } 1790 1791 static int 1792 generic_add_lease(struct file *filp, long arg, struct file_lock **flp, void **priv) 1793 { 1794 struct file_lock *fl, *my_fl = NULL, *lease; 1795 struct inode *inode = locks_inode(filp); 1796 struct file_lock_context *ctx; 1797 bool is_deleg = (*flp)->fl_flags & FL_DELEG; 1798 int error; 1799 LIST_HEAD(dispose); 1800 1801 lease = *flp; 1802 trace_generic_add_lease(inode, lease); 1803 1804 /* Note that arg is never F_UNLCK here */ 1805 ctx = locks_get_lock_context(inode, arg); 1806 if (!ctx) 1807 return -ENOMEM; 1808 1809 /* 1810 * In the delegation case we need mutual exclusion with 1811 * a number of operations that take the i_mutex. We trylock 1812 * because delegations are an optional optimization, and if 1813 * there's some chance of a conflict--we'd rather not 1814 * bother, maybe that's a sign this just isn't a good file to 1815 * hand out a delegation on. 1816 */ 1817 if (is_deleg && !inode_trylock(inode)) 1818 return -EAGAIN; 1819 1820 if (is_deleg && arg == F_WRLCK) { 1821 /* Write delegations are not currently supported: */ 1822 inode_unlock(inode); 1823 WARN_ON_ONCE(1); 1824 return -EINVAL; 1825 } 1826 1827 percpu_down_read(&file_rwsem); 1828 spin_lock(&ctx->flc_lock); 1829 time_out_leases(inode, &dispose); 1830 error = check_conflicting_open(filp, arg, lease->fl_flags); 1831 if (error) 1832 goto out; 1833 1834 /* 1835 * At this point, we know that if there is an exclusive 1836 * lease on this file, then we hold it on this filp 1837 * (otherwise our open of this file would have blocked). 1838 * And if we are trying to acquire an exclusive lease, 1839 * then the file is not open by anyone (including us) 1840 * except for this filp. 1841 */ 1842 error = -EAGAIN; 1843 list_for_each_entry(fl, &ctx->flc_lease, fl_list) { 1844 if (fl->fl_file == filp && 1845 fl->fl_owner == lease->fl_owner) { 1846 my_fl = fl; 1847 continue; 1848 } 1849 1850 /* 1851 * No exclusive leases if someone else has a lease on 1852 * this file: 1853 */ 1854 if (arg == F_WRLCK) 1855 goto out; 1856 /* 1857 * Modifying our existing lease is OK, but no getting a 1858 * new lease if someone else is opening for write: 1859 */ 1860 if (fl->fl_flags & FL_UNLOCK_PENDING) 1861 goto out; 1862 } 1863 1864 if (my_fl != NULL) { 1865 lease = my_fl; 1866 error = lease->fl_lmops->lm_change(lease, arg, &dispose); 1867 if (error) 1868 goto out; 1869 goto out_setup; 1870 } 1871 1872 error = -EINVAL; 1873 if (!leases_enable) 1874 goto out; 1875 1876 locks_insert_lock_ctx(lease, &ctx->flc_lease); 1877 /* 1878 * The check in break_lease() is lockless. It's possible for another 1879 * open to race in after we did the earlier check for a conflicting 1880 * open but before the lease was inserted. Check again for a 1881 * conflicting open and cancel the lease if there is one. 1882 * 1883 * We also add a barrier here to ensure that the insertion of the lock 1884 * precedes these checks. 1885 */ 1886 smp_mb(); 1887 error = check_conflicting_open(filp, arg, lease->fl_flags); 1888 if (error) { 1889 locks_unlink_lock_ctx(lease); 1890 goto out; 1891 } 1892 1893 out_setup: 1894 if (lease->fl_lmops->lm_setup) 1895 lease->fl_lmops->lm_setup(lease, priv); 1896 out: 1897 spin_unlock(&ctx->flc_lock); 1898 percpu_up_read(&file_rwsem); 1899 locks_dispose_list(&dispose); 1900 if (is_deleg) 1901 inode_unlock(inode); 1902 if (!error && !my_fl) 1903 *flp = NULL; 1904 return error; 1905 } 1906 1907 static int generic_delete_lease(struct file *filp, void *owner) 1908 { 1909 int error = -EAGAIN; 1910 struct file_lock *fl, *victim = NULL; 1911 struct inode *inode = locks_inode(filp); 1912 struct file_lock_context *ctx; 1913 LIST_HEAD(dispose); 1914 1915 ctx = smp_load_acquire(&inode->i_flctx); 1916 if (!ctx) { 1917 trace_generic_delete_lease(inode, NULL); 1918 return error; 1919 } 1920 1921 percpu_down_read(&file_rwsem); 1922 spin_lock(&ctx->flc_lock); 1923 list_for_each_entry(fl, &ctx->flc_lease, fl_list) { 1924 if (fl->fl_file == filp && 1925 fl->fl_owner == owner) { 1926 victim = fl; 1927 break; 1928 } 1929 } 1930 trace_generic_delete_lease(inode, victim); 1931 if (victim) 1932 error = fl->fl_lmops->lm_change(victim, F_UNLCK, &dispose); 1933 spin_unlock(&ctx->flc_lock); 1934 percpu_up_read(&file_rwsem); 1935 locks_dispose_list(&dispose); 1936 return error; 1937 } 1938 1939 /** 1940 * generic_setlease - sets a lease on an open file 1941 * @filp: file pointer 1942 * @arg: type of lease to obtain 1943 * @flp: input - file_lock to use, output - file_lock inserted 1944 * @priv: private data for lm_setup (may be NULL if lm_setup 1945 * doesn't require it) 1946 * 1947 * The (input) flp->fl_lmops->lm_break function is required 1948 * by break_lease(). 1949 */ 1950 int generic_setlease(struct file *filp, long arg, struct file_lock **flp, 1951 void **priv) 1952 { 1953 struct inode *inode = locks_inode(filp); 1954 int error; 1955 1956 if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE)) 1957 return -EACCES; 1958 if (!S_ISREG(inode->i_mode)) 1959 return -EINVAL; 1960 error = security_file_lock(filp, arg); 1961 if (error) 1962 return error; 1963 1964 switch (arg) { 1965 case F_UNLCK: 1966 return generic_delete_lease(filp, *priv); 1967 case F_RDLCK: 1968 case F_WRLCK: 1969 if (!(*flp)->fl_lmops->lm_break) { 1970 WARN_ON_ONCE(1); 1971 return -ENOLCK; 1972 } 1973 1974 return generic_add_lease(filp, arg, flp, priv); 1975 default: 1976 return -EINVAL; 1977 } 1978 } 1979 EXPORT_SYMBOL(generic_setlease); 1980 1981 #if IS_ENABLED(CONFIG_SRCU) 1982 /* 1983 * Kernel subsystems can register to be notified on any attempt to set 1984 * a new lease with the lease_notifier_chain. This is used by (e.g.) nfsd 1985 * to close files that it may have cached when there is an attempt to set a 1986 * conflicting lease. 1987 */ 1988 static struct srcu_notifier_head lease_notifier_chain; 1989 1990 static inline void 1991 lease_notifier_chain_init(void) 1992 { 1993 srcu_init_notifier_head(&lease_notifier_chain); 1994 } 1995 1996 static inline void 1997 setlease_notifier(long arg, struct file_lock *lease) 1998 { 1999 if (arg != F_UNLCK) 2000 srcu_notifier_call_chain(&lease_notifier_chain, arg, lease); 2001 } 2002 2003 int lease_register_notifier(struct notifier_block *nb) 2004 { 2005 return srcu_notifier_chain_register(&lease_notifier_chain, nb); 2006 } 2007 EXPORT_SYMBOL_GPL(lease_register_notifier); 2008 2009 void lease_unregister_notifier(struct notifier_block *nb) 2010 { 2011 srcu_notifier_chain_unregister(&lease_notifier_chain, nb); 2012 } 2013 EXPORT_SYMBOL_GPL(lease_unregister_notifier); 2014 2015 #else /* !IS_ENABLED(CONFIG_SRCU) */ 2016 static inline void 2017 lease_notifier_chain_init(void) 2018 { 2019 } 2020 2021 static inline void 2022 setlease_notifier(long arg, struct file_lock *lease) 2023 { 2024 } 2025 2026 int lease_register_notifier(struct notifier_block *nb) 2027 { 2028 return 0; 2029 } 2030 EXPORT_SYMBOL_GPL(lease_register_notifier); 2031 2032 void lease_unregister_notifier(struct notifier_block *nb) 2033 { 2034 } 2035 EXPORT_SYMBOL_GPL(lease_unregister_notifier); 2036 2037 #endif /* IS_ENABLED(CONFIG_SRCU) */ 2038 2039 /** 2040 * vfs_setlease - sets a lease on an open file 2041 * @filp: file pointer 2042 * @arg: type of lease to obtain 2043 * @lease: file_lock to use when adding a lease 2044 * @priv: private info for lm_setup when adding a lease (may be 2045 * NULL if lm_setup doesn't require it) 2046 * 2047 * Call this to establish a lease on the file. The "lease" argument is not 2048 * used for F_UNLCK requests and may be NULL. For commands that set or alter 2049 * an existing lease, the ``(*lease)->fl_lmops->lm_break`` operation must be 2050 * set; if not, this function will return -ENOLCK (and generate a scary-looking 2051 * stack trace). 2052 * 2053 * The "priv" pointer is passed directly to the lm_setup function as-is. It 2054 * may be NULL if the lm_setup operation doesn't require it. 2055 */ 2056 int 2057 vfs_setlease(struct file *filp, long arg, struct file_lock **lease, void **priv) 2058 { 2059 if (lease) 2060 setlease_notifier(arg, *lease); 2061 if (filp->f_op->setlease) 2062 return filp->f_op->setlease(filp, arg, lease, priv); 2063 else 2064 return generic_setlease(filp, arg, lease, priv); 2065 } 2066 EXPORT_SYMBOL_GPL(vfs_setlease); 2067 2068 static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg) 2069 { 2070 struct file_lock *fl; 2071 struct fasync_struct *new; 2072 int error; 2073 2074 fl = lease_alloc(filp, arg); 2075 if (IS_ERR(fl)) 2076 return PTR_ERR(fl); 2077 2078 new = fasync_alloc(); 2079 if (!new) { 2080 locks_free_lock(fl); 2081 return -ENOMEM; 2082 } 2083 new->fa_fd = fd; 2084 2085 error = vfs_setlease(filp, arg, &fl, (void **)&new); 2086 if (fl) 2087 locks_free_lock(fl); 2088 if (new) 2089 fasync_free(new); 2090 return error; 2091 } 2092 2093 /** 2094 * fcntl_setlease - sets a lease on an open file 2095 * @fd: open file descriptor 2096 * @filp: file pointer 2097 * @arg: type of lease to obtain 2098 * 2099 * Call this fcntl to establish a lease on the file. 2100 * Note that you also need to call %F_SETSIG to 2101 * receive a signal when the lease is broken. 2102 */ 2103 int fcntl_setlease(unsigned int fd, struct file *filp, long arg) 2104 { 2105 if (arg == F_UNLCK) 2106 return vfs_setlease(filp, F_UNLCK, NULL, (void **)&filp); 2107 return do_fcntl_add_lease(fd, filp, arg); 2108 } 2109 2110 /** 2111 * flock_lock_inode_wait - Apply a FLOCK-style lock to a file 2112 * @inode: inode of the file to apply to 2113 * @fl: The lock to be applied 2114 * 2115 * Apply a FLOCK style lock request to an inode. 2116 */ 2117 static int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl) 2118 { 2119 int error; 2120 might_sleep(); 2121 for (;;) { 2122 error = flock_lock_inode(inode, fl); 2123 if (error != FILE_LOCK_DEFERRED) 2124 break; 2125 error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker); 2126 if (error) 2127 break; 2128 } 2129 locks_delete_block(fl); 2130 return error; 2131 } 2132 2133 /** 2134 * locks_lock_inode_wait - Apply a lock to an inode 2135 * @inode: inode of the file to apply to 2136 * @fl: The lock to be applied 2137 * 2138 * Apply a POSIX or FLOCK style lock request to an inode. 2139 */ 2140 int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl) 2141 { 2142 int res = 0; 2143 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 2144 case FL_POSIX: 2145 res = posix_lock_inode_wait(inode, fl); 2146 break; 2147 case FL_FLOCK: 2148 res = flock_lock_inode_wait(inode, fl); 2149 break; 2150 default: 2151 BUG(); 2152 } 2153 return res; 2154 } 2155 EXPORT_SYMBOL(locks_lock_inode_wait); 2156 2157 /** 2158 * sys_flock: - flock() system call. 2159 * @fd: the file descriptor to lock. 2160 * @cmd: the type of lock to apply. 2161 * 2162 * Apply a %FL_FLOCK style lock to an open file descriptor. 2163 * The @cmd can be one of: 2164 * 2165 * - %LOCK_SH -- a shared lock. 2166 * - %LOCK_EX -- an exclusive lock. 2167 * - %LOCK_UN -- remove an existing lock. 2168 * - %LOCK_MAND -- a 'mandatory' flock. 2169 * This exists to emulate Windows Share Modes. 2170 * 2171 * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other 2172 * processes read and write access respectively. 2173 */ 2174 SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) 2175 { 2176 struct fd f = fdget(fd); 2177 struct file_lock *lock; 2178 int can_sleep, unlock; 2179 int error; 2180 2181 error = -EBADF; 2182 if (!f.file) 2183 goto out; 2184 2185 can_sleep = !(cmd & LOCK_NB); 2186 cmd &= ~LOCK_NB; 2187 unlock = (cmd == LOCK_UN); 2188 2189 if (!unlock && !(cmd & LOCK_MAND) && 2190 !(f.file->f_mode & (FMODE_READ|FMODE_WRITE))) 2191 goto out_putf; 2192 2193 lock = flock_make_lock(f.file, cmd, NULL); 2194 if (IS_ERR(lock)) { 2195 error = PTR_ERR(lock); 2196 goto out_putf; 2197 } 2198 2199 if (can_sleep) 2200 lock->fl_flags |= FL_SLEEP; 2201 2202 error = security_file_lock(f.file, lock->fl_type); 2203 if (error) 2204 goto out_free; 2205 2206 if (f.file->f_op->flock) 2207 error = f.file->f_op->flock(f.file, 2208 (can_sleep) ? F_SETLKW : F_SETLK, 2209 lock); 2210 else 2211 error = locks_lock_file_wait(f.file, lock); 2212 2213 out_free: 2214 locks_free_lock(lock); 2215 2216 out_putf: 2217 fdput(f); 2218 out: 2219 return error; 2220 } 2221 2222 /** 2223 * vfs_test_lock - test file byte range lock 2224 * @filp: The file to test lock for 2225 * @fl: The lock to test; also used to hold result 2226 * 2227 * Returns -ERRNO on failure. Indicates presence of conflicting lock by 2228 * setting conf->fl_type to something other than F_UNLCK. 2229 */ 2230 int vfs_test_lock(struct file *filp, struct file_lock *fl) 2231 { 2232 if (filp->f_op->lock) 2233 return filp->f_op->lock(filp, F_GETLK, fl); 2234 posix_test_lock(filp, fl); 2235 return 0; 2236 } 2237 EXPORT_SYMBOL_GPL(vfs_test_lock); 2238 2239 /** 2240 * locks_translate_pid - translate a file_lock's fl_pid number into a namespace 2241 * @fl: The file_lock who's fl_pid should be translated 2242 * @ns: The namespace into which the pid should be translated 2243 * 2244 * Used to tranlate a fl_pid into a namespace virtual pid number 2245 */ 2246 static pid_t locks_translate_pid(struct file_lock *fl, struct pid_namespace *ns) 2247 { 2248 pid_t vnr; 2249 struct pid *pid; 2250 2251 if (IS_OFDLCK(fl)) 2252 return -1; 2253 if (IS_REMOTELCK(fl)) 2254 return fl->fl_pid; 2255 /* 2256 * If the flock owner process is dead and its pid has been already 2257 * freed, the translation below won't work, but we still want to show 2258 * flock owner pid number in init pidns. 2259 */ 2260 if (ns == &init_pid_ns) 2261 return (pid_t)fl->fl_pid; 2262 2263 rcu_read_lock(); 2264 pid = find_pid_ns(fl->fl_pid, &init_pid_ns); 2265 vnr = pid_nr_ns(pid, ns); 2266 rcu_read_unlock(); 2267 return vnr; 2268 } 2269 2270 static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) 2271 { 2272 flock->l_pid = locks_translate_pid(fl, task_active_pid_ns(current)); 2273 #if BITS_PER_LONG == 32 2274 /* 2275 * Make sure we can represent the posix lock via 2276 * legacy 32bit flock. 2277 */ 2278 if (fl->fl_start > OFFT_OFFSET_MAX) 2279 return -EOVERFLOW; 2280 if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX) 2281 return -EOVERFLOW; 2282 #endif 2283 flock->l_start = fl->fl_start; 2284 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 2285 fl->fl_end - fl->fl_start + 1; 2286 flock->l_whence = 0; 2287 flock->l_type = fl->fl_type; 2288 return 0; 2289 } 2290 2291 #if BITS_PER_LONG == 32 2292 static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) 2293 { 2294 flock->l_pid = locks_translate_pid(fl, task_active_pid_ns(current)); 2295 flock->l_start = fl->fl_start; 2296 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 2297 fl->fl_end - fl->fl_start + 1; 2298 flock->l_whence = 0; 2299 flock->l_type = fl->fl_type; 2300 } 2301 #endif 2302 2303 /* Report the first existing lock that would conflict with l. 2304 * This implements the F_GETLK command of fcntl(). 2305 */ 2306 int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock *flock) 2307 { 2308 struct file_lock *fl; 2309 int error; 2310 2311 fl = locks_alloc_lock(); 2312 if (fl == NULL) 2313 return -ENOMEM; 2314 error = -EINVAL; 2315 if (flock->l_type != F_RDLCK && flock->l_type != F_WRLCK) 2316 goto out; 2317 2318 error = flock_to_posix_lock(filp, fl, flock); 2319 if (error) 2320 goto out; 2321 2322 if (cmd == F_OFD_GETLK) { 2323 error = -EINVAL; 2324 if (flock->l_pid != 0) 2325 goto out; 2326 2327 cmd = F_GETLK; 2328 fl->fl_flags |= FL_OFDLCK; 2329 fl->fl_owner = filp; 2330 } 2331 2332 error = vfs_test_lock(filp, fl); 2333 if (error) 2334 goto out; 2335 2336 flock->l_type = fl->fl_type; 2337 if (fl->fl_type != F_UNLCK) { 2338 error = posix_lock_to_flock(flock, fl); 2339 if (error) 2340 goto out; 2341 } 2342 out: 2343 locks_free_lock(fl); 2344 return error; 2345 } 2346 2347 /** 2348 * vfs_lock_file - file byte range lock 2349 * @filp: The file to apply the lock to 2350 * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.) 2351 * @fl: The lock to be applied 2352 * @conf: Place to return a copy of the conflicting lock, if found. 2353 * 2354 * A caller that doesn't care about the conflicting lock may pass NULL 2355 * as the final argument. 2356 * 2357 * If the filesystem defines a private ->lock() method, then @conf will 2358 * be left unchanged; so a caller that cares should initialize it to 2359 * some acceptable default. 2360 * 2361 * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX 2362 * locks, the ->lock() interface may return asynchronously, before the lock has 2363 * been granted or denied by the underlying filesystem, if (and only if) 2364 * lm_grant is set. Callers expecting ->lock() to return asynchronously 2365 * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if) 2366 * the request is for a blocking lock. When ->lock() does return asynchronously, 2367 * it must return FILE_LOCK_DEFERRED, and call ->lm_grant() when the lock 2368 * request completes. 2369 * If the request is for non-blocking lock the file system should return 2370 * FILE_LOCK_DEFERRED then try to get the lock and call the callback routine 2371 * with the result. If the request timed out the callback routine will return a 2372 * nonzero return code and the file system should release the lock. The file 2373 * system is also responsible to keep a corresponding posix lock when it 2374 * grants a lock so the VFS can find out which locks are locally held and do 2375 * the correct lock cleanup when required. 2376 * The underlying filesystem must not drop the kernel lock or call 2377 * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED 2378 * return code. 2379 */ 2380 int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) 2381 { 2382 if (filp->f_op->lock) 2383 return filp->f_op->lock(filp, cmd, fl); 2384 else 2385 return posix_lock_file(filp, fl, conf); 2386 } 2387 EXPORT_SYMBOL_GPL(vfs_lock_file); 2388 2389 static int do_lock_file_wait(struct file *filp, unsigned int cmd, 2390 struct file_lock *fl) 2391 { 2392 int error; 2393 2394 error = security_file_lock(filp, fl->fl_type); 2395 if (error) 2396 return error; 2397 2398 for (;;) { 2399 error = vfs_lock_file(filp, cmd, fl, NULL); 2400 if (error != FILE_LOCK_DEFERRED) 2401 break; 2402 error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker); 2403 if (error) 2404 break; 2405 } 2406 locks_delete_block(fl); 2407 2408 return error; 2409 } 2410 2411 /* Ensure that fl->fl_file has compatible f_mode for F_SETLK calls */ 2412 static int 2413 check_fmode_for_setlk(struct file_lock *fl) 2414 { 2415 switch (fl->fl_type) { 2416 case F_RDLCK: 2417 if (!(fl->fl_file->f_mode & FMODE_READ)) 2418 return -EBADF; 2419 break; 2420 case F_WRLCK: 2421 if (!(fl->fl_file->f_mode & FMODE_WRITE)) 2422 return -EBADF; 2423 } 2424 return 0; 2425 } 2426 2427 /* Apply the lock described by l to an open file descriptor. 2428 * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 2429 */ 2430 int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, 2431 struct flock *flock) 2432 { 2433 struct file_lock *file_lock = locks_alloc_lock(); 2434 struct inode *inode = locks_inode(filp); 2435 struct file *f; 2436 int error; 2437 2438 if (file_lock == NULL) 2439 return -ENOLCK; 2440 2441 /* Don't allow mandatory locks on files that may be memory mapped 2442 * and shared. 2443 */ 2444 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 2445 error = -EAGAIN; 2446 goto out; 2447 } 2448 2449 error = flock_to_posix_lock(filp, file_lock, flock); 2450 if (error) 2451 goto out; 2452 2453 error = check_fmode_for_setlk(file_lock); 2454 if (error) 2455 goto out; 2456 2457 /* 2458 * If the cmd is requesting file-private locks, then set the 2459 * FL_OFDLCK flag and override the owner. 2460 */ 2461 switch (cmd) { 2462 case F_OFD_SETLK: 2463 error = -EINVAL; 2464 if (flock->l_pid != 0) 2465 goto out; 2466 2467 cmd = F_SETLK; 2468 file_lock->fl_flags |= FL_OFDLCK; 2469 file_lock->fl_owner = filp; 2470 break; 2471 case F_OFD_SETLKW: 2472 error = -EINVAL; 2473 if (flock->l_pid != 0) 2474 goto out; 2475 2476 cmd = F_SETLKW; 2477 file_lock->fl_flags |= FL_OFDLCK; 2478 file_lock->fl_owner = filp; 2479 /* Fallthrough */ 2480 case F_SETLKW: 2481 file_lock->fl_flags |= FL_SLEEP; 2482 } 2483 2484 error = do_lock_file_wait(filp, cmd, file_lock); 2485 2486 /* 2487 * Attempt to detect a close/fcntl race and recover by releasing the 2488 * lock that was just acquired. There is no need to do that when we're 2489 * unlocking though, or for OFD locks. 2490 */ 2491 if (!error && file_lock->fl_type != F_UNLCK && 2492 !(file_lock->fl_flags & FL_OFDLCK)) { 2493 /* 2494 * We need that spin_lock here - it prevents reordering between 2495 * update of i_flctx->flc_posix and check for it done in 2496 * close(). rcu_read_lock() wouldn't do. 2497 */ 2498 spin_lock(¤t->files->file_lock); 2499 f = fcheck(fd); 2500 spin_unlock(¤t->files->file_lock); 2501 if (f != filp) { 2502 file_lock->fl_type = F_UNLCK; 2503 error = do_lock_file_wait(filp, cmd, file_lock); 2504 WARN_ON_ONCE(error); 2505 error = -EBADF; 2506 } 2507 } 2508 out: 2509 trace_fcntl_setlk(inode, file_lock, error); 2510 locks_free_lock(file_lock); 2511 return error; 2512 } 2513 2514 #if BITS_PER_LONG == 32 2515 /* Report the first existing lock that would conflict with l. 2516 * This implements the F_GETLK command of fcntl(). 2517 */ 2518 int fcntl_getlk64(struct file *filp, unsigned int cmd, struct flock64 *flock) 2519 { 2520 struct file_lock *fl; 2521 int error; 2522 2523 fl = locks_alloc_lock(); 2524 if (fl == NULL) 2525 return -ENOMEM; 2526 2527 error = -EINVAL; 2528 if (flock->l_type != F_RDLCK && flock->l_type != F_WRLCK) 2529 goto out; 2530 2531 error = flock64_to_posix_lock(filp, fl, flock); 2532 if (error) 2533 goto out; 2534 2535 if (cmd == F_OFD_GETLK) { 2536 error = -EINVAL; 2537 if (flock->l_pid != 0) 2538 goto out; 2539 2540 cmd = F_GETLK64; 2541 fl->fl_flags |= FL_OFDLCK; 2542 fl->fl_owner = filp; 2543 } 2544 2545 error = vfs_test_lock(filp, fl); 2546 if (error) 2547 goto out; 2548 2549 flock->l_type = fl->fl_type; 2550 if (fl->fl_type != F_UNLCK) 2551 posix_lock_to_flock64(flock, fl); 2552 2553 out: 2554 locks_free_lock(fl); 2555 return error; 2556 } 2557 2558 /* Apply the lock described by l to an open file descriptor. 2559 * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 2560 */ 2561 int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, 2562 struct flock64 *flock) 2563 { 2564 struct file_lock *file_lock = locks_alloc_lock(); 2565 struct inode *inode = locks_inode(filp); 2566 struct file *f; 2567 int error; 2568 2569 if (file_lock == NULL) 2570 return -ENOLCK; 2571 2572 /* Don't allow mandatory locks on files that may be memory mapped 2573 * and shared. 2574 */ 2575 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 2576 error = -EAGAIN; 2577 goto out; 2578 } 2579 2580 error = flock64_to_posix_lock(filp, file_lock, flock); 2581 if (error) 2582 goto out; 2583 2584 error = check_fmode_for_setlk(file_lock); 2585 if (error) 2586 goto out; 2587 2588 /* 2589 * If the cmd is requesting file-private locks, then set the 2590 * FL_OFDLCK flag and override the owner. 2591 */ 2592 switch (cmd) { 2593 case F_OFD_SETLK: 2594 error = -EINVAL; 2595 if (flock->l_pid != 0) 2596 goto out; 2597 2598 cmd = F_SETLK64; 2599 file_lock->fl_flags |= FL_OFDLCK; 2600 file_lock->fl_owner = filp; 2601 break; 2602 case F_OFD_SETLKW: 2603 error = -EINVAL; 2604 if (flock->l_pid != 0) 2605 goto out; 2606 2607 cmd = F_SETLKW64; 2608 file_lock->fl_flags |= FL_OFDLCK; 2609 file_lock->fl_owner = filp; 2610 /* Fallthrough */ 2611 case F_SETLKW64: 2612 file_lock->fl_flags |= FL_SLEEP; 2613 } 2614 2615 error = do_lock_file_wait(filp, cmd, file_lock); 2616 2617 /* 2618 * Attempt to detect a close/fcntl race and recover by releasing the 2619 * lock that was just acquired. There is no need to do that when we're 2620 * unlocking though, or for OFD locks. 2621 */ 2622 if (!error && file_lock->fl_type != F_UNLCK && 2623 !(file_lock->fl_flags & FL_OFDLCK)) { 2624 /* 2625 * We need that spin_lock here - it prevents reordering between 2626 * update of i_flctx->flc_posix and check for it done in 2627 * close(). rcu_read_lock() wouldn't do. 2628 */ 2629 spin_lock(¤t->files->file_lock); 2630 f = fcheck(fd); 2631 spin_unlock(¤t->files->file_lock); 2632 if (f != filp) { 2633 file_lock->fl_type = F_UNLCK; 2634 error = do_lock_file_wait(filp, cmd, file_lock); 2635 WARN_ON_ONCE(error); 2636 error = -EBADF; 2637 } 2638 } 2639 out: 2640 locks_free_lock(file_lock); 2641 return error; 2642 } 2643 #endif /* BITS_PER_LONG == 32 */ 2644 2645 /* 2646 * This function is called when the file is being removed 2647 * from the task's fd array. POSIX locks belonging to this task 2648 * are deleted at this time. 2649 */ 2650 void locks_remove_posix(struct file *filp, fl_owner_t owner) 2651 { 2652 int error; 2653 struct inode *inode = locks_inode(filp); 2654 struct file_lock lock; 2655 struct file_lock_context *ctx; 2656 2657 /* 2658 * If there are no locks held on this file, we don't need to call 2659 * posix_lock_file(). Another process could be setting a lock on this 2660 * file at the same time, but we wouldn't remove that lock anyway. 2661 */ 2662 ctx = smp_load_acquire(&inode->i_flctx); 2663 if (!ctx || list_empty(&ctx->flc_posix)) 2664 return; 2665 2666 locks_init_lock(&lock); 2667 lock.fl_type = F_UNLCK; 2668 lock.fl_flags = FL_POSIX | FL_CLOSE; 2669 lock.fl_start = 0; 2670 lock.fl_end = OFFSET_MAX; 2671 lock.fl_owner = owner; 2672 lock.fl_pid = current->tgid; 2673 lock.fl_file = filp; 2674 lock.fl_ops = NULL; 2675 lock.fl_lmops = NULL; 2676 2677 error = vfs_lock_file(filp, F_SETLK, &lock, NULL); 2678 2679 if (lock.fl_ops && lock.fl_ops->fl_release_private) 2680 lock.fl_ops->fl_release_private(&lock); 2681 trace_locks_remove_posix(inode, &lock, error); 2682 } 2683 EXPORT_SYMBOL(locks_remove_posix); 2684 2685 /* The i_flctx must be valid when calling into here */ 2686 static void 2687 locks_remove_flock(struct file *filp, struct file_lock_context *flctx) 2688 { 2689 struct file_lock fl; 2690 struct inode *inode = locks_inode(filp); 2691 2692 if (list_empty(&flctx->flc_flock)) 2693 return; 2694 2695 flock_make_lock(filp, LOCK_UN, &fl); 2696 fl.fl_flags |= FL_CLOSE; 2697 2698 if (filp->f_op->flock) 2699 filp->f_op->flock(filp, F_SETLKW, &fl); 2700 else 2701 flock_lock_inode(inode, &fl); 2702 2703 if (fl.fl_ops && fl.fl_ops->fl_release_private) 2704 fl.fl_ops->fl_release_private(&fl); 2705 } 2706 2707 /* The i_flctx must be valid when calling into here */ 2708 static void 2709 locks_remove_lease(struct file *filp, struct file_lock_context *ctx) 2710 { 2711 struct file_lock *fl, *tmp; 2712 LIST_HEAD(dispose); 2713 2714 if (list_empty(&ctx->flc_lease)) 2715 return; 2716 2717 percpu_down_read(&file_rwsem); 2718 spin_lock(&ctx->flc_lock); 2719 list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) 2720 if (filp == fl->fl_file) 2721 lease_modify(fl, F_UNLCK, &dispose); 2722 spin_unlock(&ctx->flc_lock); 2723 percpu_up_read(&file_rwsem); 2724 2725 locks_dispose_list(&dispose); 2726 } 2727 2728 /* 2729 * This function is called on the last close of an open file. 2730 */ 2731 void locks_remove_file(struct file *filp) 2732 { 2733 struct file_lock_context *ctx; 2734 2735 ctx = smp_load_acquire(&locks_inode(filp)->i_flctx); 2736 if (!ctx) 2737 return; 2738 2739 /* remove any OFD locks */ 2740 locks_remove_posix(filp, filp); 2741 2742 /* remove flock locks */ 2743 locks_remove_flock(filp, ctx); 2744 2745 /* remove any leases */ 2746 locks_remove_lease(filp, ctx); 2747 2748 spin_lock(&ctx->flc_lock); 2749 locks_check_ctx_file_list(filp, &ctx->flc_posix, "POSIX"); 2750 locks_check_ctx_file_list(filp, &ctx->flc_flock, "FLOCK"); 2751 locks_check_ctx_file_list(filp, &ctx->flc_lease, "LEASE"); 2752 spin_unlock(&ctx->flc_lock); 2753 } 2754 2755 /** 2756 * vfs_cancel_lock - file byte range unblock lock 2757 * @filp: The file to apply the unblock to 2758 * @fl: The lock to be unblocked 2759 * 2760 * Used by lock managers to cancel blocked requests 2761 */ 2762 int vfs_cancel_lock(struct file *filp, struct file_lock *fl) 2763 { 2764 if (filp->f_op->lock) 2765 return filp->f_op->lock(filp, F_CANCELLK, fl); 2766 return 0; 2767 } 2768 EXPORT_SYMBOL_GPL(vfs_cancel_lock); 2769 2770 #ifdef CONFIG_PROC_FS 2771 #include <linux/proc_fs.h> 2772 #include <linux/seq_file.h> 2773 2774 struct locks_iterator { 2775 int li_cpu; 2776 loff_t li_pos; 2777 }; 2778 2779 static void lock_get_status(struct seq_file *f, struct file_lock *fl, 2780 loff_t id, char *pfx) 2781 { 2782 struct inode *inode = NULL; 2783 unsigned int fl_pid; 2784 struct pid_namespace *proc_pidns = file_inode(f->file)->i_sb->s_fs_info; 2785 2786 fl_pid = locks_translate_pid(fl, proc_pidns); 2787 /* 2788 * If lock owner is dead (and pid is freed) or not visible in current 2789 * pidns, zero is shown as a pid value. Check lock info from 2790 * init_pid_ns to get saved lock pid value. 2791 */ 2792 2793 if (fl->fl_file != NULL) 2794 inode = locks_inode(fl->fl_file); 2795 2796 seq_printf(f, "%lld:%s ", id, pfx); 2797 if (IS_POSIX(fl)) { 2798 if (fl->fl_flags & FL_ACCESS) 2799 seq_puts(f, "ACCESS"); 2800 else if (IS_OFDLCK(fl)) 2801 seq_puts(f, "OFDLCK"); 2802 else 2803 seq_puts(f, "POSIX "); 2804 2805 seq_printf(f, " %s ", 2806 (inode == NULL) ? "*NOINODE*" : 2807 mandatory_lock(inode) ? "MANDATORY" : "ADVISORY "); 2808 } else if (IS_FLOCK(fl)) { 2809 if (fl->fl_type & LOCK_MAND) { 2810 seq_puts(f, "FLOCK MSNFS "); 2811 } else { 2812 seq_puts(f, "FLOCK ADVISORY "); 2813 } 2814 } else if (IS_LEASE(fl)) { 2815 if (fl->fl_flags & FL_DELEG) 2816 seq_puts(f, "DELEG "); 2817 else 2818 seq_puts(f, "LEASE "); 2819 2820 if (lease_breaking(fl)) 2821 seq_puts(f, "BREAKING "); 2822 else if (fl->fl_file) 2823 seq_puts(f, "ACTIVE "); 2824 else 2825 seq_puts(f, "BREAKER "); 2826 } else { 2827 seq_puts(f, "UNKNOWN UNKNOWN "); 2828 } 2829 if (fl->fl_type & LOCK_MAND) { 2830 seq_printf(f, "%s ", 2831 (fl->fl_type & LOCK_READ) 2832 ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ " 2833 : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE "); 2834 } else { 2835 int type = IS_LEASE(fl) ? target_leasetype(fl) : fl->fl_type; 2836 2837 seq_printf(f, "%s ", (type == F_WRLCK) ? "WRITE" : 2838 (type == F_RDLCK) ? "READ" : "UNLCK"); 2839 } 2840 if (inode) { 2841 /* userspace relies on this representation of dev_t */ 2842 seq_printf(f, "%d %02x:%02x:%lu ", fl_pid, 2843 MAJOR(inode->i_sb->s_dev), 2844 MINOR(inode->i_sb->s_dev), inode->i_ino); 2845 } else { 2846 seq_printf(f, "%d <none>:0 ", fl_pid); 2847 } 2848 if (IS_POSIX(fl)) { 2849 if (fl->fl_end == OFFSET_MAX) 2850 seq_printf(f, "%Ld EOF\n", fl->fl_start); 2851 else 2852 seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end); 2853 } else { 2854 seq_puts(f, "0 EOF\n"); 2855 } 2856 } 2857 2858 static int locks_show(struct seq_file *f, void *v) 2859 { 2860 struct locks_iterator *iter = f->private; 2861 struct file_lock *fl, *bfl; 2862 struct pid_namespace *proc_pidns = file_inode(f->file)->i_sb->s_fs_info; 2863 2864 fl = hlist_entry(v, struct file_lock, fl_link); 2865 2866 if (locks_translate_pid(fl, proc_pidns) == 0) 2867 return 0; 2868 2869 lock_get_status(f, fl, iter->li_pos, ""); 2870 2871 list_for_each_entry(bfl, &fl->fl_blocked_requests, fl_blocked_member) 2872 lock_get_status(f, bfl, iter->li_pos, " ->"); 2873 2874 return 0; 2875 } 2876 2877 static void __show_fd_locks(struct seq_file *f, 2878 struct list_head *head, int *id, 2879 struct file *filp, struct files_struct *files) 2880 { 2881 struct file_lock *fl; 2882 2883 list_for_each_entry(fl, head, fl_list) { 2884 2885 if (filp != fl->fl_file) 2886 continue; 2887 if (fl->fl_owner != files && 2888 fl->fl_owner != filp) 2889 continue; 2890 2891 (*id)++; 2892 seq_puts(f, "lock:\t"); 2893 lock_get_status(f, fl, *id, ""); 2894 } 2895 } 2896 2897 void show_fd_locks(struct seq_file *f, 2898 struct file *filp, struct files_struct *files) 2899 { 2900 struct inode *inode = locks_inode(filp); 2901 struct file_lock_context *ctx; 2902 int id = 0; 2903 2904 ctx = smp_load_acquire(&inode->i_flctx); 2905 if (!ctx) 2906 return; 2907 2908 spin_lock(&ctx->flc_lock); 2909 __show_fd_locks(f, &ctx->flc_flock, &id, filp, files); 2910 __show_fd_locks(f, &ctx->flc_posix, &id, filp, files); 2911 __show_fd_locks(f, &ctx->flc_lease, &id, filp, files); 2912 spin_unlock(&ctx->flc_lock); 2913 } 2914 2915 static void *locks_start(struct seq_file *f, loff_t *pos) 2916 __acquires(&blocked_lock_lock) 2917 { 2918 struct locks_iterator *iter = f->private; 2919 2920 iter->li_pos = *pos + 1; 2921 percpu_down_write(&file_rwsem); 2922 spin_lock(&blocked_lock_lock); 2923 return seq_hlist_start_percpu(&file_lock_list.hlist, &iter->li_cpu, *pos); 2924 } 2925 2926 static void *locks_next(struct seq_file *f, void *v, loff_t *pos) 2927 { 2928 struct locks_iterator *iter = f->private; 2929 2930 ++iter->li_pos; 2931 return seq_hlist_next_percpu(v, &file_lock_list.hlist, &iter->li_cpu, pos); 2932 } 2933 2934 static void locks_stop(struct seq_file *f, void *v) 2935 __releases(&blocked_lock_lock) 2936 { 2937 spin_unlock(&blocked_lock_lock); 2938 percpu_up_write(&file_rwsem); 2939 } 2940 2941 static const struct seq_operations locks_seq_operations = { 2942 .start = locks_start, 2943 .next = locks_next, 2944 .stop = locks_stop, 2945 .show = locks_show, 2946 }; 2947 2948 static int __init proc_locks_init(void) 2949 { 2950 proc_create_seq_private("locks", 0, NULL, &locks_seq_operations, 2951 sizeof(struct locks_iterator), NULL); 2952 return 0; 2953 } 2954 fs_initcall(proc_locks_init); 2955 #endif 2956 2957 static int __init filelock_init(void) 2958 { 2959 int i; 2960 2961 flctx_cache = kmem_cache_create("file_lock_ctx", 2962 sizeof(struct file_lock_context), 0, SLAB_PANIC, NULL); 2963 2964 filelock_cache = kmem_cache_create("file_lock_cache", 2965 sizeof(struct file_lock), 0, SLAB_PANIC, NULL); 2966 2967 for_each_possible_cpu(i) { 2968 struct file_lock_list_struct *fll = per_cpu_ptr(&file_lock_list, i); 2969 2970 spin_lock_init(&fll->lock); 2971 INIT_HLIST_HEAD(&fll->hlist); 2972 } 2973 2974 lease_notifier_chain_init(); 2975 return 0; 2976 } 2977 core_initcall(filelock_init); 2978