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> 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds #include <asm/uaccess.h> 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds #define IS_POSIX(fl) (fl->fl_flags & FL_POSIX) 1331da177e4SLinus Torvalds #define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK) 1341da177e4SLinus Torvalds #define IS_LEASE(fl) (fl->fl_flags & FL_LEASE) 1351da177e4SLinus Torvalds 136ab83fa4bSJ. Bruce Fields static bool lease_breaking(struct file_lock *fl) 137ab83fa4bSJ. Bruce Fields { 138778fc546SJ. Bruce Fields return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING); 139778fc546SJ. Bruce Fields } 140778fc546SJ. Bruce Fields 141778fc546SJ. Bruce Fields static int target_leasetype(struct file_lock *fl) 142778fc546SJ. Bruce Fields { 143778fc546SJ. Bruce Fields if (fl->fl_flags & FL_UNLOCK_PENDING) 144778fc546SJ. Bruce Fields return F_UNLCK; 145778fc546SJ. Bruce Fields if (fl->fl_flags & FL_DOWNGRADE_PENDING) 146778fc546SJ. Bruce Fields return F_RDLCK; 147778fc546SJ. Bruce Fields return fl->fl_type; 148ab83fa4bSJ. Bruce Fields } 149ab83fa4bSJ. Bruce Fields 1501da177e4SLinus Torvalds int leases_enable = 1; 1511da177e4SLinus Torvalds int lease_break_time = 45; 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds #define for_each_lock(inode, lockp) \ 1541da177e4SLinus Torvalds for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next) 1551da177e4SLinus Torvalds 15626bcbf96SChristoph Hellwig static LIST_HEAD(file_lock_list); 1571da177e4SLinus Torvalds static LIST_HEAD(blocked_list); 15872f98e72SArnd Bergmann static DEFINE_SPINLOCK(file_lock_lock); 1591da177e4SLinus Torvalds 160b89f4321SArnd Bergmann /* 161b89f4321SArnd Bergmann * Protects the two list heads above, plus the inode->i_flock list 162b89f4321SArnd Bergmann */ 163b89f4321SArnd Bergmann void lock_flocks(void) 164b89f4321SArnd Bergmann { 16572f98e72SArnd Bergmann spin_lock(&file_lock_lock); 166b89f4321SArnd Bergmann } 167b89f4321SArnd Bergmann EXPORT_SYMBOL_GPL(lock_flocks); 168b89f4321SArnd Bergmann 169b89f4321SArnd Bergmann void unlock_flocks(void) 170b89f4321SArnd Bergmann { 17172f98e72SArnd Bergmann spin_unlock(&file_lock_lock); 172b89f4321SArnd Bergmann } 173b89f4321SArnd Bergmann EXPORT_SYMBOL_GPL(unlock_flocks); 174b89f4321SArnd Bergmann 175e18b890bSChristoph Lameter static struct kmem_cache *filelock_cache __read_mostly; 1761da177e4SLinus Torvalds 177ee19cc40SMiklos Szeredi static void locks_init_lock_heads(struct file_lock *fl) 178a51cb91dSMiklos Szeredi { 179ee19cc40SMiklos Szeredi INIT_LIST_HEAD(&fl->fl_link); 180ee19cc40SMiklos Szeredi INIT_LIST_HEAD(&fl->fl_block); 181ee19cc40SMiklos Szeredi init_waitqueue_head(&fl->fl_wait); 182a51cb91dSMiklos Szeredi } 183a51cb91dSMiklos Szeredi 1841da177e4SLinus Torvalds /* Allocate an empty lock structure. */ 185c5b1f0d9SArnd Bergmann struct file_lock *locks_alloc_lock(void) 1861da177e4SLinus Torvalds { 187ee19cc40SMiklos Szeredi struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL); 188a51cb91dSMiklos Szeredi 189a51cb91dSMiklos Szeredi if (fl) 190ee19cc40SMiklos Szeredi locks_init_lock_heads(fl); 191a51cb91dSMiklos Szeredi 192a51cb91dSMiklos Szeredi return fl; 1931da177e4SLinus Torvalds } 194c5b1f0d9SArnd Bergmann EXPORT_SYMBOL_GPL(locks_alloc_lock); 1951da177e4SLinus Torvalds 196a9e61e25SFelix Blyakher void locks_release_private(struct file_lock *fl) 19747831f35STrond Myklebust { 19847831f35STrond Myklebust if (fl->fl_ops) { 19947831f35STrond Myklebust if (fl->fl_ops->fl_release_private) 20047831f35STrond Myklebust fl->fl_ops->fl_release_private(fl); 20147831f35STrond Myklebust fl->fl_ops = NULL; 20247831f35STrond Myklebust } 20347831f35STrond Myklebust if (fl->fl_lmops) { 2048fb47a4fSJ. Bruce Fields if (fl->fl_lmops->lm_release_private) 2058fb47a4fSJ. Bruce Fields fl->fl_lmops->lm_release_private(fl); 20647831f35STrond Myklebust fl->fl_lmops = NULL; 20747831f35STrond Myklebust } 20847831f35STrond Myklebust 20947831f35STrond Myklebust } 210a9e61e25SFelix Blyakher EXPORT_SYMBOL_GPL(locks_release_private); 21147831f35STrond Myklebust 2121da177e4SLinus Torvalds /* Free a lock which is not in use. */ 21305fa3135SJ. Bruce Fields void locks_free_lock(struct file_lock *fl) 2141da177e4SLinus Torvalds { 2155ce29646SMiklos Szeredi BUG_ON(waitqueue_active(&fl->fl_wait)); 2165ce29646SMiklos Szeredi BUG_ON(!list_empty(&fl->fl_block)); 2175ce29646SMiklos Szeredi BUG_ON(!list_empty(&fl->fl_link)); 2181da177e4SLinus Torvalds 21947831f35STrond Myklebust locks_release_private(fl); 2201da177e4SLinus Torvalds kmem_cache_free(filelock_cache, fl); 2211da177e4SLinus Torvalds } 22205fa3135SJ. Bruce Fields EXPORT_SYMBOL(locks_free_lock); 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds void locks_init_lock(struct file_lock *fl) 2251da177e4SLinus Torvalds { 226ee19cc40SMiklos Szeredi memset(fl, 0, sizeof(struct file_lock)); 227ee19cc40SMiklos Szeredi locks_init_lock_heads(fl); 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds EXPORT_SYMBOL(locks_init_lock); 2311da177e4SLinus Torvalds 23247831f35STrond Myklebust static void locks_copy_private(struct file_lock *new, struct file_lock *fl) 23347831f35STrond Myklebust { 23447831f35STrond Myklebust if (fl->fl_ops) { 23547831f35STrond Myklebust if (fl->fl_ops->fl_copy_lock) 23647831f35STrond Myklebust fl->fl_ops->fl_copy_lock(new, fl); 23747831f35STrond Myklebust new->fl_ops = fl->fl_ops; 23847831f35STrond Myklebust } 239bb8430a2SChristoph Hellwig if (fl->fl_lmops) 24047831f35STrond Myklebust new->fl_lmops = fl->fl_lmops; 24147831f35STrond Myklebust } 24247831f35STrond Myklebust 2431da177e4SLinus Torvalds /* 2441da177e4SLinus Torvalds * Initialize a new lock from an existing file_lock structure. 2451da177e4SLinus Torvalds */ 2461a747ee0SJ. Bruce Fields void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl) 2471da177e4SLinus Torvalds { 2481da177e4SLinus Torvalds new->fl_owner = fl->fl_owner; 2491da177e4SLinus Torvalds new->fl_pid = fl->fl_pid; 2500996905fSTrond Myklebust new->fl_file = NULL; 2511da177e4SLinus Torvalds new->fl_flags = fl->fl_flags; 2521da177e4SLinus Torvalds new->fl_type = fl->fl_type; 2531da177e4SLinus Torvalds new->fl_start = fl->fl_start; 2541da177e4SLinus Torvalds new->fl_end = fl->fl_end; 2550996905fSTrond Myklebust new->fl_ops = NULL; 2560996905fSTrond Myklebust new->fl_lmops = NULL; 2570996905fSTrond Myklebust } 2583dd7b71cSRoland Dreier EXPORT_SYMBOL(__locks_copy_lock); 2590996905fSTrond Myklebust 2600996905fSTrond Myklebust void locks_copy_lock(struct file_lock *new, struct file_lock *fl) 2610996905fSTrond Myklebust { 2620996905fSTrond Myklebust locks_release_private(new); 2630996905fSTrond Myklebust 2640996905fSTrond Myklebust __locks_copy_lock(new, fl); 2650996905fSTrond Myklebust new->fl_file = fl->fl_file; 2661da177e4SLinus Torvalds new->fl_ops = fl->fl_ops; 2671da177e4SLinus Torvalds new->fl_lmops = fl->fl_lmops; 26847831f35STrond Myklebust 26947831f35STrond Myklebust locks_copy_private(new, fl); 2701da177e4SLinus Torvalds } 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds EXPORT_SYMBOL(locks_copy_lock); 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds static inline int flock_translate_cmd(int cmd) { 2751da177e4SLinus Torvalds if (cmd & LOCK_MAND) 2761da177e4SLinus Torvalds return cmd & (LOCK_MAND | LOCK_RW); 2771da177e4SLinus Torvalds switch (cmd) { 2781da177e4SLinus Torvalds case LOCK_SH: 2791da177e4SLinus Torvalds return F_RDLCK; 2801da177e4SLinus Torvalds case LOCK_EX: 2811da177e4SLinus Torvalds return F_WRLCK; 2821da177e4SLinus Torvalds case LOCK_UN: 2831da177e4SLinus Torvalds return F_UNLCK; 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds return -EINVAL; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds /* Fill in a file_lock structure with an appropriate FLOCK lock. */ 2891da177e4SLinus Torvalds static int flock_make_lock(struct file *filp, struct file_lock **lock, 2901da177e4SLinus Torvalds unsigned int cmd) 2911da177e4SLinus Torvalds { 2921da177e4SLinus Torvalds struct file_lock *fl; 2931da177e4SLinus Torvalds int type = flock_translate_cmd(cmd); 2941da177e4SLinus Torvalds if (type < 0) 2951da177e4SLinus Torvalds return type; 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds fl = locks_alloc_lock(); 2981da177e4SLinus Torvalds if (fl == NULL) 2991da177e4SLinus Torvalds return -ENOMEM; 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds fl->fl_file = filp; 3021da177e4SLinus Torvalds fl->fl_pid = current->tgid; 3031da177e4SLinus Torvalds fl->fl_flags = FL_FLOCK; 3041da177e4SLinus Torvalds fl->fl_type = type; 3051da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds *lock = fl; 3081da177e4SLinus Torvalds return 0; 3091da177e4SLinus Torvalds } 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds static int assign_type(struct file_lock *fl, int type) 3121da177e4SLinus Torvalds { 3131da177e4SLinus Torvalds switch (type) { 3141da177e4SLinus Torvalds case F_RDLCK: 3151da177e4SLinus Torvalds case F_WRLCK: 3161da177e4SLinus Torvalds case F_UNLCK: 3171da177e4SLinus Torvalds fl->fl_type = type; 3181da177e4SLinus Torvalds break; 3191da177e4SLinus Torvalds default: 3201da177e4SLinus Torvalds return -EINVAL; 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds return 0; 3231da177e4SLinus Torvalds } 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX 3261da177e4SLinus Torvalds * style lock. 3271da177e4SLinus Torvalds */ 3281da177e4SLinus Torvalds static int flock_to_posix_lock(struct file *filp, struct file_lock *fl, 3291da177e4SLinus Torvalds struct flock *l) 3301da177e4SLinus Torvalds { 3311da177e4SLinus Torvalds off_t start, end; 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds switch (l->l_whence) { 334f5579f8cSJosef 'Jeff' Sipek case SEEK_SET: 3351da177e4SLinus Torvalds start = 0; 3361da177e4SLinus Torvalds break; 337f5579f8cSJosef 'Jeff' Sipek case SEEK_CUR: 3381da177e4SLinus Torvalds start = filp->f_pos; 3391da177e4SLinus Torvalds break; 340f5579f8cSJosef 'Jeff' Sipek case SEEK_END: 3410f7fc9e4SJosef "Jeff" Sipek start = i_size_read(filp->f_path.dentry->d_inode); 3421da177e4SLinus Torvalds break; 3431da177e4SLinus Torvalds default: 3441da177e4SLinus Torvalds return -EINVAL; 3451da177e4SLinus Torvalds } 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds /* POSIX-1996 leaves the case l->l_len < 0 undefined; 3481da177e4SLinus Torvalds POSIX-2001 defines it. */ 3491da177e4SLinus Torvalds start += l->l_start; 3501da177e4SLinus Torvalds if (start < 0) 3511da177e4SLinus Torvalds return -EINVAL; 3521da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 3534c780a46STrond Myklebust if (l->l_len > 0) { 3544c780a46STrond Myklebust end = start + l->l_len - 1; 3554c780a46STrond Myklebust fl->fl_end = end; 3564c780a46STrond Myklebust } else if (l->l_len < 0) { 3574c780a46STrond Myklebust end = start - 1; 3584c780a46STrond Myklebust fl->fl_end = end; 3594c780a46STrond Myklebust start += l->l_len; 3604c780a46STrond Myklebust if (start < 0) 3614c780a46STrond Myklebust return -EINVAL; 3624c780a46STrond Myklebust } 3634c780a46STrond Myklebust fl->fl_start = start; /* we record the absolute position */ 3644c780a46STrond Myklebust if (fl->fl_end < fl->fl_start) 3654c780a46STrond Myklebust return -EOVERFLOW; 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds fl->fl_owner = current->files; 3681da177e4SLinus Torvalds fl->fl_pid = current->tgid; 3691da177e4SLinus Torvalds fl->fl_file = filp; 3701da177e4SLinus Torvalds fl->fl_flags = FL_POSIX; 3711da177e4SLinus Torvalds fl->fl_ops = NULL; 3721da177e4SLinus Torvalds fl->fl_lmops = NULL; 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds return assign_type(fl, l->l_type); 3751da177e4SLinus Torvalds } 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds #if BITS_PER_LONG == 32 3781da177e4SLinus Torvalds static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, 3791da177e4SLinus Torvalds struct flock64 *l) 3801da177e4SLinus Torvalds { 3811da177e4SLinus Torvalds loff_t start; 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds switch (l->l_whence) { 384f5579f8cSJosef 'Jeff' Sipek case SEEK_SET: 3851da177e4SLinus Torvalds start = 0; 3861da177e4SLinus Torvalds break; 387f5579f8cSJosef 'Jeff' Sipek case SEEK_CUR: 3881da177e4SLinus Torvalds start = filp->f_pos; 3891da177e4SLinus Torvalds break; 390f5579f8cSJosef 'Jeff' Sipek case SEEK_END: 3910f7fc9e4SJosef "Jeff" Sipek start = i_size_read(filp->f_path.dentry->d_inode); 3921da177e4SLinus Torvalds break; 3931da177e4SLinus Torvalds default: 3941da177e4SLinus Torvalds return -EINVAL; 3951da177e4SLinus Torvalds } 3961da177e4SLinus Torvalds 3974c780a46STrond Myklebust start += l->l_start; 3984c780a46STrond Myklebust if (start < 0) 3991da177e4SLinus Torvalds return -EINVAL; 4001da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 4014c780a46STrond Myklebust if (l->l_len > 0) { 4024c780a46STrond Myklebust fl->fl_end = start + l->l_len - 1; 4034c780a46STrond Myklebust } else if (l->l_len < 0) { 4044c780a46STrond Myklebust fl->fl_end = start - 1; 4054c780a46STrond Myklebust start += l->l_len; 4064c780a46STrond Myklebust if (start < 0) 4074c780a46STrond Myklebust return -EINVAL; 4084c780a46STrond Myklebust } 4094c780a46STrond Myklebust fl->fl_start = start; /* we record the absolute position */ 4104c780a46STrond Myklebust if (fl->fl_end < fl->fl_start) 4114c780a46STrond Myklebust return -EOVERFLOW; 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds fl->fl_owner = current->files; 4141da177e4SLinus Torvalds fl->fl_pid = current->tgid; 4151da177e4SLinus Torvalds fl->fl_file = filp; 4161da177e4SLinus Torvalds fl->fl_flags = FL_POSIX; 4171da177e4SLinus Torvalds fl->fl_ops = NULL; 4181da177e4SLinus Torvalds fl->fl_lmops = NULL; 4191da177e4SLinus Torvalds 420f32cb532SNamhyung Kim return assign_type(fl, l->l_type); 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds #endif 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds /* default lease lock manager operations */ 4251da177e4SLinus Torvalds static void lease_break_callback(struct file_lock *fl) 4261da177e4SLinus Torvalds { 4271da177e4SLinus Torvalds kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG); 4281da177e4SLinus Torvalds } 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds static void lease_release_private_callback(struct file_lock *fl) 4311da177e4SLinus Torvalds { 4321da177e4SLinus Torvalds if (!fl->fl_file) 4331da177e4SLinus Torvalds return; 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds f_delown(fl->fl_file); 4361da177e4SLinus Torvalds fl->fl_file->f_owner.signum = 0; 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds 4397b021967SAlexey Dobriyan static const struct lock_manager_operations lease_manager_ops = { 4408fb47a4fSJ. Bruce Fields .lm_break = lease_break_callback, 4418fb47a4fSJ. Bruce Fields .lm_release_private = lease_release_private_callback, 4428fb47a4fSJ. Bruce Fields .lm_change = lease_modify, 4431da177e4SLinus Torvalds }; 4441da177e4SLinus Torvalds 4451da177e4SLinus Torvalds /* 4461da177e4SLinus Torvalds * Initialize a lease, use the default lock manager operations 4471da177e4SLinus Torvalds */ 4481da177e4SLinus Torvalds static int lease_init(struct file *filp, int type, struct file_lock *fl) 4491da177e4SLinus Torvalds { 45075dff55aSTrond Myklebust if (assign_type(fl, type) != 0) 45175dff55aSTrond Myklebust return -EINVAL; 45275dff55aSTrond Myklebust 4531da177e4SLinus Torvalds fl->fl_owner = current->files; 4541da177e4SLinus Torvalds fl->fl_pid = current->tgid; 4551da177e4SLinus Torvalds 4561da177e4SLinus Torvalds fl->fl_file = filp; 4571da177e4SLinus Torvalds fl->fl_flags = FL_LEASE; 4581da177e4SLinus Torvalds fl->fl_start = 0; 4591da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 4601da177e4SLinus Torvalds fl->fl_ops = NULL; 4611da177e4SLinus Torvalds fl->fl_lmops = &lease_manager_ops; 4621da177e4SLinus Torvalds return 0; 4631da177e4SLinus Torvalds } 4641da177e4SLinus Torvalds 4651da177e4SLinus Torvalds /* Allocate a file_lock initialised to this type of lease */ 466e32b8ee2SJ. Bruce Fields static struct file_lock *lease_alloc(struct file *filp, int type) 4671da177e4SLinus Torvalds { 4681da177e4SLinus Torvalds struct file_lock *fl = locks_alloc_lock(); 46975dff55aSTrond Myklebust int error = -ENOMEM; 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds if (fl == NULL) 472e32b8ee2SJ. Bruce Fields return ERR_PTR(error); 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds error = lease_init(filp, type, fl); 47575dff55aSTrond Myklebust if (error) { 47675dff55aSTrond Myklebust locks_free_lock(fl); 477e32b8ee2SJ. Bruce Fields return ERR_PTR(error); 47875dff55aSTrond Myklebust } 479e32b8ee2SJ. Bruce Fields return fl; 4801da177e4SLinus Torvalds } 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds /* Check if two locks overlap each other. 4831da177e4SLinus Torvalds */ 4841da177e4SLinus Torvalds static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) 4851da177e4SLinus Torvalds { 4861da177e4SLinus Torvalds return ((fl1->fl_end >= fl2->fl_start) && 4871da177e4SLinus Torvalds (fl2->fl_end >= fl1->fl_start)); 4881da177e4SLinus Torvalds } 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds /* 4911da177e4SLinus Torvalds * Check whether two locks have the same owner. 4921da177e4SLinus Torvalds */ 49333443c42SMatt Mackall static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2) 4941da177e4SLinus Torvalds { 4958fb47a4fSJ. Bruce Fields if (fl1->fl_lmops && fl1->fl_lmops->lm_compare_owner) 4961da177e4SLinus Torvalds return fl2->fl_lmops == fl1->fl_lmops && 4978fb47a4fSJ. Bruce Fields fl1->fl_lmops->lm_compare_owner(fl1, fl2); 4981da177e4SLinus Torvalds return fl1->fl_owner == fl2->fl_owner; 4991da177e4SLinus Torvalds } 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds /* Remove waiter from blocker's block list. 5021da177e4SLinus Torvalds * When blocker ends up pointing to itself then the list is empty. 5031da177e4SLinus Torvalds */ 50433443c42SMatt Mackall static void __locks_delete_block(struct file_lock *waiter) 5051da177e4SLinus Torvalds { 5061da177e4SLinus Torvalds list_del_init(&waiter->fl_block); 5071da177e4SLinus Torvalds list_del_init(&waiter->fl_link); 5081da177e4SLinus Torvalds waiter->fl_next = NULL; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds /* 5121da177e4SLinus Torvalds */ 5131da177e4SLinus Torvalds static void locks_delete_block(struct file_lock *waiter) 5141da177e4SLinus Torvalds { 515b89f4321SArnd Bergmann lock_flocks(); 5161da177e4SLinus Torvalds __locks_delete_block(waiter); 517b89f4321SArnd Bergmann unlock_flocks(); 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds /* Insert waiter into blocker's block list. 5211da177e4SLinus Torvalds * We use a circular list so that processes can be easily woken up in 5221da177e4SLinus Torvalds * the order they blocked. The documentation doesn't require this but 5231da177e4SLinus Torvalds * it seems like the reasonable thing to do. 5241da177e4SLinus Torvalds */ 5251da177e4SLinus Torvalds static void locks_insert_block(struct file_lock *blocker, 5261da177e4SLinus Torvalds struct file_lock *waiter) 5271da177e4SLinus Torvalds { 5286dc0fe8fSJ. Bruce Fields BUG_ON(!list_empty(&waiter->fl_block)); 5291da177e4SLinus Torvalds list_add_tail(&waiter->fl_block, &blocker->fl_block); 5301da177e4SLinus Torvalds waiter->fl_next = blocker; 5311da177e4SLinus Torvalds if (IS_POSIX(blocker)) 5321da177e4SLinus Torvalds list_add(&waiter->fl_link, &blocked_list); 5331da177e4SLinus Torvalds } 5341da177e4SLinus Torvalds 5351da177e4SLinus Torvalds /* Wake up processes blocked waiting for blocker. 5361da177e4SLinus Torvalds * If told to wait then schedule the processes until the block list 5371da177e4SLinus Torvalds * is empty, otherwise empty the block list ourselves. 5381da177e4SLinus Torvalds */ 5391da177e4SLinus Torvalds static void locks_wake_up_blocks(struct file_lock *blocker) 5401da177e4SLinus Torvalds { 5411da177e4SLinus Torvalds while (!list_empty(&blocker->fl_block)) { 542f0c1cd0eSPavel Emelyanov struct file_lock *waiter; 543f0c1cd0eSPavel Emelyanov 544f0c1cd0eSPavel Emelyanov waiter = list_first_entry(&blocker->fl_block, 5451da177e4SLinus Torvalds struct file_lock, fl_block); 5461da177e4SLinus Torvalds __locks_delete_block(waiter); 5478fb47a4fSJ. Bruce Fields if (waiter->fl_lmops && waiter->fl_lmops->lm_notify) 5488fb47a4fSJ. Bruce Fields waiter->fl_lmops->lm_notify(waiter); 5491da177e4SLinus Torvalds else 5501da177e4SLinus Torvalds wake_up(&waiter->fl_wait); 5511da177e4SLinus Torvalds } 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds /* Insert file lock fl into an inode's lock list at the position indicated 5551da177e4SLinus Torvalds * by pos. At the same time add the lock to the global file lock list. 5561da177e4SLinus Torvalds */ 5571da177e4SLinus Torvalds static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl) 5581da177e4SLinus Torvalds { 5591da177e4SLinus Torvalds list_add(&fl->fl_link, &file_lock_list); 5601da177e4SLinus Torvalds 561ab1f1611SVitaliy Gusev fl->fl_nspid = get_pid(task_tgid(current)); 562ab1f1611SVitaliy Gusev 5631da177e4SLinus Torvalds /* insert into file's list */ 5641da177e4SLinus Torvalds fl->fl_next = *pos; 5651da177e4SLinus Torvalds *pos = fl; 5661da177e4SLinus Torvalds } 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds /* 5691da177e4SLinus Torvalds * Delete a lock and then free it. 5701da177e4SLinus Torvalds * Wake up processes that are blocked waiting for this lock, 5711da177e4SLinus Torvalds * notify the FS that the lock has been cleared and 5721da177e4SLinus Torvalds * finally free the lock. 5731da177e4SLinus Torvalds */ 5741da177e4SLinus Torvalds static void locks_delete_lock(struct file_lock **thisfl_p) 5751da177e4SLinus Torvalds { 5761da177e4SLinus Torvalds struct file_lock *fl = *thisfl_p; 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds *thisfl_p = fl->fl_next; 5791da177e4SLinus Torvalds fl->fl_next = NULL; 5801da177e4SLinus Torvalds list_del_init(&fl->fl_link); 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); 5831da177e4SLinus Torvalds if (fl->fl_fasync != NULL) { 5841da177e4SLinus Torvalds printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync); 5851da177e4SLinus Torvalds fl->fl_fasync = NULL; 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds 588ab1f1611SVitaliy Gusev if (fl->fl_nspid) { 589ab1f1611SVitaliy Gusev put_pid(fl->fl_nspid); 590ab1f1611SVitaliy Gusev fl->fl_nspid = NULL; 591ab1f1611SVitaliy Gusev } 592ab1f1611SVitaliy Gusev 5931da177e4SLinus Torvalds locks_wake_up_blocks(fl); 5941da177e4SLinus Torvalds locks_free_lock(fl); 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. Common functionality 5981da177e4SLinus Torvalds * checks for shared/exclusive status of overlapping locks. 5991da177e4SLinus Torvalds */ 6001da177e4SLinus Torvalds static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6011da177e4SLinus Torvalds { 6021da177e4SLinus Torvalds if (sys_fl->fl_type == F_WRLCK) 6031da177e4SLinus Torvalds return 1; 6041da177e4SLinus Torvalds if (caller_fl->fl_type == F_WRLCK) 6051da177e4SLinus Torvalds return 1; 6061da177e4SLinus Torvalds return 0; 6071da177e4SLinus Torvalds } 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific 6101da177e4SLinus Torvalds * checking before calling the locks_conflict(). 6111da177e4SLinus Torvalds */ 6121da177e4SLinus Torvalds static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6131da177e4SLinus Torvalds { 6141da177e4SLinus Torvalds /* POSIX locks owned by the same process do not conflict with 6151da177e4SLinus Torvalds * each other. 6161da177e4SLinus Torvalds */ 6171da177e4SLinus Torvalds if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl)) 6181da177e4SLinus Torvalds return (0); 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds /* Check whether they overlap */ 6211da177e4SLinus Torvalds if (!locks_overlap(caller_fl, sys_fl)) 6221da177e4SLinus Torvalds return 0; 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds return (locks_conflict(caller_fl, sys_fl)); 6251da177e4SLinus Torvalds } 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific 6281da177e4SLinus Torvalds * checking before calling the locks_conflict(). 6291da177e4SLinus Torvalds */ 6301da177e4SLinus Torvalds static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6311da177e4SLinus Torvalds { 6321da177e4SLinus Torvalds /* FLOCK locks referring to the same filp do not conflict with 6331da177e4SLinus Torvalds * each other. 6341da177e4SLinus Torvalds */ 6351da177e4SLinus Torvalds if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file)) 6361da177e4SLinus Torvalds return (0); 6371da177e4SLinus Torvalds if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND)) 6381da177e4SLinus Torvalds return 0; 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds return (locks_conflict(caller_fl, sys_fl)); 6411da177e4SLinus Torvalds } 6421da177e4SLinus Torvalds 6436d34ac19SJ. Bruce Fields void 6449d6a8c5cSMarc Eshel posix_test_lock(struct file *filp, struct file_lock *fl) 6451da177e4SLinus Torvalds { 6461da177e4SLinus Torvalds struct file_lock *cfl; 6471da177e4SLinus Torvalds 648b89f4321SArnd Bergmann lock_flocks(); 6490f7fc9e4SJosef "Jeff" Sipek for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) { 6501da177e4SLinus Torvalds if (!IS_POSIX(cfl)) 6511da177e4SLinus Torvalds continue; 652b842e240SJ. Bruce Fields if (posix_locks_conflict(fl, cfl)) 6531da177e4SLinus Torvalds break; 6541da177e4SLinus Torvalds } 655ab1f1611SVitaliy Gusev if (cfl) { 6569d6a8c5cSMarc Eshel __locks_copy_lock(fl, cfl); 657ab1f1611SVitaliy Gusev if (cfl->fl_nspid) 6586c5f3e7bSPavel Emelyanov fl->fl_pid = pid_vnr(cfl->fl_nspid); 659ab1f1611SVitaliy Gusev } else 660129a84deSJ. Bruce Fields fl->fl_type = F_UNLCK; 661b89f4321SArnd Bergmann unlock_flocks(); 6626d34ac19SJ. Bruce Fields return; 6631da177e4SLinus Torvalds } 6641da177e4SLinus Torvalds EXPORT_SYMBOL(posix_test_lock); 6651da177e4SLinus Torvalds 666b533184fSJ. Bruce Fields /* 667b533184fSJ. Bruce Fields * Deadlock detection: 6681da177e4SLinus Torvalds * 669b533184fSJ. Bruce Fields * We attempt to detect deadlocks that are due purely to posix file 670b533184fSJ. Bruce Fields * locks. 6711da177e4SLinus Torvalds * 672b533184fSJ. Bruce Fields * We assume that a task can be waiting for at most one lock at a time. 673b533184fSJ. Bruce Fields * So for any acquired lock, the process holding that lock may be 674b533184fSJ. Bruce Fields * waiting on at most one other lock. That lock in turns may be held by 675b533184fSJ. Bruce Fields * someone waiting for at most one other lock. Given a requested lock 676b533184fSJ. Bruce Fields * caller_fl which is about to wait for a conflicting lock block_fl, we 677b533184fSJ. Bruce Fields * follow this chain of waiters to ensure we are not about to create a 678b533184fSJ. Bruce Fields * cycle. 67997855b49SJ. Bruce Fields * 680b533184fSJ. Bruce Fields * Since we do this before we ever put a process to sleep on a lock, we 681b533184fSJ. Bruce Fields * are ensured that there is never a cycle; that is what guarantees that 682b533184fSJ. Bruce Fields * the while() loop in posix_locks_deadlock() eventually completes. 683b533184fSJ. Bruce Fields * 684b533184fSJ. Bruce Fields * Note: the above assumption may not be true when handling lock 685b533184fSJ. Bruce Fields * requests from a broken NFS client. It may also fail in the presence 686b533184fSJ. Bruce Fields * of tasks (such as posix threads) sharing the same open file table. 687b533184fSJ. Bruce Fields * 688b533184fSJ. Bruce Fields * To handle those cases, we just bail out after a few iterations. 6891da177e4SLinus Torvalds */ 69097855b49SJ. Bruce Fields 69197855b49SJ. Bruce Fields #define MAX_DEADLK_ITERATIONS 10 69297855b49SJ. Bruce Fields 693b533184fSJ. Bruce Fields /* Find a lock that the owner of the given block_fl is blocking on. */ 694b533184fSJ. Bruce Fields static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl) 695b533184fSJ. Bruce Fields { 696b533184fSJ. Bruce Fields struct file_lock *fl; 697b533184fSJ. Bruce Fields 698b533184fSJ. Bruce Fields list_for_each_entry(fl, &blocked_list, fl_link) { 699b533184fSJ. Bruce Fields if (posix_same_owner(fl, block_fl)) 700b533184fSJ. Bruce Fields return fl->fl_next; 701b533184fSJ. Bruce Fields } 702b533184fSJ. Bruce Fields return NULL; 703b533184fSJ. Bruce Fields } 704b533184fSJ. Bruce Fields 705b0904e14SAdrian Bunk static int posix_locks_deadlock(struct file_lock *caller_fl, 7061da177e4SLinus Torvalds struct file_lock *block_fl) 7071da177e4SLinus Torvalds { 70897855b49SJ. Bruce Fields int i = 0; 7091da177e4SLinus Torvalds 710b533184fSJ. Bruce Fields while ((block_fl = what_owner_is_waiting_for(block_fl))) { 71197855b49SJ. Bruce Fields if (i++ > MAX_DEADLK_ITERATIONS) 71297855b49SJ. Bruce Fields return 0; 713b533184fSJ. Bruce Fields if (posix_same_owner(caller_fl, block_fl)) 714b533184fSJ. Bruce Fields return 1; 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds return 0; 7171da177e4SLinus Torvalds } 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks 72002888f41SJ. Bruce Fields * after any leases, but before any posix locks. 721f475ae95STrond Myklebust * 722f475ae95STrond Myklebust * Note that if called with an FL_EXISTS argument, the caller may determine 723f475ae95STrond Myklebust * whether or not a lock was successfully freed by testing the return 724f475ae95STrond Myklebust * value for -ENOENT. 7251da177e4SLinus Torvalds */ 726993dfa87STrond Myklebust static int flock_lock_file(struct file *filp, struct file_lock *request) 7271da177e4SLinus Torvalds { 728993dfa87STrond Myklebust struct file_lock *new_fl = NULL; 7291da177e4SLinus Torvalds struct file_lock **before; 7300f7fc9e4SJosef "Jeff" Sipek struct inode * inode = filp->f_path.dentry->d_inode; 7311da177e4SLinus Torvalds int error = 0; 7321da177e4SLinus Torvalds int found = 0; 7331da177e4SLinus Torvalds 734b89f4321SArnd Bergmann if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) { 735b89f4321SArnd Bergmann new_fl = locks_alloc_lock(); 736b89f4321SArnd Bergmann if (!new_fl) 737b89f4321SArnd Bergmann return -ENOMEM; 738b89f4321SArnd Bergmann } 739b89f4321SArnd Bergmann 740b89f4321SArnd Bergmann lock_flocks(); 741f07f18ddSTrond Myklebust if (request->fl_flags & FL_ACCESS) 742f07f18ddSTrond Myklebust goto find_conflict; 74384d535adSPavel Emelyanov 7441da177e4SLinus Torvalds for_each_lock(inode, before) { 7451da177e4SLinus Torvalds struct file_lock *fl = *before; 7461da177e4SLinus Torvalds if (IS_POSIX(fl)) 7471da177e4SLinus Torvalds break; 7481da177e4SLinus Torvalds if (IS_LEASE(fl)) 7491da177e4SLinus Torvalds continue; 7501da177e4SLinus Torvalds if (filp != fl->fl_file) 7511da177e4SLinus Torvalds continue; 752993dfa87STrond Myklebust if (request->fl_type == fl->fl_type) 7531da177e4SLinus Torvalds goto out; 7541da177e4SLinus Torvalds found = 1; 7551da177e4SLinus Torvalds locks_delete_lock(before); 7561da177e4SLinus Torvalds break; 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds 759f475ae95STrond Myklebust if (request->fl_type == F_UNLCK) { 760f475ae95STrond Myklebust if ((request->fl_flags & FL_EXISTS) && !found) 761f475ae95STrond Myklebust error = -ENOENT; 762993dfa87STrond Myklebust goto out; 763f475ae95STrond Myklebust } 7641da177e4SLinus Torvalds 7651da177e4SLinus Torvalds /* 7661da177e4SLinus Torvalds * If a higher-priority process was blocked on the old file lock, 7671da177e4SLinus Torvalds * give it the opportunity to lock the file. 7681da177e4SLinus Torvalds */ 769b89f4321SArnd Bergmann if (found) { 770b89f4321SArnd Bergmann unlock_flocks(); 771def01bc5SFrederic Weisbecker cond_resched(); 772b89f4321SArnd Bergmann lock_flocks(); 773b89f4321SArnd Bergmann } 7741da177e4SLinus Torvalds 775f07f18ddSTrond Myklebust find_conflict: 7761da177e4SLinus Torvalds for_each_lock(inode, before) { 7771da177e4SLinus Torvalds struct file_lock *fl = *before; 7781da177e4SLinus Torvalds if (IS_POSIX(fl)) 7791da177e4SLinus Torvalds break; 7801da177e4SLinus Torvalds if (IS_LEASE(fl)) 7811da177e4SLinus Torvalds continue; 782993dfa87STrond Myklebust if (!flock_locks_conflict(request, fl)) 7831da177e4SLinus Torvalds continue; 7841da177e4SLinus Torvalds error = -EAGAIN; 785bde74e4bSMiklos Szeredi if (!(request->fl_flags & FL_SLEEP)) 786bde74e4bSMiklos Szeredi goto out; 787bde74e4bSMiklos Szeredi error = FILE_LOCK_DEFERRED; 788993dfa87STrond Myklebust locks_insert_block(fl, request); 7891da177e4SLinus Torvalds goto out; 7901da177e4SLinus Torvalds } 791f07f18ddSTrond Myklebust if (request->fl_flags & FL_ACCESS) 792f07f18ddSTrond Myklebust goto out; 793993dfa87STrond Myklebust locks_copy_lock(new_fl, request); 7940e2f6db8SPavel Emelyanov locks_insert_lock(before, new_fl); 795993dfa87STrond Myklebust new_fl = NULL; 7969cedc194SKirill Korotaev error = 0; 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds out: 799b89f4321SArnd Bergmann unlock_flocks(); 800993dfa87STrond Myklebust if (new_fl) 801993dfa87STrond Myklebust locks_free_lock(new_fl); 8021da177e4SLinus Torvalds return error; 8031da177e4SLinus Torvalds } 8041da177e4SLinus Torvalds 805150b3934SMarc Eshel static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock) 8061da177e4SLinus Torvalds { 8071da177e4SLinus Torvalds struct file_lock *fl; 80839005d02SMiklos Szeredi struct file_lock *new_fl = NULL; 80939005d02SMiklos Szeredi struct file_lock *new_fl2 = NULL; 8101da177e4SLinus Torvalds struct file_lock *left = NULL; 8111da177e4SLinus Torvalds struct file_lock *right = NULL; 8121da177e4SLinus Torvalds struct file_lock **before; 8131da177e4SLinus Torvalds int error, added = 0; 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds /* 8161da177e4SLinus Torvalds * We may need two file_lock structures for this operation, 8171da177e4SLinus Torvalds * so we get them in advance to avoid races. 81839005d02SMiklos Szeredi * 81939005d02SMiklos Szeredi * In some cases we can be sure, that no new locks will be needed 8201da177e4SLinus Torvalds */ 82139005d02SMiklos Szeredi if (!(request->fl_flags & FL_ACCESS) && 82239005d02SMiklos Szeredi (request->fl_type != F_UNLCK || 82339005d02SMiklos Szeredi request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { 8241da177e4SLinus Torvalds new_fl = locks_alloc_lock(); 8251da177e4SLinus Torvalds new_fl2 = locks_alloc_lock(); 82639005d02SMiklos Szeredi } 8271da177e4SLinus Torvalds 828b89f4321SArnd Bergmann lock_flocks(); 8291da177e4SLinus Torvalds if (request->fl_type != F_UNLCK) { 8301da177e4SLinus Torvalds for_each_lock(inode, before) { 831526985b9SJ. Bruce Fields fl = *before; 8321da177e4SLinus Torvalds if (!IS_POSIX(fl)) 8331da177e4SLinus Torvalds continue; 8341da177e4SLinus Torvalds if (!posix_locks_conflict(request, fl)) 8351da177e4SLinus Torvalds continue; 8365842add2SAndy Adamson if (conflock) 8371a747ee0SJ. Bruce Fields __locks_copy_lock(conflock, fl); 8381da177e4SLinus Torvalds error = -EAGAIN; 8391da177e4SLinus Torvalds if (!(request->fl_flags & FL_SLEEP)) 8401da177e4SLinus Torvalds goto out; 8411da177e4SLinus Torvalds error = -EDEADLK; 8421da177e4SLinus Torvalds if (posix_locks_deadlock(request, fl)) 8431da177e4SLinus Torvalds goto out; 844bde74e4bSMiklos Szeredi error = FILE_LOCK_DEFERRED; 8451da177e4SLinus Torvalds locks_insert_block(fl, request); 8461da177e4SLinus Torvalds goto out; 8471da177e4SLinus Torvalds } 8481da177e4SLinus Torvalds } 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds /* If we're just looking for a conflict, we're done. */ 8511da177e4SLinus Torvalds error = 0; 8521da177e4SLinus Torvalds if (request->fl_flags & FL_ACCESS) 8531da177e4SLinus Torvalds goto out; 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds /* 8561da177e4SLinus Torvalds * Find the first old lock with the same owner as the new lock. 8571da177e4SLinus Torvalds */ 8581da177e4SLinus Torvalds 8591da177e4SLinus Torvalds before = &inode->i_flock; 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds /* First skip locks owned by other processes. */ 8621da177e4SLinus Torvalds while ((fl = *before) && (!IS_POSIX(fl) || 8631da177e4SLinus Torvalds !posix_same_owner(request, fl))) { 8641da177e4SLinus Torvalds before = &fl->fl_next; 8651da177e4SLinus Torvalds } 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds /* Process locks with this owner. */ 8681da177e4SLinus Torvalds while ((fl = *before) && posix_same_owner(request, fl)) { 8691da177e4SLinus Torvalds /* Detect adjacent or overlapping regions (if same lock type) 8701da177e4SLinus Torvalds */ 8711da177e4SLinus Torvalds if (request->fl_type == fl->fl_type) { 872449231d6SOlaf Kirch /* In all comparisons of start vs end, use 873449231d6SOlaf Kirch * "start - 1" rather than "end + 1". If end 874449231d6SOlaf Kirch * is OFFSET_MAX, end + 1 will become negative. 875449231d6SOlaf Kirch */ 8761da177e4SLinus Torvalds if (fl->fl_end < request->fl_start - 1) 8771da177e4SLinus Torvalds goto next_lock; 8781da177e4SLinus Torvalds /* If the next lock in the list has entirely bigger 8791da177e4SLinus Torvalds * addresses than the new one, insert the lock here. 8801da177e4SLinus Torvalds */ 881449231d6SOlaf Kirch if (fl->fl_start - 1 > request->fl_end) 8821da177e4SLinus Torvalds break; 8831da177e4SLinus Torvalds 8841da177e4SLinus Torvalds /* If we come here, the new and old lock are of the 8851da177e4SLinus Torvalds * same type and adjacent or overlapping. Make one 8861da177e4SLinus Torvalds * lock yielding from the lower start address of both 8871da177e4SLinus Torvalds * locks to the higher end address. 8881da177e4SLinus Torvalds */ 8891da177e4SLinus Torvalds if (fl->fl_start > request->fl_start) 8901da177e4SLinus Torvalds fl->fl_start = request->fl_start; 8911da177e4SLinus Torvalds else 8921da177e4SLinus Torvalds request->fl_start = fl->fl_start; 8931da177e4SLinus Torvalds if (fl->fl_end < request->fl_end) 8941da177e4SLinus Torvalds fl->fl_end = request->fl_end; 8951da177e4SLinus Torvalds else 8961da177e4SLinus Torvalds request->fl_end = fl->fl_end; 8971da177e4SLinus Torvalds if (added) { 8981da177e4SLinus Torvalds locks_delete_lock(before); 8991da177e4SLinus Torvalds continue; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds request = fl; 9021da177e4SLinus Torvalds added = 1; 9031da177e4SLinus Torvalds } 9041da177e4SLinus Torvalds else { 9051da177e4SLinus Torvalds /* Processing for different lock types is a bit 9061da177e4SLinus Torvalds * more complex. 9071da177e4SLinus Torvalds */ 9081da177e4SLinus Torvalds if (fl->fl_end < request->fl_start) 9091da177e4SLinus Torvalds goto next_lock; 9101da177e4SLinus Torvalds if (fl->fl_start > request->fl_end) 9111da177e4SLinus Torvalds break; 9121da177e4SLinus Torvalds if (request->fl_type == F_UNLCK) 9131da177e4SLinus Torvalds added = 1; 9141da177e4SLinus Torvalds if (fl->fl_start < request->fl_start) 9151da177e4SLinus Torvalds left = fl; 9161da177e4SLinus Torvalds /* If the next lock in the list has a higher end 9171da177e4SLinus Torvalds * address than the new one, insert the new one here. 9181da177e4SLinus Torvalds */ 9191da177e4SLinus Torvalds if (fl->fl_end > request->fl_end) { 9201da177e4SLinus Torvalds right = fl; 9211da177e4SLinus Torvalds break; 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds if (fl->fl_start >= request->fl_start) { 9241da177e4SLinus Torvalds /* The new lock completely replaces an old 9251da177e4SLinus Torvalds * one (This may happen several times). 9261da177e4SLinus Torvalds */ 9271da177e4SLinus Torvalds if (added) { 9281da177e4SLinus Torvalds locks_delete_lock(before); 9291da177e4SLinus Torvalds continue; 9301da177e4SLinus Torvalds } 9311da177e4SLinus Torvalds /* Replace the old lock with the new one. 9321da177e4SLinus Torvalds * Wake up anybody waiting for the old one, 9331da177e4SLinus Torvalds * as the change in lock type might satisfy 9341da177e4SLinus Torvalds * their needs. 9351da177e4SLinus Torvalds */ 9361da177e4SLinus Torvalds locks_wake_up_blocks(fl); 9371da177e4SLinus Torvalds fl->fl_start = request->fl_start; 9381da177e4SLinus Torvalds fl->fl_end = request->fl_end; 9391da177e4SLinus Torvalds fl->fl_type = request->fl_type; 94047831f35STrond Myklebust locks_release_private(fl); 94147831f35STrond Myklebust locks_copy_private(fl, request); 9421da177e4SLinus Torvalds request = fl; 9431da177e4SLinus Torvalds added = 1; 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds } 9461da177e4SLinus Torvalds /* Go on to next lock. 9471da177e4SLinus Torvalds */ 9481da177e4SLinus Torvalds next_lock: 9491da177e4SLinus Torvalds before = &fl->fl_next; 9501da177e4SLinus Torvalds } 9511da177e4SLinus Torvalds 9520d9a490aSMiklos Szeredi /* 9530d9a490aSMiklos Szeredi * The above code only modifies existing locks in case of 9540d9a490aSMiklos Szeredi * merging or replacing. If new lock(s) need to be inserted 9550d9a490aSMiklos Szeredi * all modifications are done bellow this, so it's safe yet to 9560d9a490aSMiklos Szeredi * bail out. 9570d9a490aSMiklos Szeredi */ 9580d9a490aSMiklos Szeredi error = -ENOLCK; /* "no luck" */ 9590d9a490aSMiklos Szeredi if (right && left == right && !new_fl2) 9600d9a490aSMiklos Szeredi goto out; 9610d9a490aSMiklos Szeredi 9621da177e4SLinus Torvalds error = 0; 9631da177e4SLinus Torvalds if (!added) { 964f475ae95STrond Myklebust if (request->fl_type == F_UNLCK) { 965f475ae95STrond Myklebust if (request->fl_flags & FL_EXISTS) 966f475ae95STrond Myklebust error = -ENOENT; 9671da177e4SLinus Torvalds goto out; 968f475ae95STrond Myklebust } 9690d9a490aSMiklos Szeredi 9700d9a490aSMiklos Szeredi if (!new_fl) { 9710d9a490aSMiklos Szeredi error = -ENOLCK; 9720d9a490aSMiklos Szeredi goto out; 9730d9a490aSMiklos Szeredi } 9741da177e4SLinus Torvalds locks_copy_lock(new_fl, request); 9751da177e4SLinus Torvalds locks_insert_lock(before, new_fl); 9761da177e4SLinus Torvalds new_fl = NULL; 9771da177e4SLinus Torvalds } 9781da177e4SLinus Torvalds if (right) { 9791da177e4SLinus Torvalds if (left == right) { 9801da177e4SLinus Torvalds /* The new lock breaks the old one in two pieces, 9811da177e4SLinus Torvalds * so we have to use the second new lock. 9821da177e4SLinus Torvalds */ 9831da177e4SLinus Torvalds left = new_fl2; 9841da177e4SLinus Torvalds new_fl2 = NULL; 9851da177e4SLinus Torvalds locks_copy_lock(left, right); 9861da177e4SLinus Torvalds locks_insert_lock(before, left); 9871da177e4SLinus Torvalds } 9881da177e4SLinus Torvalds right->fl_start = request->fl_end + 1; 9891da177e4SLinus Torvalds locks_wake_up_blocks(right); 9901da177e4SLinus Torvalds } 9911da177e4SLinus Torvalds if (left) { 9921da177e4SLinus Torvalds left->fl_end = request->fl_start - 1; 9931da177e4SLinus Torvalds locks_wake_up_blocks(left); 9941da177e4SLinus Torvalds } 9951da177e4SLinus Torvalds out: 996b89f4321SArnd Bergmann unlock_flocks(); 9971da177e4SLinus Torvalds /* 9981da177e4SLinus Torvalds * Free any unused locks. 9991da177e4SLinus Torvalds */ 10001da177e4SLinus Torvalds if (new_fl) 10011da177e4SLinus Torvalds locks_free_lock(new_fl); 10021da177e4SLinus Torvalds if (new_fl2) 10031da177e4SLinus Torvalds locks_free_lock(new_fl2); 10041da177e4SLinus Torvalds return error; 10051da177e4SLinus Torvalds } 10061da177e4SLinus Torvalds 10071da177e4SLinus Torvalds /** 10081da177e4SLinus Torvalds * posix_lock_file - Apply a POSIX-style lock to a file 10091da177e4SLinus Torvalds * @filp: The file to apply the lock to 10101da177e4SLinus Torvalds * @fl: The lock to be applied 1011150b3934SMarc Eshel * @conflock: Place to return a copy of the conflicting lock, if found. 10121da177e4SLinus Torvalds * 10131da177e4SLinus Torvalds * Add a POSIX style lock to a file. 10141da177e4SLinus Torvalds * We merge adjacent & overlapping locks whenever possible. 10151da177e4SLinus Torvalds * POSIX locks are sorted by owner task, then by starting address 1016f475ae95STrond Myklebust * 1017f475ae95STrond Myklebust * Note that if called with an FL_EXISTS argument, the caller may determine 1018f475ae95STrond Myklebust * whether or not a lock was successfully freed by testing the return 1019f475ae95STrond Myklebust * value for -ENOENT. 10201da177e4SLinus Torvalds */ 1021150b3934SMarc Eshel int posix_lock_file(struct file *filp, struct file_lock *fl, 10225842add2SAndy Adamson struct file_lock *conflock) 10235842add2SAndy Adamson { 1024150b3934SMarc Eshel return __posix_lock_file(filp->f_path.dentry->d_inode, fl, conflock); 10255842add2SAndy Adamson } 1026150b3934SMarc Eshel EXPORT_SYMBOL(posix_lock_file); 10271da177e4SLinus Torvalds 10281da177e4SLinus Torvalds /** 10291da177e4SLinus Torvalds * posix_lock_file_wait - Apply a POSIX-style lock to a file 10301da177e4SLinus Torvalds * @filp: The file to apply the lock to 10311da177e4SLinus Torvalds * @fl: The lock to be applied 10321da177e4SLinus Torvalds * 10331da177e4SLinus Torvalds * Add a POSIX style lock to a file. 10341da177e4SLinus Torvalds * We merge adjacent & overlapping locks whenever possible. 10351da177e4SLinus Torvalds * POSIX locks are sorted by owner task, then by starting address 10361da177e4SLinus Torvalds */ 10371da177e4SLinus Torvalds int posix_lock_file_wait(struct file *filp, struct file_lock *fl) 10381da177e4SLinus Torvalds { 10391da177e4SLinus Torvalds int error; 10401da177e4SLinus Torvalds might_sleep (); 10411da177e4SLinus Torvalds for (;;) { 1042150b3934SMarc Eshel error = posix_lock_file(filp, fl, NULL); 1043bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 10441da177e4SLinus Torvalds break; 10451da177e4SLinus Torvalds error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 10461da177e4SLinus Torvalds if (!error) 10471da177e4SLinus Torvalds continue; 10481da177e4SLinus Torvalds 10491da177e4SLinus Torvalds locks_delete_block(fl); 10501da177e4SLinus Torvalds break; 10511da177e4SLinus Torvalds } 10521da177e4SLinus Torvalds return error; 10531da177e4SLinus Torvalds } 10541da177e4SLinus Torvalds EXPORT_SYMBOL(posix_lock_file_wait); 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds /** 10571da177e4SLinus Torvalds * locks_mandatory_locked - Check for an active lock 10581da177e4SLinus Torvalds * @inode: the file to check 10591da177e4SLinus Torvalds * 10601da177e4SLinus Torvalds * Searches the inode's list of locks to find any POSIX locks which conflict. 10611da177e4SLinus Torvalds * This function is called from locks_verify_locked() only. 10621da177e4SLinus Torvalds */ 10631da177e4SLinus Torvalds int locks_mandatory_locked(struct inode *inode) 10641da177e4SLinus Torvalds { 10651da177e4SLinus Torvalds fl_owner_t owner = current->files; 10661da177e4SLinus Torvalds struct file_lock *fl; 10671da177e4SLinus Torvalds 10681da177e4SLinus Torvalds /* 10691da177e4SLinus Torvalds * Search the lock list for this inode for any POSIX locks. 10701da177e4SLinus Torvalds */ 1071b89f4321SArnd Bergmann lock_flocks(); 10721da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 10731da177e4SLinus Torvalds if (!IS_POSIX(fl)) 10741da177e4SLinus Torvalds continue; 10751da177e4SLinus Torvalds if (fl->fl_owner != owner) 10761da177e4SLinus Torvalds break; 10771da177e4SLinus Torvalds } 1078b89f4321SArnd Bergmann unlock_flocks(); 10791da177e4SLinus Torvalds return fl ? -EAGAIN : 0; 10801da177e4SLinus Torvalds } 10811da177e4SLinus Torvalds 10821da177e4SLinus Torvalds /** 10831da177e4SLinus Torvalds * locks_mandatory_area - Check for a conflicting lock 10841da177e4SLinus Torvalds * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ 10851da177e4SLinus Torvalds * for shared 10861da177e4SLinus Torvalds * @inode: the file to check 10871da177e4SLinus Torvalds * @filp: how the file was opened (if it was) 10881da177e4SLinus Torvalds * @offset: start of area to check 10891da177e4SLinus Torvalds * @count: length of area to check 10901da177e4SLinus Torvalds * 10911da177e4SLinus Torvalds * Searches the inode's list of locks to find any POSIX locks which conflict. 10921da177e4SLinus Torvalds * This function is called from rw_verify_area() and 10931da177e4SLinus Torvalds * locks_verify_truncate(). 10941da177e4SLinus Torvalds */ 10951da177e4SLinus Torvalds int locks_mandatory_area(int read_write, struct inode *inode, 10961da177e4SLinus Torvalds struct file *filp, loff_t offset, 10971da177e4SLinus Torvalds size_t count) 10981da177e4SLinus Torvalds { 10991da177e4SLinus Torvalds struct file_lock fl; 11001da177e4SLinus Torvalds int error; 11011da177e4SLinus Torvalds 11021da177e4SLinus Torvalds locks_init_lock(&fl); 11031da177e4SLinus Torvalds fl.fl_owner = current->files; 11041da177e4SLinus Torvalds fl.fl_pid = current->tgid; 11051da177e4SLinus Torvalds fl.fl_file = filp; 11061da177e4SLinus Torvalds fl.fl_flags = FL_POSIX | FL_ACCESS; 11071da177e4SLinus Torvalds if (filp && !(filp->f_flags & O_NONBLOCK)) 11081da177e4SLinus Torvalds fl.fl_flags |= FL_SLEEP; 11091da177e4SLinus Torvalds fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK; 11101da177e4SLinus Torvalds fl.fl_start = offset; 11111da177e4SLinus Torvalds fl.fl_end = offset + count - 1; 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds for (;;) { 1114150b3934SMarc Eshel error = __posix_lock_file(inode, &fl, NULL); 1115bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 11161da177e4SLinus Torvalds break; 11171da177e4SLinus Torvalds error = wait_event_interruptible(fl.fl_wait, !fl.fl_next); 11181da177e4SLinus Torvalds if (!error) { 11191da177e4SLinus Torvalds /* 11201da177e4SLinus Torvalds * If we've been sleeping someone might have 11211da177e4SLinus Torvalds * changed the permissions behind our back. 11221da177e4SLinus Torvalds */ 1123a16877caSPavel Emelyanov if (__mandatory_lock(inode)) 11241da177e4SLinus Torvalds continue; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds 11271da177e4SLinus Torvalds locks_delete_block(&fl); 11281da177e4SLinus Torvalds break; 11291da177e4SLinus Torvalds } 11301da177e4SLinus Torvalds 11311da177e4SLinus Torvalds return error; 11321da177e4SLinus Torvalds } 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds EXPORT_SYMBOL(locks_mandatory_area); 11351da177e4SLinus Torvalds 1136778fc546SJ. Bruce Fields static void lease_clear_pending(struct file_lock *fl, int arg) 1137778fc546SJ. Bruce Fields { 1138778fc546SJ. Bruce Fields switch (arg) { 1139778fc546SJ. Bruce Fields case F_UNLCK: 1140778fc546SJ. Bruce Fields fl->fl_flags &= ~FL_UNLOCK_PENDING; 1141778fc546SJ. Bruce Fields /* fall through: */ 1142778fc546SJ. Bruce Fields case F_RDLCK: 1143778fc546SJ. Bruce Fields fl->fl_flags &= ~FL_DOWNGRADE_PENDING; 1144778fc546SJ. Bruce Fields } 1145778fc546SJ. Bruce Fields } 1146778fc546SJ. Bruce Fields 11471da177e4SLinus Torvalds /* We already had a lease on this file; just change its type */ 11481da177e4SLinus Torvalds int lease_modify(struct file_lock **before, int arg) 11491da177e4SLinus Torvalds { 11501da177e4SLinus Torvalds struct file_lock *fl = *before; 11511da177e4SLinus Torvalds int error = assign_type(fl, arg); 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds if (error) 11541da177e4SLinus Torvalds return error; 1155778fc546SJ. Bruce Fields lease_clear_pending(fl, arg); 11561da177e4SLinus Torvalds locks_wake_up_blocks(fl); 11571da177e4SLinus Torvalds if (arg == F_UNLCK) 11581da177e4SLinus Torvalds locks_delete_lock(before); 11591da177e4SLinus Torvalds return 0; 11601da177e4SLinus Torvalds } 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds EXPORT_SYMBOL(lease_modify); 11631da177e4SLinus Torvalds 1164778fc546SJ. Bruce Fields static bool past_time(unsigned long then) 1165778fc546SJ. Bruce Fields { 1166778fc546SJ. Bruce Fields if (!then) 1167778fc546SJ. Bruce Fields /* 0 is a special value meaning "this never expires": */ 1168778fc546SJ. Bruce Fields return false; 1169778fc546SJ. Bruce Fields return time_after(jiffies, then); 1170778fc546SJ. Bruce Fields } 1171778fc546SJ. Bruce Fields 11721da177e4SLinus Torvalds static void time_out_leases(struct inode *inode) 11731da177e4SLinus Torvalds { 11741da177e4SLinus Torvalds struct file_lock **before; 11751da177e4SLinus Torvalds struct file_lock *fl; 11761da177e4SLinus Torvalds 11771da177e4SLinus Torvalds before = &inode->i_flock; 1178ab83fa4bSJ. Bruce Fields while ((fl = *before) && IS_LEASE(fl) && lease_breaking(fl)) { 1179778fc546SJ. Bruce Fields if (past_time(fl->fl_downgrade_time)) 1180778fc546SJ. Bruce Fields lease_modify(before, F_RDLCK); 1181778fc546SJ. Bruce Fields if (past_time(fl->fl_break_time)) 1182778fc546SJ. Bruce Fields lease_modify(before, F_UNLCK); 11831da177e4SLinus Torvalds if (fl == *before) /* lease_modify may have freed fl */ 11841da177e4SLinus Torvalds before = &fl->fl_next; 11851da177e4SLinus Torvalds } 11861da177e4SLinus Torvalds } 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds /** 11891da177e4SLinus Torvalds * __break_lease - revoke all outstanding leases on file 11901da177e4SLinus Torvalds * @inode: the inode of the file to return 11911da177e4SLinus Torvalds * @mode: the open mode (read or write) 11921da177e4SLinus Torvalds * 119387250dd2Sdavid m. richter * break_lease (inlined for speed) has checked there already is at least 119487250dd2Sdavid m. richter * some kind of lock (maybe a lease) on this file. Leases are broken on 119587250dd2Sdavid m. richter * a call to open() or truncate(). This function can sleep unless you 11961da177e4SLinus Torvalds * specified %O_NONBLOCK to your open(). 11971da177e4SLinus Torvalds */ 11981da177e4SLinus Torvalds int __break_lease(struct inode *inode, unsigned int mode) 11991da177e4SLinus Torvalds { 1200778fc546SJ. Bruce Fields int error = 0; 12011da177e4SLinus Torvalds struct file_lock *new_fl, *flock; 12021da177e4SLinus Torvalds struct file_lock *fl; 12031da177e4SLinus Torvalds unsigned long break_time; 12041da177e4SLinus Torvalds int i_have_this_lease = 0; 12058737c930SAl Viro int want_write = (mode & O_ACCMODE) != O_RDONLY; 12061da177e4SLinus Torvalds 12078737c930SAl Viro new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK); 12086d4b9e38SLinus Torvalds if (IS_ERR(new_fl)) 12096d4b9e38SLinus Torvalds return PTR_ERR(new_fl); 12101da177e4SLinus Torvalds 1211b89f4321SArnd Bergmann lock_flocks(); 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds time_out_leases(inode); 12141da177e4SLinus Torvalds 12151da177e4SLinus Torvalds flock = inode->i_flock; 12161da177e4SLinus Torvalds if ((flock == NULL) || !IS_LEASE(flock)) 12171da177e4SLinus Torvalds goto out; 12181da177e4SLinus Torvalds 1219778fc546SJ. Bruce Fields if (!locks_conflict(flock, new_fl)) 1220778fc546SJ. Bruce Fields goto out; 1221778fc546SJ. Bruce Fields 12221da177e4SLinus Torvalds for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) 12231da177e4SLinus Torvalds if (fl->fl_owner == current->files) 12241da177e4SLinus Torvalds i_have_this_lease = 1; 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds break_time = 0; 12271da177e4SLinus Torvalds if (lease_break_time > 0) { 12281da177e4SLinus Torvalds break_time = jiffies + lease_break_time * HZ; 12291da177e4SLinus Torvalds if (break_time == 0) 12301da177e4SLinus Torvalds break_time++; /* so that 0 means no break time */ 12311da177e4SLinus Torvalds } 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) { 1234778fc546SJ. Bruce Fields if (want_write) { 1235778fc546SJ. Bruce Fields if (fl->fl_flags & FL_UNLOCK_PENDING) 1236778fc546SJ. Bruce Fields continue; 1237778fc546SJ. Bruce Fields fl->fl_flags |= FL_UNLOCK_PENDING; 12381da177e4SLinus Torvalds fl->fl_break_time = break_time; 1239778fc546SJ. Bruce Fields } else { 1240778fc546SJ. Bruce Fields if (lease_breaking(flock)) 1241778fc546SJ. Bruce Fields continue; 1242778fc546SJ. Bruce Fields fl->fl_flags |= FL_DOWNGRADE_PENDING; 1243778fc546SJ. Bruce Fields fl->fl_downgrade_time = break_time; 12441da177e4SLinus Torvalds } 1245778fc546SJ. Bruce Fields fl->fl_lmops->lm_break(fl); 12461da177e4SLinus Torvalds } 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds if (i_have_this_lease || (mode & O_NONBLOCK)) { 12491da177e4SLinus Torvalds error = -EWOULDBLOCK; 12501da177e4SLinus Torvalds goto out; 12511da177e4SLinus Torvalds } 12521da177e4SLinus Torvalds 12531da177e4SLinus Torvalds restart: 12541da177e4SLinus Torvalds break_time = flock->fl_break_time; 12551da177e4SLinus Torvalds if (break_time != 0) { 12561da177e4SLinus Torvalds break_time -= jiffies; 12571da177e4SLinus Torvalds if (break_time == 0) 12581da177e4SLinus Torvalds break_time++; 12591da177e4SLinus Torvalds } 12604321e01eSMatthew Wilcox locks_insert_block(flock, new_fl); 1261b89f4321SArnd Bergmann unlock_flocks(); 12624321e01eSMatthew Wilcox error = wait_event_interruptible_timeout(new_fl->fl_wait, 12634321e01eSMatthew Wilcox !new_fl->fl_next, break_time); 1264b89f4321SArnd Bergmann lock_flocks(); 12654321e01eSMatthew Wilcox __locks_delete_block(new_fl); 12661da177e4SLinus Torvalds if (error >= 0) { 12671da177e4SLinus Torvalds if (error == 0) 12681da177e4SLinus Torvalds time_out_leases(inode); 1269778fc546SJ. Bruce Fields /* 1270778fc546SJ. Bruce Fields * Wait for the next conflicting lease that has not been 1271778fc546SJ. Bruce Fields * broken yet 1272778fc546SJ. Bruce Fields */ 12731da177e4SLinus Torvalds for (flock = inode->i_flock; flock && IS_LEASE(flock); 12741da177e4SLinus Torvalds flock = flock->fl_next) { 1275778fc546SJ. Bruce Fields if (locks_conflict(new_fl, flock)) 12761da177e4SLinus Torvalds goto restart; 12771da177e4SLinus Torvalds } 12781da177e4SLinus Torvalds error = 0; 12791da177e4SLinus Torvalds } 12801da177e4SLinus Torvalds 12811da177e4SLinus Torvalds out: 1282b89f4321SArnd Bergmann unlock_flocks(); 12831da177e4SLinus Torvalds locks_free_lock(new_fl); 12841da177e4SLinus Torvalds return error; 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds EXPORT_SYMBOL(__break_lease); 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds /** 1290a6b91919SRandy Dunlap * lease_get_mtime - get the last modified time of an inode 12911da177e4SLinus Torvalds * @inode: the inode 12921da177e4SLinus Torvalds * @time: pointer to a timespec which will contain the last modified time 12931da177e4SLinus Torvalds * 12941da177e4SLinus Torvalds * This is to force NFS clients to flush their caches for files with 12951da177e4SLinus Torvalds * exclusive leases. The justification is that if someone has an 1296a6b91919SRandy Dunlap * exclusive lease, then they could be modifying it. 12971da177e4SLinus Torvalds */ 12981da177e4SLinus Torvalds void lease_get_mtime(struct inode *inode, struct timespec *time) 12991da177e4SLinus Torvalds { 13001da177e4SLinus Torvalds struct file_lock *flock = inode->i_flock; 13011da177e4SLinus Torvalds if (flock && IS_LEASE(flock) && (flock->fl_type & F_WRLCK)) 13021da177e4SLinus Torvalds *time = current_fs_time(inode->i_sb); 13031da177e4SLinus Torvalds else 13041da177e4SLinus Torvalds *time = inode->i_mtime; 13051da177e4SLinus Torvalds } 13061da177e4SLinus Torvalds 13071da177e4SLinus Torvalds EXPORT_SYMBOL(lease_get_mtime); 13081da177e4SLinus Torvalds 13091da177e4SLinus Torvalds /** 13101da177e4SLinus Torvalds * fcntl_getlease - Enquire what lease is currently active 13111da177e4SLinus Torvalds * @filp: the file 13121da177e4SLinus Torvalds * 13131da177e4SLinus Torvalds * The value returned by this function will be one of 13141da177e4SLinus Torvalds * (if no lease break is pending): 13151da177e4SLinus Torvalds * 13161da177e4SLinus Torvalds * %F_RDLCK to indicate a shared lease is held. 13171da177e4SLinus Torvalds * 13181da177e4SLinus Torvalds * %F_WRLCK to indicate an exclusive lease is held. 13191da177e4SLinus Torvalds * 13201da177e4SLinus Torvalds * %F_UNLCK to indicate no lease is held. 13211da177e4SLinus Torvalds * 13221da177e4SLinus Torvalds * (if a lease break is pending): 13231da177e4SLinus Torvalds * 13241da177e4SLinus Torvalds * %F_RDLCK to indicate an exclusive lease needs to be 13251da177e4SLinus Torvalds * changed to a shared lease (or removed). 13261da177e4SLinus Torvalds * 13271da177e4SLinus Torvalds * %F_UNLCK to indicate the lease needs to be removed. 13281da177e4SLinus Torvalds * 13291da177e4SLinus Torvalds * XXX: sfr & willy disagree over whether F_INPROGRESS 13301da177e4SLinus Torvalds * should be returned to userspace. 13311da177e4SLinus Torvalds */ 13321da177e4SLinus Torvalds int fcntl_getlease(struct file *filp) 13331da177e4SLinus Torvalds { 13341da177e4SLinus Torvalds struct file_lock *fl; 13351da177e4SLinus Torvalds int type = F_UNLCK; 13361da177e4SLinus Torvalds 1337b89f4321SArnd Bergmann lock_flocks(); 13380f7fc9e4SJosef "Jeff" Sipek time_out_leases(filp->f_path.dentry->d_inode); 13390f7fc9e4SJosef "Jeff" Sipek for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl); 13401da177e4SLinus Torvalds fl = fl->fl_next) { 13411da177e4SLinus Torvalds if (fl->fl_file == filp) { 1342778fc546SJ. Bruce Fields type = target_leasetype(fl); 13431da177e4SLinus Torvalds break; 13441da177e4SLinus Torvalds } 13451da177e4SLinus Torvalds } 1346b89f4321SArnd Bergmann unlock_flocks(); 13471da177e4SLinus Torvalds return type; 13481da177e4SLinus Torvalds } 13491da177e4SLinus Torvalds 13508335ebd9SJ. Bruce Fields int generic_add_lease(struct file *filp, long arg, struct file_lock **flp) 13511da177e4SLinus Torvalds { 13527eaae282SKAMBAROV, ZAUR struct file_lock *fl, **before, **my_before = NULL, *lease; 13530f7fc9e4SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 13541da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 1355c1f24ef4SJ. Bruce Fields int error; 13561da177e4SLinus Torvalds 1357096657b6SJ. Bruce Fields lease = *flp; 1358096657b6SJ. Bruce Fields 13591da177e4SLinus Torvalds error = -EAGAIN; 13601da177e4SLinus Torvalds if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0)) 13611da177e4SLinus Torvalds goto out; 13621da177e4SLinus Torvalds if ((arg == F_WRLCK) 1363b7ab39f6SNick Piggin && ((dentry->d_count > 1) 13641da177e4SLinus Torvalds || (atomic_read(&inode->i_count) > 1))) 13651da177e4SLinus Torvalds goto out; 136685c59580SPavel Emelyanov 13671da177e4SLinus Torvalds /* 13681da177e4SLinus Torvalds * At this point, we know that if there is an exclusive 13691da177e4SLinus Torvalds * lease on this file, then we hold it on this filp 13701da177e4SLinus Torvalds * (otherwise our open of this file would have blocked). 13711da177e4SLinus Torvalds * And if we are trying to acquire an exclusive lease, 13721da177e4SLinus Torvalds * then the file is not open by anyone (including us) 13731da177e4SLinus Torvalds * except for this filp. 13741da177e4SLinus Torvalds */ 1375c1f24ef4SJ. Bruce Fields error = -EAGAIN; 13761da177e4SLinus Torvalds for (before = &inode->i_flock; 13771da177e4SLinus Torvalds ((fl = *before) != NULL) && IS_LEASE(fl); 13781da177e4SLinus Torvalds before = &fl->fl_next) { 1379c1f24ef4SJ. Bruce Fields if (fl->fl_file == filp) { 13801da177e4SLinus Torvalds my_before = before; 1381c1f24ef4SJ. Bruce Fields continue; 13821da177e4SLinus Torvalds } 1383c1f24ef4SJ. Bruce Fields /* 1384c1f24ef4SJ. Bruce Fields * No exclusive leases if someone else has a lease on 1385c1f24ef4SJ. Bruce Fields * this file: 1386c1f24ef4SJ. Bruce Fields */ 1387c1f24ef4SJ. Bruce Fields if (arg == F_WRLCK) 13881da177e4SLinus Torvalds goto out; 1389c1f24ef4SJ. Bruce Fields /* 1390c1f24ef4SJ. Bruce Fields * Modifying our existing lease is OK, but no getting a 1391c1f24ef4SJ. Bruce Fields * new lease if someone else is opening for write: 1392c1f24ef4SJ. Bruce Fields */ 1393c1f24ef4SJ. Bruce Fields if (fl->fl_flags & FL_UNLOCK_PENDING) 1394c1f24ef4SJ. Bruce Fields goto out; 1395c1f24ef4SJ. Bruce Fields } 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds if (my_before != NULL) { 13988fb47a4fSJ. Bruce Fields error = lease->fl_lmops->lm_change(my_before, arg); 139951ee4b84SChristoph Hellwig if (!error) 140051ee4b84SChristoph Hellwig *flp = *my_before; 14011da177e4SLinus Torvalds goto out; 14021da177e4SLinus Torvalds } 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds error = -EINVAL; 14051da177e4SLinus Torvalds if (!leases_enable) 14061da177e4SLinus Torvalds goto out; 14071da177e4SLinus Torvalds 1408c5b1f0d9SArnd Bergmann locks_insert_lock(before, lease); 140985c59580SPavel Emelyanov return 0; 14101da177e4SLinus Torvalds 14111da177e4SLinus Torvalds out: 14121da177e4SLinus Torvalds return error; 14131da177e4SLinus Torvalds } 14148335ebd9SJ. Bruce Fields 14158335ebd9SJ. Bruce Fields int generic_delete_lease(struct file *filp, struct file_lock **flp) 14168335ebd9SJ. Bruce Fields { 14178335ebd9SJ. Bruce Fields struct file_lock *fl, **before; 14188335ebd9SJ. Bruce Fields struct dentry *dentry = filp->f_path.dentry; 14198335ebd9SJ. Bruce Fields struct inode *inode = dentry->d_inode; 14208335ebd9SJ. Bruce Fields 14218335ebd9SJ. Bruce Fields for (before = &inode->i_flock; 14228335ebd9SJ. Bruce Fields ((fl = *before) != NULL) && IS_LEASE(fl); 14238335ebd9SJ. Bruce Fields before = &fl->fl_next) { 14248335ebd9SJ. Bruce Fields if (fl->fl_file != filp) 14258335ebd9SJ. Bruce Fields continue; 14268335ebd9SJ. Bruce Fields return (*flp)->fl_lmops->lm_change(before, F_UNLCK); 14278335ebd9SJ. Bruce Fields } 14288335ebd9SJ. Bruce Fields return -EAGAIN; 14298335ebd9SJ. Bruce Fields } 14308335ebd9SJ. Bruce Fields 14311da177e4SLinus Torvalds /** 14321da177e4SLinus Torvalds * generic_setlease - sets a lease on an open file 14331da177e4SLinus Torvalds * @filp: file pointer 14341da177e4SLinus Torvalds * @arg: type of lease to obtain 14351da177e4SLinus Torvalds * @flp: input - file_lock to use, output - file_lock inserted 14361da177e4SLinus Torvalds * 14371da177e4SLinus Torvalds * The (input) flp->fl_lmops->lm_break function is required 14381da177e4SLinus Torvalds * by break_lease(). 14391da177e4SLinus Torvalds * 14401da177e4SLinus Torvalds * Called with file_lock_lock held. 14411da177e4SLinus Torvalds */ 14421da177e4SLinus Torvalds int generic_setlease(struct file *filp, long arg, struct file_lock **flp) 14431da177e4SLinus Torvalds { 14441da177e4SLinus Torvalds struct dentry *dentry = filp->f_path.dentry; 14451da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 14468335ebd9SJ. Bruce Fields int error; 14471da177e4SLinus Torvalds 1448*8e96e3b7SEric W. Biederman if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE)) 14498335ebd9SJ. Bruce Fields return -EACCES; 14501da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode)) 14518335ebd9SJ. Bruce Fields return -EINVAL; 14521da177e4SLinus Torvalds error = security_file_lock(filp, arg); 14531da177e4SLinus Torvalds if (error) 14548335ebd9SJ. Bruce Fields return error; 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds time_out_leases(inode); 14571da177e4SLinus Torvalds 14581da177e4SLinus Torvalds BUG_ON(!(*flp)->fl_lmops->lm_break); 14591da177e4SLinus Torvalds 14608335ebd9SJ. Bruce Fields switch (arg) { 14618335ebd9SJ. Bruce Fields case F_UNLCK: 14628335ebd9SJ. Bruce Fields return generic_delete_lease(filp, flp); 14638335ebd9SJ. Bruce Fields case F_RDLCK: 14648335ebd9SJ. Bruce Fields case F_WRLCK: 14658335ebd9SJ. Bruce Fields return generic_add_lease(filp, arg, flp); 14668335ebd9SJ. Bruce Fields default: 14678335ebd9SJ. Bruce Fields BUG(); 14681da177e4SLinus Torvalds } 14691da177e4SLinus Torvalds } 14700af1a450SChristoph Hellwig EXPORT_SYMBOL(generic_setlease); 14711da177e4SLinus Torvalds 1472b89f4321SArnd Bergmann static int __vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 1473b89f4321SArnd Bergmann { 1474b89f4321SArnd Bergmann if (filp->f_op && filp->f_op->setlease) 1475b89f4321SArnd Bergmann return filp->f_op->setlease(filp, arg, lease); 1476b89f4321SArnd Bergmann else 1477b89f4321SArnd Bergmann return generic_setlease(filp, arg, lease); 1478b89f4321SArnd Bergmann } 1479b89f4321SArnd Bergmann 14801da177e4SLinus Torvalds /** 1481a9933ceaSJ. Bruce Fields * vfs_setlease - sets a lease on an open file 14821da177e4SLinus Torvalds * @filp: file pointer 14831da177e4SLinus Torvalds * @arg: type of lease to obtain 14841da177e4SLinus Torvalds * @lease: file_lock to use 14851da177e4SLinus Torvalds * 14861da177e4SLinus Torvalds * Call this to establish a lease on the file. 14878fb47a4fSJ. Bruce Fields * The (*lease)->fl_lmops->lm_break operation must be set; if not, 1488f9ffed26SJ. Bruce Fields * break_lease will oops! 1489f9ffed26SJ. Bruce Fields * 1490f9ffed26SJ. Bruce Fields * This will call the filesystem's setlease file method, if 1491f9ffed26SJ. Bruce Fields * defined. Note that there is no getlease method; instead, the 1492f9ffed26SJ. Bruce Fields * filesystem setlease method should call back to setlease() to 1493f9ffed26SJ. Bruce Fields * add a lease to the inode's lease list, where fcntl_getlease() can 1494f9ffed26SJ. Bruce Fields * find it. Since fcntl_getlease() only reports whether the current 1495f9ffed26SJ. Bruce Fields * task holds a lease, a cluster filesystem need only do this for 1496f9ffed26SJ. Bruce Fields * leases held by processes on this node. 1497f9ffed26SJ. Bruce Fields * 1498f9ffed26SJ. Bruce Fields * There is also no break_lease method; filesystems that 1499c9404c9cSAdam Buchbinder * handle their own leases should break leases themselves from the 1500f9ffed26SJ. Bruce Fields * filesystem's open, create, and (on truncate) setattr methods. 1501f9ffed26SJ. Bruce Fields * 1502f9ffed26SJ. Bruce Fields * Warning: the only current setlease methods exist only to disable 1503f9ffed26SJ. Bruce Fields * leases in certain cases. More vfs changes may be required to 1504f9ffed26SJ. Bruce Fields * allow a full filesystem lease implementation. 15051da177e4SLinus Torvalds */ 15061da177e4SLinus Torvalds 1507a9933ceaSJ. Bruce Fields int vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 15081da177e4SLinus Torvalds { 15091da177e4SLinus Torvalds int error; 15101da177e4SLinus Torvalds 1511b89f4321SArnd Bergmann lock_flocks(); 1512b89f4321SArnd Bergmann error = __vfs_setlease(filp, arg, lease); 1513b89f4321SArnd Bergmann unlock_flocks(); 15141da177e4SLinus Torvalds 15151da177e4SLinus Torvalds return error; 15161da177e4SLinus Torvalds } 1517a9933ceaSJ. Bruce Fields EXPORT_SYMBOL_GPL(vfs_setlease); 15181da177e4SLinus Torvalds 15190ceaf6c7SJ. Bruce Fields static int do_fcntl_delete_lease(struct file *filp) 15200ceaf6c7SJ. Bruce Fields { 15210ceaf6c7SJ. Bruce Fields struct file_lock fl, *flp = &fl; 15220ceaf6c7SJ. Bruce Fields 15230ceaf6c7SJ. Bruce Fields lease_init(filp, F_UNLCK, flp); 15240ceaf6c7SJ. Bruce Fields 15250ceaf6c7SJ. Bruce Fields return vfs_setlease(filp, F_UNLCK, &flp); 15260ceaf6c7SJ. Bruce Fields } 15270ceaf6c7SJ. Bruce Fields 15280ceaf6c7SJ. Bruce Fields static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg) 15291da177e4SLinus Torvalds { 15303df057acSJ. Bruce Fields struct file_lock *fl, *ret; 1531f7347ce4SLinus Torvalds struct fasync_struct *new; 15321da177e4SLinus Torvalds int error; 15331da177e4SLinus Torvalds 1534c5b1f0d9SArnd Bergmann fl = lease_alloc(filp, arg); 1535c5b1f0d9SArnd Bergmann if (IS_ERR(fl)) 1536c5b1f0d9SArnd Bergmann return PTR_ERR(fl); 15371da177e4SLinus Torvalds 1538f7347ce4SLinus Torvalds new = fasync_alloc(); 1539f7347ce4SLinus Torvalds if (!new) { 1540f7347ce4SLinus Torvalds locks_free_lock(fl); 1541f7347ce4SLinus Torvalds return -ENOMEM; 1542f7347ce4SLinus Torvalds } 15433df057acSJ. Bruce Fields ret = fl; 1544b89f4321SArnd Bergmann lock_flocks(); 15458896b93fSJ. Bruce Fields error = __vfs_setlease(filp, arg, &ret); 154651ee4b84SChristoph Hellwig if (error) { 154751ee4b84SChristoph Hellwig unlock_flocks(); 154851ee4b84SChristoph Hellwig locks_free_lock(fl); 154951ee4b84SChristoph Hellwig goto out_free_fasync; 155051ee4b84SChristoph Hellwig } 15513df057acSJ. Bruce Fields if (ret != fl) 15523df057acSJ. Bruce Fields locks_free_lock(fl); 15531da177e4SLinus Torvalds 1554f7347ce4SLinus Torvalds /* 1555f7347ce4SLinus Torvalds * fasync_insert_entry() returns the old entry if any. 1556f7347ce4SLinus Torvalds * If there was no old entry, then it used 'new' and 1557f7347ce4SLinus Torvalds * inserted it into the fasync list. Clear new so that 1558f7347ce4SLinus Torvalds * we don't release it here. 1559f7347ce4SLinus Torvalds */ 15603df057acSJ. Bruce Fields if (!fasync_insert_entry(fd, filp, &ret->fl_fasync, new)) 1561f7347ce4SLinus Torvalds new = NULL; 1562f7347ce4SLinus Torvalds 1563609d7fa9SEric W. Biederman error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0); 1564b89f4321SArnd Bergmann unlock_flocks(); 156551ee4b84SChristoph Hellwig 156651ee4b84SChristoph Hellwig out_free_fasync: 1567f7347ce4SLinus Torvalds if (new) 1568f7347ce4SLinus Torvalds fasync_free(new); 15691da177e4SLinus Torvalds return error; 15701da177e4SLinus Torvalds } 15711da177e4SLinus Torvalds 15721da177e4SLinus Torvalds /** 15730ceaf6c7SJ. Bruce Fields * fcntl_setlease - sets a lease on an open file 15740ceaf6c7SJ. Bruce Fields * @fd: open file descriptor 15750ceaf6c7SJ. Bruce Fields * @filp: file pointer 15760ceaf6c7SJ. Bruce Fields * @arg: type of lease to obtain 15770ceaf6c7SJ. Bruce Fields * 15780ceaf6c7SJ. Bruce Fields * Call this fcntl to establish a lease on the file. 15790ceaf6c7SJ. Bruce Fields * Note that you also need to call %F_SETSIG to 15800ceaf6c7SJ. Bruce Fields * receive a signal when the lease is broken. 15810ceaf6c7SJ. Bruce Fields */ 15820ceaf6c7SJ. Bruce Fields int fcntl_setlease(unsigned int fd, struct file *filp, long arg) 15830ceaf6c7SJ. Bruce Fields { 15840ceaf6c7SJ. Bruce Fields if (arg == F_UNLCK) 15850ceaf6c7SJ. Bruce Fields return do_fcntl_delete_lease(filp); 15860ceaf6c7SJ. Bruce Fields return do_fcntl_add_lease(fd, filp, arg); 15870ceaf6c7SJ. Bruce Fields } 15880ceaf6c7SJ. Bruce Fields 15890ceaf6c7SJ. Bruce Fields /** 15901da177e4SLinus Torvalds * flock_lock_file_wait - Apply a FLOCK-style lock to a file 15911da177e4SLinus Torvalds * @filp: The file to apply the lock to 15921da177e4SLinus Torvalds * @fl: The lock to be applied 15931da177e4SLinus Torvalds * 15941da177e4SLinus Torvalds * Add a FLOCK style lock to a file. 15951da177e4SLinus Torvalds */ 15961da177e4SLinus Torvalds int flock_lock_file_wait(struct file *filp, struct file_lock *fl) 15971da177e4SLinus Torvalds { 15981da177e4SLinus Torvalds int error; 15991da177e4SLinus Torvalds might_sleep(); 16001da177e4SLinus Torvalds for (;;) { 16011da177e4SLinus Torvalds error = flock_lock_file(filp, fl); 1602bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 16031da177e4SLinus Torvalds break; 16041da177e4SLinus Torvalds error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 16051da177e4SLinus Torvalds if (!error) 16061da177e4SLinus Torvalds continue; 16071da177e4SLinus Torvalds 16081da177e4SLinus Torvalds locks_delete_block(fl); 16091da177e4SLinus Torvalds break; 16101da177e4SLinus Torvalds } 16111da177e4SLinus Torvalds return error; 16121da177e4SLinus Torvalds } 16131da177e4SLinus Torvalds 16141da177e4SLinus Torvalds EXPORT_SYMBOL(flock_lock_file_wait); 16151da177e4SLinus Torvalds 16161da177e4SLinus Torvalds /** 16171da177e4SLinus Torvalds * sys_flock: - flock() system call. 16181da177e4SLinus Torvalds * @fd: the file descriptor to lock. 16191da177e4SLinus Torvalds * @cmd: the type of lock to apply. 16201da177e4SLinus Torvalds * 16211da177e4SLinus Torvalds * Apply a %FL_FLOCK style lock to an open file descriptor. 16221da177e4SLinus Torvalds * The @cmd can be one of 16231da177e4SLinus Torvalds * 16241da177e4SLinus Torvalds * %LOCK_SH -- a shared lock. 16251da177e4SLinus Torvalds * 16261da177e4SLinus Torvalds * %LOCK_EX -- an exclusive lock. 16271da177e4SLinus Torvalds * 16281da177e4SLinus Torvalds * %LOCK_UN -- remove an existing lock. 16291da177e4SLinus Torvalds * 16301da177e4SLinus Torvalds * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes. 16311da177e4SLinus Torvalds * 16321da177e4SLinus Torvalds * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other 16331da177e4SLinus Torvalds * processes read and write access respectively. 16341da177e4SLinus Torvalds */ 1635002c8976SHeiko Carstens SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) 16361da177e4SLinus Torvalds { 16371da177e4SLinus Torvalds struct file *filp; 16381da177e4SLinus Torvalds struct file_lock *lock; 16391da177e4SLinus Torvalds int can_sleep, unlock; 16401da177e4SLinus Torvalds int error; 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds error = -EBADF; 16431da177e4SLinus Torvalds filp = fget(fd); 16441da177e4SLinus Torvalds if (!filp) 16451da177e4SLinus Torvalds goto out; 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds can_sleep = !(cmd & LOCK_NB); 16481da177e4SLinus Torvalds cmd &= ~LOCK_NB; 16491da177e4SLinus Torvalds unlock = (cmd == LOCK_UN); 16501da177e4SLinus Torvalds 1651aeb5d727SAl Viro if (!unlock && !(cmd & LOCK_MAND) && 1652aeb5d727SAl Viro !(filp->f_mode & (FMODE_READ|FMODE_WRITE))) 16531da177e4SLinus Torvalds goto out_putf; 16541da177e4SLinus Torvalds 16551da177e4SLinus Torvalds error = flock_make_lock(filp, &lock, cmd); 16561da177e4SLinus Torvalds if (error) 16571da177e4SLinus Torvalds goto out_putf; 16581da177e4SLinus Torvalds if (can_sleep) 16591da177e4SLinus Torvalds lock->fl_flags |= FL_SLEEP; 16601da177e4SLinus Torvalds 1661713c0ecdSSten Spans error = security_file_lock(filp, lock->fl_type); 16621da177e4SLinus Torvalds if (error) 16631da177e4SLinus Torvalds goto out_free; 16641da177e4SLinus Torvalds 16651da177e4SLinus Torvalds if (filp->f_op && filp->f_op->flock) 16661da177e4SLinus Torvalds error = filp->f_op->flock(filp, 16671da177e4SLinus Torvalds (can_sleep) ? F_SETLKW : F_SETLK, 16681da177e4SLinus Torvalds lock); 16691da177e4SLinus Torvalds else 16701da177e4SLinus Torvalds error = flock_lock_file_wait(filp, lock); 16711da177e4SLinus Torvalds 16721da177e4SLinus Torvalds out_free: 16731da177e4SLinus Torvalds locks_free_lock(lock); 16741da177e4SLinus Torvalds 16751da177e4SLinus Torvalds out_putf: 16761da177e4SLinus Torvalds fput(filp); 16771da177e4SLinus Torvalds out: 16781da177e4SLinus Torvalds return error; 16791da177e4SLinus Torvalds } 16801da177e4SLinus Torvalds 16813ee17abdSJ. Bruce Fields /** 16823ee17abdSJ. Bruce Fields * vfs_test_lock - test file byte range lock 16833ee17abdSJ. Bruce Fields * @filp: The file to test lock for 16846924c554SJ. Bruce Fields * @fl: The lock to test; also used to hold result 16853ee17abdSJ. Bruce Fields * 16863ee17abdSJ. Bruce Fields * Returns -ERRNO on failure. Indicates presence of conflicting lock by 16873ee17abdSJ. Bruce Fields * setting conf->fl_type to something other than F_UNLCK. 16883ee17abdSJ. Bruce Fields */ 16893ee17abdSJ. Bruce Fields int vfs_test_lock(struct file *filp, struct file_lock *fl) 16903ee17abdSJ. Bruce Fields { 16913ee17abdSJ. Bruce Fields if (filp->f_op && filp->f_op->lock) 16923ee17abdSJ. Bruce Fields return filp->f_op->lock(filp, F_GETLK, fl); 16933ee17abdSJ. Bruce Fields posix_test_lock(filp, fl); 16943ee17abdSJ. Bruce Fields return 0; 16953ee17abdSJ. Bruce Fields } 16963ee17abdSJ. Bruce Fields EXPORT_SYMBOL_GPL(vfs_test_lock); 16973ee17abdSJ. Bruce Fields 1698c2fa1b8aSJ. Bruce Fields static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) 1699c2fa1b8aSJ. Bruce Fields { 1700c2fa1b8aSJ. Bruce Fields flock->l_pid = fl->fl_pid; 1701c2fa1b8aSJ. Bruce Fields #if BITS_PER_LONG == 32 1702c2fa1b8aSJ. Bruce Fields /* 1703c2fa1b8aSJ. Bruce Fields * Make sure we can represent the posix lock via 1704c2fa1b8aSJ. Bruce Fields * legacy 32bit flock. 1705c2fa1b8aSJ. Bruce Fields */ 1706c2fa1b8aSJ. Bruce Fields if (fl->fl_start > OFFT_OFFSET_MAX) 1707c2fa1b8aSJ. Bruce Fields return -EOVERFLOW; 1708c2fa1b8aSJ. Bruce Fields if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX) 1709c2fa1b8aSJ. Bruce Fields return -EOVERFLOW; 1710c2fa1b8aSJ. Bruce Fields #endif 1711c2fa1b8aSJ. Bruce Fields flock->l_start = fl->fl_start; 1712c2fa1b8aSJ. Bruce Fields flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1713c2fa1b8aSJ. Bruce Fields fl->fl_end - fl->fl_start + 1; 1714c2fa1b8aSJ. Bruce Fields flock->l_whence = 0; 1715129a84deSJ. Bruce Fields flock->l_type = fl->fl_type; 1716c2fa1b8aSJ. Bruce Fields return 0; 1717c2fa1b8aSJ. Bruce Fields } 1718c2fa1b8aSJ. Bruce Fields 1719c2fa1b8aSJ. Bruce Fields #if BITS_PER_LONG == 32 1720c2fa1b8aSJ. Bruce Fields static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) 1721c2fa1b8aSJ. Bruce Fields { 1722c2fa1b8aSJ. Bruce Fields flock->l_pid = fl->fl_pid; 1723c2fa1b8aSJ. Bruce Fields flock->l_start = fl->fl_start; 1724c2fa1b8aSJ. Bruce Fields flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1725c2fa1b8aSJ. Bruce Fields fl->fl_end - fl->fl_start + 1; 1726c2fa1b8aSJ. Bruce Fields flock->l_whence = 0; 1727c2fa1b8aSJ. Bruce Fields flock->l_type = fl->fl_type; 1728c2fa1b8aSJ. Bruce Fields } 1729c2fa1b8aSJ. Bruce Fields #endif 1730c2fa1b8aSJ. Bruce Fields 17311da177e4SLinus Torvalds /* Report the first existing lock that would conflict with l. 17321da177e4SLinus Torvalds * This implements the F_GETLK command of fcntl(). 17331da177e4SLinus Torvalds */ 17341da177e4SLinus Torvalds int fcntl_getlk(struct file *filp, struct flock __user *l) 17351da177e4SLinus Torvalds { 17369d6a8c5cSMarc Eshel struct file_lock file_lock; 17371da177e4SLinus Torvalds struct flock flock; 17381da177e4SLinus Torvalds int error; 17391da177e4SLinus Torvalds 17401da177e4SLinus Torvalds error = -EFAULT; 17411da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 17421da177e4SLinus Torvalds goto out; 17431da177e4SLinus Torvalds error = -EINVAL; 17441da177e4SLinus Torvalds if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 17451da177e4SLinus Torvalds goto out; 17461da177e4SLinus Torvalds 17471da177e4SLinus Torvalds error = flock_to_posix_lock(filp, &file_lock, &flock); 17481da177e4SLinus Torvalds if (error) 17491da177e4SLinus Torvalds goto out; 17501da177e4SLinus Torvalds 17513ee17abdSJ. Bruce Fields error = vfs_test_lock(filp, &file_lock); 17523ee17abdSJ. Bruce Fields if (error) 17531da177e4SLinus Torvalds goto out; 17541da177e4SLinus Torvalds 17559d6a8c5cSMarc Eshel flock.l_type = file_lock.fl_type; 17569d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) { 17579d6a8c5cSMarc Eshel error = posix_lock_to_flock(&flock, &file_lock); 1758c2fa1b8aSJ. Bruce Fields if (error) 17591da177e4SLinus Torvalds goto out; 17601da177e4SLinus Torvalds } 17611da177e4SLinus Torvalds error = -EFAULT; 17621da177e4SLinus Torvalds if (!copy_to_user(l, &flock, sizeof(flock))) 17631da177e4SLinus Torvalds error = 0; 17641da177e4SLinus Torvalds out: 17651da177e4SLinus Torvalds return error; 17661da177e4SLinus Torvalds } 17671da177e4SLinus Torvalds 17687723ec97SMarc Eshel /** 17697723ec97SMarc Eshel * vfs_lock_file - file byte range lock 17707723ec97SMarc Eshel * @filp: The file to apply the lock to 17717723ec97SMarc Eshel * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.) 17727723ec97SMarc Eshel * @fl: The lock to be applied 1773150b3934SMarc Eshel * @conf: Place to return a copy of the conflicting lock, if found. 1774150b3934SMarc Eshel * 1775150b3934SMarc Eshel * A caller that doesn't care about the conflicting lock may pass NULL 1776150b3934SMarc Eshel * as the final argument. 1777150b3934SMarc Eshel * 1778150b3934SMarc Eshel * If the filesystem defines a private ->lock() method, then @conf will 1779150b3934SMarc Eshel * be left unchanged; so a caller that cares should initialize it to 1780150b3934SMarc Eshel * some acceptable default. 17812beb6614SMarc Eshel * 17822beb6614SMarc Eshel * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX 17832beb6614SMarc Eshel * locks, the ->lock() interface may return asynchronously, before the lock has 17842beb6614SMarc Eshel * been granted or denied by the underlying filesystem, if (and only if) 17858fb47a4fSJ. Bruce Fields * lm_grant is set. Callers expecting ->lock() to return asynchronously 17862beb6614SMarc Eshel * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if) 17872beb6614SMarc Eshel * the request is for a blocking lock. When ->lock() does return asynchronously, 17888fb47a4fSJ. Bruce Fields * it must return FILE_LOCK_DEFERRED, and call ->lm_grant() when the lock 17892beb6614SMarc Eshel * request completes. 17902beb6614SMarc Eshel * If the request is for non-blocking lock the file system should return 1791bde74e4bSMiklos Szeredi * FILE_LOCK_DEFERRED then try to get the lock and call the callback routine 1792bde74e4bSMiklos Szeredi * with the result. If the request timed out the callback routine will return a 17932beb6614SMarc Eshel * nonzero return code and the file system should release the lock. The file 17942beb6614SMarc Eshel * system is also responsible to keep a corresponding posix lock when it 17952beb6614SMarc Eshel * grants a lock so the VFS can find out which locks are locally held and do 17962beb6614SMarc Eshel * the correct lock cleanup when required. 17972beb6614SMarc Eshel * The underlying filesystem must not drop the kernel lock or call 17988fb47a4fSJ. Bruce Fields * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED 17992beb6614SMarc Eshel * return code. 18007723ec97SMarc Eshel */ 1801150b3934SMarc Eshel int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) 18027723ec97SMarc Eshel { 18037723ec97SMarc Eshel if (filp->f_op && filp->f_op->lock) 18047723ec97SMarc Eshel return filp->f_op->lock(filp, cmd, fl); 18057723ec97SMarc Eshel else 1806150b3934SMarc Eshel return posix_lock_file(filp, fl, conf); 18077723ec97SMarc Eshel } 18087723ec97SMarc Eshel EXPORT_SYMBOL_GPL(vfs_lock_file); 18097723ec97SMarc Eshel 1810b648a6deSMiklos Szeredi static int do_lock_file_wait(struct file *filp, unsigned int cmd, 1811b648a6deSMiklos Szeredi struct file_lock *fl) 1812b648a6deSMiklos Szeredi { 1813b648a6deSMiklos Szeredi int error; 1814b648a6deSMiklos Szeredi 1815b648a6deSMiklos Szeredi error = security_file_lock(filp, fl->fl_type); 1816b648a6deSMiklos Szeredi if (error) 1817b648a6deSMiklos Szeredi return error; 1818b648a6deSMiklos Szeredi 1819b648a6deSMiklos Szeredi for (;;) { 1820764c76b3SMiklos Szeredi error = vfs_lock_file(filp, cmd, fl, NULL); 1821b648a6deSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 1822b648a6deSMiklos Szeredi break; 1823764c76b3SMiklos Szeredi error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 1824b648a6deSMiklos Szeredi if (!error) 1825b648a6deSMiklos Szeredi continue; 1826b648a6deSMiklos Szeredi 1827b648a6deSMiklos Szeredi locks_delete_block(fl); 1828b648a6deSMiklos Szeredi break; 1829b648a6deSMiklos Szeredi } 1830b648a6deSMiklos Szeredi 1831b648a6deSMiklos Szeredi return error; 1832b648a6deSMiklos Szeredi } 1833b648a6deSMiklos Szeredi 18341da177e4SLinus Torvalds /* Apply the lock described by l to an open file descriptor. 18351da177e4SLinus Torvalds * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 18361da177e4SLinus Torvalds */ 1837c293621bSPeter Staubach int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, 1838c293621bSPeter Staubach struct flock __user *l) 18391da177e4SLinus Torvalds { 18401da177e4SLinus Torvalds struct file_lock *file_lock = locks_alloc_lock(); 18411da177e4SLinus Torvalds struct flock flock; 18421da177e4SLinus Torvalds struct inode *inode; 18430b2bac2fSAl Viro struct file *f; 18441da177e4SLinus Torvalds int error; 18451da177e4SLinus Torvalds 18461da177e4SLinus Torvalds if (file_lock == NULL) 18471da177e4SLinus Torvalds return -ENOLCK; 18481da177e4SLinus Torvalds 18491da177e4SLinus Torvalds /* 18501da177e4SLinus Torvalds * This might block, so we do it before checking the inode. 18511da177e4SLinus Torvalds */ 18521da177e4SLinus Torvalds error = -EFAULT; 18531da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 18541da177e4SLinus Torvalds goto out; 18551da177e4SLinus Torvalds 18560f7fc9e4SJosef "Jeff" Sipek inode = filp->f_path.dentry->d_inode; 18571da177e4SLinus Torvalds 18581da177e4SLinus Torvalds /* Don't allow mandatory locks on files that may be memory mapped 18591da177e4SLinus Torvalds * and shared. 18601da177e4SLinus Torvalds */ 1861a16877caSPavel Emelyanov if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 18621da177e4SLinus Torvalds error = -EAGAIN; 18631da177e4SLinus Torvalds goto out; 18641da177e4SLinus Torvalds } 18651da177e4SLinus Torvalds 1866c293621bSPeter Staubach again: 18671da177e4SLinus Torvalds error = flock_to_posix_lock(filp, file_lock, &flock); 18681da177e4SLinus Torvalds if (error) 18691da177e4SLinus Torvalds goto out; 18701da177e4SLinus Torvalds if (cmd == F_SETLKW) { 18711da177e4SLinus Torvalds file_lock->fl_flags |= FL_SLEEP; 18721da177e4SLinus Torvalds } 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds error = -EBADF; 18751da177e4SLinus Torvalds switch (flock.l_type) { 18761da177e4SLinus Torvalds case F_RDLCK: 18771da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_READ)) 18781da177e4SLinus Torvalds goto out; 18791da177e4SLinus Torvalds break; 18801da177e4SLinus Torvalds case F_WRLCK: 18811da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_WRITE)) 18821da177e4SLinus Torvalds goto out; 18831da177e4SLinus Torvalds break; 18841da177e4SLinus Torvalds case F_UNLCK: 18851da177e4SLinus Torvalds break; 18861da177e4SLinus Torvalds default: 18871da177e4SLinus Torvalds error = -EINVAL; 18881da177e4SLinus Torvalds goto out; 18891da177e4SLinus Torvalds } 18901da177e4SLinus Torvalds 1891b648a6deSMiklos Szeredi error = do_lock_file_wait(filp, cmd, file_lock); 1892c293621bSPeter Staubach 1893c293621bSPeter Staubach /* 1894c293621bSPeter Staubach * Attempt to detect a close/fcntl race and recover by 1895c293621bSPeter Staubach * releasing the lock that was just acquired. 1896c293621bSPeter Staubach */ 18970b2bac2fSAl Viro /* 18980b2bac2fSAl Viro * we need that spin_lock here - it prevents reordering between 18990b2bac2fSAl Viro * update of inode->i_flock and check for it done in close(). 19000b2bac2fSAl Viro * rcu_read_lock() wouldn't do. 19010b2bac2fSAl Viro */ 19020b2bac2fSAl Viro spin_lock(¤t->files->file_lock); 19030b2bac2fSAl Viro f = fcheck(fd); 19040b2bac2fSAl Viro spin_unlock(¤t->files->file_lock); 19050b2bac2fSAl Viro if (!error && f != filp && flock.l_type != F_UNLCK) { 1906c293621bSPeter Staubach flock.l_type = F_UNLCK; 1907c293621bSPeter Staubach goto again; 1908c293621bSPeter Staubach } 19091da177e4SLinus Torvalds 19101da177e4SLinus Torvalds out: 19111da177e4SLinus Torvalds locks_free_lock(file_lock); 19121da177e4SLinus Torvalds return error; 19131da177e4SLinus Torvalds } 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds #if BITS_PER_LONG == 32 19161da177e4SLinus Torvalds /* Report the first existing lock that would conflict with l. 19171da177e4SLinus Torvalds * This implements the F_GETLK command of fcntl(). 19181da177e4SLinus Torvalds */ 19191da177e4SLinus Torvalds int fcntl_getlk64(struct file *filp, struct flock64 __user *l) 19201da177e4SLinus Torvalds { 19219d6a8c5cSMarc Eshel struct file_lock file_lock; 19221da177e4SLinus Torvalds struct flock64 flock; 19231da177e4SLinus Torvalds int error; 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds error = -EFAULT; 19261da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 19271da177e4SLinus Torvalds goto out; 19281da177e4SLinus Torvalds error = -EINVAL; 19291da177e4SLinus Torvalds if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 19301da177e4SLinus Torvalds goto out; 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvalds error = flock64_to_posix_lock(filp, &file_lock, &flock); 19331da177e4SLinus Torvalds if (error) 19341da177e4SLinus Torvalds goto out; 19351da177e4SLinus Torvalds 19363ee17abdSJ. Bruce Fields error = vfs_test_lock(filp, &file_lock); 19373ee17abdSJ. Bruce Fields if (error) 19381da177e4SLinus Torvalds goto out; 19391da177e4SLinus Torvalds 19409d6a8c5cSMarc Eshel flock.l_type = file_lock.fl_type; 19419d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) 19429d6a8c5cSMarc Eshel posix_lock_to_flock64(&flock, &file_lock); 19439d6a8c5cSMarc Eshel 19441da177e4SLinus Torvalds error = -EFAULT; 19451da177e4SLinus Torvalds if (!copy_to_user(l, &flock, sizeof(flock))) 19461da177e4SLinus Torvalds error = 0; 19471da177e4SLinus Torvalds 19481da177e4SLinus Torvalds out: 19491da177e4SLinus Torvalds return error; 19501da177e4SLinus Torvalds } 19511da177e4SLinus Torvalds 19521da177e4SLinus Torvalds /* Apply the lock described by l to an open file descriptor. 19531da177e4SLinus Torvalds * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 19541da177e4SLinus Torvalds */ 1955c293621bSPeter Staubach int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, 1956c293621bSPeter Staubach struct flock64 __user *l) 19571da177e4SLinus Torvalds { 19581da177e4SLinus Torvalds struct file_lock *file_lock = locks_alloc_lock(); 19591da177e4SLinus Torvalds struct flock64 flock; 19601da177e4SLinus Torvalds struct inode *inode; 19610b2bac2fSAl Viro struct file *f; 19621da177e4SLinus Torvalds int error; 19631da177e4SLinus Torvalds 19641da177e4SLinus Torvalds if (file_lock == NULL) 19651da177e4SLinus Torvalds return -ENOLCK; 19661da177e4SLinus Torvalds 19671da177e4SLinus Torvalds /* 19681da177e4SLinus Torvalds * This might block, so we do it before checking the inode. 19691da177e4SLinus Torvalds */ 19701da177e4SLinus Torvalds error = -EFAULT; 19711da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 19721da177e4SLinus Torvalds goto out; 19731da177e4SLinus Torvalds 19740f7fc9e4SJosef "Jeff" Sipek inode = filp->f_path.dentry->d_inode; 19751da177e4SLinus Torvalds 19761da177e4SLinus Torvalds /* Don't allow mandatory locks on files that may be memory mapped 19771da177e4SLinus Torvalds * and shared. 19781da177e4SLinus Torvalds */ 1979a16877caSPavel Emelyanov if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 19801da177e4SLinus Torvalds error = -EAGAIN; 19811da177e4SLinus Torvalds goto out; 19821da177e4SLinus Torvalds } 19831da177e4SLinus Torvalds 1984c293621bSPeter Staubach again: 19851da177e4SLinus Torvalds error = flock64_to_posix_lock(filp, file_lock, &flock); 19861da177e4SLinus Torvalds if (error) 19871da177e4SLinus Torvalds goto out; 19881da177e4SLinus Torvalds if (cmd == F_SETLKW64) { 19891da177e4SLinus Torvalds file_lock->fl_flags |= FL_SLEEP; 19901da177e4SLinus Torvalds } 19911da177e4SLinus Torvalds 19921da177e4SLinus Torvalds error = -EBADF; 19931da177e4SLinus Torvalds switch (flock.l_type) { 19941da177e4SLinus Torvalds case F_RDLCK: 19951da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_READ)) 19961da177e4SLinus Torvalds goto out; 19971da177e4SLinus Torvalds break; 19981da177e4SLinus Torvalds case F_WRLCK: 19991da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_WRITE)) 20001da177e4SLinus Torvalds goto out; 20011da177e4SLinus Torvalds break; 20021da177e4SLinus Torvalds case F_UNLCK: 20031da177e4SLinus Torvalds break; 20041da177e4SLinus Torvalds default: 20051da177e4SLinus Torvalds error = -EINVAL; 20061da177e4SLinus Torvalds goto out; 20071da177e4SLinus Torvalds } 20081da177e4SLinus Torvalds 2009b648a6deSMiklos Szeredi error = do_lock_file_wait(filp, cmd, file_lock); 2010c293621bSPeter Staubach 2011c293621bSPeter Staubach /* 2012c293621bSPeter Staubach * Attempt to detect a close/fcntl race and recover by 2013c293621bSPeter Staubach * releasing the lock that was just acquired. 2014c293621bSPeter Staubach */ 20150b2bac2fSAl Viro spin_lock(¤t->files->file_lock); 20160b2bac2fSAl Viro f = fcheck(fd); 20170b2bac2fSAl Viro spin_unlock(¤t->files->file_lock); 20180b2bac2fSAl Viro if (!error && f != filp && flock.l_type != F_UNLCK) { 2019c293621bSPeter Staubach flock.l_type = F_UNLCK; 2020c293621bSPeter Staubach goto again; 2021c293621bSPeter Staubach } 20221da177e4SLinus Torvalds 20231da177e4SLinus Torvalds out: 20241da177e4SLinus Torvalds locks_free_lock(file_lock); 20251da177e4SLinus Torvalds return error; 20261da177e4SLinus Torvalds } 20271da177e4SLinus Torvalds #endif /* BITS_PER_LONG == 32 */ 20281da177e4SLinus Torvalds 20291da177e4SLinus Torvalds /* 20301da177e4SLinus Torvalds * This function is called when the file is being removed 20311da177e4SLinus Torvalds * from the task's fd array. POSIX locks belonging to this task 20321da177e4SLinus Torvalds * are deleted at this time. 20331da177e4SLinus Torvalds */ 20341da177e4SLinus Torvalds void locks_remove_posix(struct file *filp, fl_owner_t owner) 20351da177e4SLinus Torvalds { 2036ff7b86b8SMiklos Szeredi struct file_lock lock; 20371da177e4SLinus Torvalds 20381da177e4SLinus Torvalds /* 20391da177e4SLinus Torvalds * If there are no locks held on this file, we don't need to call 20401da177e4SLinus Torvalds * posix_lock_file(). Another process could be setting a lock on this 20411da177e4SLinus Torvalds * file at the same time, but we wouldn't remove that lock anyway. 20421da177e4SLinus Torvalds */ 20430f7fc9e4SJosef "Jeff" Sipek if (!filp->f_path.dentry->d_inode->i_flock) 20441da177e4SLinus Torvalds return; 20451da177e4SLinus Torvalds 20461da177e4SLinus Torvalds lock.fl_type = F_UNLCK; 204775e1fcc0SMiklos Szeredi lock.fl_flags = FL_POSIX | FL_CLOSE; 20481da177e4SLinus Torvalds lock.fl_start = 0; 20491da177e4SLinus Torvalds lock.fl_end = OFFSET_MAX; 20501da177e4SLinus Torvalds lock.fl_owner = owner; 20511da177e4SLinus Torvalds lock.fl_pid = current->tgid; 20521da177e4SLinus Torvalds lock.fl_file = filp; 20531da177e4SLinus Torvalds lock.fl_ops = NULL; 20541da177e4SLinus Torvalds lock.fl_lmops = NULL; 20551da177e4SLinus Torvalds 2056150b3934SMarc Eshel vfs_lock_file(filp, F_SETLK, &lock, NULL); 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds if (lock.fl_ops && lock.fl_ops->fl_release_private) 20591da177e4SLinus Torvalds lock.fl_ops->fl_release_private(&lock); 20601da177e4SLinus Torvalds } 20611da177e4SLinus Torvalds 20621da177e4SLinus Torvalds EXPORT_SYMBOL(locks_remove_posix); 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds /* 20651da177e4SLinus Torvalds * This function is called on the last close of an open file. 20661da177e4SLinus Torvalds */ 20671da177e4SLinus Torvalds void locks_remove_flock(struct file *filp) 20681da177e4SLinus Torvalds { 20690f7fc9e4SJosef "Jeff" Sipek struct inode * inode = filp->f_path.dentry->d_inode; 20701da177e4SLinus Torvalds struct file_lock *fl; 20711da177e4SLinus Torvalds struct file_lock **before; 20721da177e4SLinus Torvalds 20731da177e4SLinus Torvalds if (!inode->i_flock) 20741da177e4SLinus Torvalds return; 20751da177e4SLinus Torvalds 20761da177e4SLinus Torvalds if (filp->f_op && filp->f_op->flock) { 20771da177e4SLinus Torvalds struct file_lock fl = { 20781da177e4SLinus Torvalds .fl_pid = current->tgid, 20791da177e4SLinus Torvalds .fl_file = filp, 20801da177e4SLinus Torvalds .fl_flags = FL_FLOCK, 20811da177e4SLinus Torvalds .fl_type = F_UNLCK, 20821da177e4SLinus Torvalds .fl_end = OFFSET_MAX, 20831da177e4SLinus Torvalds }; 20841da177e4SLinus Torvalds filp->f_op->flock(filp, F_SETLKW, &fl); 208580fec4c6STrond Myklebust if (fl.fl_ops && fl.fl_ops->fl_release_private) 208680fec4c6STrond Myklebust fl.fl_ops->fl_release_private(&fl); 20871da177e4SLinus Torvalds } 20881da177e4SLinus Torvalds 2089b89f4321SArnd Bergmann lock_flocks(); 20901da177e4SLinus Torvalds before = &inode->i_flock; 20911da177e4SLinus Torvalds 20921da177e4SLinus Torvalds while ((fl = *before) != NULL) { 20931da177e4SLinus Torvalds if (fl->fl_file == filp) { 2094c293621bSPeter Staubach if (IS_FLOCK(fl)) { 20951da177e4SLinus Torvalds locks_delete_lock(before); 20961da177e4SLinus Torvalds continue; 20971da177e4SLinus Torvalds } 20981da177e4SLinus Torvalds if (IS_LEASE(fl)) { 20991da177e4SLinus Torvalds lease_modify(before, F_UNLCK); 21001da177e4SLinus Torvalds continue; 21011da177e4SLinus Torvalds } 21021da177e4SLinus Torvalds /* What? */ 21031da177e4SLinus Torvalds BUG(); 21041da177e4SLinus Torvalds } 21051da177e4SLinus Torvalds before = &fl->fl_next; 21061da177e4SLinus Torvalds } 2107b89f4321SArnd Bergmann unlock_flocks(); 21081da177e4SLinus Torvalds } 21091da177e4SLinus Torvalds 21101da177e4SLinus Torvalds /** 21111da177e4SLinus Torvalds * posix_unblock_lock - stop waiting for a file lock 21121da177e4SLinus Torvalds * @filp: how the file was opened 21131da177e4SLinus Torvalds * @waiter: the lock which was waiting 21141da177e4SLinus Torvalds * 21151da177e4SLinus Torvalds * lockd needs to block waiting for locks. 21161da177e4SLinus Torvalds */ 211764a318eeSJ. Bruce Fields int 21181da177e4SLinus Torvalds posix_unblock_lock(struct file *filp, struct file_lock *waiter) 21191da177e4SLinus Torvalds { 212064a318eeSJ. Bruce Fields int status = 0; 212164a318eeSJ. Bruce Fields 2122b89f4321SArnd Bergmann lock_flocks(); 21235996a298SJ. Bruce Fields if (waiter->fl_next) 21241da177e4SLinus Torvalds __locks_delete_block(waiter); 212564a318eeSJ. Bruce Fields else 212664a318eeSJ. Bruce Fields status = -ENOENT; 2127b89f4321SArnd Bergmann unlock_flocks(); 212864a318eeSJ. Bruce Fields return status; 21291da177e4SLinus Torvalds } 21301da177e4SLinus Torvalds 21311da177e4SLinus Torvalds EXPORT_SYMBOL(posix_unblock_lock); 21321da177e4SLinus Torvalds 21339b9d2ab4SMarc Eshel /** 21349b9d2ab4SMarc Eshel * vfs_cancel_lock - file byte range unblock lock 21359b9d2ab4SMarc Eshel * @filp: The file to apply the unblock to 21369b9d2ab4SMarc Eshel * @fl: The lock to be unblocked 21379b9d2ab4SMarc Eshel * 21389b9d2ab4SMarc Eshel * Used by lock managers to cancel blocked requests 21399b9d2ab4SMarc Eshel */ 21409b9d2ab4SMarc Eshel int vfs_cancel_lock(struct file *filp, struct file_lock *fl) 21419b9d2ab4SMarc Eshel { 21429b9d2ab4SMarc Eshel if (filp->f_op && filp->f_op->lock) 21439b9d2ab4SMarc Eshel return filp->f_op->lock(filp, F_CANCELLK, fl); 21449b9d2ab4SMarc Eshel return 0; 21459b9d2ab4SMarc Eshel } 21469b9d2ab4SMarc Eshel 21479b9d2ab4SMarc Eshel EXPORT_SYMBOL_GPL(vfs_cancel_lock); 21489b9d2ab4SMarc Eshel 21497f8ada98SPavel Emelyanov #ifdef CONFIG_PROC_FS 2150d8ba7a36SAlexey Dobriyan #include <linux/proc_fs.h> 21517f8ada98SPavel Emelyanov #include <linux/seq_file.h> 21527f8ada98SPavel Emelyanov 21537f8ada98SPavel Emelyanov static void lock_get_status(struct seq_file *f, struct file_lock *fl, 215499dc8292SJerome Marchand loff_t id, char *pfx) 21551da177e4SLinus Torvalds { 21561da177e4SLinus Torvalds struct inode *inode = NULL; 2157ab1f1611SVitaliy Gusev unsigned int fl_pid; 2158ab1f1611SVitaliy Gusev 2159ab1f1611SVitaliy Gusev if (fl->fl_nspid) 21606c5f3e7bSPavel Emelyanov fl_pid = pid_vnr(fl->fl_nspid); 2161ab1f1611SVitaliy Gusev else 2162ab1f1611SVitaliy Gusev fl_pid = fl->fl_pid; 21631da177e4SLinus Torvalds 21641da177e4SLinus Torvalds if (fl->fl_file != NULL) 21650f7fc9e4SJosef "Jeff" Sipek inode = fl->fl_file->f_path.dentry->d_inode; 21661da177e4SLinus Torvalds 216799dc8292SJerome Marchand seq_printf(f, "%lld:%s ", id, pfx); 21681da177e4SLinus Torvalds if (IS_POSIX(fl)) { 21697f8ada98SPavel Emelyanov seq_printf(f, "%6s %s ", 21701da177e4SLinus Torvalds (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ", 21711da177e4SLinus Torvalds (inode == NULL) ? "*NOINODE*" : 2172a16877caSPavel Emelyanov mandatory_lock(inode) ? "MANDATORY" : "ADVISORY "); 21731da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 21741da177e4SLinus Torvalds if (fl->fl_type & LOCK_MAND) { 21757f8ada98SPavel Emelyanov seq_printf(f, "FLOCK MSNFS "); 21761da177e4SLinus Torvalds } else { 21777f8ada98SPavel Emelyanov seq_printf(f, "FLOCK ADVISORY "); 21781da177e4SLinus Torvalds } 21791da177e4SLinus Torvalds } else if (IS_LEASE(fl)) { 21807f8ada98SPavel Emelyanov seq_printf(f, "LEASE "); 2181ab83fa4bSJ. Bruce Fields if (lease_breaking(fl)) 21827f8ada98SPavel Emelyanov seq_printf(f, "BREAKING "); 21831da177e4SLinus Torvalds else if (fl->fl_file) 21847f8ada98SPavel Emelyanov seq_printf(f, "ACTIVE "); 21851da177e4SLinus Torvalds else 21867f8ada98SPavel Emelyanov seq_printf(f, "BREAKER "); 21871da177e4SLinus Torvalds } else { 21887f8ada98SPavel Emelyanov seq_printf(f, "UNKNOWN UNKNOWN "); 21891da177e4SLinus Torvalds } 21901da177e4SLinus Torvalds if (fl->fl_type & LOCK_MAND) { 21917f8ada98SPavel Emelyanov seq_printf(f, "%s ", 21921da177e4SLinus Torvalds (fl->fl_type & LOCK_READ) 21931da177e4SLinus Torvalds ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ " 21941da177e4SLinus Torvalds : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE "); 21951da177e4SLinus Torvalds } else { 21967f8ada98SPavel Emelyanov seq_printf(f, "%s ", 2197ab83fa4bSJ. Bruce Fields (lease_breaking(fl)) 21981da177e4SLinus Torvalds ? (fl->fl_type & F_UNLCK) ? "UNLCK" : "READ " 21991da177e4SLinus Torvalds : (fl->fl_type & F_WRLCK) ? "WRITE" : "READ "); 22001da177e4SLinus Torvalds } 22011da177e4SLinus Torvalds if (inode) { 22021da177e4SLinus Torvalds #ifdef WE_CAN_BREAK_LSLK_NOW 2203ab1f1611SVitaliy Gusev seq_printf(f, "%d %s:%ld ", fl_pid, 22041da177e4SLinus Torvalds inode->i_sb->s_id, inode->i_ino); 22051da177e4SLinus Torvalds #else 22061da177e4SLinus Torvalds /* userspace relies on this representation of dev_t ;-( */ 2207ab1f1611SVitaliy Gusev seq_printf(f, "%d %02x:%02x:%ld ", fl_pid, 22081da177e4SLinus Torvalds MAJOR(inode->i_sb->s_dev), 22091da177e4SLinus Torvalds MINOR(inode->i_sb->s_dev), inode->i_ino); 22101da177e4SLinus Torvalds #endif 22111da177e4SLinus Torvalds } else { 2212ab1f1611SVitaliy Gusev seq_printf(f, "%d <none>:0 ", fl_pid); 22131da177e4SLinus Torvalds } 22141da177e4SLinus Torvalds if (IS_POSIX(fl)) { 22151da177e4SLinus Torvalds if (fl->fl_end == OFFSET_MAX) 22167f8ada98SPavel Emelyanov seq_printf(f, "%Ld EOF\n", fl->fl_start); 22171da177e4SLinus Torvalds else 22187f8ada98SPavel Emelyanov seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end); 22191da177e4SLinus Torvalds } else { 22207f8ada98SPavel Emelyanov seq_printf(f, "0 EOF\n"); 22211da177e4SLinus Torvalds } 22221da177e4SLinus Torvalds } 22231da177e4SLinus Torvalds 22247f8ada98SPavel Emelyanov static int locks_show(struct seq_file *f, void *v) 22251da177e4SLinus Torvalds { 22267f8ada98SPavel Emelyanov struct file_lock *fl, *bfl; 22277f8ada98SPavel Emelyanov 22287f8ada98SPavel Emelyanov fl = list_entry(v, struct file_lock, fl_link); 22297f8ada98SPavel Emelyanov 223099dc8292SJerome Marchand lock_get_status(f, fl, *((loff_t *)f->private), ""); 22317f8ada98SPavel Emelyanov 22327f8ada98SPavel Emelyanov list_for_each_entry(bfl, &fl->fl_block, fl_block) 223399dc8292SJerome Marchand lock_get_status(f, bfl, *((loff_t *)f->private), " ->"); 22347f8ada98SPavel Emelyanov 22357f8ada98SPavel Emelyanov return 0; 22361da177e4SLinus Torvalds } 22371da177e4SLinus Torvalds 22387f8ada98SPavel Emelyanov static void *locks_start(struct seq_file *f, loff_t *pos) 22391da177e4SLinus Torvalds { 224099dc8292SJerome Marchand loff_t *p = f->private; 224199dc8292SJerome Marchand 2242b89f4321SArnd Bergmann lock_flocks(); 224399dc8292SJerome Marchand *p = (*pos + 1); 22447f8ada98SPavel Emelyanov return seq_list_start(&file_lock_list, *pos); 22451da177e4SLinus Torvalds } 22467f8ada98SPavel Emelyanov 22477f8ada98SPavel Emelyanov static void *locks_next(struct seq_file *f, void *v, loff_t *pos) 22487f8ada98SPavel Emelyanov { 224999dc8292SJerome Marchand loff_t *p = f->private; 225099dc8292SJerome Marchand ++*p; 22517f8ada98SPavel Emelyanov return seq_list_next(v, &file_lock_list, pos); 22521da177e4SLinus Torvalds } 22537f8ada98SPavel Emelyanov 22547f8ada98SPavel Emelyanov static void locks_stop(struct seq_file *f, void *v) 22557f8ada98SPavel Emelyanov { 2256b89f4321SArnd Bergmann unlock_flocks(); 22571da177e4SLinus Torvalds } 22581da177e4SLinus Torvalds 2259d8ba7a36SAlexey Dobriyan static const struct seq_operations locks_seq_operations = { 22607f8ada98SPavel Emelyanov .start = locks_start, 22617f8ada98SPavel Emelyanov .next = locks_next, 22627f8ada98SPavel Emelyanov .stop = locks_stop, 22637f8ada98SPavel Emelyanov .show = locks_show, 22647f8ada98SPavel Emelyanov }; 2265d8ba7a36SAlexey Dobriyan 2266d8ba7a36SAlexey Dobriyan static int locks_open(struct inode *inode, struct file *filp) 2267d8ba7a36SAlexey Dobriyan { 226899dc8292SJerome Marchand return seq_open_private(filp, &locks_seq_operations, sizeof(loff_t)); 2269d8ba7a36SAlexey Dobriyan } 2270d8ba7a36SAlexey Dobriyan 2271d8ba7a36SAlexey Dobriyan static const struct file_operations proc_locks_operations = { 2272d8ba7a36SAlexey Dobriyan .open = locks_open, 2273d8ba7a36SAlexey Dobriyan .read = seq_read, 2274d8ba7a36SAlexey Dobriyan .llseek = seq_lseek, 227599dc8292SJerome Marchand .release = seq_release_private, 2276d8ba7a36SAlexey Dobriyan }; 2277d8ba7a36SAlexey Dobriyan 2278d8ba7a36SAlexey Dobriyan static int __init proc_locks_init(void) 2279d8ba7a36SAlexey Dobriyan { 2280d8ba7a36SAlexey Dobriyan proc_create("locks", 0, NULL, &proc_locks_operations); 2281d8ba7a36SAlexey Dobriyan return 0; 2282d8ba7a36SAlexey Dobriyan } 2283d8ba7a36SAlexey Dobriyan module_init(proc_locks_init); 22847f8ada98SPavel Emelyanov #endif 22857f8ada98SPavel Emelyanov 22861da177e4SLinus Torvalds /** 22871da177e4SLinus Torvalds * lock_may_read - checks that the region is free of locks 22881da177e4SLinus Torvalds * @inode: the inode that is being read 22891da177e4SLinus Torvalds * @start: the first byte to read 22901da177e4SLinus Torvalds * @len: the number of bytes to read 22911da177e4SLinus Torvalds * 22921da177e4SLinus Torvalds * Emulates Windows locking requirements. Whole-file 22931da177e4SLinus Torvalds * mandatory locks (share modes) can prohibit a read and 22941da177e4SLinus Torvalds * byte-range POSIX locks can prohibit a read if they overlap. 22951da177e4SLinus Torvalds * 22961da177e4SLinus Torvalds * N.B. this function is only ever called 22971da177e4SLinus Torvalds * from knfsd and ownership of locks is never checked. 22981da177e4SLinus Torvalds */ 22991da177e4SLinus Torvalds int lock_may_read(struct inode *inode, loff_t start, unsigned long len) 23001da177e4SLinus Torvalds { 23011da177e4SLinus Torvalds struct file_lock *fl; 23021da177e4SLinus Torvalds int result = 1; 2303b89f4321SArnd Bergmann lock_flocks(); 23041da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 23051da177e4SLinus Torvalds if (IS_POSIX(fl)) { 23061da177e4SLinus Torvalds if (fl->fl_type == F_RDLCK) 23071da177e4SLinus Torvalds continue; 23081da177e4SLinus Torvalds if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 23091da177e4SLinus Torvalds continue; 23101da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 23111da177e4SLinus Torvalds if (!(fl->fl_type & LOCK_MAND)) 23121da177e4SLinus Torvalds continue; 23131da177e4SLinus Torvalds if (fl->fl_type & LOCK_READ) 23141da177e4SLinus Torvalds continue; 23151da177e4SLinus Torvalds } else 23161da177e4SLinus Torvalds continue; 23171da177e4SLinus Torvalds result = 0; 23181da177e4SLinus Torvalds break; 23191da177e4SLinus Torvalds } 2320b89f4321SArnd Bergmann unlock_flocks(); 23211da177e4SLinus Torvalds return result; 23221da177e4SLinus Torvalds } 23231da177e4SLinus Torvalds 23241da177e4SLinus Torvalds EXPORT_SYMBOL(lock_may_read); 23251da177e4SLinus Torvalds 23261da177e4SLinus Torvalds /** 23271da177e4SLinus Torvalds * lock_may_write - checks that the region is free of locks 23281da177e4SLinus Torvalds * @inode: the inode that is being written 23291da177e4SLinus Torvalds * @start: the first byte to write 23301da177e4SLinus Torvalds * @len: the number of bytes to write 23311da177e4SLinus Torvalds * 23321da177e4SLinus Torvalds * Emulates Windows locking requirements. Whole-file 23331da177e4SLinus Torvalds * mandatory locks (share modes) can prohibit a write and 23341da177e4SLinus Torvalds * byte-range POSIX locks can prohibit a write if they overlap. 23351da177e4SLinus Torvalds * 23361da177e4SLinus Torvalds * N.B. this function is only ever called 23371da177e4SLinus Torvalds * from knfsd and ownership of locks is never checked. 23381da177e4SLinus Torvalds */ 23391da177e4SLinus Torvalds int lock_may_write(struct inode *inode, loff_t start, unsigned long len) 23401da177e4SLinus Torvalds { 23411da177e4SLinus Torvalds struct file_lock *fl; 23421da177e4SLinus Torvalds int result = 1; 2343b89f4321SArnd Bergmann lock_flocks(); 23441da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 23451da177e4SLinus Torvalds if (IS_POSIX(fl)) { 23461da177e4SLinus Torvalds if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 23471da177e4SLinus Torvalds continue; 23481da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 23491da177e4SLinus Torvalds if (!(fl->fl_type & LOCK_MAND)) 23501da177e4SLinus Torvalds continue; 23511da177e4SLinus Torvalds if (fl->fl_type & LOCK_WRITE) 23521da177e4SLinus Torvalds continue; 23531da177e4SLinus Torvalds } else 23541da177e4SLinus Torvalds continue; 23551da177e4SLinus Torvalds result = 0; 23561da177e4SLinus Torvalds break; 23571da177e4SLinus Torvalds } 2358b89f4321SArnd Bergmann unlock_flocks(); 23591da177e4SLinus Torvalds return result; 23601da177e4SLinus Torvalds } 23611da177e4SLinus Torvalds 23621da177e4SLinus Torvalds EXPORT_SYMBOL(lock_may_write); 23631da177e4SLinus Torvalds 23641da177e4SLinus Torvalds static int __init filelock_init(void) 23651da177e4SLinus Torvalds { 23661da177e4SLinus Torvalds filelock_cache = kmem_cache_create("file_lock_cache", 2367ee19cc40SMiklos Szeredi sizeof(struct file_lock), 0, SLAB_PANIC, NULL); 2368ee19cc40SMiklos Szeredi 23691da177e4SLinus Torvalds return 0; 23701da177e4SLinus Torvalds } 23711da177e4SLinus Torvalds 23721da177e4SLinus Torvalds core_initcall(filelock_init); 2373