11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/locks.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls. 51da177e4SLinus Torvalds * Doug Evans (dje@spiff.uucp), August 07, 1992 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Deadlock detection added. 81da177e4SLinus Torvalds * FIXME: one thing isn't handled yet: 91da177e4SLinus Torvalds * - mandatory locks (requires lots of changes elsewhere) 101da177e4SLinus Torvalds * Kelly Carmichael (kelly@[142.24.8.65]), September 17, 1994. 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Miscellaneous edits, and a total rewrite of posix_lock_file() code. 131da177e4SLinus Torvalds * Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994 141da177e4SLinus Torvalds * 151da177e4SLinus Torvalds * Converted file_lock_table to a linked list from an array, which eliminates 161da177e4SLinus Torvalds * the limits on how many active file locks are open. 171da177e4SLinus Torvalds * Chad Page (pageone@netcom.com), November 27, 1994 181da177e4SLinus Torvalds * 191da177e4SLinus Torvalds * Removed dependency on file descriptors. dup()'ed file descriptors now 201da177e4SLinus Torvalds * get the same locks as the original file descriptors, and a close() on 211da177e4SLinus Torvalds * any file descriptor removes ALL the locks on the file for the current 221da177e4SLinus Torvalds * process. Since locks still depend on the process id, locks are inherited 231da177e4SLinus Torvalds * after an exec() but not after a fork(). This agrees with POSIX, and both 241da177e4SLinus Torvalds * BSD and SVR4 practice. 251da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), February 14, 1995 261da177e4SLinus Torvalds * 271da177e4SLinus Torvalds * Scrapped free list which is redundant now that we allocate locks 281da177e4SLinus Torvalds * dynamically with kmalloc()/kfree(). 291da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), February 21, 1995 301da177e4SLinus Torvalds * 311da177e4SLinus Torvalds * Implemented two lock personalities - FL_FLOCK and FL_POSIX. 321da177e4SLinus Torvalds * 331da177e4SLinus Torvalds * FL_POSIX locks are created with calls to fcntl() and lockf() through the 341da177e4SLinus Torvalds * fcntl() system call. They have the semantics described above. 351da177e4SLinus Torvalds * 361da177e4SLinus Torvalds * FL_FLOCK locks are created with calls to flock(), through the flock() 371da177e4SLinus Torvalds * system call, which is new. Old C libraries implement flock() via fcntl() 381da177e4SLinus Torvalds * and will continue to use the old, broken implementation. 391da177e4SLinus Torvalds * 401da177e4SLinus Torvalds * FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated 411da177e4SLinus Torvalds * with a file pointer (filp). As a result they can be shared by a parent 421da177e4SLinus Torvalds * process and its children after a fork(). They are removed when the last 431da177e4SLinus Torvalds * file descriptor referring to the file pointer is closed (unless explicitly 441da177e4SLinus Torvalds * unlocked). 451da177e4SLinus Torvalds * 461da177e4SLinus Torvalds * FL_FLOCK locks never deadlock, an existing lock is always removed before 471da177e4SLinus Torvalds * upgrading from shared to exclusive (or vice versa). When this happens 481da177e4SLinus Torvalds * any processes blocked by the current lock are woken up and allowed to 491da177e4SLinus Torvalds * run before the new lock is applied. 501da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995 511da177e4SLinus Torvalds * 521da177e4SLinus Torvalds * Removed some race conditions in flock_lock_file(), marked other possible 531da177e4SLinus Torvalds * races. Just grep for FIXME to see them. 541da177e4SLinus Torvalds * Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996. 551da177e4SLinus Torvalds * 561da177e4SLinus Torvalds * Addressed Dmitry's concerns. Deadlock checking no longer recursive. 571da177e4SLinus Torvalds * Lock allocation changed to GFP_ATOMIC as we can't afford to sleep 581da177e4SLinus Torvalds * once we've checked for blocking and deadlocking. 591da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), April 03, 1996. 601da177e4SLinus Torvalds * 611da177e4SLinus Torvalds * Initial implementation of mandatory locks. SunOS turned out to be 621da177e4SLinus Torvalds * a rotten model, so I implemented the "obvious" semantics. 63395cf969SPaul Bolle * See 'Documentation/filesystems/mandatory-locking.txt' for details. 641da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996. 651da177e4SLinus Torvalds * 661da177e4SLinus Torvalds * Don't allow mandatory locks on mmap()'ed files. Added simple functions to 671da177e4SLinus Torvalds * check if a file has mandatory locks, used by mmap(), open() and creat() to 681da177e4SLinus Torvalds * see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference 691da177e4SLinus Torvalds * Manual, Section 2. 701da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996. 711da177e4SLinus Torvalds * 721da177e4SLinus Torvalds * Tidied up block list handling. Added '/proc/locks' interface. 731da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996. 741da177e4SLinus Torvalds * 751da177e4SLinus Torvalds * Fixed deadlock condition for pathological code that mixes calls to 761da177e4SLinus Torvalds * flock() and fcntl(). 771da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996. 781da177e4SLinus Torvalds * 791da177e4SLinus Torvalds * Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use 801da177e4SLinus Torvalds * for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to 811da177e4SLinus Torvalds * guarantee sensible behaviour in the case where file system modules might 821da177e4SLinus Torvalds * be compiled with different options than the kernel itself. 831da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996. 841da177e4SLinus Torvalds * 851da177e4SLinus Torvalds * Added a couple of missing wake_up() calls. Thanks to Thomas Meckel 861da177e4SLinus Torvalds * (Thomas.Meckel@mni.fh-giessen.de) for spotting this. 871da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996. 881da177e4SLinus Torvalds * 891da177e4SLinus Torvalds * Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK 901da177e4SLinus Torvalds * locks. Changed process synchronisation to avoid dereferencing locks that 911da177e4SLinus Torvalds * have already been freed. 921da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996. 931da177e4SLinus Torvalds * 941da177e4SLinus Torvalds * Made the block list a circular list to minimise searching in the list. 951da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996. 961da177e4SLinus Torvalds * 971da177e4SLinus Torvalds * Made mandatory locking a mount option. Default is not to allow mandatory 981da177e4SLinus Torvalds * locking. 991da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996. 1001da177e4SLinus Torvalds * 1011da177e4SLinus Torvalds * Some adaptations for NFS support. 1021da177e4SLinus Torvalds * Olaf Kirch (okir@monad.swb.de), Dec 1996, 1031da177e4SLinus Torvalds * 1041da177e4SLinus Torvalds * Fixed /proc/locks interface so that we can't overrun the buffer we are handed. 1051da177e4SLinus Torvalds * Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997. 1061da177e4SLinus Torvalds * 1071da177e4SLinus Torvalds * Use slab allocator instead of kmalloc/kfree. 1081da177e4SLinus Torvalds * Use generic list implementation from <linux/list.h>. 1091da177e4SLinus Torvalds * Sped up posix_locks_deadlock by only considering blocked locks. 1101da177e4SLinus Torvalds * Matthew Wilcox <willy@debian.org>, March, 2000. 1111da177e4SLinus Torvalds * 1121da177e4SLinus Torvalds * Leases and LOCK_MAND 1131da177e4SLinus Torvalds * Matthew Wilcox <willy@debian.org>, June, 2000. 1141da177e4SLinus Torvalds * Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000. 1151da177e4SLinus Torvalds */ 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds #include <linux/capability.h> 1181da177e4SLinus Torvalds #include <linux/file.h> 1199f3acc31SAl Viro #include <linux/fdtable.h> 1201da177e4SLinus Torvalds #include <linux/fs.h> 1211da177e4SLinus Torvalds #include <linux/init.h> 1221da177e4SLinus Torvalds #include <linux/module.h> 1231da177e4SLinus Torvalds #include <linux/security.h> 1241da177e4SLinus Torvalds #include <linux/slab.h> 1251da177e4SLinus Torvalds #include <linux/syscalls.h> 1261da177e4SLinus Torvalds #include <linux/time.h> 1274fb3a538SDipankar Sarma #include <linux/rcupdate.h> 128ab1f1611SVitaliy Gusev #include <linux/pid_namespace.h> 129*48f74186SJeff Layton #include <linux/hashtable.h> 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds #include <asm/uaccess.h> 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds #define IS_POSIX(fl) (fl->fl_flags & FL_POSIX) 1341da177e4SLinus Torvalds #define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK) 1351da177e4SLinus Torvalds #define IS_LEASE(fl) (fl->fl_flags & FL_LEASE) 1361da177e4SLinus Torvalds 137ab83fa4bSJ. Bruce Fields static bool lease_breaking(struct file_lock *fl) 138ab83fa4bSJ. Bruce Fields { 139778fc546SJ. Bruce Fields return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING); 140778fc546SJ. Bruce Fields } 141778fc546SJ. Bruce Fields 142778fc546SJ. Bruce Fields static int target_leasetype(struct file_lock *fl) 143778fc546SJ. Bruce Fields { 144778fc546SJ. Bruce Fields if (fl->fl_flags & FL_UNLOCK_PENDING) 145778fc546SJ. Bruce Fields return F_UNLCK; 146778fc546SJ. Bruce Fields if (fl->fl_flags & FL_DOWNGRADE_PENDING) 147778fc546SJ. Bruce Fields return F_RDLCK; 148778fc546SJ. Bruce Fields return fl->fl_type; 149ab83fa4bSJ. Bruce Fields } 150ab83fa4bSJ. Bruce Fields 1511da177e4SLinus Torvalds int leases_enable = 1; 1521da177e4SLinus Torvalds int lease_break_time = 45; 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds #define for_each_lock(inode, lockp) \ 1551da177e4SLinus Torvalds for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next) 1561da177e4SLinus Torvalds 1571c8c601aSJeff Layton /* 1581c8c601aSJeff Layton * The global file_lock_list is only used for displaying /proc/locks. Protected 1591c8c601aSJeff Layton * by the file_lock_lock. 1601c8c601aSJeff Layton */ 161139ca04eSJeff Layton static HLIST_HEAD(file_lock_list); 16288974691SJeff Layton 1631c8c601aSJeff Layton /* 164*48f74186SJeff Layton * The blocked_hash is used to find POSIX lock loops for deadlock detection. 165*48f74186SJeff Layton * It is protected by file_lock_lock. 166*48f74186SJeff Layton * 167*48f74186SJeff Layton * We hash locks by lockowner in order to optimize searching for the lock a 168*48f74186SJeff Layton * particular lockowner is waiting on. 169*48f74186SJeff Layton * 170*48f74186SJeff Layton * FIXME: make this value scale via some heuristic? We generally will want more 171*48f74186SJeff Layton * buckets when we have more lockowners holding locks, but that's a little 172*48f74186SJeff Layton * difficult to determine without knowing what the workload will look like. 1731c8c601aSJeff Layton */ 174*48f74186SJeff Layton #define BLOCKED_HASH_BITS 7 175*48f74186SJeff Layton static DEFINE_HASHTABLE(blocked_hash, BLOCKED_HASH_BITS); 17688974691SJeff Layton 1771c8c601aSJeff Layton /* 178*48f74186SJeff Layton * This lock protects the blocked_hash and the file_lock_list. Generally, if 1791c8c601aSJeff Layton * you're accessing one of those lists, you want to be holding this lock. 1801c8c601aSJeff Layton * 1811c8c601aSJeff Layton * In addition, it also protects the fl->fl_block list, and the fl->fl_next 1821c8c601aSJeff Layton * pointer for file_lock structures that are acting as lock requests (in 1831c8c601aSJeff Layton * contrast to those that are acting as records of acquired locks). 1841c8c601aSJeff Layton * 1851c8c601aSJeff Layton * Note that when we acquire this lock in order to change the above fields, 1861c8c601aSJeff Layton * we often hold the i_lock as well. In certain cases, when reading the fields 1871c8c601aSJeff Layton * protected by this lock, we can skip acquiring it iff we already hold the 1881c8c601aSJeff Layton * i_lock. 1891c8c601aSJeff Layton * 1901c8c601aSJeff Layton * In particular, adding an entry to the fl_block list requires that you hold 1911c8c601aSJeff Layton * both the i_lock and the blocked_lock_lock (acquired in that order). Deleting 1921c8c601aSJeff Layton * an entry from the list however only requires the file_lock_lock. 1931c8c601aSJeff Layton */ 19472f98e72SArnd Bergmann static DEFINE_SPINLOCK(file_lock_lock); 1951da177e4SLinus Torvalds 196e18b890bSChristoph Lameter static struct kmem_cache *filelock_cache __read_mostly; 1971da177e4SLinus Torvalds 198ee19cc40SMiklos Szeredi static void locks_init_lock_heads(struct file_lock *fl) 199a51cb91dSMiklos Szeredi { 200139ca04eSJeff Layton INIT_HLIST_NODE(&fl->fl_link); 201ee19cc40SMiklos Szeredi INIT_LIST_HEAD(&fl->fl_block); 202ee19cc40SMiklos Szeredi init_waitqueue_head(&fl->fl_wait); 203a51cb91dSMiklos Szeredi } 204a51cb91dSMiklos Szeredi 2051da177e4SLinus Torvalds /* Allocate an empty lock structure. */ 206c5b1f0d9SArnd Bergmann struct file_lock *locks_alloc_lock(void) 2071da177e4SLinus Torvalds { 208ee19cc40SMiklos Szeredi struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL); 209a51cb91dSMiklos Szeredi 210a51cb91dSMiklos Szeredi if (fl) 211ee19cc40SMiklos Szeredi locks_init_lock_heads(fl); 212a51cb91dSMiklos Szeredi 213a51cb91dSMiklos Szeredi return fl; 2141da177e4SLinus Torvalds } 215c5b1f0d9SArnd Bergmann EXPORT_SYMBOL_GPL(locks_alloc_lock); 2161da177e4SLinus Torvalds 217a9e61e25SFelix Blyakher void locks_release_private(struct file_lock *fl) 21847831f35STrond Myklebust { 21947831f35STrond Myklebust if (fl->fl_ops) { 22047831f35STrond Myklebust if (fl->fl_ops->fl_release_private) 22147831f35STrond Myklebust fl->fl_ops->fl_release_private(fl); 22247831f35STrond Myklebust fl->fl_ops = NULL; 22347831f35STrond Myklebust } 22447831f35STrond Myklebust fl->fl_lmops = NULL; 22547831f35STrond Myklebust 22647831f35STrond Myklebust } 227a9e61e25SFelix Blyakher EXPORT_SYMBOL_GPL(locks_release_private); 22847831f35STrond Myklebust 2291da177e4SLinus Torvalds /* Free a lock which is not in use. */ 23005fa3135SJ. Bruce Fields void locks_free_lock(struct file_lock *fl) 2311da177e4SLinus Torvalds { 2325ce29646SMiklos Szeredi BUG_ON(waitqueue_active(&fl->fl_wait)); 2335ce29646SMiklos Szeredi BUG_ON(!list_empty(&fl->fl_block)); 234139ca04eSJeff Layton BUG_ON(!hlist_unhashed(&fl->fl_link)); 2351da177e4SLinus Torvalds 23647831f35STrond Myklebust locks_release_private(fl); 2371da177e4SLinus Torvalds kmem_cache_free(filelock_cache, fl); 2381da177e4SLinus Torvalds } 23905fa3135SJ. Bruce Fields EXPORT_SYMBOL(locks_free_lock); 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds void locks_init_lock(struct file_lock *fl) 2421da177e4SLinus Torvalds { 243ee19cc40SMiklos Szeredi memset(fl, 0, sizeof(struct file_lock)); 244ee19cc40SMiklos Szeredi locks_init_lock_heads(fl); 2451da177e4SLinus Torvalds } 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvalds EXPORT_SYMBOL(locks_init_lock); 2481da177e4SLinus Torvalds 24947831f35STrond Myklebust static void locks_copy_private(struct file_lock *new, struct file_lock *fl) 25047831f35STrond Myklebust { 25147831f35STrond Myklebust if (fl->fl_ops) { 25247831f35STrond Myklebust if (fl->fl_ops->fl_copy_lock) 25347831f35STrond Myklebust fl->fl_ops->fl_copy_lock(new, fl); 25447831f35STrond Myklebust new->fl_ops = fl->fl_ops; 25547831f35STrond Myklebust } 256bb8430a2SChristoph Hellwig if (fl->fl_lmops) 25747831f35STrond Myklebust new->fl_lmops = fl->fl_lmops; 25847831f35STrond Myklebust } 25947831f35STrond Myklebust 2601da177e4SLinus Torvalds /* 2611da177e4SLinus Torvalds * Initialize a new lock from an existing file_lock structure. 2621da177e4SLinus Torvalds */ 2631a747ee0SJ. Bruce Fields void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl) 2641da177e4SLinus Torvalds { 2651da177e4SLinus Torvalds new->fl_owner = fl->fl_owner; 2661da177e4SLinus Torvalds new->fl_pid = fl->fl_pid; 2670996905fSTrond Myklebust new->fl_file = NULL; 2681da177e4SLinus Torvalds new->fl_flags = fl->fl_flags; 2691da177e4SLinus Torvalds new->fl_type = fl->fl_type; 2701da177e4SLinus Torvalds new->fl_start = fl->fl_start; 2711da177e4SLinus Torvalds new->fl_end = fl->fl_end; 2720996905fSTrond Myklebust new->fl_ops = NULL; 2730996905fSTrond Myklebust new->fl_lmops = NULL; 2740996905fSTrond Myklebust } 2753dd7b71cSRoland Dreier EXPORT_SYMBOL(__locks_copy_lock); 2760996905fSTrond Myklebust 2770996905fSTrond Myklebust void locks_copy_lock(struct file_lock *new, struct file_lock *fl) 2780996905fSTrond Myklebust { 2790996905fSTrond Myklebust locks_release_private(new); 2800996905fSTrond Myklebust 2810996905fSTrond Myklebust __locks_copy_lock(new, fl); 2820996905fSTrond Myklebust new->fl_file = fl->fl_file; 2831da177e4SLinus Torvalds new->fl_ops = fl->fl_ops; 2841da177e4SLinus Torvalds new->fl_lmops = fl->fl_lmops; 28547831f35STrond Myklebust 28647831f35STrond Myklebust locks_copy_private(new, fl); 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds EXPORT_SYMBOL(locks_copy_lock); 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds static inline int flock_translate_cmd(int cmd) { 2921da177e4SLinus Torvalds if (cmd & LOCK_MAND) 2931da177e4SLinus Torvalds return cmd & (LOCK_MAND | LOCK_RW); 2941da177e4SLinus Torvalds switch (cmd) { 2951da177e4SLinus Torvalds case LOCK_SH: 2961da177e4SLinus Torvalds return F_RDLCK; 2971da177e4SLinus Torvalds case LOCK_EX: 2981da177e4SLinus Torvalds return F_WRLCK; 2991da177e4SLinus Torvalds case LOCK_UN: 3001da177e4SLinus Torvalds return F_UNLCK; 3011da177e4SLinus Torvalds } 3021da177e4SLinus Torvalds return -EINVAL; 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds 3051da177e4SLinus Torvalds /* Fill in a file_lock structure with an appropriate FLOCK lock. */ 3061da177e4SLinus Torvalds static int flock_make_lock(struct file *filp, struct file_lock **lock, 3071da177e4SLinus Torvalds unsigned int cmd) 3081da177e4SLinus Torvalds { 3091da177e4SLinus Torvalds struct file_lock *fl; 3101da177e4SLinus Torvalds int type = flock_translate_cmd(cmd); 3111da177e4SLinus Torvalds if (type < 0) 3121da177e4SLinus Torvalds return type; 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds fl = locks_alloc_lock(); 3151da177e4SLinus Torvalds if (fl == NULL) 3161da177e4SLinus Torvalds return -ENOMEM; 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds fl->fl_file = filp; 3191da177e4SLinus Torvalds fl->fl_pid = current->tgid; 3201da177e4SLinus Torvalds fl->fl_flags = FL_FLOCK; 3211da177e4SLinus Torvalds fl->fl_type = type; 3221da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds *lock = fl; 3251da177e4SLinus Torvalds return 0; 3261da177e4SLinus Torvalds } 3271da177e4SLinus Torvalds 3280ec4f431SJ. Bruce Fields static int assign_type(struct file_lock *fl, long type) 3291da177e4SLinus Torvalds { 3301da177e4SLinus Torvalds switch (type) { 3311da177e4SLinus Torvalds case F_RDLCK: 3321da177e4SLinus Torvalds case F_WRLCK: 3331da177e4SLinus Torvalds case F_UNLCK: 3341da177e4SLinus Torvalds fl->fl_type = type; 3351da177e4SLinus Torvalds break; 3361da177e4SLinus Torvalds default: 3371da177e4SLinus Torvalds return -EINVAL; 3381da177e4SLinus Torvalds } 3391da177e4SLinus Torvalds return 0; 3401da177e4SLinus Torvalds } 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX 3431da177e4SLinus Torvalds * style lock. 3441da177e4SLinus Torvalds */ 3451da177e4SLinus Torvalds static int flock_to_posix_lock(struct file *filp, struct file_lock *fl, 3461da177e4SLinus Torvalds struct flock *l) 3471da177e4SLinus Torvalds { 3481da177e4SLinus Torvalds off_t start, end; 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds switch (l->l_whence) { 351f5579f8cSJosef 'Jeff' Sipek case SEEK_SET: 3521da177e4SLinus Torvalds start = 0; 3531da177e4SLinus Torvalds break; 354f5579f8cSJosef 'Jeff' Sipek case SEEK_CUR: 3551da177e4SLinus Torvalds start = filp->f_pos; 3561da177e4SLinus Torvalds break; 357f5579f8cSJosef 'Jeff' Sipek case SEEK_END: 358496ad9aaSAl Viro start = i_size_read(file_inode(filp)); 3591da177e4SLinus Torvalds break; 3601da177e4SLinus Torvalds default: 3611da177e4SLinus Torvalds return -EINVAL; 3621da177e4SLinus Torvalds } 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds /* POSIX-1996 leaves the case l->l_len < 0 undefined; 3651da177e4SLinus Torvalds POSIX-2001 defines it. */ 3661da177e4SLinus Torvalds start += l->l_start; 3671da177e4SLinus Torvalds if (start < 0) 3681da177e4SLinus Torvalds return -EINVAL; 3691da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 3704c780a46STrond Myklebust if (l->l_len > 0) { 3714c780a46STrond Myklebust end = start + l->l_len - 1; 3724c780a46STrond Myklebust fl->fl_end = end; 3734c780a46STrond Myklebust } else if (l->l_len < 0) { 3744c780a46STrond Myklebust end = start - 1; 3754c780a46STrond Myklebust fl->fl_end = end; 3764c780a46STrond Myklebust start += l->l_len; 3774c780a46STrond Myklebust if (start < 0) 3784c780a46STrond Myklebust return -EINVAL; 3794c780a46STrond Myklebust } 3804c780a46STrond Myklebust fl->fl_start = start; /* we record the absolute position */ 3814c780a46STrond Myklebust if (fl->fl_end < fl->fl_start) 3824c780a46STrond Myklebust return -EOVERFLOW; 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds fl->fl_owner = current->files; 3851da177e4SLinus Torvalds fl->fl_pid = current->tgid; 3861da177e4SLinus Torvalds fl->fl_file = filp; 3871da177e4SLinus Torvalds fl->fl_flags = FL_POSIX; 3881da177e4SLinus Torvalds fl->fl_ops = NULL; 3891da177e4SLinus Torvalds fl->fl_lmops = NULL; 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds return assign_type(fl, l->l_type); 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds #if BITS_PER_LONG == 32 3951da177e4SLinus Torvalds static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, 3961da177e4SLinus Torvalds struct flock64 *l) 3971da177e4SLinus Torvalds { 3981da177e4SLinus Torvalds loff_t start; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds switch (l->l_whence) { 401f5579f8cSJosef 'Jeff' Sipek case SEEK_SET: 4021da177e4SLinus Torvalds start = 0; 4031da177e4SLinus Torvalds break; 404f5579f8cSJosef 'Jeff' Sipek case SEEK_CUR: 4051da177e4SLinus Torvalds start = filp->f_pos; 4061da177e4SLinus Torvalds break; 407f5579f8cSJosef 'Jeff' Sipek case SEEK_END: 408496ad9aaSAl Viro start = i_size_read(file_inode(filp)); 4091da177e4SLinus Torvalds break; 4101da177e4SLinus Torvalds default: 4111da177e4SLinus Torvalds return -EINVAL; 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds 4144c780a46STrond Myklebust start += l->l_start; 4154c780a46STrond Myklebust if (start < 0) 4161da177e4SLinus Torvalds return -EINVAL; 4171da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 4184c780a46STrond Myklebust if (l->l_len > 0) { 4194c780a46STrond Myklebust fl->fl_end = start + l->l_len - 1; 4204c780a46STrond Myklebust } else if (l->l_len < 0) { 4214c780a46STrond Myklebust fl->fl_end = start - 1; 4224c780a46STrond Myklebust start += l->l_len; 4234c780a46STrond Myklebust if (start < 0) 4244c780a46STrond Myklebust return -EINVAL; 4254c780a46STrond Myklebust } 4264c780a46STrond Myklebust fl->fl_start = start; /* we record the absolute position */ 4274c780a46STrond Myklebust if (fl->fl_end < fl->fl_start) 4284c780a46STrond Myklebust return -EOVERFLOW; 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds fl->fl_owner = current->files; 4311da177e4SLinus Torvalds fl->fl_pid = current->tgid; 4321da177e4SLinus Torvalds fl->fl_file = filp; 4331da177e4SLinus Torvalds fl->fl_flags = FL_POSIX; 4341da177e4SLinus Torvalds fl->fl_ops = NULL; 4351da177e4SLinus Torvalds fl->fl_lmops = NULL; 4361da177e4SLinus Torvalds 437f32cb532SNamhyung Kim return assign_type(fl, l->l_type); 4381da177e4SLinus Torvalds } 4391da177e4SLinus Torvalds #endif 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds /* default lease lock manager operations */ 4421da177e4SLinus Torvalds static void lease_break_callback(struct file_lock *fl) 4431da177e4SLinus Torvalds { 4441da177e4SLinus Torvalds kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG); 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds 4477b021967SAlexey Dobriyan static const struct lock_manager_operations lease_manager_ops = { 4488fb47a4fSJ. Bruce Fields .lm_break = lease_break_callback, 4498fb47a4fSJ. Bruce Fields .lm_change = lease_modify, 4501da177e4SLinus Torvalds }; 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds /* 4531da177e4SLinus Torvalds * Initialize a lease, use the default lock manager operations 4541da177e4SLinus Torvalds */ 4550ec4f431SJ. Bruce Fields static int lease_init(struct file *filp, long type, struct file_lock *fl) 4561da177e4SLinus Torvalds { 45775dff55aSTrond Myklebust if (assign_type(fl, type) != 0) 45875dff55aSTrond Myklebust return -EINVAL; 45975dff55aSTrond Myklebust 4601da177e4SLinus Torvalds fl->fl_owner = current->files; 4611da177e4SLinus Torvalds fl->fl_pid = current->tgid; 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds fl->fl_file = filp; 4641da177e4SLinus Torvalds fl->fl_flags = FL_LEASE; 4651da177e4SLinus Torvalds fl->fl_start = 0; 4661da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 4671da177e4SLinus Torvalds fl->fl_ops = NULL; 4681da177e4SLinus Torvalds fl->fl_lmops = &lease_manager_ops; 4691da177e4SLinus Torvalds return 0; 4701da177e4SLinus Torvalds } 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds /* Allocate a file_lock initialised to this type of lease */ 4730ec4f431SJ. Bruce Fields static struct file_lock *lease_alloc(struct file *filp, long type) 4741da177e4SLinus Torvalds { 4751da177e4SLinus Torvalds struct file_lock *fl = locks_alloc_lock(); 47675dff55aSTrond Myklebust int error = -ENOMEM; 4771da177e4SLinus Torvalds 4781da177e4SLinus Torvalds if (fl == NULL) 479e32b8ee2SJ. Bruce Fields return ERR_PTR(error); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds error = lease_init(filp, type, fl); 48275dff55aSTrond Myklebust if (error) { 48375dff55aSTrond Myklebust locks_free_lock(fl); 484e32b8ee2SJ. Bruce Fields return ERR_PTR(error); 48575dff55aSTrond Myklebust } 486e32b8ee2SJ. Bruce Fields return fl; 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds /* Check if two locks overlap each other. 4901da177e4SLinus Torvalds */ 4911da177e4SLinus Torvalds static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) 4921da177e4SLinus Torvalds { 4931da177e4SLinus Torvalds return ((fl1->fl_end >= fl2->fl_start) && 4941da177e4SLinus Torvalds (fl2->fl_end >= fl1->fl_start)); 4951da177e4SLinus Torvalds } 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds /* 4981da177e4SLinus Torvalds * Check whether two locks have the same owner. 4991da177e4SLinus Torvalds */ 50033443c42SMatt Mackall static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2) 5011da177e4SLinus Torvalds { 5028fb47a4fSJ. Bruce Fields if (fl1->fl_lmops && fl1->fl_lmops->lm_compare_owner) 5031da177e4SLinus Torvalds return fl2->fl_lmops == fl1->fl_lmops && 5048fb47a4fSJ. Bruce Fields fl1->fl_lmops->lm_compare_owner(fl1, fl2); 5051da177e4SLinus Torvalds return fl1->fl_owner == fl2->fl_owner; 5061da177e4SLinus Torvalds } 5071da177e4SLinus Torvalds 50888974691SJeff Layton static inline void 50988974691SJeff Layton locks_insert_global_locks(struct file_lock *fl) 51088974691SJeff Layton { 5111c8c601aSJeff Layton spin_lock(&file_lock_lock); 512139ca04eSJeff Layton hlist_add_head(&fl->fl_link, &file_lock_list); 5131c8c601aSJeff Layton spin_unlock(&file_lock_lock); 51488974691SJeff Layton } 51588974691SJeff Layton 51688974691SJeff Layton static inline void 51788974691SJeff Layton locks_delete_global_locks(struct file_lock *fl) 51888974691SJeff Layton { 5191c8c601aSJeff Layton spin_lock(&file_lock_lock); 520139ca04eSJeff Layton hlist_del_init(&fl->fl_link); 5211c8c601aSJeff Layton spin_unlock(&file_lock_lock); 52288974691SJeff Layton } 52388974691SJeff Layton 52488974691SJeff Layton static inline void 52588974691SJeff Layton locks_insert_global_blocked(struct file_lock *waiter) 52688974691SJeff Layton { 527*48f74186SJeff Layton hash_add(blocked_hash, &waiter->fl_link, (unsigned long)waiter->fl_owner); 52888974691SJeff Layton } 52988974691SJeff Layton 53088974691SJeff Layton static inline void 53188974691SJeff Layton locks_delete_global_blocked(struct file_lock *waiter) 53288974691SJeff Layton { 533*48f74186SJeff Layton hash_del(&waiter->fl_link); 53488974691SJeff Layton } 53588974691SJeff Layton 5361da177e4SLinus Torvalds /* Remove waiter from blocker's block list. 5371da177e4SLinus Torvalds * When blocker ends up pointing to itself then the list is empty. 5381c8c601aSJeff Layton * 5391c8c601aSJeff Layton * Must be called with file_lock_lock held. 5401da177e4SLinus Torvalds */ 54133443c42SMatt Mackall static void __locks_delete_block(struct file_lock *waiter) 5421da177e4SLinus Torvalds { 54388974691SJeff Layton locks_delete_global_blocked(waiter); 5441da177e4SLinus Torvalds list_del_init(&waiter->fl_block); 5451da177e4SLinus Torvalds waiter->fl_next = NULL; 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds 5481a9e64a7SJeff Layton static void locks_delete_block(struct file_lock *waiter) 5491da177e4SLinus Torvalds { 5501c8c601aSJeff Layton spin_lock(&file_lock_lock); 5511da177e4SLinus Torvalds __locks_delete_block(waiter); 5521c8c601aSJeff Layton spin_unlock(&file_lock_lock); 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds /* Insert waiter into blocker's block list. 5561da177e4SLinus Torvalds * We use a circular list so that processes can be easily woken up in 5571da177e4SLinus Torvalds * the order they blocked. The documentation doesn't require this but 5581da177e4SLinus Torvalds * it seems like the reasonable thing to do. 5591c8c601aSJeff Layton * 5604e8c765dSJeff Layton * Must be called with both the i_lock and file_lock_lock held. The fl_block 5614e8c765dSJeff Layton * list itself is protected by the file_lock_list, but by ensuring that the 5624e8c765dSJeff Layton * i_lock is also held on insertions we can avoid taking the file_lock_lock 5634e8c765dSJeff Layton * in some cases when we see that the fl_block list is empty. 5641da177e4SLinus Torvalds */ 5651c8c601aSJeff Layton static void __locks_insert_block(struct file_lock *blocker, 5661da177e4SLinus Torvalds struct file_lock *waiter) 5671da177e4SLinus Torvalds { 5686dc0fe8fSJ. Bruce Fields BUG_ON(!list_empty(&waiter->fl_block)); 5691da177e4SLinus Torvalds waiter->fl_next = blocker; 57088974691SJeff Layton list_add_tail(&waiter->fl_block, &blocker->fl_block); 5711da177e4SLinus Torvalds if (IS_POSIX(blocker)) 5721c8c601aSJeff Layton locks_insert_global_blocked(waiter); 5731c8c601aSJeff Layton } 5741c8c601aSJeff Layton 5751c8c601aSJeff Layton /* Must be called with i_lock held. */ 5761c8c601aSJeff Layton static void locks_insert_block(struct file_lock *blocker, 5771c8c601aSJeff Layton struct file_lock *waiter) 5781c8c601aSJeff Layton { 5791c8c601aSJeff Layton spin_lock(&file_lock_lock); 5801c8c601aSJeff Layton __locks_insert_block(blocker, waiter); 5811c8c601aSJeff Layton spin_unlock(&file_lock_lock); 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds 5841cb36012SJeff Layton /* 5851cb36012SJeff Layton * Wake up processes blocked waiting for blocker. 5861cb36012SJeff Layton * 5871c8c601aSJeff Layton * Must be called with the inode->i_lock held! 5881da177e4SLinus Torvalds */ 5891da177e4SLinus Torvalds static void locks_wake_up_blocks(struct file_lock *blocker) 5901da177e4SLinus Torvalds { 5914e8c765dSJeff Layton /* 5924e8c765dSJeff Layton * Avoid taking global lock if list is empty. This is safe since new 5934e8c765dSJeff Layton * blocked requests are only added to the list under the i_lock, and 5944e8c765dSJeff Layton * the i_lock is always held here. Note that removal from the fl_block 5954e8c765dSJeff Layton * list does not require the i_lock, so we must recheck list_empty() 5964e8c765dSJeff Layton * after acquiring the file_lock_lock. 5974e8c765dSJeff Layton */ 5984e8c765dSJeff Layton if (list_empty(&blocker->fl_block)) 5994e8c765dSJeff Layton return; 6004e8c765dSJeff Layton 6011c8c601aSJeff Layton spin_lock(&file_lock_lock); 6021da177e4SLinus Torvalds while (!list_empty(&blocker->fl_block)) { 603f0c1cd0eSPavel Emelyanov struct file_lock *waiter; 604f0c1cd0eSPavel Emelyanov 605f0c1cd0eSPavel Emelyanov waiter = list_first_entry(&blocker->fl_block, 6061da177e4SLinus Torvalds struct file_lock, fl_block); 6071da177e4SLinus Torvalds __locks_delete_block(waiter); 6088fb47a4fSJ. Bruce Fields if (waiter->fl_lmops && waiter->fl_lmops->lm_notify) 6098fb47a4fSJ. Bruce Fields waiter->fl_lmops->lm_notify(waiter); 6101da177e4SLinus Torvalds else 6111da177e4SLinus Torvalds wake_up(&waiter->fl_wait); 6121da177e4SLinus Torvalds } 6131c8c601aSJeff Layton spin_unlock(&file_lock_lock); 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds /* Insert file lock fl into an inode's lock list at the position indicated 6171da177e4SLinus Torvalds * by pos. At the same time add the lock to the global file lock list. 6181c8c601aSJeff Layton * 6191c8c601aSJeff Layton * Must be called with the i_lock held! 6201da177e4SLinus Torvalds */ 6211da177e4SLinus Torvalds static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl) 6221da177e4SLinus Torvalds { 623ab1f1611SVitaliy Gusev fl->fl_nspid = get_pid(task_tgid(current)); 624ab1f1611SVitaliy Gusev 6251da177e4SLinus Torvalds /* insert into file's list */ 6261da177e4SLinus Torvalds fl->fl_next = *pos; 6271da177e4SLinus Torvalds *pos = fl; 62888974691SJeff Layton 62988974691SJeff Layton locks_insert_global_locks(fl); 6301da177e4SLinus Torvalds } 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds /* 6331da177e4SLinus Torvalds * Delete a lock and then free it. 6341da177e4SLinus Torvalds * Wake up processes that are blocked waiting for this lock, 6351da177e4SLinus Torvalds * notify the FS that the lock has been cleared and 6361da177e4SLinus Torvalds * finally free the lock. 6371c8c601aSJeff Layton * 6381c8c601aSJeff Layton * Must be called with the i_lock held! 6391da177e4SLinus Torvalds */ 6401da177e4SLinus Torvalds static void locks_delete_lock(struct file_lock **thisfl_p) 6411da177e4SLinus Torvalds { 6421da177e4SLinus Torvalds struct file_lock *fl = *thisfl_p; 6431da177e4SLinus Torvalds 64488974691SJeff Layton locks_delete_global_locks(fl); 64588974691SJeff Layton 6461da177e4SLinus Torvalds *thisfl_p = fl->fl_next; 6471da177e4SLinus Torvalds fl->fl_next = NULL; 6481da177e4SLinus Torvalds 649ab1f1611SVitaliy Gusev if (fl->fl_nspid) { 650ab1f1611SVitaliy Gusev put_pid(fl->fl_nspid); 651ab1f1611SVitaliy Gusev fl->fl_nspid = NULL; 652ab1f1611SVitaliy Gusev } 653ab1f1611SVitaliy Gusev 6541da177e4SLinus Torvalds locks_wake_up_blocks(fl); 6551da177e4SLinus Torvalds locks_free_lock(fl); 6561da177e4SLinus Torvalds } 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. Common functionality 6591da177e4SLinus Torvalds * checks for shared/exclusive status of overlapping locks. 6601da177e4SLinus Torvalds */ 6611da177e4SLinus Torvalds static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6621da177e4SLinus Torvalds { 6631da177e4SLinus Torvalds if (sys_fl->fl_type == F_WRLCK) 6641da177e4SLinus Torvalds return 1; 6651da177e4SLinus Torvalds if (caller_fl->fl_type == F_WRLCK) 6661da177e4SLinus Torvalds return 1; 6671da177e4SLinus Torvalds return 0; 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific 6711da177e4SLinus Torvalds * checking before calling the locks_conflict(). 6721da177e4SLinus Torvalds */ 6731da177e4SLinus Torvalds static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6741da177e4SLinus Torvalds { 6751da177e4SLinus Torvalds /* POSIX locks owned by the same process do not conflict with 6761da177e4SLinus Torvalds * each other. 6771da177e4SLinus Torvalds */ 6781da177e4SLinus Torvalds if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl)) 6791da177e4SLinus Torvalds return (0); 6801da177e4SLinus Torvalds 6811da177e4SLinus Torvalds /* Check whether they overlap */ 6821da177e4SLinus Torvalds if (!locks_overlap(caller_fl, sys_fl)) 6831da177e4SLinus Torvalds return 0; 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds return (locks_conflict(caller_fl, sys_fl)); 6861da177e4SLinus Torvalds } 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific 6891da177e4SLinus Torvalds * checking before calling the locks_conflict(). 6901da177e4SLinus Torvalds */ 6911da177e4SLinus Torvalds static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6921da177e4SLinus Torvalds { 6931da177e4SLinus Torvalds /* FLOCK locks referring to the same filp do not conflict with 6941da177e4SLinus Torvalds * each other. 6951da177e4SLinus Torvalds */ 6961da177e4SLinus Torvalds if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file)) 6971da177e4SLinus Torvalds return (0); 6981da177e4SLinus Torvalds if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND)) 6991da177e4SLinus Torvalds return 0; 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds return (locks_conflict(caller_fl, sys_fl)); 7021da177e4SLinus Torvalds } 7031da177e4SLinus Torvalds 7046d34ac19SJ. Bruce Fields void 7059d6a8c5cSMarc Eshel posix_test_lock(struct file *filp, struct file_lock *fl) 7061da177e4SLinus Torvalds { 7071da177e4SLinus Torvalds struct file_lock *cfl; 7081c8c601aSJeff Layton struct inode *inode = file_inode(filp); 7091da177e4SLinus Torvalds 7101c8c601aSJeff Layton spin_lock(&inode->i_lock); 711496ad9aaSAl Viro for (cfl = file_inode(filp)->i_flock; cfl; cfl = cfl->fl_next) { 7121da177e4SLinus Torvalds if (!IS_POSIX(cfl)) 7131da177e4SLinus Torvalds continue; 714b842e240SJ. Bruce Fields if (posix_locks_conflict(fl, cfl)) 7151da177e4SLinus Torvalds break; 7161da177e4SLinus Torvalds } 717ab1f1611SVitaliy Gusev if (cfl) { 7189d6a8c5cSMarc Eshel __locks_copy_lock(fl, cfl); 719ab1f1611SVitaliy Gusev if (cfl->fl_nspid) 7206c5f3e7bSPavel Emelyanov fl->fl_pid = pid_vnr(cfl->fl_nspid); 721ab1f1611SVitaliy Gusev } else 722129a84deSJ. Bruce Fields fl->fl_type = F_UNLCK; 7231c8c601aSJeff Layton spin_unlock(&inode->i_lock); 7246d34ac19SJ. Bruce Fields return; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds EXPORT_SYMBOL(posix_test_lock); 7271da177e4SLinus Torvalds 728b533184fSJ. Bruce Fields /* 729b533184fSJ. Bruce Fields * Deadlock detection: 7301da177e4SLinus Torvalds * 731b533184fSJ. Bruce Fields * We attempt to detect deadlocks that are due purely to posix file 732b533184fSJ. Bruce Fields * locks. 7331da177e4SLinus Torvalds * 734b533184fSJ. Bruce Fields * We assume that a task can be waiting for at most one lock at a time. 735b533184fSJ. Bruce Fields * So for any acquired lock, the process holding that lock may be 736b533184fSJ. Bruce Fields * waiting on at most one other lock. That lock in turns may be held by 737b533184fSJ. Bruce Fields * someone waiting for at most one other lock. Given a requested lock 738b533184fSJ. Bruce Fields * caller_fl which is about to wait for a conflicting lock block_fl, we 739b533184fSJ. Bruce Fields * follow this chain of waiters to ensure we are not about to create a 740b533184fSJ. Bruce Fields * cycle. 74197855b49SJ. Bruce Fields * 742b533184fSJ. Bruce Fields * Since we do this before we ever put a process to sleep on a lock, we 743b533184fSJ. Bruce Fields * are ensured that there is never a cycle; that is what guarantees that 744b533184fSJ. Bruce Fields * the while() loop in posix_locks_deadlock() eventually completes. 745b533184fSJ. Bruce Fields * 746b533184fSJ. Bruce Fields * Note: the above assumption may not be true when handling lock 747b533184fSJ. Bruce Fields * requests from a broken NFS client. It may also fail in the presence 748b533184fSJ. Bruce Fields * of tasks (such as posix threads) sharing the same open file table. 749b533184fSJ. Bruce Fields * 750b533184fSJ. Bruce Fields * To handle those cases, we just bail out after a few iterations. 7511da177e4SLinus Torvalds */ 75297855b49SJ. Bruce Fields 75397855b49SJ. Bruce Fields #define MAX_DEADLK_ITERATIONS 10 75497855b49SJ. Bruce Fields 755b533184fSJ. Bruce Fields /* Find a lock that the owner of the given block_fl is blocking on. */ 756b533184fSJ. Bruce Fields static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl) 757b533184fSJ. Bruce Fields { 758b533184fSJ. Bruce Fields struct file_lock *fl; 759b533184fSJ. Bruce Fields 760*48f74186SJeff Layton hash_for_each_possible(blocked_hash, fl, fl_link, (unsigned long)block_fl->fl_owner) { 761b533184fSJ. Bruce Fields if (posix_same_owner(fl, block_fl)) 762b533184fSJ. Bruce Fields return fl->fl_next; 763b533184fSJ. Bruce Fields } 764b533184fSJ. Bruce Fields return NULL; 765b533184fSJ. Bruce Fields } 766b533184fSJ. Bruce Fields 7671c8c601aSJeff Layton /* Must be called with the file_lock_lock held! */ 768b0904e14SAdrian Bunk static int posix_locks_deadlock(struct file_lock *caller_fl, 7691da177e4SLinus Torvalds struct file_lock *block_fl) 7701da177e4SLinus Torvalds { 77197855b49SJ. Bruce Fields int i = 0; 7721da177e4SLinus Torvalds 773b533184fSJ. Bruce Fields while ((block_fl = what_owner_is_waiting_for(block_fl))) { 77497855b49SJ. Bruce Fields if (i++ > MAX_DEADLK_ITERATIONS) 77597855b49SJ. Bruce Fields return 0; 776b533184fSJ. Bruce Fields if (posix_same_owner(caller_fl, block_fl)) 777b533184fSJ. Bruce Fields return 1; 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds return 0; 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks 78302888f41SJ. Bruce Fields * after any leases, but before any posix locks. 784f475ae95STrond Myklebust * 785f475ae95STrond Myklebust * Note that if called with an FL_EXISTS argument, the caller may determine 786f475ae95STrond Myklebust * whether or not a lock was successfully freed by testing the return 787f475ae95STrond Myklebust * value for -ENOENT. 7881da177e4SLinus Torvalds */ 789993dfa87STrond Myklebust static int flock_lock_file(struct file *filp, struct file_lock *request) 7901da177e4SLinus Torvalds { 791993dfa87STrond Myklebust struct file_lock *new_fl = NULL; 7921da177e4SLinus Torvalds struct file_lock **before; 793496ad9aaSAl Viro struct inode * inode = file_inode(filp); 7941da177e4SLinus Torvalds int error = 0; 7951da177e4SLinus Torvalds int found = 0; 7961da177e4SLinus Torvalds 797b89f4321SArnd Bergmann if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) { 798b89f4321SArnd Bergmann new_fl = locks_alloc_lock(); 799b89f4321SArnd Bergmann if (!new_fl) 800b89f4321SArnd Bergmann return -ENOMEM; 801b89f4321SArnd Bergmann } 802b89f4321SArnd Bergmann 8031c8c601aSJeff Layton spin_lock(&inode->i_lock); 804f07f18ddSTrond Myklebust if (request->fl_flags & FL_ACCESS) 805f07f18ddSTrond Myklebust goto find_conflict; 80684d535adSPavel Emelyanov 8071da177e4SLinus Torvalds for_each_lock(inode, before) { 8081da177e4SLinus Torvalds struct file_lock *fl = *before; 8091da177e4SLinus Torvalds if (IS_POSIX(fl)) 8101da177e4SLinus Torvalds break; 8111da177e4SLinus Torvalds if (IS_LEASE(fl)) 8121da177e4SLinus Torvalds continue; 8131da177e4SLinus Torvalds if (filp != fl->fl_file) 8141da177e4SLinus Torvalds continue; 815993dfa87STrond Myklebust if (request->fl_type == fl->fl_type) 8161da177e4SLinus Torvalds goto out; 8171da177e4SLinus Torvalds found = 1; 8181da177e4SLinus Torvalds locks_delete_lock(before); 8191da177e4SLinus Torvalds break; 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds 822f475ae95STrond Myklebust if (request->fl_type == F_UNLCK) { 823f475ae95STrond Myklebust if ((request->fl_flags & FL_EXISTS) && !found) 824f475ae95STrond Myklebust error = -ENOENT; 825993dfa87STrond Myklebust goto out; 826f475ae95STrond Myklebust } 8271da177e4SLinus Torvalds 8281da177e4SLinus Torvalds /* 8291da177e4SLinus Torvalds * If a higher-priority process was blocked on the old file lock, 8301da177e4SLinus Torvalds * give it the opportunity to lock the file. 8311da177e4SLinus Torvalds */ 832b89f4321SArnd Bergmann if (found) { 8331c8c601aSJeff Layton spin_unlock(&inode->i_lock); 834def01bc5SFrederic Weisbecker cond_resched(); 8351c8c601aSJeff Layton spin_lock(&inode->i_lock); 836b89f4321SArnd Bergmann } 8371da177e4SLinus Torvalds 838f07f18ddSTrond Myklebust find_conflict: 8391da177e4SLinus Torvalds for_each_lock(inode, before) { 8401da177e4SLinus Torvalds struct file_lock *fl = *before; 8411da177e4SLinus Torvalds if (IS_POSIX(fl)) 8421da177e4SLinus Torvalds break; 8431da177e4SLinus Torvalds if (IS_LEASE(fl)) 8441da177e4SLinus Torvalds continue; 845993dfa87STrond Myklebust if (!flock_locks_conflict(request, fl)) 8461da177e4SLinus Torvalds continue; 8471da177e4SLinus Torvalds error = -EAGAIN; 848bde74e4bSMiklos Szeredi if (!(request->fl_flags & FL_SLEEP)) 849bde74e4bSMiklos Szeredi goto out; 850bde74e4bSMiklos Szeredi error = FILE_LOCK_DEFERRED; 851993dfa87STrond Myklebust locks_insert_block(fl, request); 8521da177e4SLinus Torvalds goto out; 8531da177e4SLinus Torvalds } 854f07f18ddSTrond Myklebust if (request->fl_flags & FL_ACCESS) 855f07f18ddSTrond Myklebust goto out; 856993dfa87STrond Myklebust locks_copy_lock(new_fl, request); 8570e2f6db8SPavel Emelyanov locks_insert_lock(before, new_fl); 858993dfa87STrond Myklebust new_fl = NULL; 8599cedc194SKirill Korotaev error = 0; 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds out: 8621c8c601aSJeff Layton spin_unlock(&inode->i_lock); 863993dfa87STrond Myklebust if (new_fl) 864993dfa87STrond Myklebust locks_free_lock(new_fl); 8651da177e4SLinus Torvalds return error; 8661da177e4SLinus Torvalds } 8671da177e4SLinus Torvalds 868150b3934SMarc Eshel static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock) 8691da177e4SLinus Torvalds { 8701da177e4SLinus Torvalds struct file_lock *fl; 87139005d02SMiklos Szeredi struct file_lock *new_fl = NULL; 87239005d02SMiklos Szeredi struct file_lock *new_fl2 = NULL; 8731da177e4SLinus Torvalds struct file_lock *left = NULL; 8741da177e4SLinus Torvalds struct file_lock *right = NULL; 8751da177e4SLinus Torvalds struct file_lock **before; 876b9746ef8SJeff Layton int error; 877b9746ef8SJeff Layton bool added = false; 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds /* 8801da177e4SLinus Torvalds * We may need two file_lock structures for this operation, 8811da177e4SLinus Torvalds * so we get them in advance to avoid races. 88239005d02SMiklos Szeredi * 88339005d02SMiklos Szeredi * In some cases we can be sure, that no new locks will be needed 8841da177e4SLinus Torvalds */ 88539005d02SMiklos Szeredi if (!(request->fl_flags & FL_ACCESS) && 88639005d02SMiklos Szeredi (request->fl_type != F_UNLCK || 88739005d02SMiklos Szeredi request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { 8881da177e4SLinus Torvalds new_fl = locks_alloc_lock(); 8891da177e4SLinus Torvalds new_fl2 = locks_alloc_lock(); 89039005d02SMiklos Szeredi } 8911da177e4SLinus Torvalds 8921c8c601aSJeff Layton spin_lock(&inode->i_lock); 8931cb36012SJeff Layton /* 8941cb36012SJeff Layton * New lock request. Walk all POSIX locks and look for conflicts. If 8951cb36012SJeff Layton * there are any, either return error or put the request on the 896*48f74186SJeff Layton * blocker's list of waiters and the global blocked_hash. 8971cb36012SJeff Layton */ 8981da177e4SLinus Torvalds if (request->fl_type != F_UNLCK) { 8991da177e4SLinus Torvalds for_each_lock(inode, before) { 900526985b9SJ. Bruce Fields fl = *before; 9011da177e4SLinus Torvalds if (!IS_POSIX(fl)) 9021da177e4SLinus Torvalds continue; 9031da177e4SLinus Torvalds if (!posix_locks_conflict(request, fl)) 9041da177e4SLinus Torvalds continue; 9055842add2SAndy Adamson if (conflock) 9061a747ee0SJ. Bruce Fields __locks_copy_lock(conflock, fl); 9071da177e4SLinus Torvalds error = -EAGAIN; 9081da177e4SLinus Torvalds if (!(request->fl_flags & FL_SLEEP)) 9091da177e4SLinus Torvalds goto out; 9101c8c601aSJeff Layton /* 9111c8c601aSJeff Layton * Deadlock detection and insertion into the blocked 9121c8c601aSJeff Layton * locks list must be done while holding the same lock! 9131c8c601aSJeff Layton */ 9141da177e4SLinus Torvalds error = -EDEADLK; 9151c8c601aSJeff Layton spin_lock(&file_lock_lock); 9161c8c601aSJeff Layton if (likely(!posix_locks_deadlock(request, fl))) { 917bde74e4bSMiklos Szeredi error = FILE_LOCK_DEFERRED; 9181c8c601aSJeff Layton __locks_insert_block(fl, request); 9191c8c601aSJeff Layton } 9201c8c601aSJeff Layton spin_unlock(&file_lock_lock); 9211da177e4SLinus Torvalds goto out; 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds } 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds /* If we're just looking for a conflict, we're done. */ 9261da177e4SLinus Torvalds error = 0; 9271da177e4SLinus Torvalds if (request->fl_flags & FL_ACCESS) 9281da177e4SLinus Torvalds goto out; 9291da177e4SLinus Torvalds 9301da177e4SLinus Torvalds /* 9311da177e4SLinus Torvalds * Find the first old lock with the same owner as the new lock. 9321da177e4SLinus Torvalds */ 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds before = &inode->i_flock; 9351da177e4SLinus Torvalds 9361da177e4SLinus Torvalds /* First skip locks owned by other processes. */ 9371da177e4SLinus Torvalds while ((fl = *before) && (!IS_POSIX(fl) || 9381da177e4SLinus Torvalds !posix_same_owner(request, fl))) { 9391da177e4SLinus Torvalds before = &fl->fl_next; 9401da177e4SLinus Torvalds } 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds /* Process locks with this owner. */ 9431da177e4SLinus Torvalds while ((fl = *before) && posix_same_owner(request, fl)) { 9441da177e4SLinus Torvalds /* Detect adjacent or overlapping regions (if same lock type) 9451da177e4SLinus Torvalds */ 9461da177e4SLinus Torvalds if (request->fl_type == fl->fl_type) { 947449231d6SOlaf Kirch /* In all comparisons of start vs end, use 948449231d6SOlaf Kirch * "start - 1" rather than "end + 1". If end 949449231d6SOlaf Kirch * is OFFSET_MAX, end + 1 will become negative. 950449231d6SOlaf Kirch */ 9511da177e4SLinus Torvalds if (fl->fl_end < request->fl_start - 1) 9521da177e4SLinus Torvalds goto next_lock; 9531da177e4SLinus Torvalds /* If the next lock in the list has entirely bigger 9541da177e4SLinus Torvalds * addresses than the new one, insert the lock here. 9551da177e4SLinus Torvalds */ 956449231d6SOlaf Kirch if (fl->fl_start - 1 > request->fl_end) 9571da177e4SLinus Torvalds break; 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds /* If we come here, the new and old lock are of the 9601da177e4SLinus Torvalds * same type and adjacent or overlapping. Make one 9611da177e4SLinus Torvalds * lock yielding from the lower start address of both 9621da177e4SLinus Torvalds * locks to the higher end address. 9631da177e4SLinus Torvalds */ 9641da177e4SLinus Torvalds if (fl->fl_start > request->fl_start) 9651da177e4SLinus Torvalds fl->fl_start = request->fl_start; 9661da177e4SLinus Torvalds else 9671da177e4SLinus Torvalds request->fl_start = fl->fl_start; 9681da177e4SLinus Torvalds if (fl->fl_end < request->fl_end) 9691da177e4SLinus Torvalds fl->fl_end = request->fl_end; 9701da177e4SLinus Torvalds else 9711da177e4SLinus Torvalds request->fl_end = fl->fl_end; 9721da177e4SLinus Torvalds if (added) { 9731da177e4SLinus Torvalds locks_delete_lock(before); 9741da177e4SLinus Torvalds continue; 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds request = fl; 977b9746ef8SJeff Layton added = true; 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds else { 9801da177e4SLinus Torvalds /* Processing for different lock types is a bit 9811da177e4SLinus Torvalds * more complex. 9821da177e4SLinus Torvalds */ 9831da177e4SLinus Torvalds if (fl->fl_end < request->fl_start) 9841da177e4SLinus Torvalds goto next_lock; 9851da177e4SLinus Torvalds if (fl->fl_start > request->fl_end) 9861da177e4SLinus Torvalds break; 9871da177e4SLinus Torvalds if (request->fl_type == F_UNLCK) 988b9746ef8SJeff Layton added = true; 9891da177e4SLinus Torvalds if (fl->fl_start < request->fl_start) 9901da177e4SLinus Torvalds left = fl; 9911da177e4SLinus Torvalds /* If the next lock in the list has a higher end 9921da177e4SLinus Torvalds * address than the new one, insert the new one here. 9931da177e4SLinus Torvalds */ 9941da177e4SLinus Torvalds if (fl->fl_end > request->fl_end) { 9951da177e4SLinus Torvalds right = fl; 9961da177e4SLinus Torvalds break; 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds if (fl->fl_start >= request->fl_start) { 9991da177e4SLinus Torvalds /* The new lock completely replaces an old 10001da177e4SLinus Torvalds * one (This may happen several times). 10011da177e4SLinus Torvalds */ 10021da177e4SLinus Torvalds if (added) { 10031da177e4SLinus Torvalds locks_delete_lock(before); 10041da177e4SLinus Torvalds continue; 10051da177e4SLinus Torvalds } 10061da177e4SLinus Torvalds /* Replace the old lock with the new one. 10071da177e4SLinus Torvalds * Wake up anybody waiting for the old one, 10081da177e4SLinus Torvalds * as the change in lock type might satisfy 10091da177e4SLinus Torvalds * their needs. 10101da177e4SLinus Torvalds */ 10111da177e4SLinus Torvalds locks_wake_up_blocks(fl); 10121da177e4SLinus Torvalds fl->fl_start = request->fl_start; 10131da177e4SLinus Torvalds fl->fl_end = request->fl_end; 10141da177e4SLinus Torvalds fl->fl_type = request->fl_type; 101547831f35STrond Myklebust locks_release_private(fl); 101647831f35STrond Myklebust locks_copy_private(fl, request); 10171da177e4SLinus Torvalds request = fl; 1018b9746ef8SJeff Layton added = true; 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds } 10211da177e4SLinus Torvalds /* Go on to next lock. 10221da177e4SLinus Torvalds */ 10231da177e4SLinus Torvalds next_lock: 10241da177e4SLinus Torvalds before = &fl->fl_next; 10251da177e4SLinus Torvalds } 10261da177e4SLinus Torvalds 10270d9a490aSMiklos Szeredi /* 10281cb36012SJeff Layton * The above code only modifies existing locks in case of merging or 10291cb36012SJeff Layton * replacing. If new lock(s) need to be inserted all modifications are 10301cb36012SJeff Layton * done below this, so it's safe yet to bail out. 10310d9a490aSMiklos Szeredi */ 10320d9a490aSMiklos Szeredi error = -ENOLCK; /* "no luck" */ 10330d9a490aSMiklos Szeredi if (right && left == right && !new_fl2) 10340d9a490aSMiklos Szeredi goto out; 10350d9a490aSMiklos Szeredi 10361da177e4SLinus Torvalds error = 0; 10371da177e4SLinus Torvalds if (!added) { 1038f475ae95STrond Myklebust if (request->fl_type == F_UNLCK) { 1039f475ae95STrond Myklebust if (request->fl_flags & FL_EXISTS) 1040f475ae95STrond Myklebust error = -ENOENT; 10411da177e4SLinus Torvalds goto out; 1042f475ae95STrond Myklebust } 10430d9a490aSMiklos Szeredi 10440d9a490aSMiklos Szeredi if (!new_fl) { 10450d9a490aSMiklos Szeredi error = -ENOLCK; 10460d9a490aSMiklos Szeredi goto out; 10470d9a490aSMiklos Szeredi } 10481da177e4SLinus Torvalds locks_copy_lock(new_fl, request); 10491da177e4SLinus Torvalds locks_insert_lock(before, new_fl); 10501da177e4SLinus Torvalds new_fl = NULL; 10511da177e4SLinus Torvalds } 10521da177e4SLinus Torvalds if (right) { 10531da177e4SLinus Torvalds if (left == right) { 10541da177e4SLinus Torvalds /* The new lock breaks the old one in two pieces, 10551da177e4SLinus Torvalds * so we have to use the second new lock. 10561da177e4SLinus Torvalds */ 10571da177e4SLinus Torvalds left = new_fl2; 10581da177e4SLinus Torvalds new_fl2 = NULL; 10591da177e4SLinus Torvalds locks_copy_lock(left, right); 10601da177e4SLinus Torvalds locks_insert_lock(before, left); 10611da177e4SLinus Torvalds } 10621da177e4SLinus Torvalds right->fl_start = request->fl_end + 1; 10631da177e4SLinus Torvalds locks_wake_up_blocks(right); 10641da177e4SLinus Torvalds } 10651da177e4SLinus Torvalds if (left) { 10661da177e4SLinus Torvalds left->fl_end = request->fl_start - 1; 10671da177e4SLinus Torvalds locks_wake_up_blocks(left); 10681da177e4SLinus Torvalds } 10691da177e4SLinus Torvalds out: 10701c8c601aSJeff Layton spin_unlock(&inode->i_lock); 10711da177e4SLinus Torvalds /* 10721da177e4SLinus Torvalds * Free any unused locks. 10731da177e4SLinus Torvalds */ 10741da177e4SLinus Torvalds if (new_fl) 10751da177e4SLinus Torvalds locks_free_lock(new_fl); 10761da177e4SLinus Torvalds if (new_fl2) 10771da177e4SLinus Torvalds locks_free_lock(new_fl2); 10781da177e4SLinus Torvalds return error; 10791da177e4SLinus Torvalds } 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds /** 10821da177e4SLinus Torvalds * posix_lock_file - Apply a POSIX-style lock to a file 10831da177e4SLinus Torvalds * @filp: The file to apply the lock to 10841da177e4SLinus Torvalds * @fl: The lock to be applied 1085150b3934SMarc Eshel * @conflock: Place to return a copy of the conflicting lock, if found. 10861da177e4SLinus Torvalds * 10871da177e4SLinus Torvalds * Add a POSIX style lock to a file. 10881da177e4SLinus Torvalds * We merge adjacent & overlapping locks whenever possible. 10891da177e4SLinus Torvalds * POSIX locks are sorted by owner task, then by starting address 1090f475ae95STrond Myklebust * 1091f475ae95STrond Myklebust * Note that if called with an FL_EXISTS argument, the caller may determine 1092f475ae95STrond Myklebust * whether or not a lock was successfully freed by testing the return 1093f475ae95STrond Myklebust * value for -ENOENT. 10941da177e4SLinus Torvalds */ 1095150b3934SMarc Eshel int posix_lock_file(struct file *filp, struct file_lock *fl, 10965842add2SAndy Adamson struct file_lock *conflock) 10975842add2SAndy Adamson { 1098496ad9aaSAl Viro return __posix_lock_file(file_inode(filp), fl, conflock); 10995842add2SAndy Adamson } 1100150b3934SMarc Eshel EXPORT_SYMBOL(posix_lock_file); 11011da177e4SLinus Torvalds 11021da177e4SLinus Torvalds /** 11031da177e4SLinus Torvalds * posix_lock_file_wait - Apply a POSIX-style lock to a file 11041da177e4SLinus Torvalds * @filp: The file to apply the lock to 11051da177e4SLinus Torvalds * @fl: The lock to be applied 11061da177e4SLinus Torvalds * 11071da177e4SLinus Torvalds * Add a POSIX style lock to a file. 11081da177e4SLinus Torvalds * We merge adjacent & overlapping locks whenever possible. 11091da177e4SLinus Torvalds * POSIX locks are sorted by owner task, then by starting address 11101da177e4SLinus Torvalds */ 11111da177e4SLinus Torvalds int posix_lock_file_wait(struct file *filp, struct file_lock *fl) 11121da177e4SLinus Torvalds { 11131da177e4SLinus Torvalds int error; 11141da177e4SLinus Torvalds might_sleep (); 11151da177e4SLinus Torvalds for (;;) { 1116150b3934SMarc Eshel error = posix_lock_file(filp, fl, NULL); 1117bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 11181da177e4SLinus Torvalds break; 11191da177e4SLinus Torvalds error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 11201da177e4SLinus Torvalds if (!error) 11211da177e4SLinus Torvalds continue; 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds locks_delete_block(fl); 11241da177e4SLinus Torvalds break; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds return error; 11271da177e4SLinus Torvalds } 11281da177e4SLinus Torvalds EXPORT_SYMBOL(posix_lock_file_wait); 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds /** 11311da177e4SLinus Torvalds * locks_mandatory_locked - Check for an active lock 11321da177e4SLinus Torvalds * @inode: the file to check 11331da177e4SLinus Torvalds * 11341da177e4SLinus Torvalds * Searches the inode's list of locks to find any POSIX locks which conflict. 11351da177e4SLinus Torvalds * This function is called from locks_verify_locked() only. 11361da177e4SLinus Torvalds */ 11371da177e4SLinus Torvalds int locks_mandatory_locked(struct inode *inode) 11381da177e4SLinus Torvalds { 11391da177e4SLinus Torvalds fl_owner_t owner = current->files; 11401da177e4SLinus Torvalds struct file_lock *fl; 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds /* 11431da177e4SLinus Torvalds * Search the lock list for this inode for any POSIX locks. 11441da177e4SLinus Torvalds */ 11451c8c601aSJeff Layton spin_lock(&inode->i_lock); 11461da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 11471da177e4SLinus Torvalds if (!IS_POSIX(fl)) 11481da177e4SLinus Torvalds continue; 11491da177e4SLinus Torvalds if (fl->fl_owner != owner) 11501da177e4SLinus Torvalds break; 11511da177e4SLinus Torvalds } 11521c8c601aSJeff Layton spin_unlock(&inode->i_lock); 11531da177e4SLinus Torvalds return fl ? -EAGAIN : 0; 11541da177e4SLinus Torvalds } 11551da177e4SLinus Torvalds 11561da177e4SLinus Torvalds /** 11571da177e4SLinus Torvalds * locks_mandatory_area - Check for a conflicting lock 11581da177e4SLinus Torvalds * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ 11591da177e4SLinus Torvalds * for shared 11601da177e4SLinus Torvalds * @inode: the file to check 11611da177e4SLinus Torvalds * @filp: how the file was opened (if it was) 11621da177e4SLinus Torvalds * @offset: start of area to check 11631da177e4SLinus Torvalds * @count: length of area to check 11641da177e4SLinus Torvalds * 11651da177e4SLinus Torvalds * Searches the inode's list of locks to find any POSIX locks which conflict. 11661da177e4SLinus Torvalds * This function is called from rw_verify_area() and 11671da177e4SLinus Torvalds * locks_verify_truncate(). 11681da177e4SLinus Torvalds */ 11691da177e4SLinus Torvalds int locks_mandatory_area(int read_write, struct inode *inode, 11701da177e4SLinus Torvalds struct file *filp, loff_t offset, 11711da177e4SLinus Torvalds size_t count) 11721da177e4SLinus Torvalds { 11731da177e4SLinus Torvalds struct file_lock fl; 11741da177e4SLinus Torvalds int error; 11751da177e4SLinus Torvalds 11761da177e4SLinus Torvalds locks_init_lock(&fl); 11771da177e4SLinus Torvalds fl.fl_owner = current->files; 11781da177e4SLinus Torvalds fl.fl_pid = current->tgid; 11791da177e4SLinus Torvalds fl.fl_file = filp; 11801da177e4SLinus Torvalds fl.fl_flags = FL_POSIX | FL_ACCESS; 11811da177e4SLinus Torvalds if (filp && !(filp->f_flags & O_NONBLOCK)) 11821da177e4SLinus Torvalds fl.fl_flags |= FL_SLEEP; 11831da177e4SLinus Torvalds fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK; 11841da177e4SLinus Torvalds fl.fl_start = offset; 11851da177e4SLinus Torvalds fl.fl_end = offset + count - 1; 11861da177e4SLinus Torvalds 11871da177e4SLinus Torvalds for (;;) { 1188150b3934SMarc Eshel error = __posix_lock_file(inode, &fl, NULL); 1189bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 11901da177e4SLinus Torvalds break; 11911da177e4SLinus Torvalds error = wait_event_interruptible(fl.fl_wait, !fl.fl_next); 11921da177e4SLinus Torvalds if (!error) { 11931da177e4SLinus Torvalds /* 11941da177e4SLinus Torvalds * If we've been sleeping someone might have 11951da177e4SLinus Torvalds * changed the permissions behind our back. 11961da177e4SLinus Torvalds */ 1197a16877caSPavel Emelyanov if (__mandatory_lock(inode)) 11981da177e4SLinus Torvalds continue; 11991da177e4SLinus Torvalds } 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds locks_delete_block(&fl); 12021da177e4SLinus Torvalds break; 12031da177e4SLinus Torvalds } 12041da177e4SLinus Torvalds 12051da177e4SLinus Torvalds return error; 12061da177e4SLinus Torvalds } 12071da177e4SLinus Torvalds 12081da177e4SLinus Torvalds EXPORT_SYMBOL(locks_mandatory_area); 12091da177e4SLinus Torvalds 1210778fc546SJ. Bruce Fields static void lease_clear_pending(struct file_lock *fl, int arg) 1211778fc546SJ. Bruce Fields { 1212778fc546SJ. Bruce Fields switch (arg) { 1213778fc546SJ. Bruce Fields case F_UNLCK: 1214778fc546SJ. Bruce Fields fl->fl_flags &= ~FL_UNLOCK_PENDING; 1215778fc546SJ. Bruce Fields /* fall through: */ 1216778fc546SJ. Bruce Fields case F_RDLCK: 1217778fc546SJ. Bruce Fields fl->fl_flags &= ~FL_DOWNGRADE_PENDING; 1218778fc546SJ. Bruce Fields } 1219778fc546SJ. Bruce Fields } 1220778fc546SJ. Bruce Fields 12211da177e4SLinus Torvalds /* We already had a lease on this file; just change its type */ 12221da177e4SLinus Torvalds int lease_modify(struct file_lock **before, int arg) 12231da177e4SLinus Torvalds { 12241da177e4SLinus Torvalds struct file_lock *fl = *before; 12251da177e4SLinus Torvalds int error = assign_type(fl, arg); 12261da177e4SLinus Torvalds 12271da177e4SLinus Torvalds if (error) 12281da177e4SLinus Torvalds return error; 1229778fc546SJ. Bruce Fields lease_clear_pending(fl, arg); 12301da177e4SLinus Torvalds locks_wake_up_blocks(fl); 12313b6e2723SFilipe Brandenburger if (arg == F_UNLCK) { 12323b6e2723SFilipe Brandenburger struct file *filp = fl->fl_file; 12333b6e2723SFilipe Brandenburger 12343b6e2723SFilipe Brandenburger f_delown(filp); 12353b6e2723SFilipe Brandenburger filp->f_owner.signum = 0; 123696d6d59cSJ. Bruce Fields fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); 123796d6d59cSJ. Bruce Fields if (fl->fl_fasync != NULL) { 123896d6d59cSJ. Bruce Fields printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync); 123996d6d59cSJ. Bruce Fields fl->fl_fasync = NULL; 124096d6d59cSJ. Bruce Fields } 12411da177e4SLinus Torvalds locks_delete_lock(before); 12423b6e2723SFilipe Brandenburger } 12431da177e4SLinus Torvalds return 0; 12441da177e4SLinus Torvalds } 12451da177e4SLinus Torvalds 12461da177e4SLinus Torvalds EXPORT_SYMBOL(lease_modify); 12471da177e4SLinus Torvalds 1248778fc546SJ. Bruce Fields static bool past_time(unsigned long then) 1249778fc546SJ. Bruce Fields { 1250778fc546SJ. Bruce Fields if (!then) 1251778fc546SJ. Bruce Fields /* 0 is a special value meaning "this never expires": */ 1252778fc546SJ. Bruce Fields return false; 1253778fc546SJ. Bruce Fields return time_after(jiffies, then); 1254778fc546SJ. Bruce Fields } 1255778fc546SJ. Bruce Fields 12561da177e4SLinus Torvalds static void time_out_leases(struct inode *inode) 12571da177e4SLinus Torvalds { 12581da177e4SLinus Torvalds struct file_lock **before; 12591da177e4SLinus Torvalds struct file_lock *fl; 12601da177e4SLinus Torvalds 12611da177e4SLinus Torvalds before = &inode->i_flock; 1262ab83fa4bSJ. Bruce Fields while ((fl = *before) && IS_LEASE(fl) && lease_breaking(fl)) { 1263778fc546SJ. Bruce Fields if (past_time(fl->fl_downgrade_time)) 1264778fc546SJ. Bruce Fields lease_modify(before, F_RDLCK); 1265778fc546SJ. Bruce Fields if (past_time(fl->fl_break_time)) 1266778fc546SJ. Bruce Fields lease_modify(before, F_UNLCK); 12671da177e4SLinus Torvalds if (fl == *before) /* lease_modify may have freed fl */ 12681da177e4SLinus Torvalds before = &fl->fl_next; 12691da177e4SLinus Torvalds } 12701da177e4SLinus Torvalds } 12711da177e4SLinus Torvalds 12721da177e4SLinus Torvalds /** 12731da177e4SLinus Torvalds * __break_lease - revoke all outstanding leases on file 12741da177e4SLinus Torvalds * @inode: the inode of the file to return 12751da177e4SLinus Torvalds * @mode: the open mode (read or write) 12761da177e4SLinus Torvalds * 127787250dd2Sdavid m. richter * break_lease (inlined for speed) has checked there already is at least 127887250dd2Sdavid m. richter * some kind of lock (maybe a lease) on this file. Leases are broken on 127987250dd2Sdavid m. richter * a call to open() or truncate(). This function can sleep unless you 12801da177e4SLinus Torvalds * specified %O_NONBLOCK to your open(). 12811da177e4SLinus Torvalds */ 12821da177e4SLinus Torvalds int __break_lease(struct inode *inode, unsigned int mode) 12831da177e4SLinus Torvalds { 1284778fc546SJ. Bruce Fields int error = 0; 12851da177e4SLinus Torvalds struct file_lock *new_fl, *flock; 12861da177e4SLinus Torvalds struct file_lock *fl; 12871da177e4SLinus Torvalds unsigned long break_time; 12881da177e4SLinus Torvalds int i_have_this_lease = 0; 12898737c930SAl Viro int want_write = (mode & O_ACCMODE) != O_RDONLY; 12901da177e4SLinus Torvalds 12918737c930SAl Viro new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK); 12926d4b9e38SLinus Torvalds if (IS_ERR(new_fl)) 12936d4b9e38SLinus Torvalds return PTR_ERR(new_fl); 12941da177e4SLinus Torvalds 12951c8c601aSJeff Layton spin_lock(&inode->i_lock); 12961da177e4SLinus Torvalds 12971da177e4SLinus Torvalds time_out_leases(inode); 12981da177e4SLinus Torvalds 12991da177e4SLinus Torvalds flock = inode->i_flock; 13001da177e4SLinus Torvalds if ((flock == NULL) || !IS_LEASE(flock)) 13011da177e4SLinus Torvalds goto out; 13021da177e4SLinus Torvalds 1303778fc546SJ. Bruce Fields if (!locks_conflict(flock, new_fl)) 1304778fc546SJ. Bruce Fields goto out; 1305778fc546SJ. Bruce Fields 13061da177e4SLinus Torvalds for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) 13071da177e4SLinus Torvalds if (fl->fl_owner == current->files) 13081da177e4SLinus Torvalds i_have_this_lease = 1; 13091da177e4SLinus Torvalds 13101da177e4SLinus Torvalds break_time = 0; 13111da177e4SLinus Torvalds if (lease_break_time > 0) { 13121da177e4SLinus Torvalds break_time = jiffies + lease_break_time * HZ; 13131da177e4SLinus Torvalds if (break_time == 0) 13141da177e4SLinus Torvalds break_time++; /* so that 0 means no break time */ 13151da177e4SLinus Torvalds } 13161da177e4SLinus Torvalds 13171da177e4SLinus Torvalds for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) { 1318778fc546SJ. Bruce Fields if (want_write) { 1319778fc546SJ. Bruce Fields if (fl->fl_flags & FL_UNLOCK_PENDING) 1320778fc546SJ. Bruce Fields continue; 1321778fc546SJ. Bruce Fields fl->fl_flags |= FL_UNLOCK_PENDING; 13221da177e4SLinus Torvalds fl->fl_break_time = break_time; 1323778fc546SJ. Bruce Fields } else { 1324778fc546SJ. Bruce Fields if (lease_breaking(flock)) 1325778fc546SJ. Bruce Fields continue; 1326778fc546SJ. Bruce Fields fl->fl_flags |= FL_DOWNGRADE_PENDING; 1327778fc546SJ. Bruce Fields fl->fl_downgrade_time = break_time; 13281da177e4SLinus Torvalds } 1329778fc546SJ. Bruce Fields fl->fl_lmops->lm_break(fl); 13301da177e4SLinus Torvalds } 13311da177e4SLinus Torvalds 13321da177e4SLinus Torvalds if (i_have_this_lease || (mode & O_NONBLOCK)) { 13331da177e4SLinus Torvalds error = -EWOULDBLOCK; 13341da177e4SLinus Torvalds goto out; 13351da177e4SLinus Torvalds } 13361da177e4SLinus Torvalds 13371da177e4SLinus Torvalds restart: 13381da177e4SLinus Torvalds break_time = flock->fl_break_time; 13391da177e4SLinus Torvalds if (break_time != 0) { 13401da177e4SLinus Torvalds break_time -= jiffies; 13411da177e4SLinus Torvalds if (break_time == 0) 13421da177e4SLinus Torvalds break_time++; 13431da177e4SLinus Torvalds } 13444321e01eSMatthew Wilcox locks_insert_block(flock, new_fl); 13451c8c601aSJeff Layton spin_unlock(&inode->i_lock); 13464321e01eSMatthew Wilcox error = wait_event_interruptible_timeout(new_fl->fl_wait, 13474321e01eSMatthew Wilcox !new_fl->fl_next, break_time); 13481c8c601aSJeff Layton spin_lock(&inode->i_lock); 13491c8c601aSJeff Layton locks_delete_block(new_fl); 13501da177e4SLinus Torvalds if (error >= 0) { 13511da177e4SLinus Torvalds if (error == 0) 13521da177e4SLinus Torvalds time_out_leases(inode); 1353778fc546SJ. Bruce Fields /* 1354778fc546SJ. Bruce Fields * Wait for the next conflicting lease that has not been 1355778fc546SJ. Bruce Fields * broken yet 1356778fc546SJ. Bruce Fields */ 13571da177e4SLinus Torvalds for (flock = inode->i_flock; flock && IS_LEASE(flock); 13581da177e4SLinus Torvalds flock = flock->fl_next) { 1359778fc546SJ. Bruce Fields if (locks_conflict(new_fl, flock)) 13601da177e4SLinus Torvalds goto restart; 13611da177e4SLinus Torvalds } 13621da177e4SLinus Torvalds error = 0; 13631da177e4SLinus Torvalds } 13641da177e4SLinus Torvalds 13651da177e4SLinus Torvalds out: 13661c8c601aSJeff Layton spin_unlock(&inode->i_lock); 13671da177e4SLinus Torvalds locks_free_lock(new_fl); 13681da177e4SLinus Torvalds return error; 13691da177e4SLinus Torvalds } 13701da177e4SLinus Torvalds 13711da177e4SLinus Torvalds EXPORT_SYMBOL(__break_lease); 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds /** 1374a6b91919SRandy Dunlap * lease_get_mtime - get the last modified time of an inode 13751da177e4SLinus Torvalds * @inode: the inode 13761da177e4SLinus Torvalds * @time: pointer to a timespec which will contain the last modified time 13771da177e4SLinus Torvalds * 13781da177e4SLinus Torvalds * This is to force NFS clients to flush their caches for files with 13791da177e4SLinus Torvalds * exclusive leases. The justification is that if someone has an 1380a6b91919SRandy Dunlap * exclusive lease, then they could be modifying it. 13811da177e4SLinus Torvalds */ 13821da177e4SLinus Torvalds void lease_get_mtime(struct inode *inode, struct timespec *time) 13831da177e4SLinus Torvalds { 13841da177e4SLinus Torvalds struct file_lock *flock = inode->i_flock; 13850ee5c6d6SJeff Layton if (flock && IS_LEASE(flock) && (flock->fl_type == F_WRLCK)) 13861da177e4SLinus Torvalds *time = current_fs_time(inode->i_sb); 13871da177e4SLinus Torvalds else 13881da177e4SLinus Torvalds *time = inode->i_mtime; 13891da177e4SLinus Torvalds } 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvalds EXPORT_SYMBOL(lease_get_mtime); 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds /** 13941da177e4SLinus Torvalds * fcntl_getlease - Enquire what lease is currently active 13951da177e4SLinus Torvalds * @filp: the file 13961da177e4SLinus Torvalds * 13971da177e4SLinus Torvalds * The value returned by this function will be one of 13981da177e4SLinus Torvalds * (if no lease break is pending): 13991da177e4SLinus Torvalds * 14001da177e4SLinus Torvalds * %F_RDLCK to indicate a shared lease is held. 14011da177e4SLinus Torvalds * 14021da177e4SLinus Torvalds * %F_WRLCK to indicate an exclusive lease is held. 14031da177e4SLinus Torvalds * 14041da177e4SLinus Torvalds * %F_UNLCK to indicate no lease is held. 14051da177e4SLinus Torvalds * 14061da177e4SLinus Torvalds * (if a lease break is pending): 14071da177e4SLinus Torvalds * 14081da177e4SLinus Torvalds * %F_RDLCK to indicate an exclusive lease needs to be 14091da177e4SLinus Torvalds * changed to a shared lease (or removed). 14101da177e4SLinus Torvalds * 14111da177e4SLinus Torvalds * %F_UNLCK to indicate the lease needs to be removed. 14121da177e4SLinus Torvalds * 14131da177e4SLinus Torvalds * XXX: sfr & willy disagree over whether F_INPROGRESS 14141da177e4SLinus Torvalds * should be returned to userspace. 14151da177e4SLinus Torvalds */ 14161da177e4SLinus Torvalds int fcntl_getlease(struct file *filp) 14171da177e4SLinus Torvalds { 14181da177e4SLinus Torvalds struct file_lock *fl; 14191c8c601aSJeff Layton struct inode *inode = file_inode(filp); 14201da177e4SLinus Torvalds int type = F_UNLCK; 14211da177e4SLinus Torvalds 14221c8c601aSJeff Layton spin_lock(&inode->i_lock); 1423496ad9aaSAl Viro time_out_leases(file_inode(filp)); 1424496ad9aaSAl Viro for (fl = file_inode(filp)->i_flock; fl && IS_LEASE(fl); 14251da177e4SLinus Torvalds fl = fl->fl_next) { 14261da177e4SLinus Torvalds if (fl->fl_file == filp) { 1427778fc546SJ. Bruce Fields type = target_leasetype(fl); 14281da177e4SLinus Torvalds break; 14291da177e4SLinus Torvalds } 14301da177e4SLinus Torvalds } 14311c8c601aSJeff Layton spin_unlock(&inode->i_lock); 14321da177e4SLinus Torvalds return type; 14331da177e4SLinus Torvalds } 14341da177e4SLinus Torvalds 1435d4f22d19SJeff Layton static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp) 14361da177e4SLinus Torvalds { 14377eaae282SKAMBAROV, ZAUR struct file_lock *fl, **before, **my_before = NULL, *lease; 14380f7fc9e4SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 14391da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 1440c1f24ef4SJ. Bruce Fields int error; 14411da177e4SLinus Torvalds 1442096657b6SJ. Bruce Fields lease = *flp; 1443096657b6SJ. Bruce Fields 14441da177e4SLinus Torvalds error = -EAGAIN; 14451da177e4SLinus Torvalds if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0)) 14461da177e4SLinus Torvalds goto out; 14471da177e4SLinus Torvalds if ((arg == F_WRLCK) 1448b7ab39f6SNick Piggin && ((dentry->d_count > 1) 14491da177e4SLinus Torvalds || (atomic_read(&inode->i_count) > 1))) 14501da177e4SLinus Torvalds goto out; 145185c59580SPavel Emelyanov 14521da177e4SLinus Torvalds /* 14531da177e4SLinus Torvalds * At this point, we know that if there is an exclusive 14541da177e4SLinus Torvalds * lease on this file, then we hold it on this filp 14551da177e4SLinus Torvalds * (otherwise our open of this file would have blocked). 14561da177e4SLinus Torvalds * And if we are trying to acquire an exclusive lease, 14571da177e4SLinus Torvalds * then the file is not open by anyone (including us) 14581da177e4SLinus Torvalds * except for this filp. 14591da177e4SLinus Torvalds */ 1460c1f24ef4SJ. Bruce Fields error = -EAGAIN; 14611da177e4SLinus Torvalds for (before = &inode->i_flock; 14621da177e4SLinus Torvalds ((fl = *before) != NULL) && IS_LEASE(fl); 14631da177e4SLinus Torvalds before = &fl->fl_next) { 1464c1f24ef4SJ. Bruce Fields if (fl->fl_file == filp) { 14651da177e4SLinus Torvalds my_before = before; 1466c1f24ef4SJ. Bruce Fields continue; 14671da177e4SLinus Torvalds } 1468c1f24ef4SJ. Bruce Fields /* 1469c1f24ef4SJ. Bruce Fields * No exclusive leases if someone else has a lease on 1470c1f24ef4SJ. Bruce Fields * this file: 1471c1f24ef4SJ. Bruce Fields */ 1472c1f24ef4SJ. Bruce Fields if (arg == F_WRLCK) 14731da177e4SLinus Torvalds goto out; 1474c1f24ef4SJ. Bruce Fields /* 1475c1f24ef4SJ. Bruce Fields * Modifying our existing lease is OK, but no getting a 1476c1f24ef4SJ. Bruce Fields * new lease if someone else is opening for write: 1477c1f24ef4SJ. Bruce Fields */ 1478c1f24ef4SJ. Bruce Fields if (fl->fl_flags & FL_UNLOCK_PENDING) 1479c1f24ef4SJ. Bruce Fields goto out; 1480c1f24ef4SJ. Bruce Fields } 14811da177e4SLinus Torvalds 14821da177e4SLinus Torvalds if (my_before != NULL) { 14838fb47a4fSJ. Bruce Fields error = lease->fl_lmops->lm_change(my_before, arg); 148451ee4b84SChristoph Hellwig if (!error) 148551ee4b84SChristoph Hellwig *flp = *my_before; 14861da177e4SLinus Torvalds goto out; 14871da177e4SLinus Torvalds } 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds error = -EINVAL; 14901da177e4SLinus Torvalds if (!leases_enable) 14911da177e4SLinus Torvalds goto out; 14921da177e4SLinus Torvalds 1493c5b1f0d9SArnd Bergmann locks_insert_lock(before, lease); 149485c59580SPavel Emelyanov return 0; 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds out: 14971da177e4SLinus Torvalds return error; 14981da177e4SLinus Torvalds } 14998335ebd9SJ. Bruce Fields 1500d4f22d19SJeff Layton static int generic_delete_lease(struct file *filp, struct file_lock **flp) 15018335ebd9SJ. Bruce Fields { 15028335ebd9SJ. Bruce Fields struct file_lock *fl, **before; 15038335ebd9SJ. Bruce Fields struct dentry *dentry = filp->f_path.dentry; 15048335ebd9SJ. Bruce Fields struct inode *inode = dentry->d_inode; 15058335ebd9SJ. Bruce Fields 15068335ebd9SJ. Bruce Fields for (before = &inode->i_flock; 15078335ebd9SJ. Bruce Fields ((fl = *before) != NULL) && IS_LEASE(fl); 15088335ebd9SJ. Bruce Fields before = &fl->fl_next) { 15098335ebd9SJ. Bruce Fields if (fl->fl_file != filp) 15108335ebd9SJ. Bruce Fields continue; 15118335ebd9SJ. Bruce Fields return (*flp)->fl_lmops->lm_change(before, F_UNLCK); 15128335ebd9SJ. Bruce Fields } 15138335ebd9SJ. Bruce Fields return -EAGAIN; 15148335ebd9SJ. Bruce Fields } 15158335ebd9SJ. Bruce Fields 15161da177e4SLinus Torvalds /** 15171da177e4SLinus Torvalds * generic_setlease - sets a lease on an open file 15181da177e4SLinus Torvalds * @filp: file pointer 15191da177e4SLinus Torvalds * @arg: type of lease to obtain 15201da177e4SLinus Torvalds * @flp: input - file_lock to use, output - file_lock inserted 15211da177e4SLinus Torvalds * 15221da177e4SLinus Torvalds * The (input) flp->fl_lmops->lm_break function is required 15231da177e4SLinus Torvalds * by break_lease(). 15241da177e4SLinus Torvalds * 15251c8c601aSJeff Layton * Called with inode->i_lock held. 15261da177e4SLinus Torvalds */ 15271da177e4SLinus Torvalds int generic_setlease(struct file *filp, long arg, struct file_lock **flp) 15281da177e4SLinus Torvalds { 15291da177e4SLinus Torvalds struct dentry *dentry = filp->f_path.dentry; 15301da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 15318335ebd9SJ. Bruce Fields int error; 15321da177e4SLinus Torvalds 15338e96e3b7SEric W. Biederman if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE)) 15348335ebd9SJ. Bruce Fields return -EACCES; 15351da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode)) 15368335ebd9SJ. Bruce Fields return -EINVAL; 15371da177e4SLinus Torvalds error = security_file_lock(filp, arg); 15381da177e4SLinus Torvalds if (error) 15398335ebd9SJ. Bruce Fields return error; 15401da177e4SLinus Torvalds 15411da177e4SLinus Torvalds time_out_leases(inode); 15421da177e4SLinus Torvalds 15431da177e4SLinus Torvalds BUG_ON(!(*flp)->fl_lmops->lm_break); 15441da177e4SLinus Torvalds 15458335ebd9SJ. Bruce Fields switch (arg) { 15468335ebd9SJ. Bruce Fields case F_UNLCK: 15478335ebd9SJ. Bruce Fields return generic_delete_lease(filp, flp); 15488335ebd9SJ. Bruce Fields case F_RDLCK: 15498335ebd9SJ. Bruce Fields case F_WRLCK: 15508335ebd9SJ. Bruce Fields return generic_add_lease(filp, arg, flp); 15518335ebd9SJ. Bruce Fields default: 15528d657eb3SDave Jones return -EINVAL; 15531da177e4SLinus Torvalds } 15541da177e4SLinus Torvalds } 15550af1a450SChristoph Hellwig EXPORT_SYMBOL(generic_setlease); 15561da177e4SLinus Torvalds 1557b89f4321SArnd Bergmann static int __vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 1558b89f4321SArnd Bergmann { 1559b89f4321SArnd Bergmann if (filp->f_op && filp->f_op->setlease) 1560b89f4321SArnd Bergmann return filp->f_op->setlease(filp, arg, lease); 1561b89f4321SArnd Bergmann else 1562b89f4321SArnd Bergmann return generic_setlease(filp, arg, lease); 1563b89f4321SArnd Bergmann } 1564b89f4321SArnd Bergmann 15651da177e4SLinus Torvalds /** 1566a9933ceaSJ. Bruce Fields * vfs_setlease - sets a lease on an open file 15671da177e4SLinus Torvalds * @filp: file pointer 15681da177e4SLinus Torvalds * @arg: type of lease to obtain 15691da177e4SLinus Torvalds * @lease: file_lock to use 15701da177e4SLinus Torvalds * 15711da177e4SLinus Torvalds * Call this to establish a lease on the file. 15728fb47a4fSJ. Bruce Fields * The (*lease)->fl_lmops->lm_break operation must be set; if not, 1573f9ffed26SJ. Bruce Fields * break_lease will oops! 1574f9ffed26SJ. Bruce Fields * 1575f9ffed26SJ. Bruce Fields * This will call the filesystem's setlease file method, if 1576f9ffed26SJ. Bruce Fields * defined. Note that there is no getlease method; instead, the 1577f9ffed26SJ. Bruce Fields * filesystem setlease method should call back to setlease() to 1578f9ffed26SJ. Bruce Fields * add a lease to the inode's lease list, where fcntl_getlease() can 1579f9ffed26SJ. Bruce Fields * find it. Since fcntl_getlease() only reports whether the current 1580f9ffed26SJ. Bruce Fields * task holds a lease, a cluster filesystem need only do this for 1581f9ffed26SJ. Bruce Fields * leases held by processes on this node. 1582f9ffed26SJ. Bruce Fields * 1583f9ffed26SJ. Bruce Fields * There is also no break_lease method; filesystems that 1584c9404c9cSAdam Buchbinder * handle their own leases should break leases themselves from the 1585f9ffed26SJ. Bruce Fields * filesystem's open, create, and (on truncate) setattr methods. 1586f9ffed26SJ. Bruce Fields * 1587f9ffed26SJ. Bruce Fields * Warning: the only current setlease methods exist only to disable 1588f9ffed26SJ. Bruce Fields * leases in certain cases. More vfs changes may be required to 1589f9ffed26SJ. Bruce Fields * allow a full filesystem lease implementation. 15901da177e4SLinus Torvalds */ 15911da177e4SLinus Torvalds 1592a9933ceaSJ. Bruce Fields int vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 15931da177e4SLinus Torvalds { 15941c8c601aSJeff Layton struct inode *inode = file_inode(filp); 15951da177e4SLinus Torvalds int error; 15961da177e4SLinus Torvalds 15971c8c601aSJeff Layton spin_lock(&inode->i_lock); 1598b89f4321SArnd Bergmann error = __vfs_setlease(filp, arg, lease); 15991c8c601aSJeff Layton spin_unlock(&inode->i_lock); 16001da177e4SLinus Torvalds 16011da177e4SLinus Torvalds return error; 16021da177e4SLinus Torvalds } 1603a9933ceaSJ. Bruce Fields EXPORT_SYMBOL_GPL(vfs_setlease); 16041da177e4SLinus Torvalds 16050ceaf6c7SJ. Bruce Fields static int do_fcntl_delete_lease(struct file *filp) 16060ceaf6c7SJ. Bruce Fields { 16070ceaf6c7SJ. Bruce Fields struct file_lock fl, *flp = &fl; 16080ceaf6c7SJ. Bruce Fields 16090ceaf6c7SJ. Bruce Fields lease_init(filp, F_UNLCK, flp); 16100ceaf6c7SJ. Bruce Fields 16110ceaf6c7SJ. Bruce Fields return vfs_setlease(filp, F_UNLCK, &flp); 16120ceaf6c7SJ. Bruce Fields } 16130ceaf6c7SJ. Bruce Fields 16140ceaf6c7SJ. Bruce Fields static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg) 16151da177e4SLinus Torvalds { 16163df057acSJ. Bruce Fields struct file_lock *fl, *ret; 16171c8c601aSJeff Layton struct inode *inode = file_inode(filp); 1618f7347ce4SLinus Torvalds struct fasync_struct *new; 16191da177e4SLinus Torvalds int error; 16201da177e4SLinus Torvalds 1621c5b1f0d9SArnd Bergmann fl = lease_alloc(filp, arg); 1622c5b1f0d9SArnd Bergmann if (IS_ERR(fl)) 1623c5b1f0d9SArnd Bergmann return PTR_ERR(fl); 16241da177e4SLinus Torvalds 1625f7347ce4SLinus Torvalds new = fasync_alloc(); 1626f7347ce4SLinus Torvalds if (!new) { 1627f7347ce4SLinus Torvalds locks_free_lock(fl); 1628f7347ce4SLinus Torvalds return -ENOMEM; 1629f7347ce4SLinus Torvalds } 16303df057acSJ. Bruce Fields ret = fl; 16311c8c601aSJeff Layton spin_lock(&inode->i_lock); 16328896b93fSJ. Bruce Fields error = __vfs_setlease(filp, arg, &ret); 163351ee4b84SChristoph Hellwig if (error) { 16341c8c601aSJeff Layton spin_unlock(&inode->i_lock); 163551ee4b84SChristoph Hellwig locks_free_lock(fl); 163651ee4b84SChristoph Hellwig goto out_free_fasync; 163751ee4b84SChristoph Hellwig } 16383df057acSJ. Bruce Fields if (ret != fl) 16393df057acSJ. Bruce Fields locks_free_lock(fl); 16401da177e4SLinus Torvalds 1641f7347ce4SLinus Torvalds /* 1642f7347ce4SLinus Torvalds * fasync_insert_entry() returns the old entry if any. 1643f7347ce4SLinus Torvalds * If there was no old entry, then it used 'new' and 1644f7347ce4SLinus Torvalds * inserted it into the fasync list. Clear new so that 1645f7347ce4SLinus Torvalds * we don't release it here. 1646f7347ce4SLinus Torvalds */ 16473df057acSJ. Bruce Fields if (!fasync_insert_entry(fd, filp, &ret->fl_fasync, new)) 1648f7347ce4SLinus Torvalds new = NULL; 1649f7347ce4SLinus Torvalds 1650609d7fa9SEric W. Biederman error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0); 16511c8c601aSJeff Layton spin_unlock(&inode->i_lock); 165251ee4b84SChristoph Hellwig 165351ee4b84SChristoph Hellwig out_free_fasync: 1654f7347ce4SLinus Torvalds if (new) 1655f7347ce4SLinus Torvalds fasync_free(new); 16561da177e4SLinus Torvalds return error; 16571da177e4SLinus Torvalds } 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds /** 16600ceaf6c7SJ. Bruce Fields * fcntl_setlease - sets a lease on an open file 16610ceaf6c7SJ. Bruce Fields * @fd: open file descriptor 16620ceaf6c7SJ. Bruce Fields * @filp: file pointer 16630ceaf6c7SJ. Bruce Fields * @arg: type of lease to obtain 16640ceaf6c7SJ. Bruce Fields * 16650ceaf6c7SJ. Bruce Fields * Call this fcntl to establish a lease on the file. 16660ceaf6c7SJ. Bruce Fields * Note that you also need to call %F_SETSIG to 16670ceaf6c7SJ. Bruce Fields * receive a signal when the lease is broken. 16680ceaf6c7SJ. Bruce Fields */ 16690ceaf6c7SJ. Bruce Fields int fcntl_setlease(unsigned int fd, struct file *filp, long arg) 16700ceaf6c7SJ. Bruce Fields { 16710ceaf6c7SJ. Bruce Fields if (arg == F_UNLCK) 16720ceaf6c7SJ. Bruce Fields return do_fcntl_delete_lease(filp); 16730ceaf6c7SJ. Bruce Fields return do_fcntl_add_lease(fd, filp, arg); 16740ceaf6c7SJ. Bruce Fields } 16750ceaf6c7SJ. Bruce Fields 16760ceaf6c7SJ. Bruce Fields /** 16771da177e4SLinus Torvalds * flock_lock_file_wait - Apply a FLOCK-style lock to a file 16781da177e4SLinus Torvalds * @filp: The file to apply the lock to 16791da177e4SLinus Torvalds * @fl: The lock to be applied 16801da177e4SLinus Torvalds * 16811da177e4SLinus Torvalds * Add a FLOCK style lock to a file. 16821da177e4SLinus Torvalds */ 16831da177e4SLinus Torvalds int flock_lock_file_wait(struct file *filp, struct file_lock *fl) 16841da177e4SLinus Torvalds { 16851da177e4SLinus Torvalds int error; 16861da177e4SLinus Torvalds might_sleep(); 16871da177e4SLinus Torvalds for (;;) { 16881da177e4SLinus Torvalds error = flock_lock_file(filp, fl); 1689bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 16901da177e4SLinus Torvalds break; 16911da177e4SLinus Torvalds error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 16921da177e4SLinus Torvalds if (!error) 16931da177e4SLinus Torvalds continue; 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds locks_delete_block(fl); 16961da177e4SLinus Torvalds break; 16971da177e4SLinus Torvalds } 16981da177e4SLinus Torvalds return error; 16991da177e4SLinus Torvalds } 17001da177e4SLinus Torvalds 17011da177e4SLinus Torvalds EXPORT_SYMBOL(flock_lock_file_wait); 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds /** 17041da177e4SLinus Torvalds * sys_flock: - flock() system call. 17051da177e4SLinus Torvalds * @fd: the file descriptor to lock. 17061da177e4SLinus Torvalds * @cmd: the type of lock to apply. 17071da177e4SLinus Torvalds * 17081da177e4SLinus Torvalds * Apply a %FL_FLOCK style lock to an open file descriptor. 17091da177e4SLinus Torvalds * The @cmd can be one of 17101da177e4SLinus Torvalds * 17111da177e4SLinus Torvalds * %LOCK_SH -- a shared lock. 17121da177e4SLinus Torvalds * 17131da177e4SLinus Torvalds * %LOCK_EX -- an exclusive lock. 17141da177e4SLinus Torvalds * 17151da177e4SLinus Torvalds * %LOCK_UN -- remove an existing lock. 17161da177e4SLinus Torvalds * 17171da177e4SLinus Torvalds * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes. 17181da177e4SLinus Torvalds * 17191da177e4SLinus Torvalds * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other 17201da177e4SLinus Torvalds * processes read and write access respectively. 17211da177e4SLinus Torvalds */ 1722002c8976SHeiko Carstens SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) 17231da177e4SLinus Torvalds { 17242903ff01SAl Viro struct fd f = fdget(fd); 17251da177e4SLinus Torvalds struct file_lock *lock; 17261da177e4SLinus Torvalds int can_sleep, unlock; 17271da177e4SLinus Torvalds int error; 17281da177e4SLinus Torvalds 17291da177e4SLinus Torvalds error = -EBADF; 17302903ff01SAl Viro if (!f.file) 17311da177e4SLinus Torvalds goto out; 17321da177e4SLinus Torvalds 17331da177e4SLinus Torvalds can_sleep = !(cmd & LOCK_NB); 17341da177e4SLinus Torvalds cmd &= ~LOCK_NB; 17351da177e4SLinus Torvalds unlock = (cmd == LOCK_UN); 17361da177e4SLinus Torvalds 1737aeb5d727SAl Viro if (!unlock && !(cmd & LOCK_MAND) && 17382903ff01SAl Viro !(f.file->f_mode & (FMODE_READ|FMODE_WRITE))) 17391da177e4SLinus Torvalds goto out_putf; 17401da177e4SLinus Torvalds 17412903ff01SAl Viro error = flock_make_lock(f.file, &lock, cmd); 17421da177e4SLinus Torvalds if (error) 17431da177e4SLinus Torvalds goto out_putf; 17441da177e4SLinus Torvalds if (can_sleep) 17451da177e4SLinus Torvalds lock->fl_flags |= FL_SLEEP; 17461da177e4SLinus Torvalds 17472903ff01SAl Viro error = security_file_lock(f.file, lock->fl_type); 17481da177e4SLinus Torvalds if (error) 17491da177e4SLinus Torvalds goto out_free; 17501da177e4SLinus Torvalds 17512903ff01SAl Viro if (f.file->f_op && f.file->f_op->flock) 17522903ff01SAl Viro error = f.file->f_op->flock(f.file, 17531da177e4SLinus Torvalds (can_sleep) ? F_SETLKW : F_SETLK, 17541da177e4SLinus Torvalds lock); 17551da177e4SLinus Torvalds else 17562903ff01SAl Viro error = flock_lock_file_wait(f.file, lock); 17571da177e4SLinus Torvalds 17581da177e4SLinus Torvalds out_free: 17591da177e4SLinus Torvalds locks_free_lock(lock); 17601da177e4SLinus Torvalds 17611da177e4SLinus Torvalds out_putf: 17622903ff01SAl Viro fdput(f); 17631da177e4SLinus Torvalds out: 17641da177e4SLinus Torvalds return error; 17651da177e4SLinus Torvalds } 17661da177e4SLinus Torvalds 17673ee17abdSJ. Bruce Fields /** 17683ee17abdSJ. Bruce Fields * vfs_test_lock - test file byte range lock 17693ee17abdSJ. Bruce Fields * @filp: The file to test lock for 17706924c554SJ. Bruce Fields * @fl: The lock to test; also used to hold result 17713ee17abdSJ. Bruce Fields * 17723ee17abdSJ. Bruce Fields * Returns -ERRNO on failure. Indicates presence of conflicting lock by 17733ee17abdSJ. Bruce Fields * setting conf->fl_type to something other than F_UNLCK. 17743ee17abdSJ. Bruce Fields */ 17753ee17abdSJ. Bruce Fields int vfs_test_lock(struct file *filp, struct file_lock *fl) 17763ee17abdSJ. Bruce Fields { 17773ee17abdSJ. Bruce Fields if (filp->f_op && filp->f_op->lock) 17783ee17abdSJ. Bruce Fields return filp->f_op->lock(filp, F_GETLK, fl); 17793ee17abdSJ. Bruce Fields posix_test_lock(filp, fl); 17803ee17abdSJ. Bruce Fields return 0; 17813ee17abdSJ. Bruce Fields } 17823ee17abdSJ. Bruce Fields EXPORT_SYMBOL_GPL(vfs_test_lock); 17833ee17abdSJ. Bruce Fields 1784c2fa1b8aSJ. Bruce Fields static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) 1785c2fa1b8aSJ. Bruce Fields { 1786c2fa1b8aSJ. Bruce Fields flock->l_pid = fl->fl_pid; 1787c2fa1b8aSJ. Bruce Fields #if BITS_PER_LONG == 32 1788c2fa1b8aSJ. Bruce Fields /* 1789c2fa1b8aSJ. Bruce Fields * Make sure we can represent the posix lock via 1790c2fa1b8aSJ. Bruce Fields * legacy 32bit flock. 1791c2fa1b8aSJ. Bruce Fields */ 1792c2fa1b8aSJ. Bruce Fields if (fl->fl_start > OFFT_OFFSET_MAX) 1793c2fa1b8aSJ. Bruce Fields return -EOVERFLOW; 1794c2fa1b8aSJ. Bruce Fields if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX) 1795c2fa1b8aSJ. Bruce Fields return -EOVERFLOW; 1796c2fa1b8aSJ. Bruce Fields #endif 1797c2fa1b8aSJ. Bruce Fields flock->l_start = fl->fl_start; 1798c2fa1b8aSJ. Bruce Fields flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1799c2fa1b8aSJ. Bruce Fields fl->fl_end - fl->fl_start + 1; 1800c2fa1b8aSJ. Bruce Fields flock->l_whence = 0; 1801129a84deSJ. Bruce Fields flock->l_type = fl->fl_type; 1802c2fa1b8aSJ. Bruce Fields return 0; 1803c2fa1b8aSJ. Bruce Fields } 1804c2fa1b8aSJ. Bruce Fields 1805c2fa1b8aSJ. Bruce Fields #if BITS_PER_LONG == 32 1806c2fa1b8aSJ. Bruce Fields static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) 1807c2fa1b8aSJ. Bruce Fields { 1808c2fa1b8aSJ. Bruce Fields flock->l_pid = fl->fl_pid; 1809c2fa1b8aSJ. Bruce Fields flock->l_start = fl->fl_start; 1810c2fa1b8aSJ. Bruce Fields flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1811c2fa1b8aSJ. Bruce Fields fl->fl_end - fl->fl_start + 1; 1812c2fa1b8aSJ. Bruce Fields flock->l_whence = 0; 1813c2fa1b8aSJ. Bruce Fields flock->l_type = fl->fl_type; 1814c2fa1b8aSJ. Bruce Fields } 1815c2fa1b8aSJ. Bruce Fields #endif 1816c2fa1b8aSJ. Bruce Fields 18171da177e4SLinus Torvalds /* Report the first existing lock that would conflict with l. 18181da177e4SLinus Torvalds * This implements the F_GETLK command of fcntl(). 18191da177e4SLinus Torvalds */ 18201da177e4SLinus Torvalds int fcntl_getlk(struct file *filp, struct flock __user *l) 18211da177e4SLinus Torvalds { 18229d6a8c5cSMarc Eshel struct file_lock file_lock; 18231da177e4SLinus Torvalds struct flock flock; 18241da177e4SLinus Torvalds int error; 18251da177e4SLinus Torvalds 18261da177e4SLinus Torvalds error = -EFAULT; 18271da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 18281da177e4SLinus Torvalds goto out; 18291da177e4SLinus Torvalds error = -EINVAL; 18301da177e4SLinus Torvalds if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 18311da177e4SLinus Torvalds goto out; 18321da177e4SLinus Torvalds 18331da177e4SLinus Torvalds error = flock_to_posix_lock(filp, &file_lock, &flock); 18341da177e4SLinus Torvalds if (error) 18351da177e4SLinus Torvalds goto out; 18361da177e4SLinus Torvalds 18373ee17abdSJ. Bruce Fields error = vfs_test_lock(filp, &file_lock); 18383ee17abdSJ. Bruce Fields if (error) 18391da177e4SLinus Torvalds goto out; 18401da177e4SLinus Torvalds 18419d6a8c5cSMarc Eshel flock.l_type = file_lock.fl_type; 18429d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) { 18439d6a8c5cSMarc Eshel error = posix_lock_to_flock(&flock, &file_lock); 1844c2fa1b8aSJ. Bruce Fields if (error) 18451da177e4SLinus Torvalds goto out; 18461da177e4SLinus Torvalds } 18471da177e4SLinus Torvalds error = -EFAULT; 18481da177e4SLinus Torvalds if (!copy_to_user(l, &flock, sizeof(flock))) 18491da177e4SLinus Torvalds error = 0; 18501da177e4SLinus Torvalds out: 18511da177e4SLinus Torvalds return error; 18521da177e4SLinus Torvalds } 18531da177e4SLinus Torvalds 18547723ec97SMarc Eshel /** 18557723ec97SMarc Eshel * vfs_lock_file - file byte range lock 18567723ec97SMarc Eshel * @filp: The file to apply the lock to 18577723ec97SMarc Eshel * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.) 18587723ec97SMarc Eshel * @fl: The lock to be applied 1859150b3934SMarc Eshel * @conf: Place to return a copy of the conflicting lock, if found. 1860150b3934SMarc Eshel * 1861150b3934SMarc Eshel * A caller that doesn't care about the conflicting lock may pass NULL 1862150b3934SMarc Eshel * as the final argument. 1863150b3934SMarc Eshel * 1864150b3934SMarc Eshel * If the filesystem defines a private ->lock() method, then @conf will 1865150b3934SMarc Eshel * be left unchanged; so a caller that cares should initialize it to 1866150b3934SMarc Eshel * some acceptable default. 18672beb6614SMarc Eshel * 18682beb6614SMarc Eshel * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX 18692beb6614SMarc Eshel * locks, the ->lock() interface may return asynchronously, before the lock has 18702beb6614SMarc Eshel * been granted or denied by the underlying filesystem, if (and only if) 18718fb47a4fSJ. Bruce Fields * lm_grant is set. Callers expecting ->lock() to return asynchronously 18722beb6614SMarc Eshel * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if) 18732beb6614SMarc Eshel * the request is for a blocking lock. When ->lock() does return asynchronously, 18748fb47a4fSJ. Bruce Fields * it must return FILE_LOCK_DEFERRED, and call ->lm_grant() when the lock 18752beb6614SMarc Eshel * request completes. 18762beb6614SMarc Eshel * If the request is for non-blocking lock the file system should return 1877bde74e4bSMiklos Szeredi * FILE_LOCK_DEFERRED then try to get the lock and call the callback routine 1878bde74e4bSMiklos Szeredi * with the result. If the request timed out the callback routine will return a 18792beb6614SMarc Eshel * nonzero return code and the file system should release the lock. The file 18802beb6614SMarc Eshel * system is also responsible to keep a corresponding posix lock when it 18812beb6614SMarc Eshel * grants a lock so the VFS can find out which locks are locally held and do 18822beb6614SMarc Eshel * the correct lock cleanup when required. 18832beb6614SMarc Eshel * The underlying filesystem must not drop the kernel lock or call 18848fb47a4fSJ. Bruce Fields * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED 18852beb6614SMarc Eshel * return code. 18867723ec97SMarc Eshel */ 1887150b3934SMarc Eshel int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) 18887723ec97SMarc Eshel { 18897723ec97SMarc Eshel if (filp->f_op && filp->f_op->lock) 18907723ec97SMarc Eshel return filp->f_op->lock(filp, cmd, fl); 18917723ec97SMarc Eshel else 1892150b3934SMarc Eshel return posix_lock_file(filp, fl, conf); 18937723ec97SMarc Eshel } 18947723ec97SMarc Eshel EXPORT_SYMBOL_GPL(vfs_lock_file); 18957723ec97SMarc Eshel 1896b648a6deSMiklos Szeredi static int do_lock_file_wait(struct file *filp, unsigned int cmd, 1897b648a6deSMiklos Szeredi struct file_lock *fl) 1898b648a6deSMiklos Szeredi { 1899b648a6deSMiklos Szeredi int error; 1900b648a6deSMiklos Szeredi 1901b648a6deSMiklos Szeredi error = security_file_lock(filp, fl->fl_type); 1902b648a6deSMiklos Szeredi if (error) 1903b648a6deSMiklos Szeredi return error; 1904b648a6deSMiklos Szeredi 1905b648a6deSMiklos Szeredi for (;;) { 1906764c76b3SMiklos Szeredi error = vfs_lock_file(filp, cmd, fl, NULL); 1907b648a6deSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 1908b648a6deSMiklos Szeredi break; 1909764c76b3SMiklos Szeredi error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 1910b648a6deSMiklos Szeredi if (!error) 1911b648a6deSMiklos Szeredi continue; 1912b648a6deSMiklos Szeredi 1913b648a6deSMiklos Szeredi locks_delete_block(fl); 1914b648a6deSMiklos Szeredi break; 1915b648a6deSMiklos Szeredi } 1916b648a6deSMiklos Szeredi 1917b648a6deSMiklos Szeredi return error; 1918b648a6deSMiklos Szeredi } 1919b648a6deSMiklos Szeredi 19201da177e4SLinus Torvalds /* Apply the lock described by l to an open file descriptor. 19211da177e4SLinus Torvalds * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 19221da177e4SLinus Torvalds */ 1923c293621bSPeter Staubach int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, 1924c293621bSPeter Staubach struct flock __user *l) 19251da177e4SLinus Torvalds { 19261da177e4SLinus Torvalds struct file_lock *file_lock = locks_alloc_lock(); 19271da177e4SLinus Torvalds struct flock flock; 19281da177e4SLinus Torvalds struct inode *inode; 19290b2bac2fSAl Viro struct file *f; 19301da177e4SLinus Torvalds int error; 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvalds if (file_lock == NULL) 19331da177e4SLinus Torvalds return -ENOLCK; 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds /* 19361da177e4SLinus Torvalds * This might block, so we do it before checking the inode. 19371da177e4SLinus Torvalds */ 19381da177e4SLinus Torvalds error = -EFAULT; 19391da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 19401da177e4SLinus Torvalds goto out; 19411da177e4SLinus Torvalds 1942496ad9aaSAl Viro inode = file_inode(filp); 19431da177e4SLinus Torvalds 19441da177e4SLinus Torvalds /* Don't allow mandatory locks on files that may be memory mapped 19451da177e4SLinus Torvalds * and shared. 19461da177e4SLinus Torvalds */ 1947a16877caSPavel Emelyanov if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 19481da177e4SLinus Torvalds error = -EAGAIN; 19491da177e4SLinus Torvalds goto out; 19501da177e4SLinus Torvalds } 19511da177e4SLinus Torvalds 1952c293621bSPeter Staubach again: 19531da177e4SLinus Torvalds error = flock_to_posix_lock(filp, file_lock, &flock); 19541da177e4SLinus Torvalds if (error) 19551da177e4SLinus Torvalds goto out; 19561da177e4SLinus Torvalds if (cmd == F_SETLKW) { 19571da177e4SLinus Torvalds file_lock->fl_flags |= FL_SLEEP; 19581da177e4SLinus Torvalds } 19591da177e4SLinus Torvalds 19601da177e4SLinus Torvalds error = -EBADF; 19611da177e4SLinus Torvalds switch (flock.l_type) { 19621da177e4SLinus Torvalds case F_RDLCK: 19631da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_READ)) 19641da177e4SLinus Torvalds goto out; 19651da177e4SLinus Torvalds break; 19661da177e4SLinus Torvalds case F_WRLCK: 19671da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_WRITE)) 19681da177e4SLinus Torvalds goto out; 19691da177e4SLinus Torvalds break; 19701da177e4SLinus Torvalds case F_UNLCK: 19711da177e4SLinus Torvalds break; 19721da177e4SLinus Torvalds default: 19731da177e4SLinus Torvalds error = -EINVAL; 19741da177e4SLinus Torvalds goto out; 19751da177e4SLinus Torvalds } 19761da177e4SLinus Torvalds 1977b648a6deSMiklos Szeredi error = do_lock_file_wait(filp, cmd, file_lock); 1978c293621bSPeter Staubach 1979c293621bSPeter Staubach /* 1980c293621bSPeter Staubach * Attempt to detect a close/fcntl race and recover by 1981c293621bSPeter Staubach * releasing the lock that was just acquired. 1982c293621bSPeter Staubach */ 19830b2bac2fSAl Viro /* 19840b2bac2fSAl Viro * we need that spin_lock here - it prevents reordering between 19850b2bac2fSAl Viro * update of inode->i_flock and check for it done in close(). 19860b2bac2fSAl Viro * rcu_read_lock() wouldn't do. 19870b2bac2fSAl Viro */ 19880b2bac2fSAl Viro spin_lock(¤t->files->file_lock); 19890b2bac2fSAl Viro f = fcheck(fd); 19900b2bac2fSAl Viro spin_unlock(¤t->files->file_lock); 19910b2bac2fSAl Viro if (!error && f != filp && flock.l_type != F_UNLCK) { 1992c293621bSPeter Staubach flock.l_type = F_UNLCK; 1993c293621bSPeter Staubach goto again; 1994c293621bSPeter Staubach } 19951da177e4SLinus Torvalds 19961da177e4SLinus Torvalds out: 19971da177e4SLinus Torvalds locks_free_lock(file_lock); 19981da177e4SLinus Torvalds return error; 19991da177e4SLinus Torvalds } 20001da177e4SLinus Torvalds 20011da177e4SLinus Torvalds #if BITS_PER_LONG == 32 20021da177e4SLinus Torvalds /* Report the first existing lock that would conflict with l. 20031da177e4SLinus Torvalds * This implements the F_GETLK command of fcntl(). 20041da177e4SLinus Torvalds */ 20051da177e4SLinus Torvalds int fcntl_getlk64(struct file *filp, struct flock64 __user *l) 20061da177e4SLinus Torvalds { 20079d6a8c5cSMarc Eshel struct file_lock file_lock; 20081da177e4SLinus Torvalds struct flock64 flock; 20091da177e4SLinus Torvalds int error; 20101da177e4SLinus Torvalds 20111da177e4SLinus Torvalds error = -EFAULT; 20121da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 20131da177e4SLinus Torvalds goto out; 20141da177e4SLinus Torvalds error = -EINVAL; 20151da177e4SLinus Torvalds if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 20161da177e4SLinus Torvalds goto out; 20171da177e4SLinus Torvalds 20181da177e4SLinus Torvalds error = flock64_to_posix_lock(filp, &file_lock, &flock); 20191da177e4SLinus Torvalds if (error) 20201da177e4SLinus Torvalds goto out; 20211da177e4SLinus Torvalds 20223ee17abdSJ. Bruce Fields error = vfs_test_lock(filp, &file_lock); 20233ee17abdSJ. Bruce Fields if (error) 20241da177e4SLinus Torvalds goto out; 20251da177e4SLinus Torvalds 20269d6a8c5cSMarc Eshel flock.l_type = file_lock.fl_type; 20279d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) 20289d6a8c5cSMarc Eshel posix_lock_to_flock64(&flock, &file_lock); 20299d6a8c5cSMarc Eshel 20301da177e4SLinus Torvalds error = -EFAULT; 20311da177e4SLinus Torvalds if (!copy_to_user(l, &flock, sizeof(flock))) 20321da177e4SLinus Torvalds error = 0; 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds out: 20351da177e4SLinus Torvalds return error; 20361da177e4SLinus Torvalds } 20371da177e4SLinus Torvalds 20381da177e4SLinus Torvalds /* Apply the lock described by l to an open file descriptor. 20391da177e4SLinus Torvalds * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 20401da177e4SLinus Torvalds */ 2041c293621bSPeter Staubach int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, 2042c293621bSPeter Staubach struct flock64 __user *l) 20431da177e4SLinus Torvalds { 20441da177e4SLinus Torvalds struct file_lock *file_lock = locks_alloc_lock(); 20451da177e4SLinus Torvalds struct flock64 flock; 20461da177e4SLinus Torvalds struct inode *inode; 20470b2bac2fSAl Viro struct file *f; 20481da177e4SLinus Torvalds int error; 20491da177e4SLinus Torvalds 20501da177e4SLinus Torvalds if (file_lock == NULL) 20511da177e4SLinus Torvalds return -ENOLCK; 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds /* 20541da177e4SLinus Torvalds * This might block, so we do it before checking the inode. 20551da177e4SLinus Torvalds */ 20561da177e4SLinus Torvalds error = -EFAULT; 20571da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 20581da177e4SLinus Torvalds goto out; 20591da177e4SLinus Torvalds 2060496ad9aaSAl Viro inode = file_inode(filp); 20611da177e4SLinus Torvalds 20621da177e4SLinus Torvalds /* Don't allow mandatory locks on files that may be memory mapped 20631da177e4SLinus Torvalds * and shared. 20641da177e4SLinus Torvalds */ 2065a16877caSPavel Emelyanov if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 20661da177e4SLinus Torvalds error = -EAGAIN; 20671da177e4SLinus Torvalds goto out; 20681da177e4SLinus Torvalds } 20691da177e4SLinus Torvalds 2070c293621bSPeter Staubach again: 20711da177e4SLinus Torvalds error = flock64_to_posix_lock(filp, file_lock, &flock); 20721da177e4SLinus Torvalds if (error) 20731da177e4SLinus Torvalds goto out; 20741da177e4SLinus Torvalds if (cmd == F_SETLKW64) { 20751da177e4SLinus Torvalds file_lock->fl_flags |= FL_SLEEP; 20761da177e4SLinus Torvalds } 20771da177e4SLinus Torvalds 20781da177e4SLinus Torvalds error = -EBADF; 20791da177e4SLinus Torvalds switch (flock.l_type) { 20801da177e4SLinus Torvalds case F_RDLCK: 20811da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_READ)) 20821da177e4SLinus Torvalds goto out; 20831da177e4SLinus Torvalds break; 20841da177e4SLinus Torvalds case F_WRLCK: 20851da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_WRITE)) 20861da177e4SLinus Torvalds goto out; 20871da177e4SLinus Torvalds break; 20881da177e4SLinus Torvalds case F_UNLCK: 20891da177e4SLinus Torvalds break; 20901da177e4SLinus Torvalds default: 20911da177e4SLinus Torvalds error = -EINVAL; 20921da177e4SLinus Torvalds goto out; 20931da177e4SLinus Torvalds } 20941da177e4SLinus Torvalds 2095b648a6deSMiklos Szeredi error = do_lock_file_wait(filp, cmd, file_lock); 2096c293621bSPeter Staubach 2097c293621bSPeter Staubach /* 2098c293621bSPeter Staubach * Attempt to detect a close/fcntl race and recover by 2099c293621bSPeter Staubach * releasing the lock that was just acquired. 2100c293621bSPeter Staubach */ 21010b2bac2fSAl Viro spin_lock(¤t->files->file_lock); 21020b2bac2fSAl Viro f = fcheck(fd); 21030b2bac2fSAl Viro spin_unlock(¤t->files->file_lock); 21040b2bac2fSAl Viro if (!error && f != filp && flock.l_type != F_UNLCK) { 2105c293621bSPeter Staubach flock.l_type = F_UNLCK; 2106c293621bSPeter Staubach goto again; 2107c293621bSPeter Staubach } 21081da177e4SLinus Torvalds 21091da177e4SLinus Torvalds out: 21101da177e4SLinus Torvalds locks_free_lock(file_lock); 21111da177e4SLinus Torvalds return error; 21121da177e4SLinus Torvalds } 21131da177e4SLinus Torvalds #endif /* BITS_PER_LONG == 32 */ 21141da177e4SLinus Torvalds 21151da177e4SLinus Torvalds /* 21161da177e4SLinus Torvalds * This function is called when the file is being removed 21171da177e4SLinus Torvalds * from the task's fd array. POSIX locks belonging to this task 21181da177e4SLinus Torvalds * are deleted at this time. 21191da177e4SLinus Torvalds */ 21201da177e4SLinus Torvalds void locks_remove_posix(struct file *filp, fl_owner_t owner) 21211da177e4SLinus Torvalds { 2122ff7b86b8SMiklos Szeredi struct file_lock lock; 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds /* 21251da177e4SLinus Torvalds * If there are no locks held on this file, we don't need to call 21261da177e4SLinus Torvalds * posix_lock_file(). Another process could be setting a lock on this 21271da177e4SLinus Torvalds * file at the same time, but we wouldn't remove that lock anyway. 21281da177e4SLinus Torvalds */ 2129496ad9aaSAl Viro if (!file_inode(filp)->i_flock) 21301da177e4SLinus Torvalds return; 21311da177e4SLinus Torvalds 21321da177e4SLinus Torvalds lock.fl_type = F_UNLCK; 213375e1fcc0SMiklos Szeredi lock.fl_flags = FL_POSIX | FL_CLOSE; 21341da177e4SLinus Torvalds lock.fl_start = 0; 21351da177e4SLinus Torvalds lock.fl_end = OFFSET_MAX; 21361da177e4SLinus Torvalds lock.fl_owner = owner; 21371da177e4SLinus Torvalds lock.fl_pid = current->tgid; 21381da177e4SLinus Torvalds lock.fl_file = filp; 21391da177e4SLinus Torvalds lock.fl_ops = NULL; 21401da177e4SLinus Torvalds lock.fl_lmops = NULL; 21411da177e4SLinus Torvalds 2142150b3934SMarc Eshel vfs_lock_file(filp, F_SETLK, &lock, NULL); 21431da177e4SLinus Torvalds 21441da177e4SLinus Torvalds if (lock.fl_ops && lock.fl_ops->fl_release_private) 21451da177e4SLinus Torvalds lock.fl_ops->fl_release_private(&lock); 21461da177e4SLinus Torvalds } 21471da177e4SLinus Torvalds 21481da177e4SLinus Torvalds EXPORT_SYMBOL(locks_remove_posix); 21491da177e4SLinus Torvalds 21501da177e4SLinus Torvalds /* 21511da177e4SLinus Torvalds * This function is called on the last close of an open file. 21521da177e4SLinus Torvalds */ 21531da177e4SLinus Torvalds void locks_remove_flock(struct file *filp) 21541da177e4SLinus Torvalds { 2155496ad9aaSAl Viro struct inode * inode = file_inode(filp); 21561da177e4SLinus Torvalds struct file_lock *fl; 21571da177e4SLinus Torvalds struct file_lock **before; 21581da177e4SLinus Torvalds 21591da177e4SLinus Torvalds if (!inode->i_flock) 21601da177e4SLinus Torvalds return; 21611da177e4SLinus Torvalds 21621da177e4SLinus Torvalds if (filp->f_op && filp->f_op->flock) { 21631da177e4SLinus Torvalds struct file_lock fl = { 21641da177e4SLinus Torvalds .fl_pid = current->tgid, 21651da177e4SLinus Torvalds .fl_file = filp, 21661da177e4SLinus Torvalds .fl_flags = FL_FLOCK, 21671da177e4SLinus Torvalds .fl_type = F_UNLCK, 21681da177e4SLinus Torvalds .fl_end = OFFSET_MAX, 21691da177e4SLinus Torvalds }; 21701da177e4SLinus Torvalds filp->f_op->flock(filp, F_SETLKW, &fl); 217180fec4c6STrond Myklebust if (fl.fl_ops && fl.fl_ops->fl_release_private) 217280fec4c6STrond Myklebust fl.fl_ops->fl_release_private(&fl); 21731da177e4SLinus Torvalds } 21741da177e4SLinus Torvalds 21751c8c601aSJeff Layton spin_lock(&inode->i_lock); 21761da177e4SLinus Torvalds before = &inode->i_flock; 21771da177e4SLinus Torvalds 21781da177e4SLinus Torvalds while ((fl = *before) != NULL) { 21791da177e4SLinus Torvalds if (fl->fl_file == filp) { 2180c293621bSPeter Staubach if (IS_FLOCK(fl)) { 21811da177e4SLinus Torvalds locks_delete_lock(before); 21821da177e4SLinus Torvalds continue; 21831da177e4SLinus Torvalds } 21841da177e4SLinus Torvalds if (IS_LEASE(fl)) { 21851da177e4SLinus Torvalds lease_modify(before, F_UNLCK); 21861da177e4SLinus Torvalds continue; 21871da177e4SLinus Torvalds } 21881da177e4SLinus Torvalds /* What? */ 21891da177e4SLinus Torvalds BUG(); 21901da177e4SLinus Torvalds } 21911da177e4SLinus Torvalds before = &fl->fl_next; 21921da177e4SLinus Torvalds } 21931c8c601aSJeff Layton spin_unlock(&inode->i_lock); 21941da177e4SLinus Torvalds } 21951da177e4SLinus Torvalds 21961da177e4SLinus Torvalds /** 21971da177e4SLinus Torvalds * posix_unblock_lock - stop waiting for a file lock 21981da177e4SLinus Torvalds * @waiter: the lock which was waiting 21991da177e4SLinus Torvalds * 22001da177e4SLinus Torvalds * lockd needs to block waiting for locks. 22011da177e4SLinus Torvalds */ 220264a318eeSJ. Bruce Fields int 2203f891a29fSJeff Layton posix_unblock_lock(struct file_lock *waiter) 22041da177e4SLinus Torvalds { 220564a318eeSJ. Bruce Fields int status = 0; 220664a318eeSJ. Bruce Fields 22071c8c601aSJeff Layton spin_lock(&file_lock_lock); 22085996a298SJ. Bruce Fields if (waiter->fl_next) 22091da177e4SLinus Torvalds __locks_delete_block(waiter); 221064a318eeSJ. Bruce Fields else 221164a318eeSJ. Bruce Fields status = -ENOENT; 22121c8c601aSJeff Layton spin_unlock(&file_lock_lock); 221364a318eeSJ. Bruce Fields return status; 22141da177e4SLinus Torvalds } 22151da177e4SLinus Torvalds EXPORT_SYMBOL(posix_unblock_lock); 22161da177e4SLinus Torvalds 22179b9d2ab4SMarc Eshel /** 22189b9d2ab4SMarc Eshel * vfs_cancel_lock - file byte range unblock lock 22199b9d2ab4SMarc Eshel * @filp: The file to apply the unblock to 22209b9d2ab4SMarc Eshel * @fl: The lock to be unblocked 22219b9d2ab4SMarc Eshel * 22229b9d2ab4SMarc Eshel * Used by lock managers to cancel blocked requests 22239b9d2ab4SMarc Eshel */ 22249b9d2ab4SMarc Eshel int vfs_cancel_lock(struct file *filp, struct file_lock *fl) 22259b9d2ab4SMarc Eshel { 22269b9d2ab4SMarc Eshel if (filp->f_op && filp->f_op->lock) 22279b9d2ab4SMarc Eshel return filp->f_op->lock(filp, F_CANCELLK, fl); 22289b9d2ab4SMarc Eshel return 0; 22299b9d2ab4SMarc Eshel } 22309b9d2ab4SMarc Eshel 22319b9d2ab4SMarc Eshel EXPORT_SYMBOL_GPL(vfs_cancel_lock); 22329b9d2ab4SMarc Eshel 22337f8ada98SPavel Emelyanov #ifdef CONFIG_PROC_FS 2234d8ba7a36SAlexey Dobriyan #include <linux/proc_fs.h> 22357f8ada98SPavel Emelyanov #include <linux/seq_file.h> 22367f8ada98SPavel Emelyanov 22377f8ada98SPavel Emelyanov static void lock_get_status(struct seq_file *f, struct file_lock *fl, 223899dc8292SJerome Marchand loff_t id, char *pfx) 22391da177e4SLinus Torvalds { 22401da177e4SLinus Torvalds struct inode *inode = NULL; 2241ab1f1611SVitaliy Gusev unsigned int fl_pid; 2242ab1f1611SVitaliy Gusev 2243ab1f1611SVitaliy Gusev if (fl->fl_nspid) 22446c5f3e7bSPavel Emelyanov fl_pid = pid_vnr(fl->fl_nspid); 2245ab1f1611SVitaliy Gusev else 2246ab1f1611SVitaliy Gusev fl_pid = fl->fl_pid; 22471da177e4SLinus Torvalds 22481da177e4SLinus Torvalds if (fl->fl_file != NULL) 2249496ad9aaSAl Viro inode = file_inode(fl->fl_file); 22501da177e4SLinus Torvalds 225199dc8292SJerome Marchand seq_printf(f, "%lld:%s ", id, pfx); 22521da177e4SLinus Torvalds if (IS_POSIX(fl)) { 22537f8ada98SPavel Emelyanov seq_printf(f, "%6s %s ", 22541da177e4SLinus Torvalds (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ", 22551da177e4SLinus Torvalds (inode == NULL) ? "*NOINODE*" : 2256a16877caSPavel Emelyanov mandatory_lock(inode) ? "MANDATORY" : "ADVISORY "); 22571da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 22581da177e4SLinus Torvalds if (fl->fl_type & LOCK_MAND) { 22597f8ada98SPavel Emelyanov seq_printf(f, "FLOCK MSNFS "); 22601da177e4SLinus Torvalds } else { 22617f8ada98SPavel Emelyanov seq_printf(f, "FLOCK ADVISORY "); 22621da177e4SLinus Torvalds } 22631da177e4SLinus Torvalds } else if (IS_LEASE(fl)) { 22647f8ada98SPavel Emelyanov seq_printf(f, "LEASE "); 2265ab83fa4bSJ. Bruce Fields if (lease_breaking(fl)) 22667f8ada98SPavel Emelyanov seq_printf(f, "BREAKING "); 22671da177e4SLinus Torvalds else if (fl->fl_file) 22687f8ada98SPavel Emelyanov seq_printf(f, "ACTIVE "); 22691da177e4SLinus Torvalds else 22707f8ada98SPavel Emelyanov seq_printf(f, "BREAKER "); 22711da177e4SLinus Torvalds } else { 22727f8ada98SPavel Emelyanov seq_printf(f, "UNKNOWN UNKNOWN "); 22731da177e4SLinus Torvalds } 22741da177e4SLinus Torvalds if (fl->fl_type & LOCK_MAND) { 22757f8ada98SPavel Emelyanov seq_printf(f, "%s ", 22761da177e4SLinus Torvalds (fl->fl_type & LOCK_READ) 22771da177e4SLinus Torvalds ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ " 22781da177e4SLinus Torvalds : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE "); 22791da177e4SLinus Torvalds } else { 22807f8ada98SPavel Emelyanov seq_printf(f, "%s ", 2281ab83fa4bSJ. Bruce Fields (lease_breaking(fl)) 22820ee5c6d6SJeff Layton ? (fl->fl_type == F_UNLCK) ? "UNLCK" : "READ " 22830ee5c6d6SJeff Layton : (fl->fl_type == F_WRLCK) ? "WRITE" : "READ "); 22841da177e4SLinus Torvalds } 22851da177e4SLinus Torvalds if (inode) { 22861da177e4SLinus Torvalds #ifdef WE_CAN_BREAK_LSLK_NOW 2287ab1f1611SVitaliy Gusev seq_printf(f, "%d %s:%ld ", fl_pid, 22881da177e4SLinus Torvalds inode->i_sb->s_id, inode->i_ino); 22891da177e4SLinus Torvalds #else 22901da177e4SLinus Torvalds /* userspace relies on this representation of dev_t ;-( */ 2291ab1f1611SVitaliy Gusev seq_printf(f, "%d %02x:%02x:%ld ", fl_pid, 22921da177e4SLinus Torvalds MAJOR(inode->i_sb->s_dev), 22931da177e4SLinus Torvalds MINOR(inode->i_sb->s_dev), inode->i_ino); 22941da177e4SLinus Torvalds #endif 22951da177e4SLinus Torvalds } else { 2296ab1f1611SVitaliy Gusev seq_printf(f, "%d <none>:0 ", fl_pid); 22971da177e4SLinus Torvalds } 22981da177e4SLinus Torvalds if (IS_POSIX(fl)) { 22991da177e4SLinus Torvalds if (fl->fl_end == OFFSET_MAX) 23007f8ada98SPavel Emelyanov seq_printf(f, "%Ld EOF\n", fl->fl_start); 23011da177e4SLinus Torvalds else 23027f8ada98SPavel Emelyanov seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end); 23031da177e4SLinus Torvalds } else { 23047f8ada98SPavel Emelyanov seq_printf(f, "0 EOF\n"); 23051da177e4SLinus Torvalds } 23061da177e4SLinus Torvalds } 23071da177e4SLinus Torvalds 23087f8ada98SPavel Emelyanov static int locks_show(struct seq_file *f, void *v) 23091da177e4SLinus Torvalds { 23107f8ada98SPavel Emelyanov struct file_lock *fl, *bfl; 23117f8ada98SPavel Emelyanov 2312139ca04eSJeff Layton fl = hlist_entry(v, struct file_lock, fl_link); 23137f8ada98SPavel Emelyanov 231499dc8292SJerome Marchand lock_get_status(f, fl, *((loff_t *)f->private), ""); 23157f8ada98SPavel Emelyanov 23167f8ada98SPavel Emelyanov list_for_each_entry(bfl, &fl->fl_block, fl_block) 231799dc8292SJerome Marchand lock_get_status(f, bfl, *((loff_t *)f->private), " ->"); 23187f8ada98SPavel Emelyanov 23197f8ada98SPavel Emelyanov return 0; 23201da177e4SLinus Torvalds } 23211da177e4SLinus Torvalds 23227f8ada98SPavel Emelyanov static void *locks_start(struct seq_file *f, loff_t *pos) 23231da177e4SLinus Torvalds { 232499dc8292SJerome Marchand loff_t *p = f->private; 232599dc8292SJerome Marchand 23261c8c601aSJeff Layton spin_lock(&file_lock_lock); 232799dc8292SJerome Marchand *p = (*pos + 1); 2328139ca04eSJeff Layton return seq_hlist_start(&file_lock_list, *pos); 23291da177e4SLinus Torvalds } 23307f8ada98SPavel Emelyanov 23317f8ada98SPavel Emelyanov static void *locks_next(struct seq_file *f, void *v, loff_t *pos) 23327f8ada98SPavel Emelyanov { 233399dc8292SJerome Marchand loff_t *p = f->private; 233499dc8292SJerome Marchand ++*p; 2335139ca04eSJeff Layton return seq_hlist_next(v, &file_lock_list, pos); 23361da177e4SLinus Torvalds } 23377f8ada98SPavel Emelyanov 23387f8ada98SPavel Emelyanov static void locks_stop(struct seq_file *f, void *v) 23397f8ada98SPavel Emelyanov { 23401c8c601aSJeff Layton spin_unlock(&file_lock_lock); 23411da177e4SLinus Torvalds } 23421da177e4SLinus Torvalds 2343d8ba7a36SAlexey Dobriyan static const struct seq_operations locks_seq_operations = { 23447f8ada98SPavel Emelyanov .start = locks_start, 23457f8ada98SPavel Emelyanov .next = locks_next, 23467f8ada98SPavel Emelyanov .stop = locks_stop, 23477f8ada98SPavel Emelyanov .show = locks_show, 23487f8ada98SPavel Emelyanov }; 2349d8ba7a36SAlexey Dobriyan 2350d8ba7a36SAlexey Dobriyan static int locks_open(struct inode *inode, struct file *filp) 2351d8ba7a36SAlexey Dobriyan { 235299dc8292SJerome Marchand return seq_open_private(filp, &locks_seq_operations, sizeof(loff_t)); 2353d8ba7a36SAlexey Dobriyan } 2354d8ba7a36SAlexey Dobriyan 2355d8ba7a36SAlexey Dobriyan static const struct file_operations proc_locks_operations = { 2356d8ba7a36SAlexey Dobriyan .open = locks_open, 2357d8ba7a36SAlexey Dobriyan .read = seq_read, 2358d8ba7a36SAlexey Dobriyan .llseek = seq_lseek, 235999dc8292SJerome Marchand .release = seq_release_private, 2360d8ba7a36SAlexey Dobriyan }; 2361d8ba7a36SAlexey Dobriyan 2362d8ba7a36SAlexey Dobriyan static int __init proc_locks_init(void) 2363d8ba7a36SAlexey Dobriyan { 2364d8ba7a36SAlexey Dobriyan proc_create("locks", 0, NULL, &proc_locks_operations); 2365d8ba7a36SAlexey Dobriyan return 0; 2366d8ba7a36SAlexey Dobriyan } 2367d8ba7a36SAlexey Dobriyan module_init(proc_locks_init); 23687f8ada98SPavel Emelyanov #endif 23697f8ada98SPavel Emelyanov 23701da177e4SLinus Torvalds /** 23711da177e4SLinus Torvalds * lock_may_read - checks that the region is free of locks 23721da177e4SLinus Torvalds * @inode: the inode that is being read 23731da177e4SLinus Torvalds * @start: the first byte to read 23741da177e4SLinus Torvalds * @len: the number of bytes to read 23751da177e4SLinus Torvalds * 23761da177e4SLinus Torvalds * Emulates Windows locking requirements. Whole-file 23771da177e4SLinus Torvalds * mandatory locks (share modes) can prohibit a read and 23781da177e4SLinus Torvalds * byte-range POSIX locks can prohibit a read if they overlap. 23791da177e4SLinus Torvalds * 23801da177e4SLinus Torvalds * N.B. this function is only ever called 23811da177e4SLinus Torvalds * from knfsd and ownership of locks is never checked. 23821da177e4SLinus Torvalds */ 23831da177e4SLinus Torvalds int lock_may_read(struct inode *inode, loff_t start, unsigned long len) 23841da177e4SLinus Torvalds { 23851da177e4SLinus Torvalds struct file_lock *fl; 23861da177e4SLinus Torvalds int result = 1; 23871c8c601aSJeff Layton 23881c8c601aSJeff Layton spin_lock(&inode->i_lock); 23891da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 23901da177e4SLinus Torvalds if (IS_POSIX(fl)) { 23911da177e4SLinus Torvalds if (fl->fl_type == F_RDLCK) 23921da177e4SLinus Torvalds continue; 23931da177e4SLinus Torvalds if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 23941da177e4SLinus Torvalds continue; 23951da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 23961da177e4SLinus Torvalds if (!(fl->fl_type & LOCK_MAND)) 23971da177e4SLinus Torvalds continue; 23981da177e4SLinus Torvalds if (fl->fl_type & LOCK_READ) 23991da177e4SLinus Torvalds continue; 24001da177e4SLinus Torvalds } else 24011da177e4SLinus Torvalds continue; 24021da177e4SLinus Torvalds result = 0; 24031da177e4SLinus Torvalds break; 24041da177e4SLinus Torvalds } 24051c8c601aSJeff Layton spin_unlock(&inode->i_lock); 24061da177e4SLinus Torvalds return result; 24071da177e4SLinus Torvalds } 24081da177e4SLinus Torvalds 24091da177e4SLinus Torvalds EXPORT_SYMBOL(lock_may_read); 24101da177e4SLinus Torvalds 24111da177e4SLinus Torvalds /** 24121da177e4SLinus Torvalds * lock_may_write - checks that the region is free of locks 24131da177e4SLinus Torvalds * @inode: the inode that is being written 24141da177e4SLinus Torvalds * @start: the first byte to write 24151da177e4SLinus Torvalds * @len: the number of bytes to write 24161da177e4SLinus Torvalds * 24171da177e4SLinus Torvalds * Emulates Windows locking requirements. Whole-file 24181da177e4SLinus Torvalds * mandatory locks (share modes) can prohibit a write and 24191da177e4SLinus Torvalds * byte-range POSIX locks can prohibit a write if they overlap. 24201da177e4SLinus Torvalds * 24211da177e4SLinus Torvalds * N.B. this function is only ever called 24221da177e4SLinus Torvalds * from knfsd and ownership of locks is never checked. 24231da177e4SLinus Torvalds */ 24241da177e4SLinus Torvalds int lock_may_write(struct inode *inode, loff_t start, unsigned long len) 24251da177e4SLinus Torvalds { 24261da177e4SLinus Torvalds struct file_lock *fl; 24271da177e4SLinus Torvalds int result = 1; 24281c8c601aSJeff Layton 24291c8c601aSJeff Layton spin_lock(&inode->i_lock); 24301da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 24311da177e4SLinus Torvalds if (IS_POSIX(fl)) { 24321da177e4SLinus Torvalds if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 24331da177e4SLinus Torvalds continue; 24341da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 24351da177e4SLinus Torvalds if (!(fl->fl_type & LOCK_MAND)) 24361da177e4SLinus Torvalds continue; 24371da177e4SLinus Torvalds if (fl->fl_type & LOCK_WRITE) 24381da177e4SLinus Torvalds continue; 24391da177e4SLinus Torvalds } else 24401da177e4SLinus Torvalds continue; 24411da177e4SLinus Torvalds result = 0; 24421da177e4SLinus Torvalds break; 24431da177e4SLinus Torvalds } 24441c8c601aSJeff Layton spin_unlock(&inode->i_lock); 24451da177e4SLinus Torvalds return result; 24461da177e4SLinus Torvalds } 24471da177e4SLinus Torvalds 24481da177e4SLinus Torvalds EXPORT_SYMBOL(lock_may_write); 24491da177e4SLinus Torvalds 24501da177e4SLinus Torvalds static int __init filelock_init(void) 24511da177e4SLinus Torvalds { 24521da177e4SLinus Torvalds filelock_cache = kmem_cache_create("file_lock_cache", 2453ee19cc40SMiklos Szeredi sizeof(struct file_lock), 0, SLAB_PANIC, NULL); 2454ee19cc40SMiklos Szeredi 24551da177e4SLinus Torvalds return 0; 24561da177e4SLinus Torvalds } 24571da177e4SLinus Torvalds 24581da177e4SLinus Torvalds core_initcall(filelock_init); 2459