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. 631da177e4SLinus Torvalds * See 'Documentation/mandatory.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> 1191da177e4SLinus Torvalds #include <linux/fs.h> 1201da177e4SLinus Torvalds #include <linux/init.h> 1211da177e4SLinus Torvalds #include <linux/module.h> 1221da177e4SLinus Torvalds #include <linux/security.h> 1231da177e4SLinus Torvalds #include <linux/slab.h> 1241da177e4SLinus Torvalds #include <linux/smp_lock.h> 1251da177e4SLinus Torvalds #include <linux/syscalls.h> 1261da177e4SLinus Torvalds #include <linux/time.h> 1274fb3a538SDipankar Sarma #include <linux/rcupdate.h> 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds #include <asm/semaphore.h> 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 1361da177e4SLinus Torvalds int leases_enable = 1; 1371da177e4SLinus Torvalds int lease_break_time = 45; 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds #define for_each_lock(inode, lockp) \ 1401da177e4SLinus Torvalds for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next) 1411da177e4SLinus Torvalds 14226bcbf96SChristoph Hellwig static LIST_HEAD(file_lock_list); 1431da177e4SLinus Torvalds static LIST_HEAD(blocked_list); 1441da177e4SLinus Torvalds 145e18b890bSChristoph Lameter static struct kmem_cache *filelock_cache __read_mostly; 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds /* Allocate an empty lock structure. */ 1481da177e4SLinus Torvalds static struct file_lock *locks_alloc_lock(void) 1491da177e4SLinus Torvalds { 150e94b1766SChristoph Lameter return kmem_cache_alloc(filelock_cache, GFP_KERNEL); 1511da177e4SLinus Torvalds } 1521da177e4SLinus Torvalds 15347831f35STrond Myklebust static void locks_release_private(struct file_lock *fl) 15447831f35STrond Myklebust { 15547831f35STrond Myklebust if (fl->fl_ops) { 15647831f35STrond Myklebust if (fl->fl_ops->fl_release_private) 15747831f35STrond Myklebust fl->fl_ops->fl_release_private(fl); 15847831f35STrond Myklebust fl->fl_ops = NULL; 15947831f35STrond Myklebust } 16047831f35STrond Myklebust if (fl->fl_lmops) { 16147831f35STrond Myklebust if (fl->fl_lmops->fl_release_private) 16247831f35STrond Myklebust fl->fl_lmops->fl_release_private(fl); 16347831f35STrond Myklebust fl->fl_lmops = NULL; 16447831f35STrond Myklebust } 16547831f35STrond Myklebust 16647831f35STrond Myklebust } 16747831f35STrond Myklebust 1681da177e4SLinus Torvalds /* Free a lock which is not in use. */ 16933443c42SMatt Mackall static void locks_free_lock(struct file_lock *fl) 1701da177e4SLinus Torvalds { 1715ce29646SMiklos Szeredi BUG_ON(waitqueue_active(&fl->fl_wait)); 1725ce29646SMiklos Szeredi BUG_ON(!list_empty(&fl->fl_block)); 1735ce29646SMiklos Szeredi BUG_ON(!list_empty(&fl->fl_link)); 1741da177e4SLinus Torvalds 17547831f35STrond Myklebust locks_release_private(fl); 1761da177e4SLinus Torvalds kmem_cache_free(filelock_cache, fl); 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds void locks_init_lock(struct file_lock *fl) 1801da177e4SLinus Torvalds { 1811da177e4SLinus Torvalds INIT_LIST_HEAD(&fl->fl_link); 1821da177e4SLinus Torvalds INIT_LIST_HEAD(&fl->fl_block); 1831da177e4SLinus Torvalds init_waitqueue_head(&fl->fl_wait); 1841da177e4SLinus Torvalds fl->fl_next = NULL; 1851da177e4SLinus Torvalds fl->fl_fasync = NULL; 1861da177e4SLinus Torvalds fl->fl_owner = NULL; 1871da177e4SLinus Torvalds fl->fl_pid = 0; 1881da177e4SLinus Torvalds fl->fl_file = NULL; 1891da177e4SLinus Torvalds fl->fl_flags = 0; 1901da177e4SLinus Torvalds fl->fl_type = 0; 1911da177e4SLinus Torvalds fl->fl_start = fl->fl_end = 0; 1921da177e4SLinus Torvalds fl->fl_ops = NULL; 1931da177e4SLinus Torvalds fl->fl_lmops = NULL; 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds EXPORT_SYMBOL(locks_init_lock); 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds /* 1991da177e4SLinus Torvalds * Initialises the fields of the file lock which are invariant for 2001da177e4SLinus Torvalds * free file_locks. 2011da177e4SLinus Torvalds */ 202e18b890bSChristoph Lameter static void init_once(void *foo, struct kmem_cache *cache, unsigned long flags) 2031da177e4SLinus Torvalds { 2041da177e4SLinus Torvalds struct file_lock *lock = (struct file_lock *) foo; 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds locks_init_lock(lock); 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 20947831f35STrond Myklebust static void locks_copy_private(struct file_lock *new, struct file_lock *fl) 21047831f35STrond Myklebust { 21147831f35STrond Myklebust if (fl->fl_ops) { 21247831f35STrond Myklebust if (fl->fl_ops->fl_copy_lock) 21347831f35STrond Myklebust fl->fl_ops->fl_copy_lock(new, fl); 21447831f35STrond Myklebust new->fl_ops = fl->fl_ops; 21547831f35STrond Myklebust } 21647831f35STrond Myklebust if (fl->fl_lmops) { 21747831f35STrond Myklebust if (fl->fl_lmops->fl_copy_lock) 21847831f35STrond Myklebust fl->fl_lmops->fl_copy_lock(new, fl); 21947831f35STrond Myklebust new->fl_lmops = fl->fl_lmops; 22047831f35STrond Myklebust } 22147831f35STrond Myklebust } 22247831f35STrond Myklebust 2231da177e4SLinus Torvalds /* 2241da177e4SLinus Torvalds * Initialize a new lock from an existing file_lock structure. 2251da177e4SLinus Torvalds */ 2260996905fSTrond Myklebust static void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl) 2271da177e4SLinus Torvalds { 2281da177e4SLinus Torvalds new->fl_owner = fl->fl_owner; 2291da177e4SLinus Torvalds new->fl_pid = fl->fl_pid; 2300996905fSTrond Myklebust new->fl_file = NULL; 2311da177e4SLinus Torvalds new->fl_flags = fl->fl_flags; 2321da177e4SLinus Torvalds new->fl_type = fl->fl_type; 2331da177e4SLinus Torvalds new->fl_start = fl->fl_start; 2341da177e4SLinus Torvalds new->fl_end = fl->fl_end; 2350996905fSTrond Myklebust new->fl_ops = NULL; 2360996905fSTrond Myklebust new->fl_lmops = NULL; 2370996905fSTrond Myklebust } 2380996905fSTrond Myklebust 2390996905fSTrond Myklebust void locks_copy_lock(struct file_lock *new, struct file_lock *fl) 2400996905fSTrond Myklebust { 2410996905fSTrond Myklebust locks_release_private(new); 2420996905fSTrond Myklebust 2430996905fSTrond Myklebust __locks_copy_lock(new, fl); 2440996905fSTrond Myklebust new->fl_file = fl->fl_file; 2451da177e4SLinus Torvalds new->fl_ops = fl->fl_ops; 2461da177e4SLinus Torvalds new->fl_lmops = fl->fl_lmops; 24747831f35STrond Myklebust 24847831f35STrond Myklebust locks_copy_private(new, fl); 2491da177e4SLinus Torvalds } 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds EXPORT_SYMBOL(locks_copy_lock); 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds static inline int flock_translate_cmd(int cmd) { 2541da177e4SLinus Torvalds if (cmd & LOCK_MAND) 2551da177e4SLinus Torvalds return cmd & (LOCK_MAND | LOCK_RW); 2561da177e4SLinus Torvalds switch (cmd) { 2571da177e4SLinus Torvalds case LOCK_SH: 2581da177e4SLinus Torvalds return F_RDLCK; 2591da177e4SLinus Torvalds case LOCK_EX: 2601da177e4SLinus Torvalds return F_WRLCK; 2611da177e4SLinus Torvalds case LOCK_UN: 2621da177e4SLinus Torvalds return F_UNLCK; 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds return -EINVAL; 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds /* Fill in a file_lock structure with an appropriate FLOCK lock. */ 2681da177e4SLinus Torvalds static int flock_make_lock(struct file *filp, struct file_lock **lock, 2691da177e4SLinus Torvalds unsigned int cmd) 2701da177e4SLinus Torvalds { 2711da177e4SLinus Torvalds struct file_lock *fl; 2721da177e4SLinus Torvalds int type = flock_translate_cmd(cmd); 2731da177e4SLinus Torvalds if (type < 0) 2741da177e4SLinus Torvalds return type; 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds fl = locks_alloc_lock(); 2771da177e4SLinus Torvalds if (fl == NULL) 2781da177e4SLinus Torvalds return -ENOMEM; 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds fl->fl_file = filp; 2811da177e4SLinus Torvalds fl->fl_pid = current->tgid; 2821da177e4SLinus Torvalds fl->fl_flags = FL_FLOCK; 2831da177e4SLinus Torvalds fl->fl_type = type; 2841da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds *lock = fl; 2871da177e4SLinus Torvalds return 0; 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds static int assign_type(struct file_lock *fl, int type) 2911da177e4SLinus Torvalds { 2921da177e4SLinus Torvalds switch (type) { 2931da177e4SLinus Torvalds case F_RDLCK: 2941da177e4SLinus Torvalds case F_WRLCK: 2951da177e4SLinus Torvalds case F_UNLCK: 2961da177e4SLinus Torvalds fl->fl_type = type; 2971da177e4SLinus Torvalds break; 2981da177e4SLinus Torvalds default: 2991da177e4SLinus Torvalds return -EINVAL; 3001da177e4SLinus Torvalds } 3011da177e4SLinus Torvalds return 0; 3021da177e4SLinus Torvalds } 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX 3051da177e4SLinus Torvalds * style lock. 3061da177e4SLinus Torvalds */ 3071da177e4SLinus Torvalds static int flock_to_posix_lock(struct file *filp, struct file_lock *fl, 3081da177e4SLinus Torvalds struct flock *l) 3091da177e4SLinus Torvalds { 3101da177e4SLinus Torvalds off_t start, end; 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds switch (l->l_whence) { 313f5579f8cSJosef 'Jeff' Sipek case SEEK_SET: 3141da177e4SLinus Torvalds start = 0; 3151da177e4SLinus Torvalds break; 316f5579f8cSJosef 'Jeff' Sipek case SEEK_CUR: 3171da177e4SLinus Torvalds start = filp->f_pos; 3181da177e4SLinus Torvalds break; 319f5579f8cSJosef 'Jeff' Sipek case SEEK_END: 3200f7fc9e4SJosef "Jeff" Sipek start = i_size_read(filp->f_path.dentry->d_inode); 3211da177e4SLinus Torvalds break; 3221da177e4SLinus Torvalds default: 3231da177e4SLinus Torvalds return -EINVAL; 3241da177e4SLinus Torvalds } 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds /* POSIX-1996 leaves the case l->l_len < 0 undefined; 3271da177e4SLinus Torvalds POSIX-2001 defines it. */ 3281da177e4SLinus Torvalds start += l->l_start; 3291da177e4SLinus Torvalds if (start < 0) 3301da177e4SLinus Torvalds return -EINVAL; 3311da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 3324c780a46STrond Myklebust if (l->l_len > 0) { 3334c780a46STrond Myklebust end = start + l->l_len - 1; 3344c780a46STrond Myklebust fl->fl_end = end; 3354c780a46STrond Myklebust } else if (l->l_len < 0) { 3364c780a46STrond Myklebust end = start - 1; 3374c780a46STrond Myklebust fl->fl_end = end; 3384c780a46STrond Myklebust start += l->l_len; 3394c780a46STrond Myklebust if (start < 0) 3404c780a46STrond Myklebust return -EINVAL; 3414c780a46STrond Myklebust } 3424c780a46STrond Myklebust fl->fl_start = start; /* we record the absolute position */ 3434c780a46STrond Myklebust if (fl->fl_end < fl->fl_start) 3444c780a46STrond Myklebust return -EOVERFLOW; 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds fl->fl_owner = current->files; 3471da177e4SLinus Torvalds fl->fl_pid = current->tgid; 3481da177e4SLinus Torvalds fl->fl_file = filp; 3491da177e4SLinus Torvalds fl->fl_flags = FL_POSIX; 3501da177e4SLinus Torvalds fl->fl_ops = NULL; 3511da177e4SLinus Torvalds fl->fl_lmops = NULL; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds return assign_type(fl, l->l_type); 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds #if BITS_PER_LONG == 32 3571da177e4SLinus Torvalds static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, 3581da177e4SLinus Torvalds struct flock64 *l) 3591da177e4SLinus Torvalds { 3601da177e4SLinus Torvalds loff_t start; 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds switch (l->l_whence) { 363f5579f8cSJosef 'Jeff' Sipek case SEEK_SET: 3641da177e4SLinus Torvalds start = 0; 3651da177e4SLinus Torvalds break; 366f5579f8cSJosef 'Jeff' Sipek case SEEK_CUR: 3671da177e4SLinus Torvalds start = filp->f_pos; 3681da177e4SLinus Torvalds break; 369f5579f8cSJosef 'Jeff' Sipek case SEEK_END: 3700f7fc9e4SJosef "Jeff" Sipek start = i_size_read(filp->f_path.dentry->d_inode); 3711da177e4SLinus Torvalds break; 3721da177e4SLinus Torvalds default: 3731da177e4SLinus Torvalds return -EINVAL; 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds 3764c780a46STrond Myklebust start += l->l_start; 3774c780a46STrond Myklebust if (start < 0) 3781da177e4SLinus Torvalds return -EINVAL; 3791da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 3804c780a46STrond Myklebust if (l->l_len > 0) { 3814c780a46STrond Myklebust fl->fl_end = start + l->l_len - 1; 3824c780a46STrond Myklebust } else if (l->l_len < 0) { 3834c780a46STrond Myklebust fl->fl_end = start - 1; 3844c780a46STrond Myklebust start += l->l_len; 3854c780a46STrond Myklebust if (start < 0) 3864c780a46STrond Myklebust return -EINVAL; 3874c780a46STrond Myklebust } 3884c780a46STrond Myklebust fl->fl_start = start; /* we record the absolute position */ 3894c780a46STrond Myklebust if (fl->fl_end < fl->fl_start) 3904c780a46STrond Myklebust return -EOVERFLOW; 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds fl->fl_owner = current->files; 3931da177e4SLinus Torvalds fl->fl_pid = current->tgid; 3941da177e4SLinus Torvalds fl->fl_file = filp; 3951da177e4SLinus Torvalds fl->fl_flags = FL_POSIX; 3961da177e4SLinus Torvalds fl->fl_ops = NULL; 3971da177e4SLinus Torvalds fl->fl_lmops = NULL; 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds switch (l->l_type) { 4001da177e4SLinus Torvalds case F_RDLCK: 4011da177e4SLinus Torvalds case F_WRLCK: 4021da177e4SLinus Torvalds case F_UNLCK: 4031da177e4SLinus Torvalds fl->fl_type = l->l_type; 4041da177e4SLinus Torvalds break; 4051da177e4SLinus Torvalds default: 4061da177e4SLinus Torvalds return -EINVAL; 4071da177e4SLinus Torvalds } 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds return (0); 4101da177e4SLinus Torvalds } 4111da177e4SLinus Torvalds #endif 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds /* default lease lock manager operations */ 4141da177e4SLinus Torvalds static void lease_break_callback(struct file_lock *fl) 4151da177e4SLinus Torvalds { 4161da177e4SLinus Torvalds kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG); 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds static void lease_release_private_callback(struct file_lock *fl) 4201da177e4SLinus Torvalds { 4211da177e4SLinus Torvalds if (!fl->fl_file) 4221da177e4SLinus Torvalds return; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds f_delown(fl->fl_file); 4251da177e4SLinus Torvalds fl->fl_file->f_owner.signum = 0; 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds 42875c96f85SAdrian Bunk static int lease_mylease_callback(struct file_lock *fl, struct file_lock *try) 4291da177e4SLinus Torvalds { 4301da177e4SLinus Torvalds return fl->fl_file == try->fl_file; 4311da177e4SLinus Torvalds } 4321da177e4SLinus Torvalds 43375c96f85SAdrian Bunk static struct lock_manager_operations lease_manager_ops = { 4341da177e4SLinus Torvalds .fl_break = lease_break_callback, 4351da177e4SLinus Torvalds .fl_release_private = lease_release_private_callback, 4361da177e4SLinus Torvalds .fl_mylease = lease_mylease_callback, 4371da177e4SLinus Torvalds .fl_change = lease_modify, 4381da177e4SLinus Torvalds }; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds /* 4411da177e4SLinus Torvalds * Initialize a lease, use the default lock manager operations 4421da177e4SLinus Torvalds */ 4431da177e4SLinus Torvalds static int lease_init(struct file *filp, int type, struct file_lock *fl) 4441da177e4SLinus Torvalds { 44575dff55aSTrond Myklebust if (assign_type(fl, type) != 0) 44675dff55aSTrond Myklebust return -EINVAL; 44775dff55aSTrond Myklebust 4481da177e4SLinus Torvalds fl->fl_owner = current->files; 4491da177e4SLinus Torvalds fl->fl_pid = current->tgid; 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds fl->fl_file = filp; 4521da177e4SLinus Torvalds fl->fl_flags = FL_LEASE; 4531da177e4SLinus Torvalds fl->fl_start = 0; 4541da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 4551da177e4SLinus Torvalds fl->fl_ops = NULL; 4561da177e4SLinus Torvalds fl->fl_lmops = &lease_manager_ops; 4571da177e4SLinus Torvalds return 0; 4581da177e4SLinus Torvalds } 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds /* Allocate a file_lock initialised to this type of lease */ 461e32b8ee2SJ. Bruce Fields static struct file_lock *lease_alloc(struct file *filp, int type) 4621da177e4SLinus Torvalds { 4631da177e4SLinus Torvalds struct file_lock *fl = locks_alloc_lock(); 46475dff55aSTrond Myklebust int error = -ENOMEM; 4651da177e4SLinus Torvalds 4661da177e4SLinus Torvalds if (fl == NULL) 467e32b8ee2SJ. Bruce Fields return ERR_PTR(error); 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds error = lease_init(filp, type, fl); 47075dff55aSTrond Myklebust if (error) { 47175dff55aSTrond Myklebust locks_free_lock(fl); 472e32b8ee2SJ. Bruce Fields return ERR_PTR(error); 47375dff55aSTrond Myklebust } 474e32b8ee2SJ. Bruce Fields return fl; 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds /* Check if two locks overlap each other. 4781da177e4SLinus Torvalds */ 4791da177e4SLinus Torvalds static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) 4801da177e4SLinus Torvalds { 4811da177e4SLinus Torvalds return ((fl1->fl_end >= fl2->fl_start) && 4821da177e4SLinus Torvalds (fl2->fl_end >= fl1->fl_start)); 4831da177e4SLinus Torvalds } 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds /* 4861da177e4SLinus Torvalds * Check whether two locks have the same owner. 4871da177e4SLinus Torvalds */ 48833443c42SMatt Mackall static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2) 4891da177e4SLinus Torvalds { 4901da177e4SLinus Torvalds if (fl1->fl_lmops && fl1->fl_lmops->fl_compare_owner) 4911da177e4SLinus Torvalds return fl2->fl_lmops == fl1->fl_lmops && 4921da177e4SLinus Torvalds fl1->fl_lmops->fl_compare_owner(fl1, fl2); 4931da177e4SLinus Torvalds return fl1->fl_owner == fl2->fl_owner; 4941da177e4SLinus Torvalds } 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds /* Remove waiter from blocker's block list. 4971da177e4SLinus Torvalds * When blocker ends up pointing to itself then the list is empty. 4981da177e4SLinus Torvalds */ 49933443c42SMatt Mackall static void __locks_delete_block(struct file_lock *waiter) 5001da177e4SLinus Torvalds { 5011da177e4SLinus Torvalds list_del_init(&waiter->fl_block); 5021da177e4SLinus Torvalds list_del_init(&waiter->fl_link); 5031da177e4SLinus Torvalds waiter->fl_next = NULL; 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds /* 5071da177e4SLinus Torvalds */ 5081da177e4SLinus Torvalds static void locks_delete_block(struct file_lock *waiter) 5091da177e4SLinus Torvalds { 5101da177e4SLinus Torvalds lock_kernel(); 5111da177e4SLinus Torvalds __locks_delete_block(waiter); 5121da177e4SLinus Torvalds unlock_kernel(); 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds /* Insert waiter into blocker's block list. 5161da177e4SLinus Torvalds * We use a circular list so that processes can be easily woken up in 5171da177e4SLinus Torvalds * the order they blocked. The documentation doesn't require this but 5181da177e4SLinus Torvalds * it seems like the reasonable thing to do. 5191da177e4SLinus Torvalds */ 5201da177e4SLinus Torvalds static void locks_insert_block(struct file_lock *blocker, 5211da177e4SLinus Torvalds struct file_lock *waiter) 5221da177e4SLinus Torvalds { 5236dc0fe8fSJ. Bruce Fields BUG_ON(!list_empty(&waiter->fl_block)); 5241da177e4SLinus Torvalds list_add_tail(&waiter->fl_block, &blocker->fl_block); 5251da177e4SLinus Torvalds waiter->fl_next = blocker; 5261da177e4SLinus Torvalds if (IS_POSIX(blocker)) 5271da177e4SLinus Torvalds list_add(&waiter->fl_link, &blocked_list); 5281da177e4SLinus Torvalds } 5291da177e4SLinus Torvalds 5301da177e4SLinus Torvalds /* Wake up processes blocked waiting for blocker. 5311da177e4SLinus Torvalds * If told to wait then schedule the processes until the block list 5321da177e4SLinus Torvalds * is empty, otherwise empty the block list ourselves. 5331da177e4SLinus Torvalds */ 5341da177e4SLinus Torvalds static void locks_wake_up_blocks(struct file_lock *blocker) 5351da177e4SLinus Torvalds { 5361da177e4SLinus Torvalds while (!list_empty(&blocker->fl_block)) { 5371da177e4SLinus Torvalds struct file_lock *waiter = list_entry(blocker->fl_block.next, 5381da177e4SLinus Torvalds struct file_lock, fl_block); 5391da177e4SLinus Torvalds __locks_delete_block(waiter); 5401da177e4SLinus Torvalds if (waiter->fl_lmops && waiter->fl_lmops->fl_notify) 5411da177e4SLinus Torvalds waiter->fl_lmops->fl_notify(waiter); 5421da177e4SLinus Torvalds else 5431da177e4SLinus Torvalds wake_up(&waiter->fl_wait); 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds /* Insert file lock fl into an inode's lock list at the position indicated 5481da177e4SLinus Torvalds * by pos. At the same time add the lock to the global file lock list. 5491da177e4SLinus Torvalds */ 5501da177e4SLinus Torvalds static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl) 5511da177e4SLinus Torvalds { 5521da177e4SLinus Torvalds list_add(&fl->fl_link, &file_lock_list); 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds /* insert into file's list */ 5551da177e4SLinus Torvalds fl->fl_next = *pos; 5561da177e4SLinus Torvalds *pos = fl; 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds if (fl->fl_ops && fl->fl_ops->fl_insert) 5591da177e4SLinus Torvalds fl->fl_ops->fl_insert(fl); 5601da177e4SLinus Torvalds } 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds /* 5631da177e4SLinus Torvalds * Delete a lock and then free it. 5641da177e4SLinus Torvalds * Wake up processes that are blocked waiting for this lock, 5651da177e4SLinus Torvalds * notify the FS that the lock has been cleared and 5661da177e4SLinus Torvalds * finally free the lock. 5671da177e4SLinus Torvalds */ 5681da177e4SLinus Torvalds static void locks_delete_lock(struct file_lock **thisfl_p) 5691da177e4SLinus Torvalds { 5701da177e4SLinus Torvalds struct file_lock *fl = *thisfl_p; 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds *thisfl_p = fl->fl_next; 5731da177e4SLinus Torvalds fl->fl_next = NULL; 5741da177e4SLinus Torvalds list_del_init(&fl->fl_link); 5751da177e4SLinus Torvalds 5761da177e4SLinus Torvalds fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); 5771da177e4SLinus Torvalds if (fl->fl_fasync != NULL) { 5781da177e4SLinus Torvalds printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync); 5791da177e4SLinus Torvalds fl->fl_fasync = NULL; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds if (fl->fl_ops && fl->fl_ops->fl_remove) 5831da177e4SLinus Torvalds fl->fl_ops->fl_remove(fl); 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds locks_wake_up_blocks(fl); 5861da177e4SLinus Torvalds locks_free_lock(fl); 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. Common functionality 5901da177e4SLinus Torvalds * checks for shared/exclusive status of overlapping locks. 5911da177e4SLinus Torvalds */ 5921da177e4SLinus Torvalds static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 5931da177e4SLinus Torvalds { 5941da177e4SLinus Torvalds if (sys_fl->fl_type == F_WRLCK) 5951da177e4SLinus Torvalds return 1; 5961da177e4SLinus Torvalds if (caller_fl->fl_type == F_WRLCK) 5971da177e4SLinus Torvalds return 1; 5981da177e4SLinus Torvalds return 0; 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific 6021da177e4SLinus Torvalds * checking before calling the locks_conflict(). 6031da177e4SLinus Torvalds */ 6041da177e4SLinus Torvalds static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6051da177e4SLinus Torvalds { 6061da177e4SLinus Torvalds /* POSIX locks owned by the same process do not conflict with 6071da177e4SLinus Torvalds * each other. 6081da177e4SLinus Torvalds */ 6091da177e4SLinus Torvalds if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl)) 6101da177e4SLinus Torvalds return (0); 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds /* Check whether they overlap */ 6131da177e4SLinus Torvalds if (!locks_overlap(caller_fl, sys_fl)) 6141da177e4SLinus Torvalds return 0; 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds return (locks_conflict(caller_fl, sys_fl)); 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific 6201da177e4SLinus Torvalds * checking before calling the locks_conflict(). 6211da177e4SLinus Torvalds */ 6221da177e4SLinus Torvalds static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) 6231da177e4SLinus Torvalds { 6241da177e4SLinus Torvalds /* FLOCK locks referring to the same filp do not conflict with 6251da177e4SLinus Torvalds * each other. 6261da177e4SLinus Torvalds */ 6271da177e4SLinus Torvalds if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file)) 6281da177e4SLinus Torvalds return (0); 6291da177e4SLinus Torvalds if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND)) 6301da177e4SLinus Torvalds return 0; 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds return (locks_conflict(caller_fl, sys_fl)); 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds static int interruptible_sleep_on_locked(wait_queue_head_t *fl_wait, int timeout) 6361da177e4SLinus Torvalds { 6371da177e4SLinus Torvalds int result = 0; 6381da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds __set_current_state(TASK_INTERRUPTIBLE); 6411da177e4SLinus Torvalds add_wait_queue(fl_wait, &wait); 6421da177e4SLinus Torvalds if (timeout == 0) 6431da177e4SLinus Torvalds schedule(); 6441da177e4SLinus Torvalds else 6451da177e4SLinus Torvalds result = schedule_timeout(timeout); 6461da177e4SLinus Torvalds if (signal_pending(current)) 6471da177e4SLinus Torvalds result = -ERESTARTSYS; 6481da177e4SLinus Torvalds remove_wait_queue(fl_wait, &wait); 6491da177e4SLinus Torvalds __set_current_state(TASK_RUNNING); 6501da177e4SLinus Torvalds return result; 6511da177e4SLinus Torvalds } 6521da177e4SLinus Torvalds 6531da177e4SLinus Torvalds static int locks_block_on_timeout(struct file_lock *blocker, struct file_lock *waiter, int time) 6541da177e4SLinus Torvalds { 6551da177e4SLinus Torvalds int result; 6561da177e4SLinus Torvalds locks_insert_block(blocker, waiter); 6571da177e4SLinus Torvalds result = interruptible_sleep_on_locked(&waiter->fl_wait, time); 6581da177e4SLinus Torvalds __locks_delete_block(waiter); 6591da177e4SLinus Torvalds return result; 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds 6626d34ac19SJ. Bruce Fields void 6639d6a8c5cSMarc Eshel posix_test_lock(struct file *filp, struct file_lock *fl) 6641da177e4SLinus Torvalds { 6651da177e4SLinus Torvalds struct file_lock *cfl; 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds lock_kernel(); 6680f7fc9e4SJosef "Jeff" Sipek for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) { 6691da177e4SLinus Torvalds if (!IS_POSIX(cfl)) 6701da177e4SLinus Torvalds continue; 671b842e240SJ. Bruce Fields if (posix_locks_conflict(fl, cfl)) 6721da177e4SLinus Torvalds break; 6731da177e4SLinus Torvalds } 6746d34ac19SJ. Bruce Fields if (cfl) 6759d6a8c5cSMarc Eshel __locks_copy_lock(fl, cfl); 6766d34ac19SJ. Bruce Fields else 677129a84deSJ. Bruce Fields fl->fl_type = F_UNLCK; 6788dc7c311SAndy Adamson unlock_kernel(); 6796d34ac19SJ. Bruce Fields return; 6801da177e4SLinus Torvalds } 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds EXPORT_SYMBOL(posix_test_lock); 6831da177e4SLinus Torvalds 6841da177e4SLinus Torvalds /* This function tests for deadlock condition before putting a process to 6851da177e4SLinus Torvalds * sleep. The detection scheme is no longer recursive. Recursive was neat, 6861da177e4SLinus Torvalds * but dangerous - we risked stack corruption if the lock data was bad, or 6871da177e4SLinus Torvalds * if the recursion was too deep for any other reason. 6881da177e4SLinus Torvalds * 6891da177e4SLinus Torvalds * We rely on the fact that a task can only be on one lock's wait queue 6901da177e4SLinus Torvalds * at a time. When we find blocked_task on a wait queue we can re-search 6911da177e4SLinus Torvalds * with blocked_task equal to that queue's owner, until either blocked_task 6921da177e4SLinus Torvalds * isn't found, or blocked_task is found on a queue owned by my_task. 6931da177e4SLinus Torvalds * 6941da177e4SLinus Torvalds * Note: the above assumption may not be true when handling lock requests 6951da177e4SLinus Torvalds * from a broken NFS client. But broken NFS clients have a lot more to 6961da177e4SLinus Torvalds * worry about than proper deadlock detection anyway... --okir 6971da177e4SLinus Torvalds */ 698b0904e14SAdrian Bunk static int posix_locks_deadlock(struct file_lock *caller_fl, 6991da177e4SLinus Torvalds struct file_lock *block_fl) 7001da177e4SLinus Torvalds { 7011da177e4SLinus Torvalds struct list_head *tmp; 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds next_task: 7041da177e4SLinus Torvalds if (posix_same_owner(caller_fl, block_fl)) 7051da177e4SLinus Torvalds return 1; 7061da177e4SLinus Torvalds list_for_each(tmp, &blocked_list) { 7071da177e4SLinus Torvalds struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link); 7081da177e4SLinus Torvalds if (posix_same_owner(fl, block_fl)) { 7091da177e4SLinus Torvalds fl = fl->fl_next; 7101da177e4SLinus Torvalds block_fl = fl; 7111da177e4SLinus Torvalds goto next_task; 7121da177e4SLinus Torvalds } 7131da177e4SLinus Torvalds } 7141da177e4SLinus Torvalds return 0; 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks 7181da177e4SLinus Torvalds * at the head of the list, but that's secret knowledge known only to 7191da177e4SLinus Torvalds * flock_lock_file and posix_lock_file. 720f475ae95STrond Myklebust * 721f475ae95STrond Myklebust * Note that if called with an FL_EXISTS argument, the caller may determine 722f475ae95STrond Myklebust * whether or not a lock was successfully freed by testing the return 723f475ae95STrond Myklebust * value for -ENOENT. 7241da177e4SLinus Torvalds */ 725993dfa87STrond Myklebust static int flock_lock_file(struct file *filp, struct file_lock *request) 7261da177e4SLinus Torvalds { 727993dfa87STrond Myklebust struct file_lock *new_fl = NULL; 7281da177e4SLinus Torvalds struct file_lock **before; 7290f7fc9e4SJosef "Jeff" Sipek struct inode * inode = filp->f_path.dentry->d_inode; 7301da177e4SLinus Torvalds int error = 0; 7311da177e4SLinus Torvalds int found = 0; 7321da177e4SLinus Torvalds 7331da177e4SLinus Torvalds lock_kernel(); 734f07f18ddSTrond Myklebust if (request->fl_flags & FL_ACCESS) 735f07f18ddSTrond Myklebust goto find_conflict; 7361da177e4SLinus Torvalds for_each_lock(inode, before) { 7371da177e4SLinus Torvalds struct file_lock *fl = *before; 7381da177e4SLinus Torvalds if (IS_POSIX(fl)) 7391da177e4SLinus Torvalds break; 7401da177e4SLinus Torvalds if (IS_LEASE(fl)) 7411da177e4SLinus Torvalds continue; 7421da177e4SLinus Torvalds if (filp != fl->fl_file) 7431da177e4SLinus Torvalds continue; 744993dfa87STrond Myklebust if (request->fl_type == fl->fl_type) 7451da177e4SLinus Torvalds goto out; 7461da177e4SLinus Torvalds found = 1; 7471da177e4SLinus Torvalds locks_delete_lock(before); 7481da177e4SLinus Torvalds break; 7491da177e4SLinus Torvalds } 7501da177e4SLinus Torvalds 751f475ae95STrond Myklebust if (request->fl_type == F_UNLCK) { 752f475ae95STrond Myklebust if ((request->fl_flags & FL_EXISTS) && !found) 753f475ae95STrond Myklebust error = -ENOENT; 754993dfa87STrond Myklebust goto out; 755f475ae95STrond Myklebust } 7561da177e4SLinus Torvalds 7579cedc194SKirill Korotaev error = -ENOMEM; 758993dfa87STrond Myklebust new_fl = locks_alloc_lock(); 759993dfa87STrond Myklebust if (new_fl == NULL) 760993dfa87STrond Myklebust goto out; 7611da177e4SLinus Torvalds /* 7621da177e4SLinus Torvalds * If a higher-priority process was blocked on the old file lock, 7631da177e4SLinus Torvalds * give it the opportunity to lock the file. 7641da177e4SLinus Torvalds */ 7651da177e4SLinus Torvalds if (found) 7661da177e4SLinus Torvalds cond_resched(); 7671da177e4SLinus Torvalds 768f07f18ddSTrond Myklebust find_conflict: 7691da177e4SLinus Torvalds for_each_lock(inode, before) { 7701da177e4SLinus Torvalds struct file_lock *fl = *before; 7711da177e4SLinus Torvalds if (IS_POSIX(fl)) 7721da177e4SLinus Torvalds break; 7731da177e4SLinus Torvalds if (IS_LEASE(fl)) 7741da177e4SLinus Torvalds continue; 775993dfa87STrond Myklebust if (!flock_locks_conflict(request, fl)) 7761da177e4SLinus Torvalds continue; 7771da177e4SLinus Torvalds error = -EAGAIN; 778993dfa87STrond Myklebust if (request->fl_flags & FL_SLEEP) 779993dfa87STrond Myklebust locks_insert_block(fl, request); 7801da177e4SLinus Torvalds goto out; 7811da177e4SLinus Torvalds } 782f07f18ddSTrond Myklebust if (request->fl_flags & FL_ACCESS) 783f07f18ddSTrond Myklebust goto out; 784993dfa87STrond Myklebust locks_copy_lock(new_fl, request); 7850e2f6db8SPavel Emelyanov locks_insert_lock(before, new_fl); 786993dfa87STrond Myklebust new_fl = NULL; 7879cedc194SKirill Korotaev error = 0; 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds out: 7901da177e4SLinus Torvalds unlock_kernel(); 791993dfa87STrond Myklebust if (new_fl) 792993dfa87STrond Myklebust locks_free_lock(new_fl); 7931da177e4SLinus Torvalds return error; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds 796150b3934SMarc Eshel static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock) 7971da177e4SLinus Torvalds { 7981da177e4SLinus Torvalds struct file_lock *fl; 79939005d02SMiklos Szeredi struct file_lock *new_fl = NULL; 80039005d02SMiklos Szeredi struct file_lock *new_fl2 = NULL; 8011da177e4SLinus Torvalds struct file_lock *left = NULL; 8021da177e4SLinus Torvalds struct file_lock *right = NULL; 8031da177e4SLinus Torvalds struct file_lock **before; 8041da177e4SLinus Torvalds int error, added = 0; 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds /* 8071da177e4SLinus Torvalds * We may need two file_lock structures for this operation, 8081da177e4SLinus Torvalds * so we get them in advance to avoid races. 80939005d02SMiklos Szeredi * 81039005d02SMiklos Szeredi * In some cases we can be sure, that no new locks will be needed 8111da177e4SLinus Torvalds */ 81239005d02SMiklos Szeredi if (!(request->fl_flags & FL_ACCESS) && 81339005d02SMiklos Szeredi (request->fl_type != F_UNLCK || 81439005d02SMiklos Szeredi request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { 8151da177e4SLinus Torvalds new_fl = locks_alloc_lock(); 8161da177e4SLinus Torvalds new_fl2 = locks_alloc_lock(); 81739005d02SMiklos Szeredi } 8181da177e4SLinus Torvalds 8191da177e4SLinus Torvalds lock_kernel(); 8201da177e4SLinus Torvalds if (request->fl_type != F_UNLCK) { 8211da177e4SLinus Torvalds for_each_lock(inode, before) { 822*526985b9SJ. Bruce Fields fl = *before; 8231da177e4SLinus Torvalds if (!IS_POSIX(fl)) 8241da177e4SLinus Torvalds continue; 8251da177e4SLinus Torvalds if (!posix_locks_conflict(request, fl)) 8261da177e4SLinus Torvalds continue; 8275842add2SAndy Adamson if (conflock) 8285842add2SAndy Adamson locks_copy_lock(conflock, fl); 8291da177e4SLinus Torvalds error = -EAGAIN; 8301da177e4SLinus Torvalds if (!(request->fl_flags & FL_SLEEP)) 8311da177e4SLinus Torvalds goto out; 8321da177e4SLinus Torvalds error = -EDEADLK; 8331da177e4SLinus Torvalds if (posix_locks_deadlock(request, fl)) 8341da177e4SLinus Torvalds goto out; 8351da177e4SLinus Torvalds error = -EAGAIN; 8361da177e4SLinus Torvalds locks_insert_block(fl, request); 8371da177e4SLinus Torvalds goto out; 8381da177e4SLinus Torvalds } 8391da177e4SLinus Torvalds } 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds /* If we're just looking for a conflict, we're done. */ 8421da177e4SLinus Torvalds error = 0; 8431da177e4SLinus Torvalds if (request->fl_flags & FL_ACCESS) 8441da177e4SLinus Torvalds goto out; 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds /* 8471da177e4SLinus Torvalds * Find the first old lock with the same owner as the new lock. 8481da177e4SLinus Torvalds */ 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds before = &inode->i_flock; 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds /* First skip locks owned by other processes. */ 8531da177e4SLinus Torvalds while ((fl = *before) && (!IS_POSIX(fl) || 8541da177e4SLinus Torvalds !posix_same_owner(request, fl))) { 8551da177e4SLinus Torvalds before = &fl->fl_next; 8561da177e4SLinus Torvalds } 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds /* Process locks with this owner. */ 8591da177e4SLinus Torvalds while ((fl = *before) && posix_same_owner(request, fl)) { 8601da177e4SLinus Torvalds /* Detect adjacent or overlapping regions (if same lock type) 8611da177e4SLinus Torvalds */ 8621da177e4SLinus Torvalds if (request->fl_type == fl->fl_type) { 863449231d6SOlaf Kirch /* In all comparisons of start vs end, use 864449231d6SOlaf Kirch * "start - 1" rather than "end + 1". If end 865449231d6SOlaf Kirch * is OFFSET_MAX, end + 1 will become negative. 866449231d6SOlaf Kirch */ 8671da177e4SLinus Torvalds if (fl->fl_end < request->fl_start - 1) 8681da177e4SLinus Torvalds goto next_lock; 8691da177e4SLinus Torvalds /* If the next lock in the list has entirely bigger 8701da177e4SLinus Torvalds * addresses than the new one, insert the lock here. 8711da177e4SLinus Torvalds */ 872449231d6SOlaf Kirch if (fl->fl_start - 1 > request->fl_end) 8731da177e4SLinus Torvalds break; 8741da177e4SLinus Torvalds 8751da177e4SLinus Torvalds /* If we come here, the new and old lock are of the 8761da177e4SLinus Torvalds * same type and adjacent or overlapping. Make one 8771da177e4SLinus Torvalds * lock yielding from the lower start address of both 8781da177e4SLinus Torvalds * locks to the higher end address. 8791da177e4SLinus Torvalds */ 8801da177e4SLinus Torvalds if (fl->fl_start > request->fl_start) 8811da177e4SLinus Torvalds fl->fl_start = request->fl_start; 8821da177e4SLinus Torvalds else 8831da177e4SLinus Torvalds request->fl_start = fl->fl_start; 8841da177e4SLinus Torvalds if (fl->fl_end < request->fl_end) 8851da177e4SLinus Torvalds fl->fl_end = request->fl_end; 8861da177e4SLinus Torvalds else 8871da177e4SLinus Torvalds request->fl_end = fl->fl_end; 8881da177e4SLinus Torvalds if (added) { 8891da177e4SLinus Torvalds locks_delete_lock(before); 8901da177e4SLinus Torvalds continue; 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds request = fl; 8931da177e4SLinus Torvalds added = 1; 8941da177e4SLinus Torvalds } 8951da177e4SLinus Torvalds else { 8961da177e4SLinus Torvalds /* Processing for different lock types is a bit 8971da177e4SLinus Torvalds * more complex. 8981da177e4SLinus Torvalds */ 8991da177e4SLinus Torvalds if (fl->fl_end < request->fl_start) 9001da177e4SLinus Torvalds goto next_lock; 9011da177e4SLinus Torvalds if (fl->fl_start > request->fl_end) 9021da177e4SLinus Torvalds break; 9031da177e4SLinus Torvalds if (request->fl_type == F_UNLCK) 9041da177e4SLinus Torvalds added = 1; 9051da177e4SLinus Torvalds if (fl->fl_start < request->fl_start) 9061da177e4SLinus Torvalds left = fl; 9071da177e4SLinus Torvalds /* If the next lock in the list has a higher end 9081da177e4SLinus Torvalds * address than the new one, insert the new one here. 9091da177e4SLinus Torvalds */ 9101da177e4SLinus Torvalds if (fl->fl_end > request->fl_end) { 9111da177e4SLinus Torvalds right = fl; 9121da177e4SLinus Torvalds break; 9131da177e4SLinus Torvalds } 9141da177e4SLinus Torvalds if (fl->fl_start >= request->fl_start) { 9151da177e4SLinus Torvalds /* The new lock completely replaces an old 9161da177e4SLinus Torvalds * one (This may happen several times). 9171da177e4SLinus Torvalds */ 9181da177e4SLinus Torvalds if (added) { 9191da177e4SLinus Torvalds locks_delete_lock(before); 9201da177e4SLinus Torvalds continue; 9211da177e4SLinus Torvalds } 9221da177e4SLinus Torvalds /* Replace the old lock with the new one. 9231da177e4SLinus Torvalds * Wake up anybody waiting for the old one, 9241da177e4SLinus Torvalds * as the change in lock type might satisfy 9251da177e4SLinus Torvalds * their needs. 9261da177e4SLinus Torvalds */ 9271da177e4SLinus Torvalds locks_wake_up_blocks(fl); 9281da177e4SLinus Torvalds fl->fl_start = request->fl_start; 9291da177e4SLinus Torvalds fl->fl_end = request->fl_end; 9301da177e4SLinus Torvalds fl->fl_type = request->fl_type; 93147831f35STrond Myklebust locks_release_private(fl); 93247831f35STrond Myklebust locks_copy_private(fl, request); 9331da177e4SLinus Torvalds request = fl; 9341da177e4SLinus Torvalds added = 1; 9351da177e4SLinus Torvalds } 9361da177e4SLinus Torvalds } 9371da177e4SLinus Torvalds /* Go on to next lock. 9381da177e4SLinus Torvalds */ 9391da177e4SLinus Torvalds next_lock: 9401da177e4SLinus Torvalds before = &fl->fl_next; 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds 9430d9a490aSMiklos Szeredi /* 9440d9a490aSMiklos Szeredi * The above code only modifies existing locks in case of 9450d9a490aSMiklos Szeredi * merging or replacing. If new lock(s) need to be inserted 9460d9a490aSMiklos Szeredi * all modifications are done bellow this, so it's safe yet to 9470d9a490aSMiklos Szeredi * bail out. 9480d9a490aSMiklos Szeredi */ 9490d9a490aSMiklos Szeredi error = -ENOLCK; /* "no luck" */ 9500d9a490aSMiklos Szeredi if (right && left == right && !new_fl2) 9510d9a490aSMiklos Szeredi goto out; 9520d9a490aSMiklos Szeredi 9531da177e4SLinus Torvalds error = 0; 9541da177e4SLinus Torvalds if (!added) { 955f475ae95STrond Myklebust if (request->fl_type == F_UNLCK) { 956f475ae95STrond Myklebust if (request->fl_flags & FL_EXISTS) 957f475ae95STrond Myklebust error = -ENOENT; 9581da177e4SLinus Torvalds goto out; 959f475ae95STrond Myklebust } 9600d9a490aSMiklos Szeredi 9610d9a490aSMiklos Szeredi if (!new_fl) { 9620d9a490aSMiklos Szeredi error = -ENOLCK; 9630d9a490aSMiklos Szeredi goto out; 9640d9a490aSMiklos Szeredi } 9651da177e4SLinus Torvalds locks_copy_lock(new_fl, request); 9661da177e4SLinus Torvalds locks_insert_lock(before, new_fl); 9671da177e4SLinus Torvalds new_fl = NULL; 9681da177e4SLinus Torvalds } 9691da177e4SLinus Torvalds if (right) { 9701da177e4SLinus Torvalds if (left == right) { 9711da177e4SLinus Torvalds /* The new lock breaks the old one in two pieces, 9721da177e4SLinus Torvalds * so we have to use the second new lock. 9731da177e4SLinus Torvalds */ 9741da177e4SLinus Torvalds left = new_fl2; 9751da177e4SLinus Torvalds new_fl2 = NULL; 9761da177e4SLinus Torvalds locks_copy_lock(left, right); 9771da177e4SLinus Torvalds locks_insert_lock(before, left); 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds right->fl_start = request->fl_end + 1; 9801da177e4SLinus Torvalds locks_wake_up_blocks(right); 9811da177e4SLinus Torvalds } 9821da177e4SLinus Torvalds if (left) { 9831da177e4SLinus Torvalds left->fl_end = request->fl_start - 1; 9841da177e4SLinus Torvalds locks_wake_up_blocks(left); 9851da177e4SLinus Torvalds } 9861da177e4SLinus Torvalds out: 9871da177e4SLinus Torvalds unlock_kernel(); 9881da177e4SLinus Torvalds /* 9891da177e4SLinus Torvalds * Free any unused locks. 9901da177e4SLinus Torvalds */ 9911da177e4SLinus Torvalds if (new_fl) 9921da177e4SLinus Torvalds locks_free_lock(new_fl); 9931da177e4SLinus Torvalds if (new_fl2) 9941da177e4SLinus Torvalds locks_free_lock(new_fl2); 9951da177e4SLinus Torvalds return error; 9961da177e4SLinus Torvalds } 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds /** 9991da177e4SLinus Torvalds * posix_lock_file - Apply a POSIX-style lock to a file 10001da177e4SLinus Torvalds * @filp: The file to apply the lock to 10011da177e4SLinus Torvalds * @fl: The lock to be applied 1002150b3934SMarc Eshel * @conflock: Place to return a copy of the conflicting lock, if found. 10031da177e4SLinus Torvalds * 10041da177e4SLinus Torvalds * Add a POSIX style lock to a file. 10051da177e4SLinus Torvalds * We merge adjacent & overlapping locks whenever possible. 10061da177e4SLinus Torvalds * POSIX locks are sorted by owner task, then by starting address 1007f475ae95STrond Myklebust * 1008f475ae95STrond Myklebust * Note that if called with an FL_EXISTS argument, the caller may determine 1009f475ae95STrond Myklebust * whether or not a lock was successfully freed by testing the return 1010f475ae95STrond Myklebust * value for -ENOENT. 10111da177e4SLinus Torvalds */ 1012150b3934SMarc Eshel int posix_lock_file(struct file *filp, struct file_lock *fl, 10135842add2SAndy Adamson struct file_lock *conflock) 10145842add2SAndy Adamson { 1015150b3934SMarc Eshel return __posix_lock_file(filp->f_path.dentry->d_inode, fl, conflock); 10165842add2SAndy Adamson } 1017150b3934SMarc Eshel EXPORT_SYMBOL(posix_lock_file); 10181da177e4SLinus Torvalds 10191da177e4SLinus Torvalds /** 10201da177e4SLinus Torvalds * posix_lock_file_wait - Apply a POSIX-style lock to a file 10211da177e4SLinus Torvalds * @filp: The file to apply the lock to 10221da177e4SLinus Torvalds * @fl: The lock to be applied 10231da177e4SLinus Torvalds * 10241da177e4SLinus Torvalds * Add a POSIX style lock to a file. 10251da177e4SLinus Torvalds * We merge adjacent & overlapping locks whenever possible. 10261da177e4SLinus Torvalds * POSIX locks are sorted by owner task, then by starting address 10271da177e4SLinus Torvalds */ 10281da177e4SLinus Torvalds int posix_lock_file_wait(struct file *filp, struct file_lock *fl) 10291da177e4SLinus Torvalds { 10301da177e4SLinus Torvalds int error; 10311da177e4SLinus Torvalds might_sleep (); 10321da177e4SLinus Torvalds for (;;) { 1033150b3934SMarc Eshel error = posix_lock_file(filp, fl, NULL); 10341da177e4SLinus Torvalds if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP)) 10351da177e4SLinus Torvalds break; 10361da177e4SLinus Torvalds error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 10371da177e4SLinus Torvalds if (!error) 10381da177e4SLinus Torvalds continue; 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds locks_delete_block(fl); 10411da177e4SLinus Torvalds break; 10421da177e4SLinus Torvalds } 10431da177e4SLinus Torvalds return error; 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds EXPORT_SYMBOL(posix_lock_file_wait); 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds /** 10481da177e4SLinus Torvalds * locks_mandatory_locked - Check for an active lock 10491da177e4SLinus Torvalds * @inode: the file to check 10501da177e4SLinus Torvalds * 10511da177e4SLinus Torvalds * Searches the inode's list of locks to find any POSIX locks which conflict. 10521da177e4SLinus Torvalds * This function is called from locks_verify_locked() only. 10531da177e4SLinus Torvalds */ 10541da177e4SLinus Torvalds int locks_mandatory_locked(struct inode *inode) 10551da177e4SLinus Torvalds { 10561da177e4SLinus Torvalds fl_owner_t owner = current->files; 10571da177e4SLinus Torvalds struct file_lock *fl; 10581da177e4SLinus Torvalds 10591da177e4SLinus Torvalds /* 10601da177e4SLinus Torvalds * Search the lock list for this inode for any POSIX locks. 10611da177e4SLinus Torvalds */ 10621da177e4SLinus Torvalds lock_kernel(); 10631da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 10641da177e4SLinus Torvalds if (!IS_POSIX(fl)) 10651da177e4SLinus Torvalds continue; 10661da177e4SLinus Torvalds if (fl->fl_owner != owner) 10671da177e4SLinus Torvalds break; 10681da177e4SLinus Torvalds } 10691da177e4SLinus Torvalds unlock_kernel(); 10701da177e4SLinus Torvalds return fl ? -EAGAIN : 0; 10711da177e4SLinus Torvalds } 10721da177e4SLinus Torvalds 10731da177e4SLinus Torvalds /** 10741da177e4SLinus Torvalds * locks_mandatory_area - Check for a conflicting lock 10751da177e4SLinus Torvalds * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ 10761da177e4SLinus Torvalds * for shared 10771da177e4SLinus Torvalds * @inode: the file to check 10781da177e4SLinus Torvalds * @filp: how the file was opened (if it was) 10791da177e4SLinus Torvalds * @offset: start of area to check 10801da177e4SLinus Torvalds * @count: length of area to check 10811da177e4SLinus Torvalds * 10821da177e4SLinus Torvalds * Searches the inode's list of locks to find any POSIX locks which conflict. 10831da177e4SLinus Torvalds * This function is called from rw_verify_area() and 10841da177e4SLinus Torvalds * locks_verify_truncate(). 10851da177e4SLinus Torvalds */ 10861da177e4SLinus Torvalds int locks_mandatory_area(int read_write, struct inode *inode, 10871da177e4SLinus Torvalds struct file *filp, loff_t offset, 10881da177e4SLinus Torvalds size_t count) 10891da177e4SLinus Torvalds { 10901da177e4SLinus Torvalds struct file_lock fl; 10911da177e4SLinus Torvalds int error; 10921da177e4SLinus Torvalds 10931da177e4SLinus Torvalds locks_init_lock(&fl); 10941da177e4SLinus Torvalds fl.fl_owner = current->files; 10951da177e4SLinus Torvalds fl.fl_pid = current->tgid; 10961da177e4SLinus Torvalds fl.fl_file = filp; 10971da177e4SLinus Torvalds fl.fl_flags = FL_POSIX | FL_ACCESS; 10981da177e4SLinus Torvalds if (filp && !(filp->f_flags & O_NONBLOCK)) 10991da177e4SLinus Torvalds fl.fl_flags |= FL_SLEEP; 11001da177e4SLinus Torvalds fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK; 11011da177e4SLinus Torvalds fl.fl_start = offset; 11021da177e4SLinus Torvalds fl.fl_end = offset + count - 1; 11031da177e4SLinus Torvalds 11041da177e4SLinus Torvalds for (;;) { 1105150b3934SMarc Eshel error = __posix_lock_file(inode, &fl, NULL); 11061da177e4SLinus Torvalds if (error != -EAGAIN) 11071da177e4SLinus Torvalds break; 11081da177e4SLinus Torvalds if (!(fl.fl_flags & FL_SLEEP)) 11091da177e4SLinus Torvalds break; 11101da177e4SLinus Torvalds error = wait_event_interruptible(fl.fl_wait, !fl.fl_next); 11111da177e4SLinus Torvalds if (!error) { 11121da177e4SLinus Torvalds /* 11131da177e4SLinus Torvalds * If we've been sleeping someone might have 11141da177e4SLinus Torvalds * changed the permissions behind our back. 11151da177e4SLinus Torvalds */ 11161da177e4SLinus Torvalds if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID) 11171da177e4SLinus Torvalds continue; 11181da177e4SLinus Torvalds } 11191da177e4SLinus Torvalds 11201da177e4SLinus Torvalds locks_delete_block(&fl); 11211da177e4SLinus Torvalds break; 11221da177e4SLinus Torvalds } 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds return error; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds 11271da177e4SLinus Torvalds EXPORT_SYMBOL(locks_mandatory_area); 11281da177e4SLinus Torvalds 11291da177e4SLinus Torvalds /* We already had a lease on this file; just change its type */ 11301da177e4SLinus Torvalds int lease_modify(struct file_lock **before, int arg) 11311da177e4SLinus Torvalds { 11321da177e4SLinus Torvalds struct file_lock *fl = *before; 11331da177e4SLinus Torvalds int error = assign_type(fl, arg); 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds if (error) 11361da177e4SLinus Torvalds return error; 11371da177e4SLinus Torvalds locks_wake_up_blocks(fl); 11381da177e4SLinus Torvalds if (arg == F_UNLCK) 11391da177e4SLinus Torvalds locks_delete_lock(before); 11401da177e4SLinus Torvalds return 0; 11411da177e4SLinus Torvalds } 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds EXPORT_SYMBOL(lease_modify); 11441da177e4SLinus Torvalds 11451da177e4SLinus Torvalds static void time_out_leases(struct inode *inode) 11461da177e4SLinus Torvalds { 11471da177e4SLinus Torvalds struct file_lock **before; 11481da177e4SLinus Torvalds struct file_lock *fl; 11491da177e4SLinus Torvalds 11501da177e4SLinus Torvalds before = &inode->i_flock; 11511da177e4SLinus Torvalds while ((fl = *before) && IS_LEASE(fl) && (fl->fl_type & F_INPROGRESS)) { 11521da177e4SLinus Torvalds if ((fl->fl_break_time == 0) 11531da177e4SLinus Torvalds || time_before(jiffies, fl->fl_break_time)) { 11541da177e4SLinus Torvalds before = &fl->fl_next; 11551da177e4SLinus Torvalds continue; 11561da177e4SLinus Torvalds } 11571da177e4SLinus Torvalds lease_modify(before, fl->fl_type & ~F_INPROGRESS); 11581da177e4SLinus Torvalds if (fl == *before) /* lease_modify may have freed fl */ 11591da177e4SLinus Torvalds before = &fl->fl_next; 11601da177e4SLinus Torvalds } 11611da177e4SLinus Torvalds } 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds /** 11641da177e4SLinus Torvalds * __break_lease - revoke all outstanding leases on file 11651da177e4SLinus Torvalds * @inode: the inode of the file to return 11661da177e4SLinus Torvalds * @mode: the open mode (read or write) 11671da177e4SLinus Torvalds * 116887250dd2Sdavid m. richter * break_lease (inlined for speed) has checked there already is at least 116987250dd2Sdavid m. richter * some kind of lock (maybe a lease) on this file. Leases are broken on 117087250dd2Sdavid m. richter * a call to open() or truncate(). This function can sleep unless you 11711da177e4SLinus Torvalds * specified %O_NONBLOCK to your open(). 11721da177e4SLinus Torvalds */ 11731da177e4SLinus Torvalds int __break_lease(struct inode *inode, unsigned int mode) 11741da177e4SLinus Torvalds { 11751da177e4SLinus Torvalds int error = 0, future; 11761da177e4SLinus Torvalds struct file_lock *new_fl, *flock; 11771da177e4SLinus Torvalds struct file_lock *fl; 11781da177e4SLinus Torvalds unsigned long break_time; 11791da177e4SLinus Torvalds int i_have_this_lease = 0; 11801da177e4SLinus Torvalds 1181e32b8ee2SJ. Bruce Fields new_fl = lease_alloc(NULL, mode & FMODE_WRITE ? F_WRLCK : F_RDLCK); 11821da177e4SLinus Torvalds 11831da177e4SLinus Torvalds lock_kernel(); 11841da177e4SLinus Torvalds 11851da177e4SLinus Torvalds time_out_leases(inode); 11861da177e4SLinus Torvalds 11871da177e4SLinus Torvalds flock = inode->i_flock; 11881da177e4SLinus Torvalds if ((flock == NULL) || !IS_LEASE(flock)) 11891da177e4SLinus Torvalds goto out; 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) 11921da177e4SLinus Torvalds if (fl->fl_owner == current->files) 11931da177e4SLinus Torvalds i_have_this_lease = 1; 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds if (mode & FMODE_WRITE) { 11961da177e4SLinus Torvalds /* If we want write access, we have to revoke any lease. */ 11971da177e4SLinus Torvalds future = F_UNLCK | F_INPROGRESS; 11981da177e4SLinus Torvalds } else if (flock->fl_type & F_INPROGRESS) { 11991da177e4SLinus Torvalds /* If the lease is already being broken, we just leave it */ 12001da177e4SLinus Torvalds future = flock->fl_type; 12011da177e4SLinus Torvalds } else if (flock->fl_type & F_WRLCK) { 12021da177e4SLinus Torvalds /* Downgrade the exclusive lease to a read-only lease. */ 12031da177e4SLinus Torvalds future = F_RDLCK | F_INPROGRESS; 12041da177e4SLinus Torvalds } else { 12051da177e4SLinus Torvalds /* the existing lease was read-only, so we can read too. */ 12061da177e4SLinus Torvalds goto out; 12071da177e4SLinus Torvalds } 12081da177e4SLinus Torvalds 1209e32b8ee2SJ. Bruce Fields if (IS_ERR(new_fl) && !i_have_this_lease 1210e32b8ee2SJ. Bruce Fields && ((mode & O_NONBLOCK) == 0)) { 1211e32b8ee2SJ. Bruce Fields error = PTR_ERR(new_fl); 12121da177e4SLinus Torvalds goto out; 12131da177e4SLinus Torvalds } 12141da177e4SLinus Torvalds 12151da177e4SLinus Torvalds break_time = 0; 12161da177e4SLinus Torvalds if (lease_break_time > 0) { 12171da177e4SLinus Torvalds break_time = jiffies + lease_break_time * HZ; 12181da177e4SLinus Torvalds if (break_time == 0) 12191da177e4SLinus Torvalds break_time++; /* so that 0 means no break time */ 12201da177e4SLinus Torvalds } 12211da177e4SLinus Torvalds 12221da177e4SLinus Torvalds for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) { 12231da177e4SLinus Torvalds if (fl->fl_type != future) { 12241da177e4SLinus Torvalds fl->fl_type = future; 12251da177e4SLinus Torvalds fl->fl_break_time = break_time; 12261da177e4SLinus Torvalds /* lease must have lmops break callback */ 12271da177e4SLinus Torvalds fl->fl_lmops->fl_break(fl); 12281da177e4SLinus Torvalds } 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds if (i_have_this_lease || (mode & O_NONBLOCK)) { 12321da177e4SLinus Torvalds error = -EWOULDBLOCK; 12331da177e4SLinus Torvalds goto out; 12341da177e4SLinus Torvalds } 12351da177e4SLinus Torvalds 12361da177e4SLinus Torvalds restart: 12371da177e4SLinus Torvalds break_time = flock->fl_break_time; 12381da177e4SLinus Torvalds if (break_time != 0) { 12391da177e4SLinus Torvalds break_time -= jiffies; 12401da177e4SLinus Torvalds if (break_time == 0) 12411da177e4SLinus Torvalds break_time++; 12421da177e4SLinus Torvalds } 12431da177e4SLinus Torvalds error = locks_block_on_timeout(flock, new_fl, break_time); 12441da177e4SLinus Torvalds if (error >= 0) { 12451da177e4SLinus Torvalds if (error == 0) 12461da177e4SLinus Torvalds time_out_leases(inode); 12471da177e4SLinus Torvalds /* Wait for the next lease that has not been broken yet */ 12481da177e4SLinus Torvalds for (flock = inode->i_flock; flock && IS_LEASE(flock); 12491da177e4SLinus Torvalds flock = flock->fl_next) { 12501da177e4SLinus Torvalds if (flock->fl_type & F_INPROGRESS) 12511da177e4SLinus Torvalds goto restart; 12521da177e4SLinus Torvalds } 12531da177e4SLinus Torvalds error = 0; 12541da177e4SLinus Torvalds } 12551da177e4SLinus Torvalds 12561da177e4SLinus Torvalds out: 12571da177e4SLinus Torvalds unlock_kernel(); 1258e32b8ee2SJ. Bruce Fields if (!IS_ERR(new_fl)) 12591da177e4SLinus Torvalds locks_free_lock(new_fl); 12601da177e4SLinus Torvalds return error; 12611da177e4SLinus Torvalds } 12621da177e4SLinus Torvalds 12631da177e4SLinus Torvalds EXPORT_SYMBOL(__break_lease); 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds /** 12661da177e4SLinus Torvalds * lease_get_mtime 12671da177e4SLinus Torvalds * @inode: the inode 12681da177e4SLinus Torvalds * @time: pointer to a timespec which will contain the last modified time 12691da177e4SLinus Torvalds * 12701da177e4SLinus Torvalds * This is to force NFS clients to flush their caches for files with 12711da177e4SLinus Torvalds * exclusive leases. The justification is that if someone has an 12721da177e4SLinus Torvalds * exclusive lease, then they could be modifiying it. 12731da177e4SLinus Torvalds */ 12741da177e4SLinus Torvalds void lease_get_mtime(struct inode *inode, struct timespec *time) 12751da177e4SLinus Torvalds { 12761da177e4SLinus Torvalds struct file_lock *flock = inode->i_flock; 12771da177e4SLinus Torvalds if (flock && IS_LEASE(flock) && (flock->fl_type & F_WRLCK)) 12781da177e4SLinus Torvalds *time = current_fs_time(inode->i_sb); 12791da177e4SLinus Torvalds else 12801da177e4SLinus Torvalds *time = inode->i_mtime; 12811da177e4SLinus Torvalds } 12821da177e4SLinus Torvalds 12831da177e4SLinus Torvalds EXPORT_SYMBOL(lease_get_mtime); 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds /** 12861da177e4SLinus Torvalds * fcntl_getlease - Enquire what lease is currently active 12871da177e4SLinus Torvalds * @filp: the file 12881da177e4SLinus Torvalds * 12891da177e4SLinus Torvalds * The value returned by this function will be one of 12901da177e4SLinus Torvalds * (if no lease break is pending): 12911da177e4SLinus Torvalds * 12921da177e4SLinus Torvalds * %F_RDLCK to indicate a shared lease is held. 12931da177e4SLinus Torvalds * 12941da177e4SLinus Torvalds * %F_WRLCK to indicate an exclusive lease is held. 12951da177e4SLinus Torvalds * 12961da177e4SLinus Torvalds * %F_UNLCK to indicate no lease is held. 12971da177e4SLinus Torvalds * 12981da177e4SLinus Torvalds * (if a lease break is pending): 12991da177e4SLinus Torvalds * 13001da177e4SLinus Torvalds * %F_RDLCK to indicate an exclusive lease needs to be 13011da177e4SLinus Torvalds * changed to a shared lease (or removed). 13021da177e4SLinus Torvalds * 13031da177e4SLinus Torvalds * %F_UNLCK to indicate the lease needs to be removed. 13041da177e4SLinus Torvalds * 13051da177e4SLinus Torvalds * XXX: sfr & willy disagree over whether F_INPROGRESS 13061da177e4SLinus Torvalds * should be returned to userspace. 13071da177e4SLinus Torvalds */ 13081da177e4SLinus Torvalds int fcntl_getlease(struct file *filp) 13091da177e4SLinus Torvalds { 13101da177e4SLinus Torvalds struct file_lock *fl; 13111da177e4SLinus Torvalds int type = F_UNLCK; 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds lock_kernel(); 13140f7fc9e4SJosef "Jeff" Sipek time_out_leases(filp->f_path.dentry->d_inode); 13150f7fc9e4SJosef "Jeff" Sipek for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl); 13161da177e4SLinus Torvalds fl = fl->fl_next) { 13171da177e4SLinus Torvalds if (fl->fl_file == filp) { 13181da177e4SLinus Torvalds type = fl->fl_type & ~F_INPROGRESS; 13191da177e4SLinus Torvalds break; 13201da177e4SLinus Torvalds } 13211da177e4SLinus Torvalds } 13221da177e4SLinus Torvalds unlock_kernel(); 13231da177e4SLinus Torvalds return type; 13241da177e4SLinus Torvalds } 13251da177e4SLinus Torvalds 13261da177e4SLinus Torvalds /** 13270af1a450SChristoph Hellwig * generic_setlease - sets a lease on an open file 13281da177e4SLinus Torvalds * @filp: file pointer 13291da177e4SLinus Torvalds * @arg: type of lease to obtain 13301da177e4SLinus Torvalds * @flp: input - file_lock to use, output - file_lock inserted 13311da177e4SLinus Torvalds * 13321da177e4SLinus Torvalds * The (input) flp->fl_lmops->fl_break function is required 13331da177e4SLinus Torvalds * by break_lease(). 13341da177e4SLinus Torvalds * 13351da177e4SLinus Torvalds * Called with kernel lock held. 13361da177e4SLinus Torvalds */ 13370af1a450SChristoph Hellwig int generic_setlease(struct file *filp, long arg, struct file_lock **flp) 13381da177e4SLinus Torvalds { 13397eaae282SKAMBAROV, ZAUR struct file_lock *fl, **before, **my_before = NULL, *lease; 13400f7fc9e4SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 13411da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 13421da177e4SLinus Torvalds int error, rdlease_count = 0, wrlease_count = 0; 13431da177e4SLinus Torvalds 13446d5e8b05SJ. Bruce Fields if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE)) 13456d5e8b05SJ. Bruce Fields return -EACCES; 13466d5e8b05SJ. Bruce Fields if (!S_ISREG(inode->i_mode)) 13476d5e8b05SJ. Bruce Fields return -EINVAL; 13486d5e8b05SJ. Bruce Fields error = security_file_lock(filp, arg); 13496d5e8b05SJ. Bruce Fields if (error) 13506d5e8b05SJ. Bruce Fields return error; 13516d5e8b05SJ. Bruce Fields 13521da177e4SLinus Torvalds time_out_leases(inode); 13531da177e4SLinus Torvalds 1354d2ab0b0cSJ. Bruce Fields BUG_ON(!(*flp)->fl_lmops->fl_break); 13551da177e4SLinus Torvalds 13567eaae282SKAMBAROV, ZAUR lease = *flp; 13577eaae282SKAMBAROV, ZAUR 13581da177e4SLinus Torvalds error = -EAGAIN; 13591da177e4SLinus Torvalds if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0)) 13601da177e4SLinus Torvalds goto out; 13611da177e4SLinus Torvalds if ((arg == F_WRLCK) 13621da177e4SLinus Torvalds && ((atomic_read(&dentry->d_count) > 1) 13631da177e4SLinus Torvalds || (atomic_read(&inode->i_count) > 1))) 13641da177e4SLinus Torvalds goto out; 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds /* 13671da177e4SLinus Torvalds * At this point, we know that if there is an exclusive 13681da177e4SLinus Torvalds * lease on this file, then we hold it on this filp 13691da177e4SLinus Torvalds * (otherwise our open of this file would have blocked). 13701da177e4SLinus Torvalds * And if we are trying to acquire an exclusive lease, 13711da177e4SLinus Torvalds * then the file is not open by anyone (including us) 13721da177e4SLinus Torvalds * except for this filp. 13731da177e4SLinus Torvalds */ 13741da177e4SLinus Torvalds for (before = &inode->i_flock; 13751da177e4SLinus Torvalds ((fl = *before) != NULL) && IS_LEASE(fl); 13761da177e4SLinus Torvalds before = &fl->fl_next) { 13771da177e4SLinus Torvalds if (lease->fl_lmops->fl_mylease(fl, lease)) 13781da177e4SLinus Torvalds my_before = before; 13791da177e4SLinus Torvalds else if (fl->fl_type == (F_INPROGRESS | F_UNLCK)) 13801da177e4SLinus Torvalds /* 13811da177e4SLinus Torvalds * Someone is in the process of opening this 13821da177e4SLinus Torvalds * file for writing so we may not take an 13831da177e4SLinus Torvalds * exclusive lease on it. 13841da177e4SLinus Torvalds */ 13851da177e4SLinus Torvalds wrlease_count++; 13861da177e4SLinus Torvalds else 13871da177e4SLinus Torvalds rdlease_count++; 13881da177e4SLinus Torvalds } 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds if ((arg == F_RDLCK && (wrlease_count > 0)) || 13911da177e4SLinus Torvalds (arg == F_WRLCK && ((rdlease_count + wrlease_count) > 0))) 13921da177e4SLinus Torvalds goto out; 13931da177e4SLinus Torvalds 13941da177e4SLinus Torvalds if (my_before != NULL) { 139575dff55aSTrond Myklebust *flp = *my_before; 13961da177e4SLinus Torvalds error = lease->fl_lmops->fl_change(my_before, arg); 13971da177e4SLinus Torvalds goto out; 13981da177e4SLinus Torvalds } 13991da177e4SLinus Torvalds 14001da177e4SLinus Torvalds error = 0; 14011da177e4SLinus Torvalds if (arg == F_UNLCK) 14021da177e4SLinus Torvalds goto out; 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds error = -EINVAL; 14051da177e4SLinus Torvalds if (!leases_enable) 14061da177e4SLinus Torvalds goto out; 14071da177e4SLinus Torvalds 140874361cb6STrond Myklebust error = -ENOMEM; 140974361cb6STrond Myklebust fl = locks_alloc_lock(); 141074361cb6STrond Myklebust if (fl == NULL) 14111da177e4SLinus Torvalds goto out; 14121da177e4SLinus Torvalds 14131da177e4SLinus Torvalds locks_copy_lock(fl, lease); 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds locks_insert_lock(before, fl); 14161da177e4SLinus Torvalds 14171da177e4SLinus Torvalds *flp = fl; 141874361cb6STrond Myklebust error = 0; 14191da177e4SLinus Torvalds out: 14201da177e4SLinus Torvalds return error; 14211da177e4SLinus Torvalds } 14220af1a450SChristoph Hellwig EXPORT_SYMBOL(generic_setlease); 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds /** 1425a9933ceaSJ. Bruce Fields * vfs_setlease - sets a lease on an open file 14261da177e4SLinus Torvalds * @filp: file pointer 14271da177e4SLinus Torvalds * @arg: type of lease to obtain 14281da177e4SLinus Torvalds * @lease: file_lock to use 14291da177e4SLinus Torvalds * 14301da177e4SLinus Torvalds * Call this to establish a lease on the file. 1431f9ffed26SJ. Bruce Fields * The (*lease)->fl_lmops->fl_break operation must be set; if not, 1432f9ffed26SJ. Bruce Fields * break_lease will oops! 1433f9ffed26SJ. Bruce Fields * 1434f9ffed26SJ. Bruce Fields * This will call the filesystem's setlease file method, if 1435f9ffed26SJ. Bruce Fields * defined. Note that there is no getlease method; instead, the 1436f9ffed26SJ. Bruce Fields * filesystem setlease method should call back to setlease() to 1437f9ffed26SJ. Bruce Fields * add a lease to the inode's lease list, where fcntl_getlease() can 1438f9ffed26SJ. Bruce Fields * find it. Since fcntl_getlease() only reports whether the current 1439f9ffed26SJ. Bruce Fields * task holds a lease, a cluster filesystem need only do this for 1440f9ffed26SJ. Bruce Fields * leases held by processes on this node. 1441f9ffed26SJ. Bruce Fields * 1442f9ffed26SJ. Bruce Fields * There is also no break_lease method; filesystems that 1443f9ffed26SJ. Bruce Fields * handle their own leases shoud break leases themselves from the 1444f9ffed26SJ. Bruce Fields * filesystem's open, create, and (on truncate) setattr methods. 1445f9ffed26SJ. Bruce Fields * 1446f9ffed26SJ. Bruce Fields * Warning: the only current setlease methods exist only to disable 1447f9ffed26SJ. Bruce Fields * leases in certain cases. More vfs changes may be required to 1448f9ffed26SJ. Bruce Fields * allow a full filesystem lease implementation. 14491da177e4SLinus Torvalds */ 14501da177e4SLinus Torvalds 1451a9933ceaSJ. Bruce Fields int vfs_setlease(struct file *filp, long arg, struct file_lock **lease) 14521da177e4SLinus Torvalds { 14531da177e4SLinus Torvalds int error; 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds lock_kernel(); 1456f9ffed26SJ. Bruce Fields if (filp->f_op && filp->f_op->setlease) 1457f9ffed26SJ. Bruce Fields error = filp->f_op->setlease(filp, arg, lease); 1458f9ffed26SJ. Bruce Fields else 14590af1a450SChristoph Hellwig error = generic_setlease(filp, arg, lease); 14601da177e4SLinus Torvalds unlock_kernel(); 14611da177e4SLinus Torvalds 14621da177e4SLinus Torvalds return error; 14631da177e4SLinus Torvalds } 1464a9933ceaSJ. Bruce Fields EXPORT_SYMBOL_GPL(vfs_setlease); 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds /** 14671da177e4SLinus Torvalds * fcntl_setlease - sets a lease on an open file 14681da177e4SLinus Torvalds * @fd: open file descriptor 14691da177e4SLinus Torvalds * @filp: file pointer 14701da177e4SLinus Torvalds * @arg: type of lease to obtain 14711da177e4SLinus Torvalds * 14721da177e4SLinus Torvalds * Call this fcntl to establish a lease on the file. 14731da177e4SLinus Torvalds * Note that you also need to call %F_SETSIG to 14741da177e4SLinus Torvalds * receive a signal when the lease is broken. 14751da177e4SLinus Torvalds */ 14761da177e4SLinus Torvalds int fcntl_setlease(unsigned int fd, struct file *filp, long arg) 14771da177e4SLinus Torvalds { 14781da177e4SLinus Torvalds struct file_lock fl, *flp = &fl; 14790f7fc9e4SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 14801da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 14811da177e4SLinus Torvalds int error; 14821da177e4SLinus Torvalds 14831da177e4SLinus Torvalds locks_init_lock(&fl); 14841da177e4SLinus Torvalds error = lease_init(filp, arg, &fl); 14851da177e4SLinus Torvalds if (error) 14861da177e4SLinus Torvalds return error; 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds lock_kernel(); 14891da177e4SLinus Torvalds 1490a9933ceaSJ. Bruce Fields error = vfs_setlease(filp, arg, &flp); 1491dc15ae14SJ. Bruce Fields if (error || arg == F_UNLCK) 14921da177e4SLinus Torvalds goto out_unlock; 14931da177e4SLinus Torvalds 14941da177e4SLinus Torvalds error = fasync_helper(fd, filp, 1, &flp->fl_fasync); 14951da177e4SLinus Torvalds if (error < 0) { 14966d5e8b05SJ. Bruce Fields /* remove lease just inserted by setlease */ 14971da177e4SLinus Torvalds flp->fl_type = F_UNLCK | F_INPROGRESS; 14981da177e4SLinus Torvalds flp->fl_break_time = jiffies - 10; 14991da177e4SLinus Torvalds time_out_leases(inode); 15001da177e4SLinus Torvalds goto out_unlock; 15011da177e4SLinus Torvalds } 15021da177e4SLinus Torvalds 1503609d7fa9SEric W. Biederman error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0); 15041da177e4SLinus Torvalds out_unlock: 15051da177e4SLinus Torvalds unlock_kernel(); 15061da177e4SLinus Torvalds return error; 15071da177e4SLinus Torvalds } 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds /** 15101da177e4SLinus Torvalds * flock_lock_file_wait - Apply a FLOCK-style lock to a file 15111da177e4SLinus Torvalds * @filp: The file to apply the lock to 15121da177e4SLinus Torvalds * @fl: The lock to be applied 15131da177e4SLinus Torvalds * 15141da177e4SLinus Torvalds * Add a FLOCK style lock to a file. 15151da177e4SLinus Torvalds */ 15161da177e4SLinus Torvalds int flock_lock_file_wait(struct file *filp, struct file_lock *fl) 15171da177e4SLinus Torvalds { 15181da177e4SLinus Torvalds int error; 15191da177e4SLinus Torvalds might_sleep(); 15201da177e4SLinus Torvalds for (;;) { 15211da177e4SLinus Torvalds error = flock_lock_file(filp, fl); 15221da177e4SLinus Torvalds if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP)) 15231da177e4SLinus Torvalds break; 15241da177e4SLinus Torvalds error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); 15251da177e4SLinus Torvalds if (!error) 15261da177e4SLinus Torvalds continue; 15271da177e4SLinus Torvalds 15281da177e4SLinus Torvalds locks_delete_block(fl); 15291da177e4SLinus Torvalds break; 15301da177e4SLinus Torvalds } 15311da177e4SLinus Torvalds return error; 15321da177e4SLinus Torvalds } 15331da177e4SLinus Torvalds 15341da177e4SLinus Torvalds EXPORT_SYMBOL(flock_lock_file_wait); 15351da177e4SLinus Torvalds 15361da177e4SLinus Torvalds /** 15371da177e4SLinus Torvalds * sys_flock: - flock() system call. 15381da177e4SLinus Torvalds * @fd: the file descriptor to lock. 15391da177e4SLinus Torvalds * @cmd: the type of lock to apply. 15401da177e4SLinus Torvalds * 15411da177e4SLinus Torvalds * Apply a %FL_FLOCK style lock to an open file descriptor. 15421da177e4SLinus Torvalds * The @cmd can be one of 15431da177e4SLinus Torvalds * 15441da177e4SLinus Torvalds * %LOCK_SH -- a shared lock. 15451da177e4SLinus Torvalds * 15461da177e4SLinus Torvalds * %LOCK_EX -- an exclusive lock. 15471da177e4SLinus Torvalds * 15481da177e4SLinus Torvalds * %LOCK_UN -- remove an existing lock. 15491da177e4SLinus Torvalds * 15501da177e4SLinus Torvalds * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes. 15511da177e4SLinus Torvalds * 15521da177e4SLinus Torvalds * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other 15531da177e4SLinus Torvalds * processes read and write access respectively. 15541da177e4SLinus Torvalds */ 15551da177e4SLinus Torvalds asmlinkage long sys_flock(unsigned int fd, unsigned int cmd) 15561da177e4SLinus Torvalds { 15571da177e4SLinus Torvalds struct file *filp; 15581da177e4SLinus Torvalds struct file_lock *lock; 15591da177e4SLinus Torvalds int can_sleep, unlock; 15601da177e4SLinus Torvalds int error; 15611da177e4SLinus Torvalds 15621da177e4SLinus Torvalds error = -EBADF; 15631da177e4SLinus Torvalds filp = fget(fd); 15641da177e4SLinus Torvalds if (!filp) 15651da177e4SLinus Torvalds goto out; 15661da177e4SLinus Torvalds 15671da177e4SLinus Torvalds can_sleep = !(cmd & LOCK_NB); 15681da177e4SLinus Torvalds cmd &= ~LOCK_NB; 15691da177e4SLinus Torvalds unlock = (cmd == LOCK_UN); 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds if (!unlock && !(cmd & LOCK_MAND) && !(filp->f_mode & 3)) 15721da177e4SLinus Torvalds goto out_putf; 15731da177e4SLinus Torvalds 15741da177e4SLinus Torvalds error = flock_make_lock(filp, &lock, cmd); 15751da177e4SLinus Torvalds if (error) 15761da177e4SLinus Torvalds goto out_putf; 15771da177e4SLinus Torvalds if (can_sleep) 15781da177e4SLinus Torvalds lock->fl_flags |= FL_SLEEP; 15791da177e4SLinus Torvalds 15801da177e4SLinus Torvalds error = security_file_lock(filp, cmd); 15811da177e4SLinus Torvalds if (error) 15821da177e4SLinus Torvalds goto out_free; 15831da177e4SLinus Torvalds 15841da177e4SLinus Torvalds if (filp->f_op && filp->f_op->flock) 15851da177e4SLinus Torvalds error = filp->f_op->flock(filp, 15861da177e4SLinus Torvalds (can_sleep) ? F_SETLKW : F_SETLK, 15871da177e4SLinus Torvalds lock); 15881da177e4SLinus Torvalds else 15891da177e4SLinus Torvalds error = flock_lock_file_wait(filp, lock); 15901da177e4SLinus Torvalds 15911da177e4SLinus Torvalds out_free: 15921da177e4SLinus Torvalds locks_free_lock(lock); 15931da177e4SLinus Torvalds 15941da177e4SLinus Torvalds out_putf: 15951da177e4SLinus Torvalds fput(filp); 15961da177e4SLinus Torvalds out: 15971da177e4SLinus Torvalds return error; 15981da177e4SLinus Torvalds } 15991da177e4SLinus Torvalds 16003ee17abdSJ. Bruce Fields /** 16013ee17abdSJ. Bruce Fields * vfs_test_lock - test file byte range lock 16023ee17abdSJ. Bruce Fields * @filp: The file to test lock for 16036924c554SJ. Bruce Fields * @fl: The lock to test; also used to hold result 16043ee17abdSJ. Bruce Fields * 16053ee17abdSJ. Bruce Fields * Returns -ERRNO on failure. Indicates presence of conflicting lock by 16063ee17abdSJ. Bruce Fields * setting conf->fl_type to something other than F_UNLCK. 16073ee17abdSJ. Bruce Fields */ 16083ee17abdSJ. Bruce Fields int vfs_test_lock(struct file *filp, struct file_lock *fl) 16093ee17abdSJ. Bruce Fields { 16103ee17abdSJ. Bruce Fields if (filp->f_op && filp->f_op->lock) 16113ee17abdSJ. Bruce Fields return filp->f_op->lock(filp, F_GETLK, fl); 16123ee17abdSJ. Bruce Fields posix_test_lock(filp, fl); 16133ee17abdSJ. Bruce Fields return 0; 16143ee17abdSJ. Bruce Fields } 16153ee17abdSJ. Bruce Fields EXPORT_SYMBOL_GPL(vfs_test_lock); 16163ee17abdSJ. Bruce Fields 1617c2fa1b8aSJ. Bruce Fields static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) 1618c2fa1b8aSJ. Bruce Fields { 1619c2fa1b8aSJ. Bruce Fields flock->l_pid = fl->fl_pid; 1620c2fa1b8aSJ. Bruce Fields #if BITS_PER_LONG == 32 1621c2fa1b8aSJ. Bruce Fields /* 1622c2fa1b8aSJ. Bruce Fields * Make sure we can represent the posix lock via 1623c2fa1b8aSJ. Bruce Fields * legacy 32bit flock. 1624c2fa1b8aSJ. Bruce Fields */ 1625c2fa1b8aSJ. Bruce Fields if (fl->fl_start > OFFT_OFFSET_MAX) 1626c2fa1b8aSJ. Bruce Fields return -EOVERFLOW; 1627c2fa1b8aSJ. Bruce Fields if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX) 1628c2fa1b8aSJ. Bruce Fields return -EOVERFLOW; 1629c2fa1b8aSJ. Bruce Fields #endif 1630c2fa1b8aSJ. Bruce Fields flock->l_start = fl->fl_start; 1631c2fa1b8aSJ. Bruce Fields flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1632c2fa1b8aSJ. Bruce Fields fl->fl_end - fl->fl_start + 1; 1633c2fa1b8aSJ. Bruce Fields flock->l_whence = 0; 1634129a84deSJ. Bruce Fields flock->l_type = fl->fl_type; 1635c2fa1b8aSJ. Bruce Fields return 0; 1636c2fa1b8aSJ. Bruce Fields } 1637c2fa1b8aSJ. Bruce Fields 1638c2fa1b8aSJ. Bruce Fields #if BITS_PER_LONG == 32 1639c2fa1b8aSJ. Bruce Fields static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) 1640c2fa1b8aSJ. Bruce Fields { 1641c2fa1b8aSJ. Bruce Fields flock->l_pid = fl->fl_pid; 1642c2fa1b8aSJ. Bruce Fields flock->l_start = fl->fl_start; 1643c2fa1b8aSJ. Bruce Fields flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : 1644c2fa1b8aSJ. Bruce Fields fl->fl_end - fl->fl_start + 1; 1645c2fa1b8aSJ. Bruce Fields flock->l_whence = 0; 1646c2fa1b8aSJ. Bruce Fields flock->l_type = fl->fl_type; 1647c2fa1b8aSJ. Bruce Fields } 1648c2fa1b8aSJ. Bruce Fields #endif 1649c2fa1b8aSJ. Bruce Fields 16501da177e4SLinus Torvalds /* Report the first existing lock that would conflict with l. 16511da177e4SLinus Torvalds * This implements the F_GETLK command of fcntl(). 16521da177e4SLinus Torvalds */ 16531da177e4SLinus Torvalds int fcntl_getlk(struct file *filp, struct flock __user *l) 16541da177e4SLinus Torvalds { 16559d6a8c5cSMarc Eshel struct file_lock file_lock; 16561da177e4SLinus Torvalds struct flock flock; 16571da177e4SLinus Torvalds int error; 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds error = -EFAULT; 16601da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 16611da177e4SLinus Torvalds goto out; 16621da177e4SLinus Torvalds error = -EINVAL; 16631da177e4SLinus Torvalds if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 16641da177e4SLinus Torvalds goto out; 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds error = flock_to_posix_lock(filp, &file_lock, &flock); 16671da177e4SLinus Torvalds if (error) 16681da177e4SLinus Torvalds goto out; 16691da177e4SLinus Torvalds 16703ee17abdSJ. Bruce Fields error = vfs_test_lock(filp, &file_lock); 16713ee17abdSJ. Bruce Fields if (error) 16721da177e4SLinus Torvalds goto out; 16731da177e4SLinus Torvalds 16749d6a8c5cSMarc Eshel flock.l_type = file_lock.fl_type; 16759d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) { 16769d6a8c5cSMarc Eshel error = posix_lock_to_flock(&flock, &file_lock); 1677c2fa1b8aSJ. Bruce Fields if (error) 16781da177e4SLinus Torvalds goto out; 16791da177e4SLinus Torvalds } 16801da177e4SLinus Torvalds error = -EFAULT; 16811da177e4SLinus Torvalds if (!copy_to_user(l, &flock, sizeof(flock))) 16821da177e4SLinus Torvalds error = 0; 16831da177e4SLinus Torvalds out: 16841da177e4SLinus Torvalds return error; 16851da177e4SLinus Torvalds } 16861da177e4SLinus Torvalds 16877723ec97SMarc Eshel /** 16887723ec97SMarc Eshel * vfs_lock_file - file byte range lock 16897723ec97SMarc Eshel * @filp: The file to apply the lock to 16907723ec97SMarc Eshel * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.) 16917723ec97SMarc Eshel * @fl: The lock to be applied 1692150b3934SMarc Eshel * @conf: Place to return a copy of the conflicting lock, if found. 1693150b3934SMarc Eshel * 1694150b3934SMarc Eshel * A caller that doesn't care about the conflicting lock may pass NULL 1695150b3934SMarc Eshel * as the final argument. 1696150b3934SMarc Eshel * 1697150b3934SMarc Eshel * If the filesystem defines a private ->lock() method, then @conf will 1698150b3934SMarc Eshel * be left unchanged; so a caller that cares should initialize it to 1699150b3934SMarc Eshel * some acceptable default. 17002beb6614SMarc Eshel * 17012beb6614SMarc Eshel * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX 17022beb6614SMarc Eshel * locks, the ->lock() interface may return asynchronously, before the lock has 17032beb6614SMarc Eshel * been granted or denied by the underlying filesystem, if (and only if) 17042beb6614SMarc Eshel * fl_grant is set. Callers expecting ->lock() to return asynchronously 17052beb6614SMarc Eshel * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if) 17062beb6614SMarc Eshel * the request is for a blocking lock. When ->lock() does return asynchronously, 17072beb6614SMarc Eshel * it must return -EINPROGRESS, and call ->fl_grant() when the lock 17082beb6614SMarc Eshel * request completes. 17092beb6614SMarc Eshel * If the request is for non-blocking lock the file system should return 17102beb6614SMarc Eshel * -EINPROGRESS then try to get the lock and call the callback routine with 17112beb6614SMarc Eshel * the result. If the request timed out the callback routine will return a 17122beb6614SMarc Eshel * nonzero return code and the file system should release the lock. The file 17132beb6614SMarc Eshel * system is also responsible to keep a corresponding posix lock when it 17142beb6614SMarc Eshel * grants a lock so the VFS can find out which locks are locally held and do 17152beb6614SMarc Eshel * the correct lock cleanup when required. 17162beb6614SMarc Eshel * The underlying filesystem must not drop the kernel lock or call 17172beb6614SMarc Eshel * ->fl_grant() before returning to the caller with a -EINPROGRESS 17182beb6614SMarc Eshel * return code. 17197723ec97SMarc Eshel */ 1720150b3934SMarc Eshel int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) 17217723ec97SMarc Eshel { 17227723ec97SMarc Eshel if (filp->f_op && filp->f_op->lock) 17237723ec97SMarc Eshel return filp->f_op->lock(filp, cmd, fl); 17247723ec97SMarc Eshel else 1725150b3934SMarc Eshel return posix_lock_file(filp, fl, conf); 17267723ec97SMarc Eshel } 17277723ec97SMarc Eshel EXPORT_SYMBOL_GPL(vfs_lock_file); 17287723ec97SMarc Eshel 17291da177e4SLinus Torvalds /* Apply the lock described by l to an open file descriptor. 17301da177e4SLinus Torvalds * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 17311da177e4SLinus Torvalds */ 1732c293621bSPeter Staubach int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, 1733c293621bSPeter Staubach struct flock __user *l) 17341da177e4SLinus Torvalds { 17351da177e4SLinus Torvalds struct file_lock *file_lock = locks_alloc_lock(); 17361da177e4SLinus Torvalds struct flock flock; 17371da177e4SLinus Torvalds struct inode *inode; 17381da177e4SLinus Torvalds int error; 17391da177e4SLinus Torvalds 17401da177e4SLinus Torvalds if (file_lock == NULL) 17411da177e4SLinus Torvalds return -ENOLCK; 17421da177e4SLinus Torvalds 17431da177e4SLinus Torvalds /* 17441da177e4SLinus Torvalds * This might block, so we do it before checking the inode. 17451da177e4SLinus Torvalds */ 17461da177e4SLinus Torvalds error = -EFAULT; 17471da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 17481da177e4SLinus Torvalds goto out; 17491da177e4SLinus Torvalds 17500f7fc9e4SJosef "Jeff" Sipek inode = filp->f_path.dentry->d_inode; 17511da177e4SLinus Torvalds 17521da177e4SLinus Torvalds /* Don't allow mandatory locks on files that may be memory mapped 17531da177e4SLinus Torvalds * and shared. 17541da177e4SLinus Torvalds */ 17551da177e4SLinus Torvalds if (IS_MANDLOCK(inode) && 17561da177e4SLinus Torvalds (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID && 17571da177e4SLinus Torvalds mapping_writably_mapped(filp->f_mapping)) { 17581da177e4SLinus Torvalds error = -EAGAIN; 17591da177e4SLinus Torvalds goto out; 17601da177e4SLinus Torvalds } 17611da177e4SLinus Torvalds 1762c293621bSPeter Staubach again: 17631da177e4SLinus Torvalds error = flock_to_posix_lock(filp, file_lock, &flock); 17641da177e4SLinus Torvalds if (error) 17651da177e4SLinus Torvalds goto out; 17661da177e4SLinus Torvalds if (cmd == F_SETLKW) { 17671da177e4SLinus Torvalds file_lock->fl_flags |= FL_SLEEP; 17681da177e4SLinus Torvalds } 17691da177e4SLinus Torvalds 17701da177e4SLinus Torvalds error = -EBADF; 17711da177e4SLinus Torvalds switch (flock.l_type) { 17721da177e4SLinus Torvalds case F_RDLCK: 17731da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_READ)) 17741da177e4SLinus Torvalds goto out; 17751da177e4SLinus Torvalds break; 17761da177e4SLinus Torvalds case F_WRLCK: 17771da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_WRITE)) 17781da177e4SLinus Torvalds goto out; 17791da177e4SLinus Torvalds break; 17801da177e4SLinus Torvalds case F_UNLCK: 17811da177e4SLinus Torvalds break; 17821da177e4SLinus Torvalds default: 17831da177e4SLinus Torvalds error = -EINVAL; 17841da177e4SLinus Torvalds goto out; 17851da177e4SLinus Torvalds } 17861da177e4SLinus Torvalds 17871da177e4SLinus Torvalds error = security_file_lock(filp, file_lock->fl_type); 17881da177e4SLinus Torvalds if (error) 17891da177e4SLinus Torvalds goto out; 17901da177e4SLinus Torvalds 17911da177e4SLinus Torvalds for (;;) { 1792150b3934SMarc Eshel error = vfs_lock_file(filp, cmd, file_lock, NULL); 1793226a998dSJ. Bruce Fields if (error != -EAGAIN || cmd == F_SETLK) 17941da177e4SLinus Torvalds break; 17951da177e4SLinus Torvalds error = wait_event_interruptible(file_lock->fl_wait, 17961da177e4SLinus Torvalds !file_lock->fl_next); 17971da177e4SLinus Torvalds if (!error) 17981da177e4SLinus Torvalds continue; 17991da177e4SLinus Torvalds 18001da177e4SLinus Torvalds locks_delete_block(file_lock); 18011da177e4SLinus Torvalds break; 18021da177e4SLinus Torvalds } 1803c293621bSPeter Staubach 1804c293621bSPeter Staubach /* 1805c293621bSPeter Staubach * Attempt to detect a close/fcntl race and recover by 1806c293621bSPeter Staubach * releasing the lock that was just acquired. 1807c293621bSPeter Staubach */ 1808c293621bSPeter Staubach if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) { 1809c293621bSPeter Staubach flock.l_type = F_UNLCK; 1810c293621bSPeter Staubach goto again; 1811c293621bSPeter Staubach } 18121da177e4SLinus Torvalds 18131da177e4SLinus Torvalds out: 18141da177e4SLinus Torvalds locks_free_lock(file_lock); 18151da177e4SLinus Torvalds return error; 18161da177e4SLinus Torvalds } 18171da177e4SLinus Torvalds 18181da177e4SLinus Torvalds #if BITS_PER_LONG == 32 18191da177e4SLinus Torvalds /* Report the first existing lock that would conflict with l. 18201da177e4SLinus Torvalds * This implements the F_GETLK command of fcntl(). 18211da177e4SLinus Torvalds */ 18221da177e4SLinus Torvalds int fcntl_getlk64(struct file *filp, struct flock64 __user *l) 18231da177e4SLinus Torvalds { 18249d6a8c5cSMarc Eshel struct file_lock file_lock; 18251da177e4SLinus Torvalds struct flock64 flock; 18261da177e4SLinus Torvalds int error; 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds error = -EFAULT; 18291da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 18301da177e4SLinus Torvalds goto out; 18311da177e4SLinus Torvalds error = -EINVAL; 18321da177e4SLinus Torvalds if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 18331da177e4SLinus Torvalds goto out; 18341da177e4SLinus Torvalds 18351da177e4SLinus Torvalds error = flock64_to_posix_lock(filp, &file_lock, &flock); 18361da177e4SLinus Torvalds if (error) 18371da177e4SLinus Torvalds goto out; 18381da177e4SLinus Torvalds 18393ee17abdSJ. Bruce Fields error = vfs_test_lock(filp, &file_lock); 18403ee17abdSJ. Bruce Fields if (error) 18411da177e4SLinus Torvalds goto out; 18421da177e4SLinus Torvalds 18439d6a8c5cSMarc Eshel flock.l_type = file_lock.fl_type; 18449d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) 18459d6a8c5cSMarc Eshel posix_lock_to_flock64(&flock, &file_lock); 18469d6a8c5cSMarc Eshel 18471da177e4SLinus Torvalds error = -EFAULT; 18481da177e4SLinus Torvalds if (!copy_to_user(l, &flock, sizeof(flock))) 18491da177e4SLinus Torvalds error = 0; 18501da177e4SLinus Torvalds 18511da177e4SLinus Torvalds out: 18521da177e4SLinus Torvalds return error; 18531da177e4SLinus Torvalds } 18541da177e4SLinus Torvalds 18551da177e4SLinus Torvalds /* Apply the lock described by l to an open file descriptor. 18561da177e4SLinus Torvalds * This implements both the F_SETLK and F_SETLKW commands of fcntl(). 18571da177e4SLinus Torvalds */ 1858c293621bSPeter Staubach int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, 1859c293621bSPeter Staubach struct flock64 __user *l) 18601da177e4SLinus Torvalds { 18611da177e4SLinus Torvalds struct file_lock *file_lock = locks_alloc_lock(); 18621da177e4SLinus Torvalds struct flock64 flock; 18631da177e4SLinus Torvalds struct inode *inode; 18641da177e4SLinus Torvalds int error; 18651da177e4SLinus Torvalds 18661da177e4SLinus Torvalds if (file_lock == NULL) 18671da177e4SLinus Torvalds return -ENOLCK; 18681da177e4SLinus Torvalds 18691da177e4SLinus Torvalds /* 18701da177e4SLinus Torvalds * This might block, so we do it before checking the inode. 18711da177e4SLinus Torvalds */ 18721da177e4SLinus Torvalds error = -EFAULT; 18731da177e4SLinus Torvalds if (copy_from_user(&flock, l, sizeof(flock))) 18741da177e4SLinus Torvalds goto out; 18751da177e4SLinus Torvalds 18760f7fc9e4SJosef "Jeff" Sipek inode = filp->f_path.dentry->d_inode; 18771da177e4SLinus Torvalds 18781da177e4SLinus Torvalds /* Don't allow mandatory locks on files that may be memory mapped 18791da177e4SLinus Torvalds * and shared. 18801da177e4SLinus Torvalds */ 18811da177e4SLinus Torvalds if (IS_MANDLOCK(inode) && 18821da177e4SLinus Torvalds (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID && 18831da177e4SLinus Torvalds mapping_writably_mapped(filp->f_mapping)) { 18841da177e4SLinus Torvalds error = -EAGAIN; 18851da177e4SLinus Torvalds goto out; 18861da177e4SLinus Torvalds } 18871da177e4SLinus Torvalds 1888c293621bSPeter Staubach again: 18891da177e4SLinus Torvalds error = flock64_to_posix_lock(filp, file_lock, &flock); 18901da177e4SLinus Torvalds if (error) 18911da177e4SLinus Torvalds goto out; 18921da177e4SLinus Torvalds if (cmd == F_SETLKW64) { 18931da177e4SLinus Torvalds file_lock->fl_flags |= FL_SLEEP; 18941da177e4SLinus Torvalds } 18951da177e4SLinus Torvalds 18961da177e4SLinus Torvalds error = -EBADF; 18971da177e4SLinus Torvalds switch (flock.l_type) { 18981da177e4SLinus Torvalds case F_RDLCK: 18991da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_READ)) 19001da177e4SLinus Torvalds goto out; 19011da177e4SLinus Torvalds break; 19021da177e4SLinus Torvalds case F_WRLCK: 19031da177e4SLinus Torvalds if (!(filp->f_mode & FMODE_WRITE)) 19041da177e4SLinus Torvalds goto out; 19051da177e4SLinus Torvalds break; 19061da177e4SLinus Torvalds case F_UNLCK: 19071da177e4SLinus Torvalds break; 19081da177e4SLinus Torvalds default: 19091da177e4SLinus Torvalds error = -EINVAL; 19101da177e4SLinus Torvalds goto out; 19111da177e4SLinus Torvalds } 19121da177e4SLinus Torvalds 19131da177e4SLinus Torvalds error = security_file_lock(filp, file_lock->fl_type); 19141da177e4SLinus Torvalds if (error) 19151da177e4SLinus Torvalds goto out; 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds for (;;) { 1918150b3934SMarc Eshel error = vfs_lock_file(filp, cmd, file_lock, NULL); 1919226a998dSJ. Bruce Fields if (error != -EAGAIN || cmd == F_SETLK64) 19201da177e4SLinus Torvalds break; 19211da177e4SLinus Torvalds error = wait_event_interruptible(file_lock->fl_wait, 19221da177e4SLinus Torvalds !file_lock->fl_next); 19231da177e4SLinus Torvalds if (!error) 19241da177e4SLinus Torvalds continue; 19251da177e4SLinus Torvalds 19261da177e4SLinus Torvalds locks_delete_block(file_lock); 19271da177e4SLinus Torvalds break; 19281da177e4SLinus Torvalds } 1929c293621bSPeter Staubach 1930c293621bSPeter Staubach /* 1931c293621bSPeter Staubach * Attempt to detect a close/fcntl race and recover by 1932c293621bSPeter Staubach * releasing the lock that was just acquired. 1933c293621bSPeter Staubach */ 1934c293621bSPeter Staubach if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) { 1935c293621bSPeter Staubach flock.l_type = F_UNLCK; 1936c293621bSPeter Staubach goto again; 1937c293621bSPeter Staubach } 19381da177e4SLinus Torvalds 19391da177e4SLinus Torvalds out: 19401da177e4SLinus Torvalds locks_free_lock(file_lock); 19411da177e4SLinus Torvalds return error; 19421da177e4SLinus Torvalds } 19431da177e4SLinus Torvalds #endif /* BITS_PER_LONG == 32 */ 19441da177e4SLinus Torvalds 19451da177e4SLinus Torvalds /* 19461da177e4SLinus Torvalds * This function is called when the file is being removed 19471da177e4SLinus Torvalds * from the task's fd array. POSIX locks belonging to this task 19481da177e4SLinus Torvalds * are deleted at this time. 19491da177e4SLinus Torvalds */ 19501da177e4SLinus Torvalds void locks_remove_posix(struct file *filp, fl_owner_t owner) 19511da177e4SLinus Torvalds { 1952ff7b86b8SMiklos Szeredi struct file_lock lock; 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds /* 19551da177e4SLinus Torvalds * If there are no locks held on this file, we don't need to call 19561da177e4SLinus Torvalds * posix_lock_file(). Another process could be setting a lock on this 19571da177e4SLinus Torvalds * file at the same time, but we wouldn't remove that lock anyway. 19581da177e4SLinus Torvalds */ 19590f7fc9e4SJosef "Jeff" Sipek if (!filp->f_path.dentry->d_inode->i_flock) 19601da177e4SLinus Torvalds return; 19611da177e4SLinus Torvalds 19621da177e4SLinus Torvalds lock.fl_type = F_UNLCK; 196375e1fcc0SMiklos Szeredi lock.fl_flags = FL_POSIX | FL_CLOSE; 19641da177e4SLinus Torvalds lock.fl_start = 0; 19651da177e4SLinus Torvalds lock.fl_end = OFFSET_MAX; 19661da177e4SLinus Torvalds lock.fl_owner = owner; 19671da177e4SLinus Torvalds lock.fl_pid = current->tgid; 19681da177e4SLinus Torvalds lock.fl_file = filp; 19691da177e4SLinus Torvalds lock.fl_ops = NULL; 19701da177e4SLinus Torvalds lock.fl_lmops = NULL; 19711da177e4SLinus Torvalds 1972150b3934SMarc Eshel vfs_lock_file(filp, F_SETLK, &lock, NULL); 19731da177e4SLinus Torvalds 19741da177e4SLinus Torvalds if (lock.fl_ops && lock.fl_ops->fl_release_private) 19751da177e4SLinus Torvalds lock.fl_ops->fl_release_private(&lock); 19761da177e4SLinus Torvalds } 19771da177e4SLinus Torvalds 19781da177e4SLinus Torvalds EXPORT_SYMBOL(locks_remove_posix); 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds /* 19811da177e4SLinus Torvalds * This function is called on the last close of an open file. 19821da177e4SLinus Torvalds */ 19831da177e4SLinus Torvalds void locks_remove_flock(struct file *filp) 19841da177e4SLinus Torvalds { 19850f7fc9e4SJosef "Jeff" Sipek struct inode * inode = filp->f_path.dentry->d_inode; 19861da177e4SLinus Torvalds struct file_lock *fl; 19871da177e4SLinus Torvalds struct file_lock **before; 19881da177e4SLinus Torvalds 19891da177e4SLinus Torvalds if (!inode->i_flock) 19901da177e4SLinus Torvalds return; 19911da177e4SLinus Torvalds 19921da177e4SLinus Torvalds if (filp->f_op && filp->f_op->flock) { 19931da177e4SLinus Torvalds struct file_lock fl = { 19941da177e4SLinus Torvalds .fl_pid = current->tgid, 19951da177e4SLinus Torvalds .fl_file = filp, 19961da177e4SLinus Torvalds .fl_flags = FL_FLOCK, 19971da177e4SLinus Torvalds .fl_type = F_UNLCK, 19981da177e4SLinus Torvalds .fl_end = OFFSET_MAX, 19991da177e4SLinus Torvalds }; 20001da177e4SLinus Torvalds filp->f_op->flock(filp, F_SETLKW, &fl); 200180fec4c6STrond Myklebust if (fl.fl_ops && fl.fl_ops->fl_release_private) 200280fec4c6STrond Myklebust fl.fl_ops->fl_release_private(&fl); 20031da177e4SLinus Torvalds } 20041da177e4SLinus Torvalds 20051da177e4SLinus Torvalds lock_kernel(); 20061da177e4SLinus Torvalds before = &inode->i_flock; 20071da177e4SLinus Torvalds 20081da177e4SLinus Torvalds while ((fl = *before) != NULL) { 20091da177e4SLinus Torvalds if (fl->fl_file == filp) { 2010c293621bSPeter Staubach if (IS_FLOCK(fl)) { 20111da177e4SLinus Torvalds locks_delete_lock(before); 20121da177e4SLinus Torvalds continue; 20131da177e4SLinus Torvalds } 20141da177e4SLinus Torvalds if (IS_LEASE(fl)) { 20151da177e4SLinus Torvalds lease_modify(before, F_UNLCK); 20161da177e4SLinus Torvalds continue; 20171da177e4SLinus Torvalds } 20181da177e4SLinus Torvalds /* What? */ 20191da177e4SLinus Torvalds BUG(); 20201da177e4SLinus Torvalds } 20211da177e4SLinus Torvalds before = &fl->fl_next; 20221da177e4SLinus Torvalds } 20231da177e4SLinus Torvalds unlock_kernel(); 20241da177e4SLinus Torvalds } 20251da177e4SLinus Torvalds 20261da177e4SLinus Torvalds /** 20271da177e4SLinus Torvalds * posix_unblock_lock - stop waiting for a file lock 20281da177e4SLinus Torvalds * @filp: how the file was opened 20291da177e4SLinus Torvalds * @waiter: the lock which was waiting 20301da177e4SLinus Torvalds * 20311da177e4SLinus Torvalds * lockd needs to block waiting for locks. 20321da177e4SLinus Torvalds */ 203364a318eeSJ. Bruce Fields int 20341da177e4SLinus Torvalds posix_unblock_lock(struct file *filp, struct file_lock *waiter) 20351da177e4SLinus Torvalds { 203664a318eeSJ. Bruce Fields int status = 0; 203764a318eeSJ. Bruce Fields 20381da177e4SLinus Torvalds lock_kernel(); 20395996a298SJ. Bruce Fields if (waiter->fl_next) 20401da177e4SLinus Torvalds __locks_delete_block(waiter); 204164a318eeSJ. Bruce Fields else 204264a318eeSJ. Bruce Fields status = -ENOENT; 20431da177e4SLinus Torvalds unlock_kernel(); 204464a318eeSJ. Bruce Fields return status; 20451da177e4SLinus Torvalds } 20461da177e4SLinus Torvalds 20471da177e4SLinus Torvalds EXPORT_SYMBOL(posix_unblock_lock); 20481da177e4SLinus Torvalds 20499b9d2ab4SMarc Eshel /** 20509b9d2ab4SMarc Eshel * vfs_cancel_lock - file byte range unblock lock 20519b9d2ab4SMarc Eshel * @filp: The file to apply the unblock to 20529b9d2ab4SMarc Eshel * @fl: The lock to be unblocked 20539b9d2ab4SMarc Eshel * 20549b9d2ab4SMarc Eshel * Used by lock managers to cancel blocked requests 20559b9d2ab4SMarc Eshel */ 20569b9d2ab4SMarc Eshel int vfs_cancel_lock(struct file *filp, struct file_lock *fl) 20579b9d2ab4SMarc Eshel { 20589b9d2ab4SMarc Eshel if (filp->f_op && filp->f_op->lock) 20599b9d2ab4SMarc Eshel return filp->f_op->lock(filp, F_CANCELLK, fl); 20609b9d2ab4SMarc Eshel return 0; 20619b9d2ab4SMarc Eshel } 20629b9d2ab4SMarc Eshel 20639b9d2ab4SMarc Eshel EXPORT_SYMBOL_GPL(vfs_cancel_lock); 20649b9d2ab4SMarc Eshel 20651da177e4SLinus Torvalds static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx) 20661da177e4SLinus Torvalds { 20671da177e4SLinus Torvalds struct inode *inode = NULL; 20681da177e4SLinus Torvalds 20691da177e4SLinus Torvalds if (fl->fl_file != NULL) 20700f7fc9e4SJosef "Jeff" Sipek inode = fl->fl_file->f_path.dentry->d_inode; 20711da177e4SLinus Torvalds 20721da177e4SLinus Torvalds out += sprintf(out, "%d:%s ", id, pfx); 20731da177e4SLinus Torvalds if (IS_POSIX(fl)) { 20741da177e4SLinus Torvalds out += sprintf(out, "%6s %s ", 20751da177e4SLinus Torvalds (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ", 20761da177e4SLinus Torvalds (inode == NULL) ? "*NOINODE*" : 20771da177e4SLinus Torvalds (IS_MANDLOCK(inode) && 20781da177e4SLinus Torvalds (inode->i_mode & (S_IXGRP | S_ISGID)) == S_ISGID) ? 20791da177e4SLinus Torvalds "MANDATORY" : "ADVISORY "); 20801da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 20811da177e4SLinus Torvalds if (fl->fl_type & LOCK_MAND) { 20821da177e4SLinus Torvalds out += sprintf(out, "FLOCK MSNFS "); 20831da177e4SLinus Torvalds } else { 20841da177e4SLinus Torvalds out += sprintf(out, "FLOCK ADVISORY "); 20851da177e4SLinus Torvalds } 20861da177e4SLinus Torvalds } else if (IS_LEASE(fl)) { 20871da177e4SLinus Torvalds out += sprintf(out, "LEASE "); 20881da177e4SLinus Torvalds if (fl->fl_type & F_INPROGRESS) 20891da177e4SLinus Torvalds out += sprintf(out, "BREAKING "); 20901da177e4SLinus Torvalds else if (fl->fl_file) 20911da177e4SLinus Torvalds out += sprintf(out, "ACTIVE "); 20921da177e4SLinus Torvalds else 20931da177e4SLinus Torvalds out += sprintf(out, "BREAKER "); 20941da177e4SLinus Torvalds } else { 20951da177e4SLinus Torvalds out += sprintf(out, "UNKNOWN UNKNOWN "); 20961da177e4SLinus Torvalds } 20971da177e4SLinus Torvalds if (fl->fl_type & LOCK_MAND) { 20981da177e4SLinus Torvalds out += sprintf(out, "%s ", 20991da177e4SLinus Torvalds (fl->fl_type & LOCK_READ) 21001da177e4SLinus Torvalds ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ " 21011da177e4SLinus Torvalds : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE "); 21021da177e4SLinus Torvalds } else { 21031da177e4SLinus Torvalds out += sprintf(out, "%s ", 21041da177e4SLinus Torvalds (fl->fl_type & F_INPROGRESS) 21051da177e4SLinus Torvalds ? (fl->fl_type & F_UNLCK) ? "UNLCK" : "READ " 21061da177e4SLinus Torvalds : (fl->fl_type & F_WRLCK) ? "WRITE" : "READ "); 21071da177e4SLinus Torvalds } 21081da177e4SLinus Torvalds if (inode) { 21091da177e4SLinus Torvalds #ifdef WE_CAN_BREAK_LSLK_NOW 21101da177e4SLinus Torvalds out += sprintf(out, "%d %s:%ld ", fl->fl_pid, 21111da177e4SLinus Torvalds inode->i_sb->s_id, inode->i_ino); 21121da177e4SLinus Torvalds #else 21131da177e4SLinus Torvalds /* userspace relies on this representation of dev_t ;-( */ 21141da177e4SLinus Torvalds out += sprintf(out, "%d %02x:%02x:%ld ", fl->fl_pid, 21151da177e4SLinus Torvalds MAJOR(inode->i_sb->s_dev), 21161da177e4SLinus Torvalds MINOR(inode->i_sb->s_dev), inode->i_ino); 21171da177e4SLinus Torvalds #endif 21181da177e4SLinus Torvalds } else { 21191da177e4SLinus Torvalds out += sprintf(out, "%d <none>:0 ", fl->fl_pid); 21201da177e4SLinus Torvalds } 21211da177e4SLinus Torvalds if (IS_POSIX(fl)) { 21221da177e4SLinus Torvalds if (fl->fl_end == OFFSET_MAX) 21231da177e4SLinus Torvalds out += sprintf(out, "%Ld EOF\n", fl->fl_start); 21241da177e4SLinus Torvalds else 21251da177e4SLinus Torvalds out += sprintf(out, "%Ld %Ld\n", fl->fl_start, 21261da177e4SLinus Torvalds fl->fl_end); 21271da177e4SLinus Torvalds } else { 21281da177e4SLinus Torvalds out += sprintf(out, "0 EOF\n"); 21291da177e4SLinus Torvalds } 21301da177e4SLinus Torvalds } 21311da177e4SLinus Torvalds 21321da177e4SLinus Torvalds static void move_lock_status(char **p, off_t* pos, off_t offset) 21331da177e4SLinus Torvalds { 21341da177e4SLinus Torvalds int len; 21351da177e4SLinus Torvalds len = strlen(*p); 21361da177e4SLinus Torvalds if(*pos >= offset) { 21371da177e4SLinus Torvalds /* the complete line is valid */ 21381da177e4SLinus Torvalds *p += len; 21391da177e4SLinus Torvalds *pos += len; 21401da177e4SLinus Torvalds return; 21411da177e4SLinus Torvalds } 21421da177e4SLinus Torvalds if(*pos+len > offset) { 21431da177e4SLinus Torvalds /* use the second part of the line */ 21441da177e4SLinus Torvalds int i = offset-*pos; 21451da177e4SLinus Torvalds memmove(*p,*p+i,len-i); 21461da177e4SLinus Torvalds *p += len-i; 21471da177e4SLinus Torvalds *pos += len; 21481da177e4SLinus Torvalds return; 21491da177e4SLinus Torvalds } 21501da177e4SLinus Torvalds /* discard the complete line */ 21511da177e4SLinus Torvalds *pos += len; 21521da177e4SLinus Torvalds } 21531da177e4SLinus Torvalds 21541da177e4SLinus Torvalds /** 21551da177e4SLinus Torvalds * get_locks_status - reports lock usage in /proc/locks 21561da177e4SLinus Torvalds * @buffer: address in userspace to write into 21571da177e4SLinus Torvalds * @start: ? 21581da177e4SLinus Torvalds * @offset: how far we are through the buffer 21591da177e4SLinus Torvalds * @length: how much to read 21601da177e4SLinus Torvalds */ 21611da177e4SLinus Torvalds 21621da177e4SLinus Torvalds int get_locks_status(char *buffer, char **start, off_t offset, int length) 21631da177e4SLinus Torvalds { 21641da177e4SLinus Torvalds struct list_head *tmp; 21651da177e4SLinus Torvalds char *q = buffer; 21661da177e4SLinus Torvalds off_t pos = 0; 21671da177e4SLinus Torvalds int i = 0; 21681da177e4SLinus Torvalds 21691da177e4SLinus Torvalds lock_kernel(); 21701da177e4SLinus Torvalds list_for_each(tmp, &file_lock_list) { 21711da177e4SLinus Torvalds struct list_head *btmp; 21721da177e4SLinus Torvalds struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link); 21731da177e4SLinus Torvalds lock_get_status(q, fl, ++i, ""); 21741da177e4SLinus Torvalds move_lock_status(&q, &pos, offset); 21751da177e4SLinus Torvalds 21761da177e4SLinus Torvalds if(pos >= offset+length) 21771da177e4SLinus Torvalds goto done; 21781da177e4SLinus Torvalds 21791da177e4SLinus Torvalds list_for_each(btmp, &fl->fl_block) { 21801da177e4SLinus Torvalds struct file_lock *bfl = list_entry(btmp, 21811da177e4SLinus Torvalds struct file_lock, fl_block); 21821da177e4SLinus Torvalds lock_get_status(q, bfl, i, " ->"); 21831da177e4SLinus Torvalds move_lock_status(&q, &pos, offset); 21841da177e4SLinus Torvalds 21851da177e4SLinus Torvalds if(pos >= offset+length) 21861da177e4SLinus Torvalds goto done; 21871da177e4SLinus Torvalds } 21881da177e4SLinus Torvalds } 21891da177e4SLinus Torvalds done: 21901da177e4SLinus Torvalds unlock_kernel(); 21911da177e4SLinus Torvalds *start = buffer; 21921da177e4SLinus Torvalds if(q-buffer < length) 21931da177e4SLinus Torvalds return (q-buffer); 21941da177e4SLinus Torvalds return length; 21951da177e4SLinus Torvalds } 21961da177e4SLinus Torvalds 21971da177e4SLinus Torvalds /** 21981da177e4SLinus Torvalds * lock_may_read - checks that the region is free of locks 21991da177e4SLinus Torvalds * @inode: the inode that is being read 22001da177e4SLinus Torvalds * @start: the first byte to read 22011da177e4SLinus Torvalds * @len: the number of bytes to read 22021da177e4SLinus Torvalds * 22031da177e4SLinus Torvalds * Emulates Windows locking requirements. Whole-file 22041da177e4SLinus Torvalds * mandatory locks (share modes) can prohibit a read and 22051da177e4SLinus Torvalds * byte-range POSIX locks can prohibit a read if they overlap. 22061da177e4SLinus Torvalds * 22071da177e4SLinus Torvalds * N.B. this function is only ever called 22081da177e4SLinus Torvalds * from knfsd and ownership of locks is never checked. 22091da177e4SLinus Torvalds */ 22101da177e4SLinus Torvalds int lock_may_read(struct inode *inode, loff_t start, unsigned long len) 22111da177e4SLinus Torvalds { 22121da177e4SLinus Torvalds struct file_lock *fl; 22131da177e4SLinus Torvalds int result = 1; 22141da177e4SLinus Torvalds lock_kernel(); 22151da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 22161da177e4SLinus Torvalds if (IS_POSIX(fl)) { 22171da177e4SLinus Torvalds if (fl->fl_type == F_RDLCK) 22181da177e4SLinus Torvalds continue; 22191da177e4SLinus Torvalds if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 22201da177e4SLinus Torvalds continue; 22211da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 22221da177e4SLinus Torvalds if (!(fl->fl_type & LOCK_MAND)) 22231da177e4SLinus Torvalds continue; 22241da177e4SLinus Torvalds if (fl->fl_type & LOCK_READ) 22251da177e4SLinus Torvalds continue; 22261da177e4SLinus Torvalds } else 22271da177e4SLinus Torvalds continue; 22281da177e4SLinus Torvalds result = 0; 22291da177e4SLinus Torvalds break; 22301da177e4SLinus Torvalds } 22311da177e4SLinus Torvalds unlock_kernel(); 22321da177e4SLinus Torvalds return result; 22331da177e4SLinus Torvalds } 22341da177e4SLinus Torvalds 22351da177e4SLinus Torvalds EXPORT_SYMBOL(lock_may_read); 22361da177e4SLinus Torvalds 22371da177e4SLinus Torvalds /** 22381da177e4SLinus Torvalds * lock_may_write - checks that the region is free of locks 22391da177e4SLinus Torvalds * @inode: the inode that is being written 22401da177e4SLinus Torvalds * @start: the first byte to write 22411da177e4SLinus Torvalds * @len: the number of bytes to write 22421da177e4SLinus Torvalds * 22431da177e4SLinus Torvalds * Emulates Windows locking requirements. Whole-file 22441da177e4SLinus Torvalds * mandatory locks (share modes) can prohibit a write and 22451da177e4SLinus Torvalds * byte-range POSIX locks can prohibit a write if they overlap. 22461da177e4SLinus Torvalds * 22471da177e4SLinus Torvalds * N.B. this function is only ever called 22481da177e4SLinus Torvalds * from knfsd and ownership of locks is never checked. 22491da177e4SLinus Torvalds */ 22501da177e4SLinus Torvalds int lock_may_write(struct inode *inode, loff_t start, unsigned long len) 22511da177e4SLinus Torvalds { 22521da177e4SLinus Torvalds struct file_lock *fl; 22531da177e4SLinus Torvalds int result = 1; 22541da177e4SLinus Torvalds lock_kernel(); 22551da177e4SLinus Torvalds for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 22561da177e4SLinus Torvalds if (IS_POSIX(fl)) { 22571da177e4SLinus Torvalds if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 22581da177e4SLinus Torvalds continue; 22591da177e4SLinus Torvalds } else if (IS_FLOCK(fl)) { 22601da177e4SLinus Torvalds if (!(fl->fl_type & LOCK_MAND)) 22611da177e4SLinus Torvalds continue; 22621da177e4SLinus Torvalds if (fl->fl_type & LOCK_WRITE) 22631da177e4SLinus Torvalds continue; 22641da177e4SLinus Torvalds } else 22651da177e4SLinus Torvalds continue; 22661da177e4SLinus Torvalds result = 0; 22671da177e4SLinus Torvalds break; 22681da177e4SLinus Torvalds } 22691da177e4SLinus Torvalds unlock_kernel(); 22701da177e4SLinus Torvalds return result; 22711da177e4SLinus Torvalds } 22721da177e4SLinus Torvalds 22731da177e4SLinus Torvalds EXPORT_SYMBOL(lock_may_write); 22741da177e4SLinus Torvalds 22751da177e4SLinus Torvalds static int __init filelock_init(void) 22761da177e4SLinus Torvalds { 22771da177e4SLinus Torvalds filelock_cache = kmem_cache_create("file_lock_cache", 22781da177e4SLinus Torvalds sizeof(struct file_lock), 0, SLAB_PANIC, 227920c2df83SPaul Mundt init_once); 22801da177e4SLinus Torvalds return 0; 22811da177e4SLinus Torvalds } 22821da177e4SLinus Torvalds 22831da177e4SLinus Torvalds core_initcall(filelock_init); 2284