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 */ 51366189be7SPavel Shilovsky 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 } 51966189be7SPavel Shilovsky EXPORT_SYMBOL(locks_delete_block); 5201da177e4SLinus Torvalds 5211da177e4SLinus Torvalds /* Insert waiter into blocker's block list. 5221da177e4SLinus Torvalds * We use a circular list so that processes can be easily woken up in 5231da177e4SLinus Torvalds * the order they blocked. The documentation doesn't require this but 5241da177e4SLinus Torvalds * it seems like the reasonable thing to do. 5251da177e4SLinus Torvalds */ 5261da177e4SLinus Torvalds static void locks_insert_block(struct file_lock *blocker, 5271da177e4SLinus Torvalds struct file_lock *waiter) 5281da177e4SLinus Torvalds { 5296dc0fe8fSJ. Bruce Fields BUG_ON(!list_empty(&waiter->fl_block)); 5301da177e4SLinus Torvalds list_add_tail(&waiter->fl_block, &blocker->fl_block); 5311da177e4SLinus Torvalds waiter->fl_next = blocker; 5321da177e4SLinus Torvalds if (IS_POSIX(blocker)) 5331da177e4SLinus Torvalds list_add(&waiter->fl_link, &blocked_list); 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds /* Wake up processes blocked waiting for blocker. 5371da177e4SLinus Torvalds * If told to wait then schedule the processes until the block list 5381da177e4SLinus Torvalds * is empty, otherwise empty the block list ourselves. 5391da177e4SLinus Torvalds */ 5401da177e4SLinus Torvalds static void locks_wake_up_blocks(struct file_lock *blocker) 5411da177e4SLinus Torvalds { 5421da177e4SLinus Torvalds while (!list_empty(&blocker->fl_block)) { 543f0c1cd0eSPavel Emelyanov struct file_lock *waiter; 544f0c1cd0eSPavel Emelyanov 545f0c1cd0eSPavel Emelyanov waiter = list_first_entry(&blocker->fl_block, 5461da177e4SLinus Torvalds struct file_lock, fl_block); 5471da177e4SLinus Torvalds __locks_delete_block(waiter); 5488fb47a4fSJ. Bruce Fields if (waiter->fl_lmops && waiter->fl_lmops->lm_notify) 5498fb47a4fSJ. Bruce Fields waiter->fl_lmops->lm_notify(waiter); 5501da177e4SLinus Torvalds else 5511da177e4SLinus Torvalds wake_up(&waiter->fl_wait); 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds /* Insert file lock fl into an inode's lock list at the position indicated 5561da177e4SLinus Torvalds * by pos. At the same time add the lock to the global file lock list. 5571da177e4SLinus Torvalds */ 5581da177e4SLinus Torvalds static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl) 5591da177e4SLinus Torvalds { 5601da177e4SLinus Torvalds list_add(&fl->fl_link, &file_lock_list); 5611da177e4SLinus Torvalds 562ab1f1611SVitaliy Gusev fl->fl_nspid = get_pid(task_tgid(current)); 563ab1f1611SVitaliy Gusev 5641da177e4SLinus Torvalds /* insert into file's list */ 5651da177e4SLinus Torvalds fl->fl_next = *pos; 5661da177e4SLinus Torvalds *pos = fl; 5671da177e4SLinus Torvalds } 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* 5701da177e4SLinus Torvalds * Delete a lock and then free it. 5711da177e4SLinus Torvalds * Wake up processes that are blocked waiting for this lock, 5721da177e4SLinus Torvalds * notify the FS that the lock has been cleared and 5731da177e4SLinus Torvalds * finally free the lock. 5741da177e4SLinus Torvalds */ 5751da177e4SLinus Torvalds static void locks_delete_lock(struct file_lock **thisfl_p) 5761da177e4SLinus Torvalds { 5771da177e4SLinus Torvalds struct file_lock *fl = *thisfl_p; 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds *thisfl_p = fl->fl_next; 5801da177e4SLinus Torvalds fl->fl_next = NULL; 5811da177e4SLinus Torvalds list_del_init(&fl->fl_link); 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); 5841da177e4SLinus Torvalds if (fl->fl_fasync != NULL) { 5851da177e4SLinus Torvalds printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync); 5861da177e4SLinus Torvalds fl->fl_fasync = NULL; 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds 589ab1f1611SVitaliy Gusev if (fl->fl_nspid) { 590ab1f1611SVitaliy Gusev put_pid(fl->fl_nspid); 591ab1f1611SVitaliy Gusev fl->fl_nspid = NULL; 592ab1f1611SVitaliy Gusev } 593ab1f1611SVitaliy Gusev 5941da177e4SLinus Torvalds locks_wake_up_blocks(fl); 5951da177e4SLinus Torvalds locks_free_lock(fl); 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. Common functionality 5991da177e4SLinus Torvalds * checks for shared/exclusive status of overlapping locks. 6001da177e4SLinus Torvalds */ 6011da177e4SLinus Torvalds static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6021da177e4SLinus Torvalds { 6031da177e4SLinus Torvalds if (sys_fl->fl_type == F_WRLCK) 6041da177e4SLinus Torvalds return 1; 6051da177e4SLinus Torvalds if (caller_fl->fl_type == F_WRLCK) 6061da177e4SLinus Torvalds return 1; 6071da177e4SLinus Torvalds return 0; 6081da177e4SLinus Torvalds } 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific 6111da177e4SLinus Torvalds * checking before calling the locks_conflict(). 6121da177e4SLinus Torvalds */ 6131da177e4SLinus Torvalds static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6141da177e4SLinus Torvalds { 6151da177e4SLinus Torvalds /* POSIX locks owned by the same process do not conflict with 6161da177e4SLinus Torvalds * each other. 6171da177e4SLinus Torvalds */ 6181da177e4SLinus Torvalds if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl)) 6191da177e4SLinus Torvalds return (0); 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds /* Check whether they overlap */ 6221da177e4SLinus Torvalds if (!locks_overlap(caller_fl, sys_fl)) 6231da177e4SLinus Torvalds return 0; 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds return (locks_conflict(caller_fl, sys_fl)); 6261da177e4SLinus Torvalds } 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific 6291da177e4SLinus Torvalds * checking before calling the locks_conflict(). 6301da177e4SLinus Torvalds */ 6311da177e4SLinus Torvalds static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6321da177e4SLinus Torvalds { 6331da177e4SLinus Torvalds /* FLOCK locks referring to the same filp do not conflict with 6341da177e4SLinus Torvalds * each other. 6351da177e4SLinus Torvalds */ 6361da177e4SLinus Torvalds if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file)) 6371da177e4SLinus Torvalds return (0); 6381da177e4SLinus Torvalds if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND)) 6391da177e4SLinus Torvalds return 0; 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds return (locks_conflict(caller_fl, sys_fl)); 6421da177e4SLinus Torvalds } 6431da177e4SLinus Torvalds 6446d34ac19SJ. Bruce Fields void 6459d6a8c5cSMarc Eshel posix_test_lock(struct file *filp, struct file_lock *fl) 6461da177e4SLinus Torvalds { 6471da177e4SLinus Torvalds struct file_lock *cfl; 6481da177e4SLinus Torvalds 649b89f4321SArnd Bergmann lock_flocks(); 6500f7fc9e4SJosef "Jeff" Sipek for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) { 6511da177e4SLinus Torvalds if (!IS_POSIX(cfl)) 6521da177e4SLinus Torvalds continue; 653b842e240SJ. Bruce Fields if (posix_locks_conflict(fl, cfl)) 6541da177e4SLinus Torvalds break; 6551da177e4SLinus Torvalds } 656ab1f1611SVitaliy Gusev if (cfl) { 6579d6a8c5cSMarc Eshel __locks_copy_lock(fl, cfl); 658ab1f1611SVitaliy Gusev if (cfl->fl_nspid) 6596c5f3e7bSPavel Emelyanov fl->fl_pid = pid_vnr(cfl->fl_nspid); 660ab1f1611SVitaliy Gusev } else 661129a84deSJ. Bruce Fields fl->fl_type = F_UNLCK; 662b89f4321SArnd Bergmann unlock_flocks(); 6636d34ac19SJ. Bruce Fields return; 6641da177e4SLinus Torvalds } 6651da177e4SLinus Torvalds EXPORT_SYMBOL(posix_test_lock); 6661da177e4SLinus Torvalds 667b533184fSJ. Bruce Fields /* 668b533184fSJ. Bruce Fields * Deadlock detection: 6691da177e4SLinus Torvalds * 670b533184fSJ. Bruce Fields * We attempt to detect deadlocks that are due purely to posix file 671b533184fSJ. Bruce Fields * locks. 6721da177e4SLinus Torvalds * 673b533184fSJ. Bruce Fields * We assume that a task can be waiting for at most one lock at a time. 674b533184fSJ. Bruce Fields * So for any acquired lock, the process holding that lock may be 675b533184fSJ. Bruce Fields * waiting on at most one other lock. That lock in turns may be held by 676b533184fSJ. Bruce Fields * someone waiting for at most one other lock. Given a requested lock 677b533184fSJ. Bruce Fields * caller_fl which is about to wait for a conflicting lock block_fl, we 678b533184fSJ. Bruce Fields * follow this chain of waiters to ensure we are not about to create a 679b533184fSJ. Bruce Fields * cycle. 68097855b49SJ. Bruce Fields * 681b533184fSJ. Bruce Fields * Since we do this before we ever put a process to sleep on a lock, we 682b533184fSJ. Bruce Fields * are ensured that there is never a cycle; that is what guarantees that 683b533184fSJ. Bruce Fields * the while() loop in posix_locks_deadlock() eventually completes. 684b533184fSJ. Bruce Fields * 685b533184fSJ. Bruce Fields * Note: the above assumption may not be true when handling lock 686b533184fSJ. Bruce Fields * requests from a broken NFS client. It may also fail in the presence 687b533184fSJ. Bruce Fields * of tasks (such as posix threads) sharing the same open file table. 688b533184fSJ. Bruce Fields * 689b533184fSJ. Bruce Fields * To handle those cases, we just bail out after a few iterations. 6901da177e4SLinus Torvalds */ 69197855b49SJ. Bruce Fields 69297855b49SJ. Bruce Fields #define MAX_DEADLK_ITERATIONS 10 69397855b49SJ. Bruce Fields 694b533184fSJ. Bruce Fields /* Find a lock that the owner of the given block_fl is blocking on. */ 695b533184fSJ. Bruce Fields static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl) 696b533184fSJ. Bruce Fields { 697b533184fSJ. Bruce Fields struct file_lock *fl; 698b533184fSJ. Bruce Fields 699b533184fSJ. Bruce Fields list_for_each_entry(fl, &blocked_list, fl_link) { 700b533184fSJ. Bruce Fields if (posix_same_owner(fl, block_fl)) 701b533184fSJ. Bruce Fields return fl->fl_next; 702b533184fSJ. Bruce Fields } 703b533184fSJ. Bruce Fields return NULL; 704b533184fSJ. Bruce Fields } 705b533184fSJ. Bruce Fields 706b0904e14SAdrian Bunk static int posix_locks_deadlock(struct file_lock *caller_fl, 7071da177e4SLinus Torvalds struct file_lock *block_fl) 7081da177e4SLinus Torvalds { 70997855b49SJ. Bruce Fields int i = 0; 7101da177e4SLinus Torvalds 711b533184fSJ. Bruce Fields while ((block_fl = what_owner_is_waiting_for(block_fl))) { 71297855b49SJ. Bruce Fields if (i++ > MAX_DEADLK_ITERATIONS) 71397855b49SJ. Bruce Fields return 0; 714b533184fSJ. Bruce Fields if (posix_same_owner(caller_fl, block_fl)) 715b533184fSJ. Bruce Fields return 1; 7161da177e4SLinus Torvalds } 7171da177e4SLinus Torvalds return 0; 7181da177e4SLinus Torvalds } 7191da177e4SLinus Torvalds 7201da177e4SLinus Torvalds /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks 72102888f41SJ. Bruce Fields * after any leases, but before any posix locks. 722f475ae95STrond Myklebust * 723f475ae95STrond Myklebust * Note that if called with an FL_EXISTS argument, the caller may determine 724f475ae95STrond Myklebust * whether or not a lock was successfully freed by testing the return 725f475ae95STrond Myklebust * value for -ENOENT. 7261da177e4SLinus Torvalds */ 727993dfa87STrond Myklebust static int flock_lock_file(struct file *filp, struct file_lock *request) 7281da177e4SLinus Torvalds { 729993dfa87STrond Myklebust struct file_lock *new_fl = NULL; 7301da177e4SLinus Torvalds struct file_lock **before; 7310f7fc9e4SJosef "Jeff" Sipek struct inode * inode = filp->f_path.dentry->d_inode; 7321da177e4SLinus Torvalds int error = 0; 7331da177e4SLinus Torvalds int found = 0; 7341da177e4SLinus Torvalds 735b89f4321SArnd Bergmann if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) { 736b89f4321SArnd Bergmann new_fl = locks_alloc_lock(); 737b89f4321SArnd Bergmann if (!new_fl) 738b89f4321SArnd Bergmann return -ENOMEM; 739b89f4321SArnd Bergmann } 740b89f4321SArnd Bergmann 741b89f4321SArnd Bergmann lock_flocks(); 742f07f18ddSTrond Myklebust if (request->fl_flags & FL_ACCESS) 743f07f18ddSTrond Myklebust goto find_conflict; 74484d535adSPavel Emelyanov 7451da177e4SLinus Torvalds for_each_lock(inode, before) { 7461da177e4SLinus Torvalds struct file_lock *fl = *before; 7471da177e4SLinus Torvalds if (IS_POSIX(fl)) 7481da177e4SLinus Torvalds break; 7491da177e4SLinus Torvalds if (IS_LEASE(fl)) 7501da177e4SLinus Torvalds continue; 7511da177e4SLinus Torvalds if (filp != fl->fl_file) 7521da177e4SLinus Torvalds continue; 753993dfa87STrond Myklebust if (request->fl_type == fl->fl_type) 7541da177e4SLinus Torvalds goto out; 7551da177e4SLinus Torvalds found = 1; 7561da177e4SLinus Torvalds locks_delete_lock(before); 7571da177e4SLinus Torvalds break; 7581da177e4SLinus Torvalds } 7591da177e4SLinus Torvalds 760f475ae95STrond Myklebust if (request->fl_type == F_UNLCK) { 761f475ae95STrond Myklebust if ((request->fl_flags & FL_EXISTS) && !found) 762f475ae95STrond Myklebust error = -ENOENT; 763993dfa87STrond Myklebust goto out; 764f475ae95STrond Myklebust } 7651da177e4SLinus Torvalds 7661da177e4SLinus Torvalds /* 7671da177e4SLinus Torvalds * If a higher-priority process was blocked on the old file lock, 7681da177e4SLinus Torvalds * give it the opportunity to lock the file. 7691da177e4SLinus Torvalds */ 770b89f4321SArnd Bergmann if (found) { 771b89f4321SArnd Bergmann unlock_flocks(); 772def01bc5SFrederic Weisbecker cond_resched(); 773b89f4321SArnd Bergmann lock_flocks(); 774b89f4321SArnd Bergmann } 7751da177e4SLinus Torvalds 776f07f18ddSTrond Myklebust find_conflict: 7771da177e4SLinus Torvalds for_each_lock(inode, before) { 7781da177e4SLinus Torvalds struct file_lock *fl = *before; 7791da177e4SLinus Torvalds if (IS_POSIX(fl)) 7801da177e4SLinus Torvalds break; 7811da177e4SLinus Torvalds if (IS_LEASE(fl)) 7821da177e4SLinus Torvalds continue; 783993dfa87STrond Myklebust if (!flock_locks_conflict(request, fl)) 7841da177e4SLinus Torvalds continue; 7851da177e4SLinus Torvalds error = -EAGAIN; 786bde74e4bSMiklos Szeredi if (!(request->fl_flags & FL_SLEEP)) 787bde74e4bSMiklos Szeredi goto out; 788bde74e4bSMiklos Szeredi error = FILE_LOCK_DEFERRED; 789993dfa87STrond Myklebust locks_insert_block(fl, request); 7901da177e4SLinus Torvalds goto out; 7911da177e4SLinus Torvalds } 792f07f18ddSTrond Myklebust if (request->fl_flags & FL_ACCESS) 793f07f18ddSTrond Myklebust goto out; 794993dfa87STrond Myklebust locks_copy_lock(new_fl, request); 7950e2f6db8SPavel Emelyanov locks_insert_lock(before, new_fl); 796993dfa87STrond Myklebust new_fl = NULL; 7979cedc194SKirill Korotaev error = 0; 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds out: 800b89f4321SArnd Bergmann unlock_flocks(); 801993dfa87STrond Myklebust if (new_fl) 802993dfa87STrond Myklebust locks_free_lock(new_fl); 8031da177e4SLinus Torvalds return error; 8041da177e4SLinus Torvalds } 8051da177e4SLinus Torvalds 806150b3934SMarc Eshel static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock) 8071da177e4SLinus Torvalds { 8081da177e4SLinus Torvalds struct file_lock *fl; 80939005d02SMiklos Szeredi struct file_lock *new_fl = NULL; 81039005d02SMiklos Szeredi struct file_lock *new_fl2 = NULL; 8111da177e4SLinus Torvalds struct file_lock *left = NULL; 8121da177e4SLinus Torvalds struct file_lock *right = NULL; 8131da177e4SLinus Torvalds struct file_lock **before; 8141da177e4SLinus Torvalds int error, added = 0; 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds /* 8171da177e4SLinus Torvalds * We may need two file_lock structures for this operation, 8181da177e4SLinus Torvalds * so we get them in advance to avoid races. 81939005d02SMiklos Szeredi * 82039005d02SMiklos Szeredi * In some cases we can be sure, that no new locks will be needed 8211da177e4SLinus Torvalds */ 82239005d02SMiklos Szeredi if (!(request->fl_flags & FL_ACCESS) && 82339005d02SMiklos Szeredi (request->fl_type != F_UNLCK || 82439005d02SMiklos Szeredi request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { 8251da177e4SLinus Torvalds new_fl = locks_alloc_lock(); 8261da177e4SLinus Torvalds new_fl2 = locks_alloc_lock(); 82739005d02SMiklos Szeredi } 8281da177e4SLinus Torvalds 829b89f4321SArnd Bergmann lock_flocks(); 8301da177e4SLinus Torvalds if (request->fl_type != F_UNLCK) { 8311da177e4SLinus Torvalds for_each_lock(inode, before) { 832526985b9SJ. Bruce Fields fl = *before; 8331da177e4SLinus Torvalds if (!IS_POSIX(fl)) 8341da177e4SLinus Torvalds continue; 8351da177e4SLinus Torvalds if (!posix_locks_conflict(request, fl)) 8361da177e4SLinus Torvalds continue; 8375842add2SAndy Adamson if (conflock) 8381a747ee0SJ. Bruce Fields __locks_copy_lock(conflock, fl); 8391da177e4SLinus Torvalds error = -EAGAIN; 8401da177e4SLinus Torvalds if (!(request->fl_flags & FL_SLEEP)) 8411da177e4SLinus Torvalds goto out; 8421da177e4SLinus Torvalds error = -EDEADLK; 8431da177e4SLinus Torvalds if (posix_locks_deadlock(request, fl)) 8441da177e4SLinus Torvalds goto out; 845bde74e4bSMiklos Szeredi error = FILE_LOCK_DEFERRED; 8461da177e4SLinus Torvalds locks_insert_block(fl, request); 8471da177e4SLinus Torvalds goto out; 8481da177e4SLinus Torvalds } 8491da177e4SLinus Torvalds } 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds /* If we're just looking for a conflict, we're done. */ 8521da177e4SLinus Torvalds error = 0; 8531da177e4SLinus Torvalds if (request->fl_flags & FL_ACCESS) 8541da177e4SLinus Torvalds goto out; 8551da177e4SLinus Torvalds 8561da177e4SLinus Torvalds /* 8571da177e4SLinus Torvalds * Find the first old lock with the same owner as the new lock. 8581da177e4SLinus Torvalds */ 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds before = &inode->i_flock; 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds /* First skip locks owned by other processes. */ 8631da177e4SLinus Torvalds while ((fl = *before) && (!IS_POSIX(fl) || 8641da177e4SLinus Torvalds !posix_same_owner(request, fl))) { 8651da177e4SLinus Torvalds before = &fl->fl_next; 8661da177e4SLinus Torvalds } 8671da177e4SLinus Torvalds 8681da177e4SLinus Torvalds /* Process locks with this owner. */ 8691da177e4SLinus Torvalds while ((fl = *before) && posix_same_owner(request, fl)) { 8701da177e4SLinus Torvalds /* Detect adjacent or overlapping regions (if same lock type) 8711da177e4SLinus Torvalds */ 8721da177e4SLinus Torvalds if (request->fl_type == fl->fl_type) { 873449231d6SOlaf Kirch /* In all comparisons of start vs end, use 874449231d6SOlaf Kirch * "start - 1" rather than "end + 1". If end 875449231d6SOlaf Kirch * is OFFSET_MAX, end + 1 will become negative. 876449231d6SOlaf Kirch */ 8771da177e4SLinus Torvalds if (fl->fl_end < request->fl_start - 1) 8781da177e4SLinus Torvalds goto next_lock; 8791da177e4SLinus Torvalds /* If the next lock in the list has entirely bigger 8801da177e4SLinus Torvalds * addresses than the new one, insert the lock here. 8811da177e4SLinus Torvalds */ 882449231d6SOlaf Kirch if (fl->fl_start - 1 > request->fl_end) 8831da177e4SLinus Torvalds break; 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds /* If we come here, the new and old lock are of the 8861da177e4SLinus Torvalds * same type and adjacent or overlapping. Make one 8871da177e4SLinus Torvalds * lock yielding from the lower start address of both 8881da177e4SLinus Torvalds * locks to the higher end address. 8891da177e4SLinus Torvalds */ 8901da177e4SLinus Torvalds if (fl->fl_start > request->fl_start) 8911da177e4SLinus Torvalds fl->fl_start = request->fl_start; 8921da177e4SLinus Torvalds else 8931da177e4SLinus Torvalds request->fl_start = fl->fl_start; 8941da177e4SLinus Torvalds if (fl->fl_end < request->fl_end) 8951da177e4SLinus Torvalds fl->fl_end = request->fl_end; 8961da177e4SLinus Torvalds else 8971da177e4SLinus Torvalds request->fl_end = fl->fl_end; 8981da177e4SLinus Torvalds if (added) { 8991da177e4SLinus Torvalds locks_delete_lock(before); 9001da177e4SLinus Torvalds continue; 9011da177e4SLinus Torvalds } 9021da177e4SLinus Torvalds request = fl; 9031da177e4SLinus Torvalds added = 1; 9041da177e4SLinus Torvalds } 9051da177e4SLinus Torvalds else { 9061da177e4SLinus Torvalds /* Processing for different lock types is a bit 9071da177e4SLinus Torvalds * more complex. 9081da177e4SLinus Torvalds */ 9091da177e4SLinus Torvalds if (fl->fl_end < request->fl_start) 9101da177e4SLinus Torvalds goto next_lock; 9111da177e4SLinus Torvalds if (fl->fl_start > request->fl_end) 9121da177e4SLinus Torvalds break; 9131da177e4SLinus Torvalds if (request->fl_type == F_UNLCK) 9141da177e4SLinus Torvalds added = 1; 9151da177e4SLinus Torvalds if (fl->fl_start < request->fl_start) 9161da177e4SLinus Torvalds left = fl; 9171da177e4SLinus Torvalds /* If the next lock in the list has a higher end 9181da177e4SLinus Torvalds * address than the new one, insert the new one here. 9191da177e4SLinus Torvalds */ 9201da177e4SLinus Torvalds if (fl->fl_end > request->fl_end) { 9211da177e4SLinus Torvalds right = fl; 9221da177e4SLinus Torvalds break; 9231da177e4SLinus Torvalds } 9241da177e4SLinus Torvalds if (fl->fl_start >= request->fl_start) { 9251da177e4SLinus Torvalds /* The new lock completely replaces an old 9261da177e4SLinus Torvalds * one (This may happen several times). 9271da177e4SLinus Torvalds */ 9281da177e4SLinus Torvalds if (added) { 9291da177e4SLinus Torvalds locks_delete_lock(before); 9301da177e4SLinus Torvalds continue; 9311da177e4SLinus Torvalds } 9321da177e4SLinus Torvalds /* Replace the old lock with the new one. 9331da177e4SLinus Torvalds * Wake up anybody waiting for the old one, 9341da177e4SLinus Torvalds * as the change in lock type might satisfy 9351da177e4SLinus Torvalds * their needs. 9361da177e4SLinus Torvalds */ 9371da177e4SLinus Torvalds locks_wake_up_blocks(fl); 9381da177e4SLinus Torvalds fl->fl_start = request->fl_start; 9391da177e4SLinus Torvalds fl->fl_end = request->fl_end; 9401da177e4SLinus Torvalds fl->fl_type = request->fl_type; 94147831f35STrond Myklebust locks_release_private(fl); 94247831f35STrond Myklebust locks_copy_private(fl, request); 9431da177e4SLinus Torvalds request = fl; 9441da177e4SLinus Torvalds added = 1; 9451da177e4SLinus Torvalds } 9461da177e4SLinus Torvalds } 9471da177e4SLinus Torvalds /* Go on to next lock. 9481da177e4SLinus Torvalds */ 9491da177e4SLinus Torvalds next_lock: 9501da177e4SLinus Torvalds before = &fl->fl_next; 9511da177e4SLinus Torvalds } 9521da177e4SLinus Torvalds 9530d9a490aSMiklos Szeredi /* 9540d9a490aSMiklos Szeredi * The above code only modifies existing locks in case of 9550d9a490aSMiklos Szeredi * merging or replacing. If new lock(s) need to be inserted 9560d9a490aSMiklos Szeredi * all modifications are done bellow this, so it's safe yet to 9570d9a490aSMiklos Szeredi * bail out. 9580d9a490aSMiklos Szeredi */ 9590d9a490aSMiklos Szeredi error = -ENOLCK; /* "no luck" */ 9600d9a490aSMiklos Szeredi if (right && left == right && !new_fl2) 9610d9a490aSMiklos Szeredi goto out; 9620d9a490aSMiklos Szeredi 9631da177e4SLinus Torvalds error = 0; 9641da177e4SLinus Torvalds if (!added) { 965f475ae95STrond Myklebust if (request->fl_type == F_UNLCK) { 966f475ae95STrond Myklebust if (request->fl_flags & FL_EXISTS) 967f475ae95STrond Myklebust error = -ENOENT; 9681da177e4SLinus Torvalds goto out; 969f475ae95STrond Myklebust } 9700d9a490aSMiklos Szeredi 9710d9a490aSMiklos Szeredi if (!new_fl) { 9720d9a490aSMiklos Szeredi error = -ENOLCK; 9730d9a490aSMiklos Szeredi goto out; 9740d9a490aSMiklos Szeredi } 9751da177e4SLinus Torvalds locks_copy_lock(new_fl, request); 9761da177e4SLinus Torvalds locks_insert_lock(before, new_fl); 9771da177e4SLinus Torvalds new_fl = NULL; 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds if (right) { 9801da177e4SLinus Torvalds if (left == right) { 9811da177e4SLinus Torvalds /* The new lock breaks the old one in two pieces, 9821da177e4SLinus Torvalds * so we have to use the second new lock. 9831da177e4SLinus Torvalds */ 9841da177e4SLinus Torvalds left = new_fl2; 9851da177e4SLinus Torvalds new_fl2 = NULL; 9861da177e4SLinus Torvalds locks_copy_lock(left, right); 9871da177e4SLinus Torvalds locks_insert_lock(before, left); 9881da177e4SLinus Torvalds } 9891da177e4SLinus Torvalds right->fl_start = request->fl_end + 1; 9901da177e4SLinus Torvalds locks_wake_up_blocks(right); 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds if (left) { 9931da177e4SLinus Torvalds left->fl_end = request->fl_start - 1; 9941da177e4SLinus Torvalds locks_wake_up_blocks(left); 9951da177e4SLinus Torvalds } 9961da177e4SLinus Torvalds out: 997b89f4321SArnd Bergmann unlock_flocks(); 9981da177e4SLinus Torvalds /* 9991da177e4SLinus Torvalds * Free any unused locks. 10001da177e4SLinus Torvalds */ 10011da177e4SLinus Torvalds if (new_fl) 10021da177e4SLinus Torvalds locks_free_lock(new_fl); 10031da177e4SLinus Torvalds if (new_fl2) 10041da177e4SLinus Torvalds locks_free_lock(new_fl2); 10051da177e4SLinus Torvalds return error; 10061da177e4SLinus Torvalds } 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds /** 10091da177e4SLinus Torvalds * posix_lock_file - Apply a POSIX-style lock to a file 10101da177e4SLinus Torvalds * @filp: The file to apply the lock to 10111da177e4SLinus Torvalds * @fl: The lock to be applied 1012150b3934SMarc Eshel * @conflock: Place to return a copy of the conflicting lock, if found. 10131da177e4SLinus Torvalds * 10141da177e4SLinus Torvalds * Add a POSIX style lock to a file. 10151da177e4SLinus Torvalds * We merge adjacent & overlapping locks whenever possible. 10161da177e4SLinus Torvalds * POSIX locks are sorted by owner task, then by starting address 1017f475ae95STrond Myklebust * 1018f475ae95STrond Myklebust * Note that if called with an FL_EXISTS argument, the caller may determine 1019f475ae95STrond Myklebust * whether or not a lock was successfully freed by testing the return 1020f475ae95STrond Myklebust * value for -ENOENT. 10211da177e4SLinus Torvalds */ 1022150b3934SMarc Eshel int posix_lock_file(struct file *filp, struct file_lock *fl, 10235842add2SAndy Adamson struct file_lock *conflock) 10245842add2SAndy Adamson { 1025150b3934SMarc Eshel return __posix_lock_file(filp->f_path.dentry->d_inode, fl, conflock); 10265842add2SAndy Adamson } 1027150b3934SMarc Eshel EXPORT_SYMBOL(posix_lock_file); 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds /** 10301da177e4SLinus Torvalds * posix_lock_file_wait - Apply a POSIX-style lock to a file 10311da177e4SLinus Torvalds * @filp: The file to apply the lock to 10321da177e4SLinus Torvalds * @fl: The lock to be applied 10331da177e4SLinus Torvalds * 10341da177e4SLinus Torvalds * Add a POSIX style lock to a file. 10351da177e4SLinus Torvalds * We merge adjacent & overlapping locks whenever possible. 10361da177e4SLinus Torvalds * POSIX locks are sorted by owner task, then by starting address 10371da177e4SLinus Torvalds */ 10381da177e4SLinus Torvalds int posix_lock_file_wait(struct file *filp, struct file_lock *fl) 10391da177e4SLinus Torvalds { 10401da177e4SLinus Torvalds int error; 10411da177e4SLinus Torvalds might_sleep (); 10421da177e4SLinus Torvalds for (;;) { 1043150b3934SMarc Eshel error = posix_lock_file(filp, fl, NULL); 1044bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 10451da177e4SLinus Torvalds break; 10461da177e4SLinus Torvalds error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 10471da177e4SLinus Torvalds if (!error) 10481da177e4SLinus Torvalds continue; 10491da177e4SLinus Torvalds 10501da177e4SLinus Torvalds locks_delete_block(fl); 10511da177e4SLinus Torvalds break; 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds return error; 10541da177e4SLinus Torvalds } 10551da177e4SLinus Torvalds EXPORT_SYMBOL(posix_lock_file_wait); 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvalds /** 10581da177e4SLinus Torvalds * locks_mandatory_locked - Check for an active lock 10591da177e4SLinus Torvalds * @inode: the file to check 10601da177e4SLinus Torvalds * 10611da177e4SLinus Torvalds * Searches the inode's list of locks to find any POSIX locks which conflict. 10621da177e4SLinus Torvalds * This function is called from locks_verify_locked() only. 10631da177e4SLinus Torvalds */ 10641da177e4SLinus Torvalds int locks_mandatory_locked(struct inode *inode) 10651da177e4SLinus Torvalds { 10661da177e4SLinus Torvalds fl_owner_t owner = current->files; 10671da177e4SLinus Torvalds struct file_lock *fl; 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds /* 10701da177e4SLinus Torvalds * Search the lock list for this inode for any POSIX locks. 10711da177e4SLinus Torvalds */ 1072b89f4321SArnd Bergmann lock_flocks(); 10731da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 10741da177e4SLinus Torvalds if (!IS_POSIX(fl)) 10751da177e4SLinus Torvalds continue; 10761da177e4SLinus Torvalds if (fl->fl_owner != owner) 10771da177e4SLinus Torvalds break; 10781da177e4SLinus Torvalds } 1079b89f4321SArnd Bergmann unlock_flocks(); 10801da177e4SLinus Torvalds return fl ? -EAGAIN : 0; 10811da177e4SLinus Torvalds } 10821da177e4SLinus Torvalds 10831da177e4SLinus Torvalds /** 10841da177e4SLinus Torvalds * locks_mandatory_area - Check for a conflicting lock 10851da177e4SLinus Torvalds * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ 10861da177e4SLinus Torvalds * for shared 10871da177e4SLinus Torvalds * @inode: the file to check 10881da177e4SLinus Torvalds * @filp: how the file was opened (if it was) 10891da177e4SLinus Torvalds * @offset: start of area to check 10901da177e4SLinus Torvalds * @count: length of area to check 10911da177e4SLinus Torvalds * 10921da177e4SLinus Torvalds * Searches the inode's list of locks to find any POSIX locks which conflict. 10931da177e4SLinus Torvalds * This function is called from rw_verify_area() and 10941da177e4SLinus Torvalds * locks_verify_truncate(). 10951da177e4SLinus Torvalds */ 10961da177e4SLinus Torvalds int locks_mandatory_area(int read_write, struct inode *inode, 10971da177e4SLinus Torvalds struct file *filp, loff_t offset, 10981da177e4SLinus Torvalds size_t count) 10991da177e4SLinus Torvalds { 11001da177e4SLinus Torvalds struct file_lock fl; 11011da177e4SLinus Torvalds int error; 11021da177e4SLinus Torvalds 11031da177e4SLinus Torvalds locks_init_lock(&fl); 11041da177e4SLinus Torvalds fl.fl_owner = current->files; 11051da177e4SLinus Torvalds fl.fl_pid = current->tgid; 11061da177e4SLinus Torvalds fl.fl_file = filp; 11071da177e4SLinus Torvalds fl.fl_flags = FL_POSIX | FL_ACCESS; 11081da177e4SLinus Torvalds if (filp && !(filp->f_flags & O_NONBLOCK)) 11091da177e4SLinus Torvalds fl.fl_flags |= FL_SLEEP; 11101da177e4SLinus Torvalds fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK; 11111da177e4SLinus Torvalds fl.fl_start = offset; 11121da177e4SLinus Torvalds fl.fl_end = offset + count - 1; 11131da177e4SLinus Torvalds 11141da177e4SLinus Torvalds for (;;) { 1115150b3934SMarc Eshel error = __posix_lock_file(inode, &fl, NULL); 1116bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 11171da177e4SLinus Torvalds break; 11181da177e4SLinus Torvalds error = wait_event_interruptible(fl.fl_wait, !fl.fl_next); 11191da177e4SLinus Torvalds if (!error) { 11201da177e4SLinus Torvalds /* 11211da177e4SLinus Torvalds * If we've been sleeping someone might have 11221da177e4SLinus Torvalds * changed the permissions behind our back. 11231da177e4SLinus Torvalds */ 1124a16877caSPavel Emelyanov if (__mandatory_lock(inode)) 11251da177e4SLinus Torvalds continue; 11261da177e4SLinus Torvalds } 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds locks_delete_block(&fl); 11291da177e4SLinus Torvalds break; 11301da177e4SLinus Torvalds } 11311da177e4SLinus Torvalds 11321da177e4SLinus Torvalds return error; 11331da177e4SLinus Torvalds } 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds EXPORT_SYMBOL(locks_mandatory_area); 11361da177e4SLinus Torvalds 1137778fc546SJ. Bruce Fields static void lease_clear_pending(struct file_lock *fl, int arg) 1138778fc546SJ. Bruce Fields { 1139778fc546SJ. Bruce Fields switch (arg) { 1140778fc546SJ. Bruce Fields case F_UNLCK: 1141778fc546SJ. Bruce Fields fl->fl_flags &= ~FL_UNLOCK_PENDING; 1142778fc546SJ. Bruce Fields /* fall through: */ 1143778fc546SJ. Bruce Fields case F_RDLCK: 1144778fc546SJ. Bruce Fields fl->fl_flags &= ~FL_DOWNGRADE_PENDING; 1145778fc546SJ. Bruce Fields } 1146778fc546SJ. Bruce Fields } 1147778fc546SJ. Bruce Fields 11481da177e4SLinus Torvalds /* We already had a lease on this file; just change its type */ 11491da177e4SLinus Torvalds int lease_modify(struct file_lock **before, int arg) 11501da177e4SLinus Torvalds { 11511da177e4SLinus Torvalds struct file_lock *fl = *before; 11521da177e4SLinus Torvalds int error = assign_type(fl, arg); 11531da177e4SLinus Torvalds 11541da177e4SLinus Torvalds if (error) 11551da177e4SLinus Torvalds return error; 1156778fc546SJ. Bruce Fields lease_clear_pending(fl, arg); 11571da177e4SLinus Torvalds locks_wake_up_blocks(fl); 11581da177e4SLinus Torvalds if (arg == F_UNLCK) 11591da177e4SLinus Torvalds locks_delete_lock(before); 11601da177e4SLinus Torvalds return 0; 11611da177e4SLinus Torvalds } 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds EXPORT_SYMBOL(lease_modify); 11641da177e4SLinus Torvalds 1165778fc546SJ. Bruce Fields static bool past_time(unsigned long then) 1166778fc546SJ. Bruce Fields { 1167778fc546SJ. Bruce Fields if (!then) 1168778fc546SJ. Bruce Fields /* 0 is a special value meaning "this never expires": */ 1169778fc546SJ. Bruce Fields return false; 1170778fc546SJ. Bruce Fields return time_after(jiffies, then); 1171778fc546SJ. Bruce Fields } 1172778fc546SJ. Bruce Fields 11731da177e4SLinus Torvalds static void time_out_leases(struct inode *inode) 11741da177e4SLinus Torvalds { 11751da177e4SLinus Torvalds struct file_lock **before; 11761da177e4SLinus Torvalds struct file_lock *fl; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds before = &inode->i_flock; 1179ab83fa4bSJ. Bruce Fields while ((fl = *before) && IS_LEASE(fl) && lease_breaking(fl)) { 1180778fc546SJ. Bruce Fields if (past_time(fl->fl_downgrade_time)) 1181778fc546SJ. Bruce Fields lease_modify(before, F_RDLCK); 1182778fc546SJ. Bruce Fields if (past_time(fl->fl_break_time)) 1183778fc546SJ. Bruce Fields lease_modify(before, F_UNLCK); 11841da177e4SLinus Torvalds if (fl == *before) /* lease_modify may have freed fl */ 11851da177e4SLinus Torvalds before = &fl->fl_next; 11861da177e4SLinus Torvalds } 11871da177e4SLinus Torvalds } 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds /** 11901da177e4SLinus Torvalds * __break_lease - revoke all outstanding leases on file 11911da177e4SLinus Torvalds * @inode: the inode of the file to return 11921da177e4SLinus Torvalds * @mode: the open mode (read or write) 11931da177e4SLinus Torvalds * 119487250dd2Sdavid m. richter * break_lease (inlined for speed) has checked there already is at least 119587250dd2Sdavid m. richter * some kind of lock (maybe a lease) on this file. Leases are broken on 119687250dd2Sdavid m. richter * a call to open() or truncate(). This function can sleep unless you 11971da177e4SLinus Torvalds * specified %O_NONBLOCK to your open(). 11981da177e4SLinus Torvalds */ 11991da177e4SLinus Torvalds int __break_lease(struct inode *inode, unsigned int mode) 12001da177e4SLinus Torvalds { 1201778fc546SJ. Bruce Fields int error = 0; 12021da177e4SLinus Torvalds struct file_lock *new_fl, *flock; 12031da177e4SLinus Torvalds struct file_lock *fl; 12041da177e4SLinus Torvalds unsigned long break_time; 12051da177e4SLinus Torvalds int i_have_this_lease = 0; 12068737c930SAl Viro int want_write = (mode & O_ACCMODE) != O_RDONLY; 12071da177e4SLinus Torvalds 12088737c930SAl Viro new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK); 12096d4b9e38SLinus Torvalds if (IS_ERR(new_fl)) 12106d4b9e38SLinus Torvalds return PTR_ERR(new_fl); 12111da177e4SLinus Torvalds 1212b89f4321SArnd Bergmann lock_flocks(); 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds time_out_leases(inode); 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds flock = inode->i_flock; 12171da177e4SLinus Torvalds if ((flock == NULL) || !IS_LEASE(flock)) 12181da177e4SLinus Torvalds goto out; 12191da177e4SLinus Torvalds 1220778fc546SJ. Bruce Fields if (!locks_conflict(flock, new_fl)) 1221778fc546SJ. Bruce Fields goto out; 1222778fc546SJ. Bruce Fields 12231da177e4SLinus Torvalds for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) 12241da177e4SLinus Torvalds if (fl->fl_owner == current->files) 12251da177e4SLinus Torvalds i_have_this_lease = 1; 12261da177e4SLinus Torvalds 12271da177e4SLinus Torvalds break_time = 0; 12281da177e4SLinus Torvalds if (lease_break_time > 0) { 12291da177e4SLinus Torvalds break_time = jiffies + lease_break_time * HZ; 12301da177e4SLinus Torvalds if (break_time == 0) 12311da177e4SLinus Torvalds break_time++; /* so that 0 means no break time */ 12321da177e4SLinus Torvalds } 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) { 1235778fc546SJ. Bruce Fields if (want_write) { 1236778fc546SJ. Bruce Fields if (fl->fl_flags & FL_UNLOCK_PENDING) 1237778fc546SJ. Bruce Fields continue; 1238778fc546SJ. Bruce Fields fl->fl_flags |= FL_UNLOCK_PENDING; 12391da177e4SLinus Torvalds fl->fl_break_time = break_time; 1240778fc546SJ. Bruce Fields } else { 1241778fc546SJ. Bruce Fields if (lease_breaking(flock)) 1242778fc546SJ. Bruce Fields continue; 1243778fc546SJ. Bruce Fields fl->fl_flags |= FL_DOWNGRADE_PENDING; 1244778fc546SJ. Bruce Fields fl->fl_downgrade_time = break_time; 12451da177e4SLinus Torvalds } 1246778fc546SJ. Bruce Fields fl->fl_lmops->lm_break(fl); 12471da177e4SLinus Torvalds } 12481da177e4SLinus Torvalds 12491da177e4SLinus Torvalds if (i_have_this_lease || (mode & O_NONBLOCK)) { 12501da177e4SLinus Torvalds error = -EWOULDBLOCK; 12511da177e4SLinus Torvalds goto out; 12521da177e4SLinus Torvalds } 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds restart: 12551da177e4SLinus Torvalds break_time = flock->fl_break_time; 12561da177e4SLinus Torvalds if (break_time != 0) { 12571da177e4SLinus Torvalds break_time -= jiffies; 12581da177e4SLinus Torvalds if (break_time == 0) 12591da177e4SLinus Torvalds break_time++; 12601da177e4SLinus Torvalds } 12614321e01eSMatthew Wilcox locks_insert_block(flock, new_fl); 1262b89f4321SArnd Bergmann unlock_flocks(); 12634321e01eSMatthew Wilcox error = wait_event_interruptible_timeout(new_fl->fl_wait, 12644321e01eSMatthew Wilcox !new_fl->fl_next, break_time); 1265b89f4321SArnd Bergmann lock_flocks(); 12664321e01eSMatthew Wilcox __locks_delete_block(new_fl); 12671da177e4SLinus Torvalds if (error >= 0) { 12681da177e4SLinus Torvalds if (error == 0) 12691da177e4SLinus Torvalds time_out_leases(inode); 1270778fc546SJ. Bruce Fields /* 1271778fc546SJ. Bruce Fields * Wait for the next conflicting lease that has not been 1272778fc546SJ. Bruce Fields * broken yet 1273778fc546SJ. Bruce Fields */ 12741da177e4SLinus Torvalds for (flock = inode->i_flock; flock && IS_LEASE(flock); 12751da177e4SLinus Torvalds flock = flock->fl_next) { 1276778fc546SJ. Bruce Fields if (locks_conflict(new_fl, flock)) 12771da177e4SLinus Torvalds goto restart; 12781da177e4SLinus Torvalds } 12791da177e4SLinus Torvalds error = 0; 12801da177e4SLinus Torvalds } 12811da177e4SLinus Torvalds 12821da177e4SLinus Torvalds out: 1283b89f4321SArnd Bergmann unlock_flocks(); 12841da177e4SLinus Torvalds locks_free_lock(new_fl); 12851da177e4SLinus Torvalds return error; 12861da177e4SLinus Torvalds } 12871da177e4SLinus Torvalds 12881da177e4SLinus Torvalds EXPORT_SYMBOL(__break_lease); 12891da177e4SLinus Torvalds 12901da177e4SLinus Torvalds /** 1291a6b91919SRandy Dunlap * lease_get_mtime - get the last modified time of an inode 12921da177e4SLinus Torvalds * @inode: the inode 12931da177e4SLinus Torvalds * @time: pointer to a timespec which will contain the last modified time 12941da177e4SLinus Torvalds * 12951da177e4SLinus Torvalds * This is to force NFS clients to flush their caches for files with 12961da177e4SLinus Torvalds * exclusive leases. The justification is that if someone has an 1297a6b91919SRandy Dunlap * exclusive lease, then they could be modifying it. 12981da177e4SLinus Torvalds */ 12991da177e4SLinus Torvalds void lease_get_mtime(struct inode *inode, struct timespec *time) 13001da177e4SLinus Torvalds { 13011da177e4SLinus Torvalds struct file_lock *flock = inode->i_flock; 13021da177e4SLinus Torvalds if (flock && IS_LEASE(flock) && (flock->fl_type & F_WRLCK)) 13031da177e4SLinus Torvalds *time = current_fs_time(inode->i_sb); 13041da177e4SLinus Torvalds else 13051da177e4SLinus Torvalds *time = inode->i_mtime; 13061da177e4SLinus Torvalds } 13071da177e4SLinus Torvalds 13081da177e4SLinus Torvalds EXPORT_SYMBOL(lease_get_mtime); 13091da177e4SLinus Torvalds 13101da177e4SLinus Torvalds /** 13111da177e4SLinus Torvalds * fcntl_getlease - Enquire what lease is currently active 13121da177e4SLinus Torvalds * @filp: the file 13131da177e4SLinus Torvalds * 13141da177e4SLinus Torvalds * The value returned by this function will be one of 13151da177e4SLinus Torvalds * (if no lease break is pending): 13161da177e4SLinus Torvalds * 13171da177e4SLinus Torvalds * %F_RDLCK to indicate a shared lease is held. 13181da177e4SLinus Torvalds * 13191da177e4SLinus Torvalds * %F_WRLCK to indicate an exclusive lease is held. 13201da177e4SLinus Torvalds * 13211da177e4SLinus Torvalds * %F_UNLCK to indicate no lease is held. 13221da177e4SLinus Torvalds * 13231da177e4SLinus Torvalds * (if a lease break is pending): 13241da177e4SLinus Torvalds * 13251da177e4SLinus Torvalds * %F_RDLCK to indicate an exclusive lease needs to be 13261da177e4SLinus Torvalds * changed to a shared lease (or removed). 13271da177e4SLinus Torvalds * 13281da177e4SLinus Torvalds * %F_UNLCK to indicate the lease needs to be removed. 13291da177e4SLinus Torvalds * 13301da177e4SLinus Torvalds * XXX: sfr & willy disagree over whether F_INPROGRESS 13311da177e4SLinus Torvalds * should be returned to userspace. 13321da177e4SLinus Torvalds */ 13331da177e4SLinus Torvalds int fcntl_getlease(struct file *filp) 13341da177e4SLinus Torvalds { 13351da177e4SLinus Torvalds struct file_lock *fl; 13361da177e4SLinus Torvalds int type = F_UNLCK; 13371da177e4SLinus Torvalds 1338b89f4321SArnd Bergmann lock_flocks(); 13390f7fc9e4SJosef "Jeff" Sipek time_out_leases(filp->f_path.dentry->d_inode); 13400f7fc9e4SJosef "Jeff" Sipek for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl); 13411da177e4SLinus Torvalds fl = fl->fl_next) { 13421da177e4SLinus Torvalds if (fl->fl_file == filp) { 1343778fc546SJ. Bruce Fields type = target_leasetype(fl); 13441da177e4SLinus Torvalds break; 13451da177e4SLinus Torvalds } 13461da177e4SLinus Torvalds } 1347b89f4321SArnd Bergmann unlock_flocks(); 13481da177e4SLinus Torvalds return type; 13491da177e4SLinus Torvalds } 13501da177e4SLinus Torvalds 13518335ebd9SJ. Bruce Fields int generic_add_lease(struct file *filp, long arg, struct file_lock **flp) 13521da177e4SLinus Torvalds { 13537eaae282SKAMBAROV, ZAUR struct file_lock *fl, **before, **my_before = NULL, *lease; 13540f7fc9e4SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 13551da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 1356c1f24ef4SJ. Bruce Fields int error; 13571da177e4SLinus Torvalds 1358096657b6SJ. Bruce Fields lease = *flp; 1359096657b6SJ. Bruce Fields 13601da177e4SLinus Torvalds error = -EAGAIN; 13611da177e4SLinus Torvalds if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0)) 13621da177e4SLinus Torvalds goto out; 13631da177e4SLinus Torvalds if ((arg == F_WRLCK) 1364b7ab39f6SNick Piggin && ((dentry->d_count > 1) 13651da177e4SLinus Torvalds || (atomic_read(&inode->i_count) > 1))) 13661da177e4SLinus Torvalds goto out; 136785c59580SPavel Emelyanov 13681da177e4SLinus Torvalds /* 13691da177e4SLinus Torvalds * At this point, we know that if there is an exclusive 13701da177e4SLinus Torvalds * lease on this file, then we hold it on this filp 13711da177e4SLinus Torvalds * (otherwise our open of this file would have blocked). 13721da177e4SLinus Torvalds * And if we are trying to acquire an exclusive lease, 13731da177e4SLinus Torvalds * then the file is not open by anyone (including us) 13741da177e4SLinus Torvalds * except for this filp. 13751da177e4SLinus Torvalds */ 1376c1f24ef4SJ. Bruce Fields error = -EAGAIN; 13771da177e4SLinus Torvalds for (before = &inode->i_flock; 13781da177e4SLinus Torvalds ((fl = *before) != NULL) && IS_LEASE(fl); 13791da177e4SLinus Torvalds before = &fl->fl_next) { 1380c1f24ef4SJ. Bruce Fields if (fl->fl_file == filp) { 13811da177e4SLinus Torvalds my_before = before; 1382c1f24ef4SJ. Bruce Fields continue; 13831da177e4SLinus Torvalds } 1384c1f24ef4SJ. Bruce Fields /* 1385c1f24ef4SJ. Bruce Fields * No exclusive leases if someone else has a lease on 1386c1f24ef4SJ. Bruce Fields * this file: 1387c1f24ef4SJ. Bruce Fields */ 1388c1f24ef4SJ. Bruce Fields if (arg == F_WRLCK) 13891da177e4SLinus Torvalds goto out; 1390c1f24ef4SJ. Bruce Fields /* 1391c1f24ef4SJ. Bruce Fields * Modifying our existing lease is OK, but no getting a 1392c1f24ef4SJ. Bruce Fields * new lease if someone else is opening for write: 1393c1f24ef4SJ. Bruce Fields */ 1394c1f24ef4SJ. Bruce Fields if (fl->fl_flags & FL_UNLOCK_PENDING) 1395c1f24ef4SJ. Bruce Fields goto out; 1396c1f24ef4SJ. Bruce Fields } 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds if (my_before != NULL) { 13998fb47a4fSJ. Bruce Fields error = lease->fl_lmops->lm_change(my_before, arg); 140051ee4b84SChristoph Hellwig if (!error) 140151ee4b84SChristoph Hellwig *flp = *my_before; 14021da177e4SLinus Torvalds goto out; 14031da177e4SLinus Torvalds } 14041da177e4SLinus Torvalds 14051da177e4SLinus Torvalds error = -EINVAL; 14061da177e4SLinus Torvalds if (!leases_enable) 14071da177e4SLinus Torvalds goto out; 14081da177e4SLinus Torvalds 1409c5b1f0d9SArnd Bergmann locks_insert_lock(before, lease); 141085c59580SPavel Emelyanov return 0; 14111da177e4SLinus Torvalds 14121da177e4SLinus Torvalds out: 14131da177e4SLinus Torvalds return error; 14141da177e4SLinus Torvalds } 14158335ebd9SJ. Bruce Fields 14168335ebd9SJ. Bruce Fields int generic_delete_lease(struct file *filp, struct file_lock **flp) 14178335ebd9SJ. Bruce Fields { 14188335ebd9SJ. Bruce Fields struct file_lock *fl, **before; 14198335ebd9SJ. Bruce Fields struct dentry *dentry = filp->f_path.dentry; 14208335ebd9SJ. Bruce Fields struct inode *inode = dentry->d_inode; 14218335ebd9SJ. Bruce Fields 14228335ebd9SJ. Bruce Fields for (before = &inode->i_flock; 14238335ebd9SJ. Bruce Fields ((fl = *before) != NULL) && IS_LEASE(fl); 14248335ebd9SJ. Bruce Fields before = &fl->fl_next) { 14258335ebd9SJ. Bruce Fields if (fl->fl_file != filp) 14268335ebd9SJ. Bruce Fields continue; 14278335ebd9SJ. Bruce Fields return (*flp)->fl_lmops->lm_change(before, F_UNLCK); 14288335ebd9SJ. Bruce Fields } 14298335ebd9SJ. Bruce Fields return -EAGAIN; 14308335ebd9SJ. Bruce Fields } 14318335ebd9SJ. Bruce Fields 14321da177e4SLinus Torvalds /** 14331da177e4SLinus Torvalds * generic_setlease - sets a lease on an open file 14341da177e4SLinus Torvalds * @filp: file pointer 14351da177e4SLinus Torvalds * @arg: type of lease to obtain 14361da177e4SLinus Torvalds * @flp: input - file_lock to use, output - file_lock inserted 14371da177e4SLinus Torvalds * 14381da177e4SLinus Torvalds * The (input) flp->fl_lmops->lm_break function is required 14391da177e4SLinus Torvalds * by break_lease(). 14401da177e4SLinus Torvalds * 14411da177e4SLinus Torvalds * Called with file_lock_lock held. 14421da177e4SLinus Torvalds */ 14431da177e4SLinus Torvalds int generic_setlease(struct file *filp, long arg, struct file_lock **flp) 14441da177e4SLinus Torvalds { 14451da177e4SLinus Torvalds struct dentry *dentry = filp->f_path.dentry; 14461da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 14478335ebd9SJ. Bruce Fields int error; 14481da177e4SLinus Torvalds 14498e96e3b7SEric W. Biederman if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE)) 14508335ebd9SJ. Bruce Fields return -EACCES; 14511da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode)) 14528335ebd9SJ. Bruce Fields return -EINVAL; 14531da177e4SLinus Torvalds error = security_file_lock(filp, arg); 14541da177e4SLinus Torvalds if (error) 14558335ebd9SJ. Bruce Fields return error; 14561da177e4SLinus Torvalds 14571da177e4SLinus Torvalds time_out_leases(inode); 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds BUG_ON(!(*flp)->fl_lmops->lm_break); 14601da177e4SLinus Torvalds 14618335ebd9SJ. Bruce Fields switch (arg) { 14628335ebd9SJ. Bruce Fields case F_UNLCK: 14638335ebd9SJ. Bruce Fields return generic_delete_lease(filp, flp); 14648335ebd9SJ. Bruce Fields case F_RDLCK: 14658335ebd9SJ. Bruce Fields case F_WRLCK: 14668335ebd9SJ. Bruce Fields return generic_add_lease(filp, arg, flp); 14678335ebd9SJ. Bruce Fields default: 1468*8d657eb3SDave Jones return -EINVAL; 14691da177e4SLinus Torvalds } 14701da177e4SLinus Torvalds } 14710af1a450SChristoph Hellwig EXPORT_SYMBOL(generic_setlease); 14721da177e4SLinus Torvalds 1473b89f4321SArnd Bergmann static int __vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 1474b89f4321SArnd Bergmann { 1475b89f4321SArnd Bergmann if (filp->f_op && filp->f_op->setlease) 1476b89f4321SArnd Bergmann return filp->f_op->setlease(filp, arg, lease); 1477b89f4321SArnd Bergmann else 1478b89f4321SArnd Bergmann return generic_setlease(filp, arg, lease); 1479b89f4321SArnd Bergmann } 1480b89f4321SArnd Bergmann 14811da177e4SLinus Torvalds /** 1482a9933ceaSJ. Bruce Fields * vfs_setlease - sets a lease on an open file 14831da177e4SLinus Torvalds * @filp: file pointer 14841da177e4SLinus Torvalds * @arg: type of lease to obtain 14851da177e4SLinus Torvalds * @lease: file_lock to use 14861da177e4SLinus Torvalds * 14871da177e4SLinus Torvalds * Call this to establish a lease on the file. 14888fb47a4fSJ. Bruce Fields * The (*lease)->fl_lmops->lm_break operation must be set; if not, 1489f9ffed26SJ. Bruce Fields * break_lease will oops! 1490f9ffed26SJ. Bruce Fields * 1491f9ffed26SJ. Bruce Fields * This will call the filesystem's setlease file method, if 1492f9ffed26SJ. Bruce Fields * defined. Note that there is no getlease method; instead, the 1493f9ffed26SJ. Bruce Fields * filesystem setlease method should call back to setlease() to 1494f9ffed26SJ. Bruce Fields * add a lease to the inode's lease list, where fcntl_getlease() can 1495f9ffed26SJ. Bruce Fields * find it. Since fcntl_getlease() only reports whether the current 1496f9ffed26SJ. Bruce Fields * task holds a lease, a cluster filesystem need only do this for 1497f9ffed26SJ. Bruce Fields * leases held by processes on this node. 1498f9ffed26SJ. Bruce Fields * 1499f9ffed26SJ. Bruce Fields * There is also no break_lease method; filesystems that 1500c9404c9cSAdam Buchbinder * handle their own leases should break leases themselves from the 1501f9ffed26SJ. Bruce Fields * filesystem's open, create, and (on truncate) setattr methods. 1502f9ffed26SJ. Bruce Fields * 1503f9ffed26SJ. Bruce Fields * Warning: the only current setlease methods exist only to disable 1504f9ffed26SJ. Bruce Fields * leases in certain cases. More vfs changes may be required to 1505f9ffed26SJ. Bruce Fields * allow a full filesystem lease implementation. 15061da177e4SLinus Torvalds */ 15071da177e4SLinus Torvalds 1508a9933ceaSJ. Bruce Fields int vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 15091da177e4SLinus Torvalds { 15101da177e4SLinus Torvalds int error; 15111da177e4SLinus Torvalds 1512b89f4321SArnd Bergmann lock_flocks(); 1513b89f4321SArnd Bergmann error = __vfs_setlease(filp, arg, lease); 1514b89f4321SArnd Bergmann unlock_flocks(); 15151da177e4SLinus Torvalds 15161da177e4SLinus Torvalds return error; 15171da177e4SLinus Torvalds } 1518a9933ceaSJ. Bruce Fields EXPORT_SYMBOL_GPL(vfs_setlease); 15191da177e4SLinus Torvalds 15200ceaf6c7SJ. Bruce Fields static int do_fcntl_delete_lease(struct file *filp) 15210ceaf6c7SJ. Bruce Fields { 15220ceaf6c7SJ. Bruce Fields struct file_lock fl, *flp = &fl; 15230ceaf6c7SJ. Bruce Fields 15240ceaf6c7SJ. Bruce Fields lease_init(filp, F_UNLCK, flp); 15250ceaf6c7SJ. Bruce Fields 15260ceaf6c7SJ. Bruce Fields return vfs_setlease(filp, F_UNLCK, &flp); 15270ceaf6c7SJ. Bruce Fields } 15280ceaf6c7SJ. Bruce Fields 15290ceaf6c7SJ. Bruce Fields static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg) 15301da177e4SLinus Torvalds { 15313df057acSJ. Bruce Fields struct file_lock *fl, *ret; 1532f7347ce4SLinus Torvalds struct fasync_struct *new; 15331da177e4SLinus Torvalds int error; 15341da177e4SLinus Torvalds 1535c5b1f0d9SArnd Bergmann fl = lease_alloc(filp, arg); 1536c5b1f0d9SArnd Bergmann if (IS_ERR(fl)) 1537c5b1f0d9SArnd Bergmann return PTR_ERR(fl); 15381da177e4SLinus Torvalds 1539f7347ce4SLinus Torvalds new = fasync_alloc(); 1540f7347ce4SLinus Torvalds if (!new) { 1541f7347ce4SLinus Torvalds locks_free_lock(fl); 1542f7347ce4SLinus Torvalds return -ENOMEM; 1543f7347ce4SLinus Torvalds } 15443df057acSJ. Bruce Fields ret = fl; 1545b89f4321SArnd Bergmann lock_flocks(); 15468896b93fSJ. Bruce Fields error = __vfs_setlease(filp, arg, &ret); 154751ee4b84SChristoph Hellwig if (error) { 154851ee4b84SChristoph Hellwig unlock_flocks(); 154951ee4b84SChristoph Hellwig locks_free_lock(fl); 155051ee4b84SChristoph Hellwig goto out_free_fasync; 155151ee4b84SChristoph Hellwig } 15523df057acSJ. Bruce Fields if (ret != fl) 15533df057acSJ. Bruce Fields locks_free_lock(fl); 15541da177e4SLinus Torvalds 1555f7347ce4SLinus Torvalds /* 1556f7347ce4SLinus Torvalds * fasync_insert_entry() returns the old entry if any. 1557f7347ce4SLinus Torvalds * If there was no old entry, then it used 'new' and 1558f7347ce4SLinus Torvalds * inserted it into the fasync list. Clear new so that 1559f7347ce4SLinus Torvalds * we don't release it here. 1560f7347ce4SLinus Torvalds */ 15613df057acSJ. Bruce Fields if (!fasync_insert_entry(fd, filp, &ret->fl_fasync, new)) 1562f7347ce4SLinus Torvalds new = NULL; 1563f7347ce4SLinus Torvalds 1564609d7fa9SEric W. Biederman error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0); 1565b89f4321SArnd Bergmann unlock_flocks(); 156651ee4b84SChristoph Hellwig 156751ee4b84SChristoph Hellwig out_free_fasync: 1568f7347ce4SLinus Torvalds if (new) 1569f7347ce4SLinus Torvalds fasync_free(new); 15701da177e4SLinus Torvalds return error; 15711da177e4SLinus Torvalds } 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds /** 15740ceaf6c7SJ. Bruce Fields * fcntl_setlease - sets a lease on an open file 15750ceaf6c7SJ. Bruce Fields * @fd: open file descriptor 15760ceaf6c7SJ. Bruce Fields * @filp: file pointer 15770ceaf6c7SJ. Bruce Fields * @arg: type of lease to obtain 15780ceaf6c7SJ. Bruce Fields * 15790ceaf6c7SJ. Bruce Fields * Call this fcntl to establish a lease on the file. 15800ceaf6c7SJ. Bruce Fields * Note that you also need to call %F_SETSIG to 15810ceaf6c7SJ. Bruce Fields * receive a signal when the lease is broken. 15820ceaf6c7SJ. Bruce Fields */ 15830ceaf6c7SJ. Bruce Fields int fcntl_setlease(unsigned int fd, struct file *filp, long arg) 15840ceaf6c7SJ. Bruce Fields { 15850ceaf6c7SJ. Bruce Fields if (arg == F_UNLCK) 15860ceaf6c7SJ. Bruce Fields return do_fcntl_delete_lease(filp); 15870ceaf6c7SJ. Bruce Fields return do_fcntl_add_lease(fd, filp, arg); 15880ceaf6c7SJ. Bruce Fields } 15890ceaf6c7SJ. Bruce Fields 15900ceaf6c7SJ. Bruce Fields /** 15911da177e4SLinus Torvalds * flock_lock_file_wait - Apply a FLOCK-style lock to a file 15921da177e4SLinus Torvalds * @filp: The file to apply the lock to 15931da177e4SLinus Torvalds * @fl: The lock to be applied 15941da177e4SLinus Torvalds * 15951da177e4SLinus Torvalds * Add a FLOCK style lock to a file. 15961da177e4SLinus Torvalds */ 15971da177e4SLinus Torvalds int flock_lock_file_wait(struct file *filp, struct file_lock *fl) 15981da177e4SLinus Torvalds { 15991da177e4SLinus Torvalds int error; 16001da177e4SLinus Torvalds might_sleep(); 16011da177e4SLinus Torvalds for (;;) { 16021da177e4SLinus Torvalds error = flock_lock_file(filp, fl); 1603bde74e4bSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 16041da177e4SLinus Torvalds break; 16051da177e4SLinus Torvalds error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 16061da177e4SLinus Torvalds if (!error) 16071da177e4SLinus Torvalds continue; 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds locks_delete_block(fl); 16101da177e4SLinus Torvalds break; 16111da177e4SLinus Torvalds } 16121da177e4SLinus Torvalds return error; 16131da177e4SLinus Torvalds } 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds EXPORT_SYMBOL(flock_lock_file_wait); 16161da177e4SLinus Torvalds 16171da177e4SLinus Torvalds /** 16181da177e4SLinus Torvalds * sys_flock: - flock() system call. 16191da177e4SLinus Torvalds * @fd: the file descriptor to lock. 16201da177e4SLinus Torvalds * @cmd: the type of lock to apply. 16211da177e4SLinus Torvalds * 16221da177e4SLinus Torvalds * Apply a %FL_FLOCK style lock to an open file descriptor. 16231da177e4SLinus Torvalds * The @cmd can be one of 16241da177e4SLinus Torvalds * 16251da177e4SLinus Torvalds * %LOCK_SH -- a shared lock. 16261da177e4SLinus Torvalds * 16271da177e4SLinus Torvalds * %LOCK_EX -- an exclusive lock. 16281da177e4SLinus Torvalds * 16291da177e4SLinus Torvalds * %LOCK_UN -- remove an existing lock. 16301da177e4SLinus Torvalds * 16311da177e4SLinus Torvalds * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes. 16321da177e4SLinus Torvalds * 16331da177e4SLinus Torvalds * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other 16341da177e4SLinus Torvalds * processes read and write access respectively. 16351da177e4SLinus Torvalds */ 1636002c8976SHeiko Carstens SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) 16371da177e4SLinus Torvalds { 16381da177e4SLinus Torvalds struct file *filp; 1639bdc68959SAl Viro int fput_needed; 16401da177e4SLinus Torvalds struct file_lock *lock; 16411da177e4SLinus Torvalds int can_sleep, unlock; 16421da177e4SLinus Torvalds int error; 16431da177e4SLinus Torvalds 16441da177e4SLinus Torvalds error = -EBADF; 1645bdc68959SAl Viro filp = fget_light(fd, &fput_needed); 16461da177e4SLinus Torvalds if (!filp) 16471da177e4SLinus Torvalds goto out; 16481da177e4SLinus Torvalds 16491da177e4SLinus Torvalds can_sleep = !(cmd & LOCK_NB); 16501da177e4SLinus Torvalds cmd &= ~LOCK_NB; 16511da177e4SLinus Torvalds unlock = (cmd == LOCK_UN); 16521da177e4SLinus Torvalds 1653aeb5d727SAl Viro if (!unlock && !(cmd & LOCK_MAND) && 1654aeb5d727SAl Viro !(filp->f_mode & (FMODE_READ|FMODE_WRITE))) 16551da177e4SLinus Torvalds goto out_putf; 16561da177e4SLinus Torvalds 16571da177e4SLinus Torvalds error = flock_make_lock(filp, &lock, cmd); 16581da177e4SLinus Torvalds if (error) 16591da177e4SLinus Torvalds goto out_putf; 16601da177e4SLinus Torvalds if (can_sleep) 16611da177e4SLinus Torvalds lock->fl_flags |= FL_SLEEP; 16621da177e4SLinus Torvalds 1663713c0ecdSSten Spans error = security_file_lock(filp, lock->fl_type); 16641da177e4SLinus Torvalds if (error) 16651da177e4SLinus Torvalds goto out_free; 16661da177e4SLinus Torvalds 16671da177e4SLinus Torvalds if (filp->f_op && filp->f_op->flock) 16681da177e4SLinus Torvalds error = filp->f_op->flock(filp, 16691da177e4SLinus Torvalds (can_sleep) ? F_SETLKW : F_SETLK, 16701da177e4SLinus Torvalds lock); 16711da177e4SLinus Torvalds else 16721da177e4SLinus Torvalds error = flock_lock_file_wait(filp, lock); 16731da177e4SLinus Torvalds 16741da177e4SLinus Torvalds out_free: 16751da177e4SLinus Torvalds locks_free_lock(lock); 16761da177e4SLinus Torvalds 16771da177e4SLinus Torvalds out_putf: 1678bdc68959SAl Viro fput_light(filp, fput_needed); 16791da177e4SLinus Torvalds out: 16801da177e4SLinus Torvalds return error; 16811da177e4SLinus Torvalds } 16821da177e4SLinus Torvalds 16833ee17abdSJ. Bruce Fields /** 16843ee17abdSJ. Bruce Fields * vfs_test_lock - test file byte range lock 16853ee17abdSJ. Bruce Fields * @filp: The file to test lock for 16866924c554SJ. Bruce Fields * @fl: The lock to test; also used to hold result 16873ee17abdSJ. Bruce Fields * 16883ee17abdSJ. Bruce Fields * Returns -ERRNO on failure. Indicates presence of conflicting lock by 16893ee17abdSJ. Bruce Fields * setting conf->fl_type to something other than F_UNLCK. 16903ee17abdSJ. Bruce Fields */ 16913ee17abdSJ. Bruce Fields int vfs_test_lock(struct file *filp, struct file_lock *fl) 16923ee17abdSJ. Bruce Fields { 16933ee17abdSJ. Bruce Fields if (filp->f_op && filp->f_op->lock) 16943ee17abdSJ. Bruce Fields return filp->f_op->lock(filp, F_GETLK, fl); 16953ee17abdSJ. Bruce Fields posix_test_lock(filp, fl); 16963ee17abdSJ. Bruce Fields return 0; 16973ee17abdSJ. Bruce Fields } 16983ee17abdSJ. Bruce Fields EXPORT_SYMBOL_GPL(vfs_test_lock); 16993ee17abdSJ. Bruce Fields 1700c2fa1b8aSJ. Bruce Fields static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) 1701c2fa1b8aSJ. Bruce Fields { 1702c2fa1b8aSJ. Bruce Fields flock->l_pid = fl->fl_pid; 1703c2fa1b8aSJ. Bruce Fields #if BITS_PER_LONG == 32 1704c2fa1b8aSJ. Bruce Fields /* 1705c2fa1b8aSJ. Bruce Fields * Make sure we can represent the posix lock via 1706c2fa1b8aSJ. Bruce Fields * legacy 32bit flock. 1707c2fa1b8aSJ. Bruce Fields */ 1708c2fa1b8aSJ. Bruce Fields if (fl->fl_start > OFFT_OFFSET_MAX) 1709c2fa1b8aSJ. Bruce Fields return -EOVERFLOW; 1710c2fa1b8aSJ. Bruce Fields if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX) 1711c2fa1b8aSJ. Bruce Fields return -EOVERFLOW; 1712c2fa1b8aSJ. Bruce Fields #endif 1713c2fa1b8aSJ. Bruce Fields flock->l_start = fl->fl_start; 1714c2fa1b8aSJ. Bruce Fields flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1715c2fa1b8aSJ. Bruce Fields fl->fl_end - fl->fl_start + 1; 1716c2fa1b8aSJ. Bruce Fields flock->l_whence = 0; 1717129a84deSJ. Bruce Fields flock->l_type = fl->fl_type; 1718c2fa1b8aSJ. Bruce Fields return 0; 1719c2fa1b8aSJ. Bruce Fields } 1720c2fa1b8aSJ. Bruce Fields 1721c2fa1b8aSJ. Bruce Fields #if BITS_PER_LONG == 32 1722c2fa1b8aSJ. Bruce Fields static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) 1723c2fa1b8aSJ. Bruce Fields { 1724c2fa1b8aSJ. Bruce Fields flock->l_pid = fl->fl_pid; 1725c2fa1b8aSJ. Bruce Fields flock->l_start = fl->fl_start; 1726c2fa1b8aSJ. Bruce Fields flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1727c2fa1b8aSJ. Bruce Fields fl->fl_end - fl->fl_start + 1; 1728c2fa1b8aSJ. Bruce Fields flock->l_whence = 0; 1729c2fa1b8aSJ. Bruce Fields flock->l_type = fl->fl_type; 1730c2fa1b8aSJ. Bruce Fields } 1731c2fa1b8aSJ. Bruce Fields #endif 1732c2fa1b8aSJ. Bruce Fields 17331da177e4SLinus Torvalds /* Report the first existing lock that would conflict with l. 17341da177e4SLinus Torvalds * This implements the F_GETLK command of fcntl(). 17351da177e4SLinus Torvalds */ 17361da177e4SLinus Torvalds int fcntl_getlk(struct file *filp, struct flock __user *l) 17371da177e4SLinus Torvalds { 17389d6a8c5cSMarc Eshel struct file_lock file_lock; 17391da177e4SLinus Torvalds struct flock flock; 17401da177e4SLinus Torvalds int error; 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds error = -EFAULT; 17431da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 17441da177e4SLinus Torvalds goto out; 17451da177e4SLinus Torvalds error = -EINVAL; 17461da177e4SLinus Torvalds if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 17471da177e4SLinus Torvalds goto out; 17481da177e4SLinus Torvalds 17491da177e4SLinus Torvalds error = flock_to_posix_lock(filp, &file_lock, &flock); 17501da177e4SLinus Torvalds if (error) 17511da177e4SLinus Torvalds goto out; 17521da177e4SLinus Torvalds 17533ee17abdSJ. Bruce Fields error = vfs_test_lock(filp, &file_lock); 17543ee17abdSJ. Bruce Fields if (error) 17551da177e4SLinus Torvalds goto out; 17561da177e4SLinus Torvalds 17579d6a8c5cSMarc Eshel flock.l_type = file_lock.fl_type; 17589d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) { 17599d6a8c5cSMarc Eshel error = posix_lock_to_flock(&flock, &file_lock); 1760c2fa1b8aSJ. Bruce Fields if (error) 17611da177e4SLinus Torvalds goto out; 17621da177e4SLinus Torvalds } 17631da177e4SLinus Torvalds error = -EFAULT; 17641da177e4SLinus Torvalds if (!copy_to_user(l, &flock, sizeof(flock))) 17651da177e4SLinus Torvalds error = 0; 17661da177e4SLinus Torvalds out: 17671da177e4SLinus Torvalds return error; 17681da177e4SLinus Torvalds } 17691da177e4SLinus Torvalds 17707723ec97SMarc Eshel /** 17717723ec97SMarc Eshel * vfs_lock_file - file byte range lock 17727723ec97SMarc Eshel * @filp: The file to apply the lock to 17737723ec97SMarc Eshel * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.) 17747723ec97SMarc Eshel * @fl: The lock to be applied 1775150b3934SMarc Eshel * @conf: Place to return a copy of the conflicting lock, if found. 1776150b3934SMarc Eshel * 1777150b3934SMarc Eshel * A caller that doesn't care about the conflicting lock may pass NULL 1778150b3934SMarc Eshel * as the final argument. 1779150b3934SMarc Eshel * 1780150b3934SMarc Eshel * If the filesystem defines a private ->lock() method, then @conf will 1781150b3934SMarc Eshel * be left unchanged; so a caller that cares should initialize it to 1782150b3934SMarc Eshel * some acceptable default. 17832beb6614SMarc Eshel * 17842beb6614SMarc Eshel * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX 17852beb6614SMarc Eshel * locks, the ->lock() interface may return asynchronously, before the lock has 17862beb6614SMarc Eshel * been granted or denied by the underlying filesystem, if (and only if) 17878fb47a4fSJ. Bruce Fields * lm_grant is set. Callers expecting ->lock() to return asynchronously 17882beb6614SMarc Eshel * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if) 17892beb6614SMarc Eshel * the request is for a blocking lock. When ->lock() does return asynchronously, 17908fb47a4fSJ. Bruce Fields * it must return FILE_LOCK_DEFERRED, and call ->lm_grant() when the lock 17912beb6614SMarc Eshel * request completes. 17922beb6614SMarc Eshel * If the request is for non-blocking lock the file system should return 1793bde74e4bSMiklos Szeredi * FILE_LOCK_DEFERRED then try to get the lock and call the callback routine 1794bde74e4bSMiklos Szeredi * with the result. If the request timed out the callback routine will return a 17952beb6614SMarc Eshel * nonzero return code and the file system should release the lock. The file 17962beb6614SMarc Eshel * system is also responsible to keep a corresponding posix lock when it 17972beb6614SMarc Eshel * grants a lock so the VFS can find out which locks are locally held and do 17982beb6614SMarc Eshel * the correct lock cleanup when required. 17992beb6614SMarc Eshel * The underlying filesystem must not drop the kernel lock or call 18008fb47a4fSJ. Bruce Fields * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED 18012beb6614SMarc Eshel * return code. 18027723ec97SMarc Eshel */ 1803150b3934SMarc Eshel int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) 18047723ec97SMarc Eshel { 18057723ec97SMarc Eshel if (filp->f_op && filp->f_op->lock) 18067723ec97SMarc Eshel return filp->f_op->lock(filp, cmd, fl); 18077723ec97SMarc Eshel else 1808150b3934SMarc Eshel return posix_lock_file(filp, fl, conf); 18097723ec97SMarc Eshel } 18107723ec97SMarc Eshel EXPORT_SYMBOL_GPL(vfs_lock_file); 18117723ec97SMarc Eshel 1812b648a6deSMiklos Szeredi static int do_lock_file_wait(struct file *filp, unsigned int cmd, 1813b648a6deSMiklos Szeredi struct file_lock *fl) 1814b648a6deSMiklos Szeredi { 1815b648a6deSMiklos Szeredi int error; 1816b648a6deSMiklos Szeredi 1817b648a6deSMiklos Szeredi error = security_file_lock(filp, fl->fl_type); 1818b648a6deSMiklos Szeredi if (error) 1819b648a6deSMiklos Szeredi return error; 1820b648a6deSMiklos Szeredi 1821b648a6deSMiklos Szeredi for (;;) { 1822764c76b3SMiklos Szeredi error = vfs_lock_file(filp, cmd, fl, NULL); 1823b648a6deSMiklos Szeredi if (error != FILE_LOCK_DEFERRED) 1824b648a6deSMiklos Szeredi break; 1825764c76b3SMiklos Szeredi error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 1826b648a6deSMiklos Szeredi if (!error) 1827b648a6deSMiklos Szeredi continue; 1828b648a6deSMiklos Szeredi 1829b648a6deSMiklos Szeredi locks_delete_block(fl); 1830b648a6deSMiklos Szeredi break; 1831b648a6deSMiklos Szeredi } 1832b648a6deSMiklos Szeredi 1833b648a6deSMiklos Szeredi return error; 1834b648a6deSMiklos Szeredi } 1835b648a6deSMiklos Szeredi 18361da177e4SLinus Torvalds /* Apply the lock described by l to an open file descriptor. 18371da177e4SLinus Torvalds * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 18381da177e4SLinus Torvalds */ 1839c293621bSPeter Staubach int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, 1840c293621bSPeter Staubach struct flock __user *l) 18411da177e4SLinus Torvalds { 18421da177e4SLinus Torvalds struct file_lock *file_lock = locks_alloc_lock(); 18431da177e4SLinus Torvalds struct flock flock; 18441da177e4SLinus Torvalds struct inode *inode; 18450b2bac2fSAl Viro struct file *f; 18461da177e4SLinus Torvalds int error; 18471da177e4SLinus Torvalds 18481da177e4SLinus Torvalds if (file_lock == NULL) 18491da177e4SLinus Torvalds return -ENOLCK; 18501da177e4SLinus Torvalds 18511da177e4SLinus Torvalds /* 18521da177e4SLinus Torvalds * This might block, so we do it before checking the inode. 18531da177e4SLinus Torvalds */ 18541da177e4SLinus Torvalds error = -EFAULT; 18551da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 18561da177e4SLinus Torvalds goto out; 18571da177e4SLinus Torvalds 18580f7fc9e4SJosef "Jeff" Sipek inode = filp->f_path.dentry->d_inode; 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds /* Don't allow mandatory locks on files that may be memory mapped 18611da177e4SLinus Torvalds * and shared. 18621da177e4SLinus Torvalds */ 1863a16877caSPavel Emelyanov if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 18641da177e4SLinus Torvalds error = -EAGAIN; 18651da177e4SLinus Torvalds goto out; 18661da177e4SLinus Torvalds } 18671da177e4SLinus Torvalds 1868c293621bSPeter Staubach again: 18691da177e4SLinus Torvalds error = flock_to_posix_lock(filp, file_lock, &flock); 18701da177e4SLinus Torvalds if (error) 18711da177e4SLinus Torvalds goto out; 18721da177e4SLinus Torvalds if (cmd == F_SETLKW) { 18731da177e4SLinus Torvalds file_lock->fl_flags |= FL_SLEEP; 18741da177e4SLinus Torvalds } 18751da177e4SLinus Torvalds 18761da177e4SLinus Torvalds error = -EBADF; 18771da177e4SLinus Torvalds switch (flock.l_type) { 18781da177e4SLinus Torvalds case F_RDLCK: 18791da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_READ)) 18801da177e4SLinus Torvalds goto out; 18811da177e4SLinus Torvalds break; 18821da177e4SLinus Torvalds case F_WRLCK: 18831da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_WRITE)) 18841da177e4SLinus Torvalds goto out; 18851da177e4SLinus Torvalds break; 18861da177e4SLinus Torvalds case F_UNLCK: 18871da177e4SLinus Torvalds break; 18881da177e4SLinus Torvalds default: 18891da177e4SLinus Torvalds error = -EINVAL; 18901da177e4SLinus Torvalds goto out; 18911da177e4SLinus Torvalds } 18921da177e4SLinus Torvalds 1893b648a6deSMiklos Szeredi error = do_lock_file_wait(filp, cmd, file_lock); 1894c293621bSPeter Staubach 1895c293621bSPeter Staubach /* 1896c293621bSPeter Staubach * Attempt to detect a close/fcntl race and recover by 1897c293621bSPeter Staubach * releasing the lock that was just acquired. 1898c293621bSPeter Staubach */ 18990b2bac2fSAl Viro /* 19000b2bac2fSAl Viro * we need that spin_lock here - it prevents reordering between 19010b2bac2fSAl Viro * update of inode->i_flock and check for it done in close(). 19020b2bac2fSAl Viro * rcu_read_lock() wouldn't do. 19030b2bac2fSAl Viro */ 19040b2bac2fSAl Viro spin_lock(¤t->files->file_lock); 19050b2bac2fSAl Viro f = fcheck(fd); 19060b2bac2fSAl Viro spin_unlock(¤t->files->file_lock); 19070b2bac2fSAl Viro if (!error && f != filp && flock.l_type != F_UNLCK) { 1908c293621bSPeter Staubach flock.l_type = F_UNLCK; 1909c293621bSPeter Staubach goto again; 1910c293621bSPeter Staubach } 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds out: 19131da177e4SLinus Torvalds locks_free_lock(file_lock); 19141da177e4SLinus Torvalds return error; 19151da177e4SLinus Torvalds } 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds #if BITS_PER_LONG == 32 19181da177e4SLinus Torvalds /* Report the first existing lock that would conflict with l. 19191da177e4SLinus Torvalds * This implements the F_GETLK command of fcntl(). 19201da177e4SLinus Torvalds */ 19211da177e4SLinus Torvalds int fcntl_getlk64(struct file *filp, struct flock64 __user *l) 19221da177e4SLinus Torvalds { 19239d6a8c5cSMarc Eshel struct file_lock file_lock; 19241da177e4SLinus Torvalds struct flock64 flock; 19251da177e4SLinus Torvalds int error; 19261da177e4SLinus Torvalds 19271da177e4SLinus Torvalds error = -EFAULT; 19281da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 19291da177e4SLinus Torvalds goto out; 19301da177e4SLinus Torvalds error = -EINVAL; 19311da177e4SLinus Torvalds if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 19321da177e4SLinus Torvalds goto out; 19331da177e4SLinus Torvalds 19341da177e4SLinus Torvalds error = flock64_to_posix_lock(filp, &file_lock, &flock); 19351da177e4SLinus Torvalds if (error) 19361da177e4SLinus Torvalds goto out; 19371da177e4SLinus Torvalds 19383ee17abdSJ. Bruce Fields error = vfs_test_lock(filp, &file_lock); 19393ee17abdSJ. Bruce Fields if (error) 19401da177e4SLinus Torvalds goto out; 19411da177e4SLinus Torvalds 19429d6a8c5cSMarc Eshel flock.l_type = file_lock.fl_type; 19439d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) 19449d6a8c5cSMarc Eshel posix_lock_to_flock64(&flock, &file_lock); 19459d6a8c5cSMarc Eshel 19461da177e4SLinus Torvalds error = -EFAULT; 19471da177e4SLinus Torvalds if (!copy_to_user(l, &flock, sizeof(flock))) 19481da177e4SLinus Torvalds error = 0; 19491da177e4SLinus Torvalds 19501da177e4SLinus Torvalds out: 19511da177e4SLinus Torvalds return error; 19521da177e4SLinus Torvalds } 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds /* Apply the lock described by l to an open file descriptor. 19551da177e4SLinus Torvalds * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 19561da177e4SLinus Torvalds */ 1957c293621bSPeter Staubach int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, 1958c293621bSPeter Staubach struct flock64 __user *l) 19591da177e4SLinus Torvalds { 19601da177e4SLinus Torvalds struct file_lock *file_lock = locks_alloc_lock(); 19611da177e4SLinus Torvalds struct flock64 flock; 19621da177e4SLinus Torvalds struct inode *inode; 19630b2bac2fSAl Viro struct file *f; 19641da177e4SLinus Torvalds int error; 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds if (file_lock == NULL) 19671da177e4SLinus Torvalds return -ENOLCK; 19681da177e4SLinus Torvalds 19691da177e4SLinus Torvalds /* 19701da177e4SLinus Torvalds * This might block, so we do it before checking the inode. 19711da177e4SLinus Torvalds */ 19721da177e4SLinus Torvalds error = -EFAULT; 19731da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 19741da177e4SLinus Torvalds goto out; 19751da177e4SLinus Torvalds 19760f7fc9e4SJosef "Jeff" Sipek inode = filp->f_path.dentry->d_inode; 19771da177e4SLinus Torvalds 19781da177e4SLinus Torvalds /* Don't allow mandatory locks on files that may be memory mapped 19791da177e4SLinus Torvalds * and shared. 19801da177e4SLinus Torvalds */ 1981a16877caSPavel Emelyanov if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { 19821da177e4SLinus Torvalds error = -EAGAIN; 19831da177e4SLinus Torvalds goto out; 19841da177e4SLinus Torvalds } 19851da177e4SLinus Torvalds 1986c293621bSPeter Staubach again: 19871da177e4SLinus Torvalds error = flock64_to_posix_lock(filp, file_lock, &flock); 19881da177e4SLinus Torvalds if (error) 19891da177e4SLinus Torvalds goto out; 19901da177e4SLinus Torvalds if (cmd == F_SETLKW64) { 19911da177e4SLinus Torvalds file_lock->fl_flags |= FL_SLEEP; 19921da177e4SLinus Torvalds } 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds error = -EBADF; 19951da177e4SLinus Torvalds switch (flock.l_type) { 19961da177e4SLinus Torvalds case F_RDLCK: 19971da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_READ)) 19981da177e4SLinus Torvalds goto out; 19991da177e4SLinus Torvalds break; 20001da177e4SLinus Torvalds case F_WRLCK: 20011da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_WRITE)) 20021da177e4SLinus Torvalds goto out; 20031da177e4SLinus Torvalds break; 20041da177e4SLinus Torvalds case F_UNLCK: 20051da177e4SLinus Torvalds break; 20061da177e4SLinus Torvalds default: 20071da177e4SLinus Torvalds error = -EINVAL; 20081da177e4SLinus Torvalds goto out; 20091da177e4SLinus Torvalds } 20101da177e4SLinus Torvalds 2011b648a6deSMiklos Szeredi error = do_lock_file_wait(filp, cmd, file_lock); 2012c293621bSPeter Staubach 2013c293621bSPeter Staubach /* 2014c293621bSPeter Staubach * Attempt to detect a close/fcntl race and recover by 2015c293621bSPeter Staubach * releasing the lock that was just acquired. 2016c293621bSPeter Staubach */ 20170b2bac2fSAl Viro spin_lock(¤t->files->file_lock); 20180b2bac2fSAl Viro f = fcheck(fd); 20190b2bac2fSAl Viro spin_unlock(¤t->files->file_lock); 20200b2bac2fSAl Viro if (!error && f != filp && flock.l_type != F_UNLCK) { 2021c293621bSPeter Staubach flock.l_type = F_UNLCK; 2022c293621bSPeter Staubach goto again; 2023c293621bSPeter Staubach } 20241da177e4SLinus Torvalds 20251da177e4SLinus Torvalds out: 20261da177e4SLinus Torvalds locks_free_lock(file_lock); 20271da177e4SLinus Torvalds return error; 20281da177e4SLinus Torvalds } 20291da177e4SLinus Torvalds #endif /* BITS_PER_LONG == 32 */ 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds /* 20321da177e4SLinus Torvalds * This function is called when the file is being removed 20331da177e4SLinus Torvalds * from the task's fd array. POSIX locks belonging to this task 20341da177e4SLinus Torvalds * are deleted at this time. 20351da177e4SLinus Torvalds */ 20361da177e4SLinus Torvalds void locks_remove_posix(struct file *filp, fl_owner_t owner) 20371da177e4SLinus Torvalds { 2038ff7b86b8SMiklos Szeredi struct file_lock lock; 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds /* 20411da177e4SLinus Torvalds * If there are no locks held on this file, we don't need to call 20421da177e4SLinus Torvalds * posix_lock_file(). Another process could be setting a lock on this 20431da177e4SLinus Torvalds * file at the same time, but we wouldn't remove that lock anyway. 20441da177e4SLinus Torvalds */ 20450f7fc9e4SJosef "Jeff" Sipek if (!filp->f_path.dentry->d_inode->i_flock) 20461da177e4SLinus Torvalds return; 20471da177e4SLinus Torvalds 20481da177e4SLinus Torvalds lock.fl_type = F_UNLCK; 204975e1fcc0SMiklos Szeredi lock.fl_flags = FL_POSIX | FL_CLOSE; 20501da177e4SLinus Torvalds lock.fl_start = 0; 20511da177e4SLinus Torvalds lock.fl_end = OFFSET_MAX; 20521da177e4SLinus Torvalds lock.fl_owner = owner; 20531da177e4SLinus Torvalds lock.fl_pid = current->tgid; 20541da177e4SLinus Torvalds lock.fl_file = filp; 20551da177e4SLinus Torvalds lock.fl_ops = NULL; 20561da177e4SLinus Torvalds lock.fl_lmops = NULL; 20571da177e4SLinus Torvalds 2058150b3934SMarc Eshel vfs_lock_file(filp, F_SETLK, &lock, NULL); 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds if (lock.fl_ops && lock.fl_ops->fl_release_private) 20611da177e4SLinus Torvalds lock.fl_ops->fl_release_private(&lock); 20621da177e4SLinus Torvalds } 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds EXPORT_SYMBOL(locks_remove_posix); 20651da177e4SLinus Torvalds 20661da177e4SLinus Torvalds /* 20671da177e4SLinus Torvalds * This function is called on the last close of an open file. 20681da177e4SLinus Torvalds */ 20691da177e4SLinus Torvalds void locks_remove_flock(struct file *filp) 20701da177e4SLinus Torvalds { 20710f7fc9e4SJosef "Jeff" Sipek struct inode * inode = filp->f_path.dentry->d_inode; 20721da177e4SLinus Torvalds struct file_lock *fl; 20731da177e4SLinus Torvalds struct file_lock **before; 20741da177e4SLinus Torvalds 20751da177e4SLinus Torvalds if (!inode->i_flock) 20761da177e4SLinus Torvalds return; 20771da177e4SLinus Torvalds 20781da177e4SLinus Torvalds if (filp->f_op && filp->f_op->flock) { 20791da177e4SLinus Torvalds struct file_lock fl = { 20801da177e4SLinus Torvalds .fl_pid = current->tgid, 20811da177e4SLinus Torvalds .fl_file = filp, 20821da177e4SLinus Torvalds .fl_flags = FL_FLOCK, 20831da177e4SLinus Torvalds .fl_type = F_UNLCK, 20841da177e4SLinus Torvalds .fl_end = OFFSET_MAX, 20851da177e4SLinus Torvalds }; 20861da177e4SLinus Torvalds filp->f_op->flock(filp, F_SETLKW, &fl); 208780fec4c6STrond Myklebust if (fl.fl_ops && fl.fl_ops->fl_release_private) 208880fec4c6STrond Myklebust fl.fl_ops->fl_release_private(&fl); 20891da177e4SLinus Torvalds } 20901da177e4SLinus Torvalds 2091b89f4321SArnd Bergmann lock_flocks(); 20921da177e4SLinus Torvalds before = &inode->i_flock; 20931da177e4SLinus Torvalds 20941da177e4SLinus Torvalds while ((fl = *before) != NULL) { 20951da177e4SLinus Torvalds if (fl->fl_file == filp) { 2096c293621bSPeter Staubach if (IS_FLOCK(fl)) { 20971da177e4SLinus Torvalds locks_delete_lock(before); 20981da177e4SLinus Torvalds continue; 20991da177e4SLinus Torvalds } 21001da177e4SLinus Torvalds if (IS_LEASE(fl)) { 21011da177e4SLinus Torvalds lease_modify(before, F_UNLCK); 21021da177e4SLinus Torvalds continue; 21031da177e4SLinus Torvalds } 21041da177e4SLinus Torvalds /* What? */ 21051da177e4SLinus Torvalds BUG(); 21061da177e4SLinus Torvalds } 21071da177e4SLinus Torvalds before = &fl->fl_next; 21081da177e4SLinus Torvalds } 2109b89f4321SArnd Bergmann unlock_flocks(); 21101da177e4SLinus Torvalds } 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds /** 21131da177e4SLinus Torvalds * posix_unblock_lock - stop waiting for a file lock 21141da177e4SLinus Torvalds * @filp: how the file was opened 21151da177e4SLinus Torvalds * @waiter: the lock which was waiting 21161da177e4SLinus Torvalds * 21171da177e4SLinus Torvalds * lockd needs to block waiting for locks. 21181da177e4SLinus Torvalds */ 211964a318eeSJ. Bruce Fields int 21201da177e4SLinus Torvalds posix_unblock_lock(struct file *filp, struct file_lock *waiter) 21211da177e4SLinus Torvalds { 212264a318eeSJ. Bruce Fields int status = 0; 212364a318eeSJ. Bruce Fields 2124b89f4321SArnd Bergmann lock_flocks(); 21255996a298SJ. Bruce Fields if (waiter->fl_next) 21261da177e4SLinus Torvalds __locks_delete_block(waiter); 212764a318eeSJ. Bruce Fields else 212864a318eeSJ. Bruce Fields status = -ENOENT; 2129b89f4321SArnd Bergmann unlock_flocks(); 213064a318eeSJ. Bruce Fields return status; 21311da177e4SLinus Torvalds } 21321da177e4SLinus Torvalds 21331da177e4SLinus Torvalds EXPORT_SYMBOL(posix_unblock_lock); 21341da177e4SLinus Torvalds 21359b9d2ab4SMarc Eshel /** 21369b9d2ab4SMarc Eshel * vfs_cancel_lock - file byte range unblock lock 21379b9d2ab4SMarc Eshel * @filp: The file to apply the unblock to 21389b9d2ab4SMarc Eshel * @fl: The lock to be unblocked 21399b9d2ab4SMarc Eshel * 21409b9d2ab4SMarc Eshel * Used by lock managers to cancel blocked requests 21419b9d2ab4SMarc Eshel */ 21429b9d2ab4SMarc Eshel int vfs_cancel_lock(struct file *filp, struct file_lock *fl) 21439b9d2ab4SMarc Eshel { 21449b9d2ab4SMarc Eshel if (filp->f_op && filp->f_op->lock) 21459b9d2ab4SMarc Eshel return filp->f_op->lock(filp, F_CANCELLK, fl); 21469b9d2ab4SMarc Eshel return 0; 21479b9d2ab4SMarc Eshel } 21489b9d2ab4SMarc Eshel 21499b9d2ab4SMarc Eshel EXPORT_SYMBOL_GPL(vfs_cancel_lock); 21509b9d2ab4SMarc Eshel 21517f8ada98SPavel Emelyanov #ifdef CONFIG_PROC_FS 2152d8ba7a36SAlexey Dobriyan #include <linux/proc_fs.h> 21537f8ada98SPavel Emelyanov #include <linux/seq_file.h> 21547f8ada98SPavel Emelyanov 21557f8ada98SPavel Emelyanov static void lock_get_status(struct seq_file *f, struct file_lock *fl, 215699dc8292SJerome Marchand loff_t id, char *pfx) 21571da177e4SLinus Torvalds { 21581da177e4SLinus Torvalds struct inode *inode = NULL; 2159ab1f1611SVitaliy Gusev unsigned int fl_pid; 2160ab1f1611SVitaliy Gusev 2161ab1f1611SVitaliy Gusev if (fl->fl_nspid) 21626c5f3e7bSPavel Emelyanov fl_pid = pid_vnr(fl->fl_nspid); 2163ab1f1611SVitaliy Gusev else 2164ab1f1611SVitaliy Gusev fl_pid = fl->fl_pid; 21651da177e4SLinus Torvalds 21661da177e4SLinus Torvalds if (fl->fl_file != NULL) 21670f7fc9e4SJosef "Jeff" Sipek inode = fl->fl_file->f_path.dentry->d_inode; 21681da177e4SLinus Torvalds 216999dc8292SJerome Marchand seq_printf(f, "%lld:%s ", id, pfx); 21701da177e4SLinus Torvalds if (IS_POSIX(fl)) { 21717f8ada98SPavel Emelyanov seq_printf(f, "%6s %s ", 21721da177e4SLinus Torvalds (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ", 21731da177e4SLinus Torvalds (inode == NULL) ? "*NOINODE*" : 2174a16877caSPavel Emelyanov mandatory_lock(inode) ? "MANDATORY" : "ADVISORY "); 21751da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 21761da177e4SLinus Torvalds if (fl->fl_type & LOCK_MAND) { 21777f8ada98SPavel Emelyanov seq_printf(f, "FLOCK MSNFS "); 21781da177e4SLinus Torvalds } else { 21797f8ada98SPavel Emelyanov seq_printf(f, "FLOCK ADVISORY "); 21801da177e4SLinus Torvalds } 21811da177e4SLinus Torvalds } else if (IS_LEASE(fl)) { 21827f8ada98SPavel Emelyanov seq_printf(f, "LEASE "); 2183ab83fa4bSJ. Bruce Fields if (lease_breaking(fl)) 21847f8ada98SPavel Emelyanov seq_printf(f, "BREAKING "); 21851da177e4SLinus Torvalds else if (fl->fl_file) 21867f8ada98SPavel Emelyanov seq_printf(f, "ACTIVE "); 21871da177e4SLinus Torvalds else 21887f8ada98SPavel Emelyanov seq_printf(f, "BREAKER "); 21891da177e4SLinus Torvalds } else { 21907f8ada98SPavel Emelyanov seq_printf(f, "UNKNOWN UNKNOWN "); 21911da177e4SLinus Torvalds } 21921da177e4SLinus Torvalds if (fl->fl_type & LOCK_MAND) { 21937f8ada98SPavel Emelyanov seq_printf(f, "%s ", 21941da177e4SLinus Torvalds (fl->fl_type & LOCK_READ) 21951da177e4SLinus Torvalds ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ " 21961da177e4SLinus Torvalds : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE "); 21971da177e4SLinus Torvalds } else { 21987f8ada98SPavel Emelyanov seq_printf(f, "%s ", 2199ab83fa4bSJ. Bruce Fields (lease_breaking(fl)) 22001da177e4SLinus Torvalds ? (fl->fl_type & F_UNLCK) ? "UNLCK" : "READ " 22011da177e4SLinus Torvalds : (fl->fl_type & F_WRLCK) ? "WRITE" : "READ "); 22021da177e4SLinus Torvalds } 22031da177e4SLinus Torvalds if (inode) { 22041da177e4SLinus Torvalds #ifdef WE_CAN_BREAK_LSLK_NOW 2205ab1f1611SVitaliy Gusev seq_printf(f, "%d %s:%ld ", fl_pid, 22061da177e4SLinus Torvalds inode->i_sb->s_id, inode->i_ino); 22071da177e4SLinus Torvalds #else 22081da177e4SLinus Torvalds /* userspace relies on this representation of dev_t ;-( */ 2209ab1f1611SVitaliy Gusev seq_printf(f, "%d %02x:%02x:%ld ", fl_pid, 22101da177e4SLinus Torvalds MAJOR(inode->i_sb->s_dev), 22111da177e4SLinus Torvalds MINOR(inode->i_sb->s_dev), inode->i_ino); 22121da177e4SLinus Torvalds #endif 22131da177e4SLinus Torvalds } else { 2214ab1f1611SVitaliy Gusev seq_printf(f, "%d <none>:0 ", fl_pid); 22151da177e4SLinus Torvalds } 22161da177e4SLinus Torvalds if (IS_POSIX(fl)) { 22171da177e4SLinus Torvalds if (fl->fl_end == OFFSET_MAX) 22187f8ada98SPavel Emelyanov seq_printf(f, "%Ld EOF\n", fl->fl_start); 22191da177e4SLinus Torvalds else 22207f8ada98SPavel Emelyanov seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end); 22211da177e4SLinus Torvalds } else { 22227f8ada98SPavel Emelyanov seq_printf(f, "0 EOF\n"); 22231da177e4SLinus Torvalds } 22241da177e4SLinus Torvalds } 22251da177e4SLinus Torvalds 22267f8ada98SPavel Emelyanov static int locks_show(struct seq_file *f, void *v) 22271da177e4SLinus Torvalds { 22287f8ada98SPavel Emelyanov struct file_lock *fl, *bfl; 22297f8ada98SPavel Emelyanov 22307f8ada98SPavel Emelyanov fl = list_entry(v, struct file_lock, fl_link); 22317f8ada98SPavel Emelyanov 223299dc8292SJerome Marchand lock_get_status(f, fl, *((loff_t *)f->private), ""); 22337f8ada98SPavel Emelyanov 22347f8ada98SPavel Emelyanov list_for_each_entry(bfl, &fl->fl_block, fl_block) 223599dc8292SJerome Marchand lock_get_status(f, bfl, *((loff_t *)f->private), " ->"); 22367f8ada98SPavel Emelyanov 22377f8ada98SPavel Emelyanov return 0; 22381da177e4SLinus Torvalds } 22391da177e4SLinus Torvalds 22407f8ada98SPavel Emelyanov static void *locks_start(struct seq_file *f, loff_t *pos) 22411da177e4SLinus Torvalds { 224299dc8292SJerome Marchand loff_t *p = f->private; 224399dc8292SJerome Marchand 2244b89f4321SArnd Bergmann lock_flocks(); 224599dc8292SJerome Marchand *p = (*pos + 1); 22467f8ada98SPavel Emelyanov return seq_list_start(&file_lock_list, *pos); 22471da177e4SLinus Torvalds } 22487f8ada98SPavel Emelyanov 22497f8ada98SPavel Emelyanov static void *locks_next(struct seq_file *f, void *v, loff_t *pos) 22507f8ada98SPavel Emelyanov { 225199dc8292SJerome Marchand loff_t *p = f->private; 225299dc8292SJerome Marchand ++*p; 22537f8ada98SPavel Emelyanov return seq_list_next(v, &file_lock_list, pos); 22541da177e4SLinus Torvalds } 22557f8ada98SPavel Emelyanov 22567f8ada98SPavel Emelyanov static void locks_stop(struct seq_file *f, void *v) 22577f8ada98SPavel Emelyanov { 2258b89f4321SArnd Bergmann unlock_flocks(); 22591da177e4SLinus Torvalds } 22601da177e4SLinus Torvalds 2261d8ba7a36SAlexey Dobriyan static const struct seq_operations locks_seq_operations = { 22627f8ada98SPavel Emelyanov .start = locks_start, 22637f8ada98SPavel Emelyanov .next = locks_next, 22647f8ada98SPavel Emelyanov .stop = locks_stop, 22657f8ada98SPavel Emelyanov .show = locks_show, 22667f8ada98SPavel Emelyanov }; 2267d8ba7a36SAlexey Dobriyan 2268d8ba7a36SAlexey Dobriyan static int locks_open(struct inode *inode, struct file *filp) 2269d8ba7a36SAlexey Dobriyan { 227099dc8292SJerome Marchand return seq_open_private(filp, &locks_seq_operations, sizeof(loff_t)); 2271d8ba7a36SAlexey Dobriyan } 2272d8ba7a36SAlexey Dobriyan 2273d8ba7a36SAlexey Dobriyan static const struct file_operations proc_locks_operations = { 2274d8ba7a36SAlexey Dobriyan .open = locks_open, 2275d8ba7a36SAlexey Dobriyan .read = seq_read, 2276d8ba7a36SAlexey Dobriyan .llseek = seq_lseek, 227799dc8292SJerome Marchand .release = seq_release_private, 2278d8ba7a36SAlexey Dobriyan }; 2279d8ba7a36SAlexey Dobriyan 2280d8ba7a36SAlexey Dobriyan static int __init proc_locks_init(void) 2281d8ba7a36SAlexey Dobriyan { 2282d8ba7a36SAlexey Dobriyan proc_create("locks", 0, NULL, &proc_locks_operations); 2283d8ba7a36SAlexey Dobriyan return 0; 2284d8ba7a36SAlexey Dobriyan } 2285d8ba7a36SAlexey Dobriyan module_init(proc_locks_init); 22867f8ada98SPavel Emelyanov #endif 22877f8ada98SPavel Emelyanov 22881da177e4SLinus Torvalds /** 22891da177e4SLinus Torvalds * lock_may_read - checks that the region is free of locks 22901da177e4SLinus Torvalds * @inode: the inode that is being read 22911da177e4SLinus Torvalds * @start: the first byte to read 22921da177e4SLinus Torvalds * @len: the number of bytes to read 22931da177e4SLinus Torvalds * 22941da177e4SLinus Torvalds * Emulates Windows locking requirements. Whole-file 22951da177e4SLinus Torvalds * mandatory locks (share modes) can prohibit a read and 22961da177e4SLinus Torvalds * byte-range POSIX locks can prohibit a read if they overlap. 22971da177e4SLinus Torvalds * 22981da177e4SLinus Torvalds * N.B. this function is only ever called 22991da177e4SLinus Torvalds * from knfsd and ownership of locks is never checked. 23001da177e4SLinus Torvalds */ 23011da177e4SLinus Torvalds int lock_may_read(struct inode *inode, loff_t start, unsigned long len) 23021da177e4SLinus Torvalds { 23031da177e4SLinus Torvalds struct file_lock *fl; 23041da177e4SLinus Torvalds int result = 1; 2305b89f4321SArnd Bergmann lock_flocks(); 23061da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 23071da177e4SLinus Torvalds if (IS_POSIX(fl)) { 23081da177e4SLinus Torvalds if (fl->fl_type == F_RDLCK) 23091da177e4SLinus Torvalds continue; 23101da177e4SLinus Torvalds if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 23111da177e4SLinus Torvalds continue; 23121da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 23131da177e4SLinus Torvalds if (!(fl->fl_type & LOCK_MAND)) 23141da177e4SLinus Torvalds continue; 23151da177e4SLinus Torvalds if (fl->fl_type & LOCK_READ) 23161da177e4SLinus Torvalds continue; 23171da177e4SLinus Torvalds } else 23181da177e4SLinus Torvalds continue; 23191da177e4SLinus Torvalds result = 0; 23201da177e4SLinus Torvalds break; 23211da177e4SLinus Torvalds } 2322b89f4321SArnd Bergmann unlock_flocks(); 23231da177e4SLinus Torvalds return result; 23241da177e4SLinus Torvalds } 23251da177e4SLinus Torvalds 23261da177e4SLinus Torvalds EXPORT_SYMBOL(lock_may_read); 23271da177e4SLinus Torvalds 23281da177e4SLinus Torvalds /** 23291da177e4SLinus Torvalds * lock_may_write - checks that the region is free of locks 23301da177e4SLinus Torvalds * @inode: the inode that is being written 23311da177e4SLinus Torvalds * @start: the first byte to write 23321da177e4SLinus Torvalds * @len: the number of bytes to write 23331da177e4SLinus Torvalds * 23341da177e4SLinus Torvalds * Emulates Windows locking requirements. Whole-file 23351da177e4SLinus Torvalds * mandatory locks (share modes) can prohibit a write and 23361da177e4SLinus Torvalds * byte-range POSIX locks can prohibit a write if they overlap. 23371da177e4SLinus Torvalds * 23381da177e4SLinus Torvalds * N.B. this function is only ever called 23391da177e4SLinus Torvalds * from knfsd and ownership of locks is never checked. 23401da177e4SLinus Torvalds */ 23411da177e4SLinus Torvalds int lock_may_write(struct inode *inode, loff_t start, unsigned long len) 23421da177e4SLinus Torvalds { 23431da177e4SLinus Torvalds struct file_lock *fl; 23441da177e4SLinus Torvalds int result = 1; 2345b89f4321SArnd Bergmann lock_flocks(); 23461da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 23471da177e4SLinus Torvalds if (IS_POSIX(fl)) { 23481da177e4SLinus Torvalds if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 23491da177e4SLinus Torvalds continue; 23501da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 23511da177e4SLinus Torvalds if (!(fl->fl_type & LOCK_MAND)) 23521da177e4SLinus Torvalds continue; 23531da177e4SLinus Torvalds if (fl->fl_type & LOCK_WRITE) 23541da177e4SLinus Torvalds continue; 23551da177e4SLinus Torvalds } else 23561da177e4SLinus Torvalds continue; 23571da177e4SLinus Torvalds result = 0; 23581da177e4SLinus Torvalds break; 23591da177e4SLinus Torvalds } 2360b89f4321SArnd Bergmann unlock_flocks(); 23611da177e4SLinus Torvalds return result; 23621da177e4SLinus Torvalds } 23631da177e4SLinus Torvalds 23641da177e4SLinus Torvalds EXPORT_SYMBOL(lock_may_write); 23651da177e4SLinus Torvalds 23661da177e4SLinus Torvalds static int __init filelock_init(void) 23671da177e4SLinus Torvalds { 23681da177e4SLinus Torvalds filelock_cache = kmem_cache_create("file_lock_cache", 2369ee19cc40SMiklos Szeredi sizeof(struct file_lock), 0, SLAB_PANIC, NULL); 2370ee19cc40SMiklos Szeredi 23711da177e4SLinus Torvalds return 0; 23721da177e4SLinus Torvalds } 23731da177e4SLinus Torvalds 23741da177e4SLinus Torvalds core_initcall(filelock_init); 2375