#define MSNFS /* HACK HACK */ /* * linux/fs/locks.c * * Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls. * Doug Evans (dje@spiff.uucp), August 07, 1992 * * Deadlock detection added. * FIXME: one thing isn't handled yet: * - mandatory locks (requires lots of changes elsewhere) * Kelly Carmichael (kelly@[142.24.8.65]), September 17, 1994. * * Miscellaneous edits, and a total rewrite of posix_lock_file() code. * Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994 * * Converted file_lock_table to a linked list from an array, which eliminates * the limits on how many active file locks are open. * Chad Page (pageone@netcom.com), November 27, 1994 * * Removed dependency on file descriptors. dup()'ed file descriptors now * get the same locks as the original file descriptors, and a close() on * any file descriptor removes ALL the locks on the file for the current * process. Since locks still depend on the process id, locks are inherited * after an exec() but not after a fork(). This agrees with POSIX, and both * BSD and SVR4 practice. * Andy Walker (andy@lysaker.kvaerner.no), February 14, 1995 * * Scrapped free list which is redundant now that we allocate locks * dynamically with kmalloc()/kfree(). * Andy Walker (andy@lysaker.kvaerner.no), February 21, 1995 * * Implemented two lock personalities - FL_FLOCK and FL_POSIX. * * FL_POSIX locks are created with calls to fcntl() and lockf() through the * fcntl() system call. They have the semantics described above. * * FL_FLOCK locks are created with calls to flock(), through the flock() * system call, which is new. Old C libraries implement flock() via fcntl() * and will continue to use the old, broken implementation. * * FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated * with a file pointer (filp). As a result they can be shared by a parent * process and its children after a fork(). They are removed when the last * file descriptor referring to the file pointer is closed (unless explicitly * unlocked). * * FL_FLOCK locks never deadlock, an existing lock is always removed before * upgrading from shared to exclusive (or vice versa). When this happens * any processes blocked by the current lock are woken up and allowed to * run before the new lock is applied. * Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995 * * Removed some race conditions in flock_lock_file(), marked other possible * races. Just grep for FIXME to see them. * Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996. * * Addressed Dmitry's concerns. Deadlock checking no longer recursive. * Lock allocation changed to GFP_ATOMIC as we can't afford to sleep * once we've checked for blocking and deadlocking. * Andy Walker (andy@lysaker.kvaerner.no), April 03, 1996. * * Initial implementation of mandatory locks. SunOS turned out to be * a rotten model, so I implemented the "obvious" semantics. * See 'linux/Documentation/mandatory.txt' for details. * Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996. * * Don't allow mandatory locks on mmap()'ed files. Added simple functions to * check if a file has mandatory locks, used by mmap(), open() and creat() to * see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference * Manual, Section 2. * Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996. * * Tidied up block list handling. Added '/proc/locks' interface. * Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996. * * Fixed deadlock condition for pathological code that mixes calls to * flock() and fcntl(). * Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996. * * Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use * for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to * guarantee sensible behaviour in the case where file system modules might * be compiled with different options than the kernel itself. * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996. * * Added a couple of missing wake_up() calls. Thanks to Thomas Meckel * (Thomas.Meckel@mni.fh-giessen.de) for spotting this. * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996. * * Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK * locks. Changed process synchronisation to avoid dereferencing locks that * have already been freed. * Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996. * * Made the block list a circular list to minimise searching in the list. * Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996. * * Made mandatory locking a mount option. Default is not to allow mandatory * locking. * Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996. * * Some adaptations for NFS support. * Olaf Kirch (okir@monad.swb.de), Dec 1996, * * Fixed /proc/locks interface so that we can't overrun the buffer we are handed. * Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997. * * Use slab allocator instead of kmalloc/kfree. * Use generic list implementation from <linux/list.h>. * Sped up posix_locks_deadlock by only considering blocked locks. * Matthew Wilcox <willy@thepuffingroup.com>, March, 2000. * * Leases and LOCK_MAND * Matthew Wilcox <willy@linuxcare.com>, June, 2000. * Stephen Rothwell <sfr@linuxcare.com>, June, 2000. */ #include <linux/malloc.h> #include <linux/file.h> #include <linux/smp_lock.h> #include <linux/init.h> #include <linux/capability.h> #include <linux/sched.h> #include <asm/semaphore.h> #include <asm/uaccess.h> int leases_enable = 1; int lease_break_time = 45; LIST_HEAD(file_lock_list); static LIST_HEAD(blocked_list); static kmem_cache_t *filelock_cache; /* Allocate an empty lock structure. */ 137 static struct file_lock *locks_alloc_lock(int account) { struct file_lock *fl; 140 if (account && current->locks >= current->rlim[RLIMIT_LOCKS].rlim_cur) 141 return NULL; fl = kmem_cache_alloc(filelock_cache, SLAB_KERNEL); 143 if (fl) current->locks++; 145 return fl; } /* Free a lock which is not in use. */ 149 static inline void locks_free_lock(struct file_lock *fl) { 151 if (fl == NULL) { 152 BUG(); 153 return; } current->locks--; 156 if (waitqueue_active(&fl->fl_wait)) panic("Attempting to free lock with active wait queue"); 159 if (!list_empty(&fl->fl_block)) panic("Attempting to free lock with active block list"); 162 if (!list_empty(&fl->fl_link)) panic("Attempting to free lock on active lock list"); kmem_cache_free(filelock_cache, fl); } 168 void locks_init_lock(struct file_lock *fl) { 170 INIT_LIST_HEAD(&fl->fl_link); 171 INIT_LIST_HEAD(&fl->fl_block); init_waitqueue_head(&fl->fl_wait); fl->fl_next = NULL; fl->fl_fasync = NULL; fl->fl_owner = 0; fl->fl_pid = 0; fl->fl_file = NULL; fl->fl_flags = 0; fl->fl_type = 0; fl->fl_start = fl->fl_end = 0; fl->fl_notify = NULL; fl->fl_insert = NULL; fl->fl_remove = NULL; } /* * Initialises the fields of the file lock which are invariant for * free file_locks. */ 190 static void init_once(void *foo, kmem_cache_t *cache, unsigned long flags) { struct file_lock *lock = (struct file_lock *) foo; if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) != 195 SLAB_CTOR_CONSTRUCTOR) 196 return; locks_init_lock(lock); } /* * Initialize a new lock from an existing file_lock structure. */ 204 void locks_copy_lock(struct file_lock *new, struct file_lock *fl) { new->fl_owner = fl->fl_owner; new->fl_pid = fl->fl_pid; new->fl_file = fl->fl_file; new->fl_flags = fl->fl_flags; new->fl_type = fl->fl_type; new->fl_start = fl->fl_start; new->fl_end = fl->fl_end; new->fl_notify = fl->fl_notify; new->fl_insert = fl->fl_insert; new->fl_remove = fl->fl_remove; new->fl_u = fl->fl_u; } /* Fill in a file_lock structure with an appropriate FLOCK lock. */ 220 static struct file_lock *flock_make_lock(struct file *filp, unsigned int type) { struct file_lock *fl = locks_alloc_lock(1); 223 if (fl == NULL) 224 return NULL; fl->fl_owner = NULL; fl->fl_file = filp; fl->fl_pid = current->pid; fl->fl_flags = FL_FLOCK; fl->fl_type = type; fl->fl_start = 0; fl->fl_end = OFFSET_MAX; fl->fl_notify = NULL; fl->fl_insert = NULL; fl->fl_remove = NULL; 237 return fl; } 240 static int assign_type(struct file_lock *fl, int type) { 242 switch (type) { 243 case F_RDLCK: 244 case F_WRLCK: 245 case F_UNLCK: fl->fl_type = type; 247 break; 248 default: 249 return -EINVAL; } 251 return 0; } /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX * style lock. */ 257 static int flock_to_posix_lock(struct file *filp, struct file_lock *fl, struct flock *l) { loff_t start; 262 switch (l->l_whence) { 263 case 0: /*SEEK_SET*/ start = 0; 265 break; 266 case 1: /*SEEK_CUR*/ start = filp->f_pos; 268 break; 269 case 2: /*SEEK_END*/ start = filp->f_dentry->d_inode->i_size; 271 break; 272 default: 273 return (0); } 276 if (((start += l->l_start) < 0) || (l->l_len < 0)) 277 return (0); fl->fl_end = start + l->l_len - 1; 279 if (l->l_len > 0 && fl->fl_end < 0) 280 return (0); 281 if (fl->fl_end > OFFT_OFFSET_MAX) 282 return 0; fl->fl_start = start; /* we record the absolute position */ 284 if (l->l_len == 0) fl->fl_end = OFFSET_MAX; fl->fl_owner = current->files; fl->fl_pid = current->pid; fl->fl_file = filp; fl->fl_flags = FL_POSIX; fl->fl_notify = NULL; fl->fl_insert = NULL; fl->fl_remove = NULL; 295 return (assign_type(fl, l->l_type) == 0); } #if BITS_PER_LONG == 32 299 static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, struct flock64 *l) { loff_t start; 304 switch (l->l_whence) { 305 case 0: /*SEEK_SET*/ start = 0; 307 break; 308 case 1: /*SEEK_CUR*/ start = filp->f_pos; 310 break; 311 case 2: /*SEEK_END*/ start = filp->f_dentry->d_inode->i_size; 313 break; 314 default: 315 return (0); } 318 if (((start += l->l_start) < 0) || (l->l_len < 0)) 319 return (0); fl->fl_end = start + l->l_len - 1; 321 if (l->l_len > 0 && fl->fl_end < 0) 322 return (0); fl->fl_start = start; /* we record the absolute position */ 324 if (l->l_len == 0) fl->fl_end = OFFSET_MAX; fl->fl_owner = current->files; fl->fl_pid = current->pid; fl->fl_file = filp; fl->fl_flags = FL_POSIX; fl->fl_notify = NULL; fl->fl_insert = NULL; fl->fl_remove = NULL; 335 switch (l->l_type) { 336 case F_RDLCK: 337 case F_WRLCK: 338 case F_UNLCK: fl->fl_type = l->l_type; 340 break; 341 default: 342 return (0); } 345 return (1); } #endif /* Allocate a file_lock initialised to this type of lease */ 350 static int lease_alloc(struct file *filp, int type, struct file_lock **flp) { struct file_lock *fl = locks_alloc_lock(1); 353 if (fl == NULL) 354 return -ENOMEM; fl->fl_owner = current->files; fl->fl_pid = current->pid; fl->fl_file = filp; fl->fl_flags = FL_LEASE; 361 if (assign_type(fl, type) != 0) { locks_free_lock(fl); 363 return -EINVAL; } fl->fl_start = 0; fl->fl_end = OFFSET_MAX; fl->fl_notify = NULL; fl->fl_insert = NULL; fl->fl_remove = NULL; *flp = fl; 372 return 0; } /* Check if two locks overlap each other. */ 377 static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) { return ((fl1->fl_end >= fl2->fl_start) && 380 (fl2->fl_end >= fl1->fl_start)); } /* * Check whether two locks have the same owner * N.B. Do we need the test on PID as well as owner? * (Clone tasks should be considered as one "owner".) */ static inline int 389 locks_same_owner(struct file_lock *fl1, struct file_lock *fl2) { return (fl1->fl_owner == fl2->fl_owner) && 392 (fl1->fl_pid == fl2->fl_pid); } /* Remove waiter from blocker's block list. * When blocker ends up pointing to itself then the list is empty. */ 398 static void locks_delete_block(struct file_lock *waiter) { list_del(&waiter->fl_block); 401 INIT_LIST_HEAD(&waiter->fl_block); list_del(&waiter->fl_link); 403 INIT_LIST_HEAD(&waiter->fl_link); waiter->fl_next = NULL; } /* Insert waiter into blocker's block list. * We use a circular list so that processes can be easily woken up in * the order they blocked. The documentation doesn't require this but * it seems like the reasonable thing to do. */ 412 static void locks_insert_block(struct file_lock *blocker, struct file_lock *waiter) { 415 if (!list_empty(&waiter->fl_block)) { printk(KERN_ERR "locks_insert_block: removing duplicated lock " "(pid=%d %Ld-%Ld type=%d)\n", waiter->fl_pid, waiter->fl_start, waiter->fl_end, waiter->fl_type); locks_delete_block(waiter); } list_add_tail(&waiter->fl_block, &blocker->fl_block); waiter->fl_next = blocker; list_add(&waiter->fl_link, &blocked_list); } static inline 427 void locks_notify_blocked(struct file_lock *waiter) { 429 if (waiter->fl_notify) waiter->fl_notify(waiter); 431 else wake_up(&waiter->fl_wait); } /* Wake up processes blocked waiting for blocker. * If told to wait then schedule the processes until the block list * is empty, otherwise empty the block list ourselves. */ 439 static void locks_wake_up_blocks(struct file_lock *blocker, unsigned int wait) { 441 while (!list_empty(&blocker->fl_block)) { struct file_lock *waiter = list_entry(blocker->fl_block.next, struct file_lock, fl_block); 444 if (wait) { locks_notify_blocked(waiter); /* Let the blocked process remove waiter from the * block list when it gets scheduled. */ current->policy |= SCHED_YIELD; schedule(); 451 } else { /* Remove waiter from the block list, because by the * time it wakes up blocker won't exist any more. */ locks_delete_block(waiter); locks_notify_blocked(waiter); } } } /* Insert file lock fl into an inode's lock list at the position indicated * by pos. At the same time add the lock to the global file lock list. */ 464 static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl) { list_add(&fl->fl_link, &file_lock_list); /* insert into file's list */ fl->fl_next = *pos; *pos = fl; 472 if (fl->fl_insert) fl->fl_insert(fl); } /* Delete a lock and then free it. * Remove our lock from the lock lists, wake up processes that are blocked * waiting for this lock, notify the FS that the lock has been cleared and * finally free the lock. */ 481 static void locks_delete_lock(struct file_lock **thisfl_p, unsigned int wait) { struct file_lock *fl = *thisfl_p; *thisfl_p = fl->fl_next; fl->fl_next = NULL; list_del(&fl->fl_link); 489 INIT_LIST_HEAD(&fl->fl_link); fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); 492 if (fl->fl_fasync != NULL){ printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync); fl->fl_fasync = NULL; } 497 if (fl->fl_remove) fl->fl_remove(fl); locks_wake_up_blocks(fl, wait); locks_free_lock(fl); } /* * Call back client filesystem in order to get it to unregister a lock, * then delete lock. Essentially useful only in locks_remove_*(). * Note: this must be called with the semaphore already held! */ 509 static inline void locks_unlock_delete(struct file_lock **thisfl_p) { struct file_lock *fl = *thisfl_p; int (*lock)(struct file *, int, struct file_lock *); if (fl->fl_file->f_op && 515 (lock = fl->fl_file->f_op->lock) != NULL) { fl->fl_type = F_UNLCK; lock(fl->fl_file, F_SETLK, fl); } locks_delete_lock(thisfl_p, 0); } /* Determine if lock sys_fl blocks lock caller_fl. Common functionality * checks for shared/exclusive status of overlapping locks. */ 525 static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) { 527 switch (caller_fl->fl_type) { 528 case F_RDLCK: 529 return (sys_fl->fl_type == F_WRLCK); 531 case F_WRLCK: 532 return (1); 534 default: printk("locks_conflict(): impossible lock type - %d\n", caller_fl->fl_type); 537 break; } 539 return (0); /* This should never happen */ } /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific * checking before calling the locks_conflict(). */ 545 static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) { /* POSIX locks owned by the same process do not conflict with * each other. */ if (!(sys_fl->fl_flags & FL_POSIX) || 551 locks_same_owner(caller_fl, sys_fl)) 552 return (0); /* Check whether they overlap */ 555 if (!locks_overlap(caller_fl, sys_fl)) 556 return 0; 558 return (locks_conflict(caller_fl, sys_fl)); } /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific * checking before calling the locks_conflict(). */ 564 static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) { /* FLOCK locks referring to the same filp do not conflict with * each other. */ if (!(sys_fl->fl_flags & FL_FLOCK) || 570 (caller_fl->fl_file == sys_fl->fl_file)) 571 return (0); #ifdef MSNFS 573 if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND)) 574 return 0; #endif 577 return (locks_conflict(caller_fl, sys_fl)); } 580 static int interruptible_sleep_on_locked(wait_queue_head_t *fl_wait, int timeout) { int result = 0; DECLARE_WAITQUEUE(wait, current); current->state = TASK_INTERRUPTIBLE; add_wait_queue(fl_wait, &wait); 587 if (timeout == 0) schedule(); 589 else result = schedule_timeout(timeout); 591 if (signal_pending(current)) result = -ERESTARTSYS; remove_wait_queue(fl_wait, &wait); current->state = TASK_RUNNING; 595 return result; } 598 static int locks_block_on(struct file_lock *blocker, struct file_lock *waiter) { int result; locks_insert_block(blocker, waiter); result = interruptible_sleep_on_locked(&waiter->fl_wait, 0); locks_delete_block(waiter); 604 return result; } 607 static int locks_block_on_timeout(struct file_lock *blocker, struct file_lock *waiter, int time) { int result; locks_insert_block(blocker, waiter); result = interruptible_sleep_on_locked(&waiter->fl_wait, time); locks_delete_block(waiter); 613 return result; } struct file_lock * 617 posix_test_lock(struct file *filp, struct file_lock *fl) { struct file_lock *cfl; 621 lock_kernel(); 622 for (cfl = filp->f_dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) { 623 if (!(cfl->fl_flags & FL_POSIX)) 624 continue; 625 if (posix_locks_conflict(cfl, fl)) 626 break; } 628 unlock_kernel(); 630 return (cfl); } /* This function tests for deadlock condition before putting a process to * sleep. The detection scheme is no longer recursive. Recursive was neat, * but dangerous - we risked stack corruption if the lock data was bad, or * if the recursion was too deep for any other reason. * * We rely on the fact that a task can only be on one lock's wait queue * at a time. When we find blocked_task on a wait queue we can re-search * with blocked_task equal to that queue's owner, until either blocked_task * isn't found, or blocked_task is found on a queue owned by my_task. * * Note: the above assumption may not be true when handling lock requests * from a broken NFS client. But broken NFS clients have a lot more to * worry about than proper deadlock detection anyway... --okir */ 647 static int posix_locks_deadlock(struct file_lock *caller_fl, struct file_lock *block_fl) { struct list_head *tmp; fl_owner_t caller_owner, blocked_owner; unsigned int caller_pid, blocked_pid; caller_owner = caller_fl->fl_owner; caller_pid = caller_fl->fl_pid; blocked_owner = block_fl->fl_owner; blocked_pid = block_fl->fl_pid; next_task: 660 if (caller_owner == blocked_owner && caller_pid == blocked_pid) 661 return 1; 662 list_for_each(tmp, &blocked_list) { struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link); if ((fl->fl_owner == blocked_owner) 665 && (fl->fl_pid == blocked_pid)) { fl = fl->fl_next; blocked_owner = fl->fl_owner; blocked_pid = fl->fl_pid; 669 goto next_task; } } 672 return 0; } 675 int locks_mandatory_locked(struct inode *inode) { fl_owner_t owner = current->files; struct file_lock *fl; /* * Search the lock list for this inode for any POSIX locks. */ 683 lock_kernel(); 684 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 685 if (!(fl->fl_flags & FL_POSIX)) 686 continue; 687 if (fl->fl_owner != owner) 688 break; } 690 unlock_kernel(); 691 return fl ? -EAGAIN : 0; } 694 int locks_mandatory_area(int read_write, struct inode *inode, struct file *filp, loff_t offset, size_t count) { struct file_lock *fl; struct file_lock *new_fl = locks_alloc_lock(0); int error; new_fl->fl_owner = current->files; new_fl->fl_pid = current->pid; new_fl->fl_file = filp; new_fl->fl_flags = FL_POSIX | FL_ACCESS; new_fl->fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK; new_fl->fl_start = offset; new_fl->fl_end = offset + count - 1; error = 0; 711 lock_kernel(); repeat: /* Search the lock list for this inode for locks that conflict with * the proposed read/write. */ 717 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 718 if (!(fl->fl_flags & FL_POSIX)) 719 continue; 720 if (fl->fl_start > new_fl->fl_end) 721 break; 722 if (posix_locks_conflict(new_fl, fl)) { error = -EAGAIN; 724 if (filp && (filp->f_flags & O_NONBLOCK)) 725 break; error = -EDEADLK; 727 if (posix_locks_deadlock(new_fl, fl)) 728 break; error = locks_block_on(fl, new_fl); 731 if (error != 0) 732 break; /* * If we've been sleeping someone might have * changed the permissions behind our back. */ 738 if ((inode->i_mode & (S_ISGID | S_IXGRP)) != S_ISGID) 739 break; 740 goto repeat; } } locks_free_lock(new_fl); 744 unlock_kernel(); 745 return error; } /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks * at the head of the list, but that's secret knowledge known only to * flock_lock_file and posix_lock_file. */ 752 static int flock_lock_file(struct file *filp, unsigned int lock_type, unsigned int wait) { struct file_lock *fl; struct file_lock *new_fl = NULL; struct file_lock **before; struct inode * inode = filp->f_dentry->d_inode; int error, change; int unlock = (lock_type == F_UNLCK); /* * If we need a new lock, get it in advance to avoid races. */ 765 if (!unlock) { error = -ENOLCK; new_fl = flock_make_lock(filp, lock_type); 768 if (!new_fl) 769 return error; } error = 0; search: change = 0; before = &inode->i_flock; 776 while (((fl = *before) != NULL) && (fl->fl_flags & FL_FLOCK)) { 777 if (filp == fl->fl_file) { 778 if (lock_type == fl->fl_type) 779 goto out; change = 1; 781 break; } before = &fl->fl_next; } /* change means that we are changing the type of an existing lock, * or else unlocking it. */ 788 if (change) { /* N.B. What if the wait argument is false? */ locks_delete_lock(before, !unlock); /* * If we waited, another lock may have been added ... */ 794 if (!unlock) 795 goto search; } 797 if (unlock) 798 goto out; repeat: 801 for (fl = inode->i_flock; (fl != NULL) && (fl->fl_flags & FL_FLOCK); fl = fl->fl_next) { 803 if (!flock_locks_conflict(new_fl, fl)) 804 continue; error = -EAGAIN; 806 if (!wait) 807 goto out; error = locks_block_on(fl, new_fl); 809 if (error != 0) 810 goto out; 811 goto repeat; } locks_insert_lock(&inode->i_flock, new_fl); new_fl = NULL; error = 0; out: 818 if (new_fl) locks_free_lock(new_fl); 820 return error; } /** * posix_lock_file: * @filp: The file to apply the lock to * @caller: The lock to be applied * @wait: 1 to retry automatically, 0 to return -EAGAIN * * Add a POSIX style lock to a file. * We merge adjacent locks whenever possible. POSIX locks are sorted by owner * task, then by starting address * * Kai Petzke writes: * To make freeing a lock much faster, we keep a pointer to the lock before the * actual one. But the real gain of the new coding was, that lock_it() and * unlock_it() became one function. * * To all purists: Yes, I use a few goto's. Just pass on to the next function. */ 841 int posix_lock_file(struct file *filp, struct file_lock *caller, unsigned int wait) { struct file_lock *fl; struct file_lock *new_fl, *new_fl2; struct file_lock *left = NULL; struct file_lock *right = NULL; struct file_lock **before; struct inode * inode = filp->f_dentry->d_inode; int error, added = 0; /* * We may need two file_lock structures for this operation, * so we get them in advance to avoid races. */ new_fl = locks_alloc_lock(0); new_fl2 = locks_alloc_lock(0); error = -ENOLCK; /* "no luck" */ 859 if (!(new_fl && new_fl2)) 860 goto out; 862 lock_kernel(); 863 if (caller->fl_type != F_UNLCK) { repeat: 865 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 866 if (!(fl->fl_flags & FL_POSIX)) 867 continue; 868 if (!posix_locks_conflict(caller, fl)) 869 continue; error = -EAGAIN; 871 if (!wait) 872 goto out; error = -EDEADLK; 874 if (posix_locks_deadlock(caller, fl)) 875 goto out; error = locks_block_on(fl, caller); 878 if (error != 0) 879 goto out; 880 goto repeat; } } /* * We've allocated the new locks in advance, so there are no * errors possible (and no blocking operations) from here on. * * Find the first old lock with the same owner as the new lock. */ before = &inode->i_flock; /* First skip locks owned by other processes. */ while ((fl = *before) && (!(fl->fl_flags & FL_POSIX) || 896 !locks_same_owner(caller, fl))) { before = &fl->fl_next; } /* Process locks with this owner. */ 902 while ((fl = *before) && locks_same_owner(caller, fl)) { /* Detect adjacent or overlapping regions (if same lock type) */ 905 if (caller->fl_type == fl->fl_type) { 906 if (fl->fl_end < caller->fl_start - 1) 907 goto next_lock; /* If the next lock in the list has entirely bigger * addresses than the new one, insert the lock here. */ 911 if (fl->fl_start > caller->fl_end + 1) 912 break; /* If we come here, the new and old lock are of the * same type and adjacent or overlapping. Make one * lock yielding from the lower start address of both * locks to the higher end address. */ 919 if (fl->fl_start > caller->fl_start) fl->fl_start = caller->fl_start; 921 else caller->fl_start = fl->fl_start; 923 if (fl->fl_end < caller->fl_end) fl->fl_end = caller->fl_end; 925 else caller->fl_end = fl->fl_end; 927 if (added) { locks_delete_lock(before, 0); 929 continue; } caller = fl; added = 1; } 934 else { /* Processing for different lock types is a bit * more complex. */ 938 if (fl->fl_end < caller->fl_start) 939 goto next_lock; 940 if (fl->fl_start > caller->fl_end) 941 break; 942 if (caller->fl_type == F_UNLCK) added = 1; 944 if (fl->fl_start < caller->fl_start) left = fl; /* If the next lock in the list has a higher end * address than the new one, insert the new one here. */ 949 if (fl->fl_end > caller->fl_end) { right = fl; 951 break; } 953 if (fl->fl_start >= caller->fl_start) { /* The new lock completely replaces an old * one (This may happen several times). */ 957 if (added) { locks_delete_lock(before, 0); 959 continue; } /* Replace the old lock with the new one. * Wake up anybody waiting for the old one, * as the change in lock type might satisfy * their needs. */ locks_wake_up_blocks(fl, 0); /* This cannot schedule()! */ fl->fl_start = caller->fl_start; fl->fl_end = caller->fl_end; fl->fl_type = caller->fl_type; fl->fl_u = caller->fl_u; caller = fl; added = 1; } } /* Go on to next lock. */ next_lock: before = &fl->fl_next; } error = 0; 982 if (!added) { 983 if (caller->fl_type == F_UNLCK) 984 goto out; locks_copy_lock(new_fl, caller); locks_insert_lock(before, new_fl); new_fl = NULL; } 989 if (right) { 990 if (left == right) { /* The new lock breaks the old one in two pieces, * so we have to use the second new lock. */ left = new_fl2; new_fl2 = NULL; locks_copy_lock(left, right); locks_insert_lock(before, left); } right->fl_start = caller->fl_end + 1; locks_wake_up_blocks(right, 0); } 1002 if (left) { left->fl_end = caller->fl_start - 1; locks_wake_up_blocks(left, 0); } out: 1007 unlock_kernel(); /* * Free any unused locks. */ 1011 if (new_fl) locks_free_lock(new_fl); 1013 if (new_fl2) locks_free_lock(new_fl2); 1015 return error; } 1018 static inline int flock_translate_cmd(int cmd) { #ifdef MSNFS 1020 if (cmd & LOCK_MAND) 1021 return cmd & (LOCK_MAND | LOCK_RW); #endif 1023 switch (cmd &~ LOCK_NB) { 1024 case LOCK_SH: 1025 return F_RDLCK; 1026 case LOCK_EX: 1027 return F_WRLCK; 1028 case LOCK_UN: 1029 return F_UNLCK; } 1031 return -EINVAL; } /** * __get_lease - revoke all outstanding leases on file * @inode: the inode of the file to return * @mode: the open mode (read or write) * * get_lease (inlined for speed) has checked there already * is a lease on this file. Leases are broken on a call to open() * or truncate(). This function can sleep unless you * specified %O_NONBLOCK to your open(). */ 1044 int __get_lease(struct inode *inode, unsigned int mode) { int error = 0, future; struct file_lock *new_fl, *flock; struct file_lock *fl; int alloc_err; alloc_err = lease_alloc(NULL, 0, &new_fl); 1053 lock_kernel(); flock = inode->i_flock; 1055 if (flock->fl_type & F_INPROGRESS) { if ((mode & O_NONBLOCK) 1057 || (flock->fl_owner == current->files)) { error = -EWOULDBLOCK; 1059 goto out; } 1061 if (alloc_err != 0) { error = alloc_err; 1063 goto out; } 1065 do { error = locks_block_on(flock, new_fl); 1067 if (error != 0) 1068 goto out; flock = inode->i_flock; 1070 if (!(flock && (flock->fl_flags & FL_LEASE))) 1071 goto out; 1072 } while (flock->fl_type & F_INPROGRESS); } 1075 if (mode & FMODE_WRITE) { /* If we want write access, we have to revoke any lease. */ future = F_UNLCK | F_INPROGRESS; 1078 } else if (flock->fl_type & F_WRLCK) { /* Downgrade the exclusive lease to a read-only lease. */ future = F_RDLCK | F_INPROGRESS; 1081 } else { /* the existing lease was read-only, so we can read too. */ 1083 goto out; } 1086 if (alloc_err && (flock->fl_owner != current->files)) { error = alloc_err; 1088 goto out; } fl = flock; 1092 do { fl->fl_type = future; fl = fl->fl_next; 1095 } while (fl != NULL && (fl->fl_flags & FL_LEASE)); kill_fasync(&flock->fl_fasync, SIGIO, POLL_MSG); 1099 if ((mode & O_NONBLOCK) || (flock->fl_owner == current->files)) { error = -EWOULDBLOCK; 1101 goto out; } 1104 if (lease_break_time > 0) error = lease_break_time * HZ; 1106 else error = 0; restart: error = locks_block_on_timeout(flock, new_fl, error); 1110 if (error == 0) { /* We timed out. Unilaterally break the lease. */ locks_delete_lock(&inode->i_flock, 0); printk(KERN_WARNING "lease timed out\n"); 1114 } else if (error > 0) { flock = inode->i_flock; 1116 if (flock && (flock->fl_flags & FL_LEASE)) 1117 goto restart; error = 0; } out: 1122 unlock_kernel(); 1123 if (!alloc_err) locks_free_lock(new_fl); 1125 return error; } /** * lease_get_mtime * @inode: the inode * * This is to force NFS clients to flush their caches for files with * exclusive leases. The justification is that if someone has an * exclusive lease, then they could be modifiying it. */ 1136 time_t lease_get_mtime(struct inode *inode) { struct file_lock *flock = inode->i_flock; 1139 if (flock && (flock->fl_flags & FL_LEASE) && (flock->fl_type & F_WRLCK)) 1140 return CURRENT_TIME; 1141 return inode->i_mtime; } /** * fcntl_getlease - Enquire what lease is currently active * @filp: the file * * The value returned by this function will be one of * * %F_RDLCK to indicate a read-only (type II) lease is held. * * %F_WRLCK to indicate an exclusive lease is held. * * XXX: sfr & i disagree over whether F_INPROGRESS * should be returned to userspace. */ 1157 int fcntl_getlease(struct file *filp) { struct file_lock *fl; fl = filp->f_dentry->d_inode->i_flock; 1162 if ((fl == NULL) || ((fl->fl_flags & FL_LEASE) == 0)) 1163 return F_UNLCK; 1164 return fl->fl_type & ~F_INPROGRESS; } /* We already had a lease on this file; just change its type */ 1168 static int lease_modify(struct file_lock **before, int arg, int fd, struct file *filp) { struct file_lock *fl = *before; int error = assign_type(fl, arg); 1172 if (error < 0) 1173 goto out; locks_wake_up_blocks(fl, 0); 1177 if (arg == F_UNLCK) { filp->f_owner.pid = 0; filp->f_owner.uid = 0; filp->f_owner.euid = 0; filp->f_owner.signum = 0; locks_delete_lock(before, 0); fasync_helper(fd, filp, 0, &fl->fl_fasync); } out: 1187 return error; } /** * fcntl_setlease - sets a lease on an open file * @fd: open file descriptor * @filp: file pointer * @arg: type of lease to obtain * * Call this fcntl to establish a lease on the file. * Note that you also need to call %F_SETSIG to * receive a signal when the lease is broken. */ 1200 int fcntl_setlease(unsigned int fd, struct file *filp, long arg) { struct file_lock *fl, **before, **my_before = NULL; struct dentry *dentry; struct inode *inode; int error, rdlease_count = 0, wrlease_count = 0; dentry = filp->f_dentry; inode = dentry->d_inode; 1210 if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE)) 1211 return -EACCES; 1212 if (!S_ISREG(inode->i_mode)) 1213 return -EINVAL; /* * FIXME: What about F_RDLCK and files open for writing? */ if ((arg == F_WRLCK) && ((atomic_read(&dentry->d_count) > 1) 1220 || (atomic_read(&inode->i_count) > 1))) 1221 return -EAGAIN; before = &inode->i_flock; 1225 lock_kernel(); 1227 while ((fl = *before) != NULL) { 1228 if (fl->fl_flags != FL_LEASE) 1229 break; 1230 if (fl->fl_file == filp) my_before = before; 1232 else if (fl->fl_type & F_WRLCK) wrlease_count++; 1234 else rdlease_count++; before = &fl->fl_next; } if ((arg == F_RDLCK && (wrlease_count > 0)) || 1240 (arg == F_WRLCK && ((rdlease_count + wrlease_count) > 0))) { error = -EAGAIN; 1242 goto out_unlock; } 1245 if (my_before != NULL) { error = lease_modify(my_before, arg, fd, filp); 1247 goto out_unlock; } 1250 if (arg == F_UNLCK) { error = 0; 1252 goto out_unlock; } 1255 if (!leases_enable) { error = -EINVAL; 1257 goto out_unlock; } error = lease_alloc(filp, arg, &fl); 1261 if (error) 1262 goto out_unlock; error = fasync_helper(fd, filp, 1, &fl->fl_fasync); 1265 if (error < 0) { locks_free_lock(fl); 1267 goto out_unlock; } fl->fl_next = *before; *before = fl; list_add(&fl->fl_link, &file_lock_list); filp->f_owner.pid = current->pid; filp->f_owner.uid = current->uid; filp->f_owner.euid = current->euid; out_unlock: 1276 unlock_kernel(); 1277 return error; } /** * sys_flock: - flock() system call. * @fd: the file descriptor to lock. * @cmd: the type of lock to apply. * * Apply a %FL_FLOCK style lock to an open file descriptor. * The @cmd can be one of * * %LOCK_SH -- a shared lock. * * %LOCK_EX -- an exclusive lock. * * %LOCK_UN -- remove an existing lock. * * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes. * * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other * processes read and write access respectively. */ 1299 asmlinkage long sys_flock(unsigned int fd, unsigned int cmd) { struct file *filp; int error, type; error = -EBADF; filp = fget(fd); 1306 if (!filp) 1307 goto out; error = flock_translate_cmd(cmd); 1310 if (error < 0) 1311 goto out_putf; type = error; error = -EBADF; if ((type != F_UNLCK) #ifdef MSNFS && !(type & LOCK_MAND) #endif 1319 && !(filp->f_mode & 3)) 1320 goto out_putf; 1322 lock_kernel(); error = flock_lock_file(filp, type, (cmd & (LOCK_UN | LOCK_NB)) ? 0 : 1); 1325 unlock_kernel(); out_putf: fput(filp); out: 1330 return error; } /* Report the first existing lock that would conflict with l. * This implements the F_GETLK command of fcntl(). */ 1336 int fcntl_getlk(unsigned int fd, struct flock *l) { struct file *filp; struct file_lock *fl, file_lock; struct flock flock; int error; error = -EFAULT; 1344 if (copy_from_user(&flock, l, sizeof(flock))) 1345 goto out; error = -EINVAL; 1347 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 1348 goto out; error = -EBADF; filp = fget(fd); 1352 if (!filp) 1353 goto out; error = -EINVAL; 1356 if (!flock_to_posix_lock(filp, &file_lock, &flock)) 1357 goto out_putf; 1359 if (filp->f_op && filp->f_op->lock) { error = filp->f_op->lock(filp, F_GETLK, &file_lock); 1361 if (error < 0) 1362 goto out_putf; 1363 else if (error == LOCK_USE_CLNT) /* Bypass for NFS with no locking - 2.0.36 compat */ fl = posix_test_lock(filp, &file_lock); 1366 else fl = (file_lock.fl_type == F_UNLCK ? NULL : &file_lock); 1368 } else { fl = posix_test_lock(filp, &file_lock); } flock.l_type = F_UNLCK; 1373 if (fl != NULL) { flock.l_pid = fl->fl_pid; #if BITS_PER_LONG == 32 /* * Make sure we can represent the posix lock via * legacy 32bit flock. */ error = -EOVERFLOW; 1381 if (fl->fl_start > OFFT_OFFSET_MAX) 1382 goto out_putf; if ((fl->fl_end != OFFSET_MAX) 1384 && (fl->fl_end > OFFT_OFFSET_MAX)) 1385 goto out_putf; #endif flock.l_start = fl->fl_start; flock.l_len = fl->fl_end == OFFSET_MAX ? 0 : fl->fl_end - fl->fl_start + 1; flock.l_whence = 0; flock.l_type = fl->fl_type; } error = -EFAULT; 1394 if (!copy_to_user(l, &flock, sizeof(flock))) error = 0; out_putf: fput(filp); out: 1400 return error; } /* Apply the lock described by l to an open file descriptor. * This implements both the F_SETLK and F_SETLKW commands of fcntl(). */ 1406 int fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l) { struct file *filp; struct file_lock *file_lock = locks_alloc_lock(0); struct flock flock; struct inode *inode; int error; /* * This might block, so we do it before checking the inode. */ error = -EFAULT; 1418 if (copy_from_user(&flock, l, sizeof(flock))) 1419 goto out; /* Get arguments and validate them ... */ error = -EBADF; filp = fget(fd); 1426 if (!filp) 1427 goto out; error = -EINVAL; inode = filp->f_dentry->d_inode; /* Don't allow mandatory locks on files that may be memory mapped * and shared. */ if (IS_MANDLOCK(inode) && 1436 (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID) { struct address_space *mapping = inode->i_mapping; 1439 if (mapping->i_mmap_shared != NULL) { error = -EAGAIN; 1441 goto out_putf; } } error = -EINVAL; 1446 if (!flock_to_posix_lock(filp, file_lock, &flock)) 1447 goto out_putf; error = -EBADF; 1450 switch (flock.l_type) { 1451 case F_RDLCK: 1452 if (!(filp->f_mode & FMODE_READ)) 1453 goto out_putf; 1454 break; 1455 case F_WRLCK: 1456 if (!(filp->f_mode & FMODE_WRITE)) 1457 goto out_putf; 1458 break; 1459 case F_UNLCK: 1460 break; 1461 case F_SHLCK: 1462 case F_EXLCK: #ifdef __sparc__ /* warn a bit for now, but don't overdo it */ { static int count = 0; if (!count) { count=1; printk(KERN_WARNING "fcntl_setlk() called by process %d (%s) with broken flock() emulation\n", current->pid, current->comm); } } if (!(filp->f_mode & 3)) goto out_putf; break; #endif 1478 default: error = -EINVAL; 1480 goto out_putf; } 1483 if (filp->f_op && filp->f_op->lock != NULL) { error = filp->f_op->lock(filp, cmd, file_lock); 1485 if (error < 0) 1486 goto out_putf; } error = posix_lock_file(filp, file_lock, cmd == F_SETLKW); out_putf: fput(filp); out: locks_free_lock(file_lock); 1494 return error; } #if BITS_PER_LONG == 32 /* Report the first existing lock that would conflict with l. * This implements the F_GETLK command of fcntl(). */ 1501 int fcntl_getlk64(unsigned int fd, struct flock64 *l) { struct file *filp; struct file_lock *fl, file_lock; struct flock64 flock; int error; error = -EFAULT; 1509 if (copy_from_user(&flock, l, sizeof(flock))) 1510 goto out; error = -EINVAL; 1512 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) 1513 goto out; error = -EBADF; filp = fget(fd); 1517 if (!filp) 1518 goto out; error = -EINVAL; 1521 if (!flock64_to_posix_lock(filp, &file_lock, &flock)) 1522 goto out_putf; 1524 if (filp->f_op && filp->f_op->lock) { error = filp->f_op->lock(filp, F_GETLK, &file_lock); 1526 if (error < 0) 1527 goto out_putf; 1528 else if (error == LOCK_USE_CLNT) /* Bypass for NFS with no locking - 2.0.36 compat */ fl = posix_test_lock(filp, &file_lock); 1531 else fl = (file_lock.fl_type == F_UNLCK ? NULL : &file_lock); 1533 } else { fl = posix_test_lock(filp, &file_lock); } flock.l_type = F_UNLCK; 1538 if (fl != NULL) { flock.l_pid = fl->fl_pid; flock.l_start = fl->fl_start; flock.l_len = fl->fl_end == OFFSET_MAX ? 0 : fl->fl_end - fl->fl_start + 1; flock.l_whence = 0; flock.l_type = fl->fl_type; } error = -EFAULT; 1547 if (!copy_to_user(l, &flock, sizeof(flock))) error = 0; out_putf: fput(filp); out: 1553 return error; } /* Apply the lock described by l to an open file descriptor. * This implements both the F_SETLK and F_SETLKW commands of fcntl(). */ 1559 int fcntl_setlk64(unsigned int fd, unsigned int cmd, struct flock64 *l) { struct file *filp; struct file_lock *file_lock = locks_alloc_lock(0); struct flock64 flock; struct inode *inode; int error; /* * This might block, so we do it before checking the inode. */ error = -EFAULT; 1571 if (copy_from_user(&flock, l, sizeof(flock))) 1572 goto out; /* Get arguments and validate them ... */ error = -EBADF; filp = fget(fd); 1579 if (!filp) 1580 goto out; error = -EINVAL; inode = filp->f_dentry->d_inode; /* Don't allow mandatory locks on files that may be memory mapped * and shared. */ if (IS_MANDLOCK(inode) && 1589 (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID) { struct address_space *mapping = inode->i_mapping; 1592 if (mapping->i_mmap_shared != NULL) { error = -EAGAIN; 1594 goto out_putf; } } error = -EINVAL; 1599 if (!flock64_to_posix_lock(filp, file_lock, &flock)) 1600 goto out_putf; error = -EBADF; 1603 switch (flock.l_type) { 1604 case F_RDLCK: 1605 if (!(filp->f_mode & FMODE_READ)) 1606 goto out_putf; 1607 break; 1608 case F_WRLCK: 1609 if (!(filp->f_mode & FMODE_WRITE)) 1610 goto out_putf; 1611 break; 1612 case F_UNLCK: 1613 break; 1614 case F_SHLCK: 1615 case F_EXLCK: 1616 default: error = -EINVAL; 1618 goto out_putf; } 1621 if (filp->f_op && filp->f_op->lock != NULL) { error = filp->f_op->lock(filp, cmd, file_lock); 1623 if (error < 0) 1624 goto out_putf; } error = posix_lock_file(filp, file_lock, cmd == F_SETLKW64); out_putf: fput(filp); out: locks_free_lock(file_lock); 1632 return error; } #endif /* BITS_PER_LONG == 32 */ /* * This function is called when the file is being removed * from the task's fd array. */ 1640 void locks_remove_posix(struct file *filp, fl_owner_t owner) { struct inode * inode = filp->f_dentry->d_inode; struct file_lock *fl; struct file_lock **before; /* * For POSIX locks we free all locks on this file for the given task. */ 1649 if (!inode->i_flock) { /* * Notice that something might be grabbing a lock right now. * Consider it as a race won by us - event is async, so even if * we miss the lock added we can trivially consider it as added * after we went through this call. */ 1656 return; } 1658 lock_kernel(); before = &inode->i_flock; 1660 while ((fl = *before) != NULL) { 1661 if ((fl->fl_flags & FL_POSIX) && fl->fl_owner == owner) { locks_unlock_delete(before); 1663 continue; } before = &fl->fl_next; } 1667 unlock_kernel(); } /* * This function is called on the last close of an open file. */ 1673 void locks_remove_flock(struct file *filp) { struct inode * inode = filp->f_dentry->d_inode; struct file_lock *fl; struct file_lock **before; 1679 if (!inode->i_flock) 1680 return; 1682 lock_kernel(); before = &inode->i_flock; 1685 while ((fl = *before) != NULL) { if ((fl->fl_flags & (FL_FLOCK|FL_LEASE)) 1687 && (fl->fl_file == filp)) { locks_delete_lock(before, 0); 1689 continue; } before = &fl->fl_next; } 1693 unlock_kernel(); } /** * posix_block_lock - blocks waiting for a file lock * @blocker: the lock which is blocking * @waiter: the lock which conflicts and has to wait * * lockd needs to block waiting for locks. */ void 1704 posix_block_lock(struct file_lock *blocker, struct file_lock *waiter) { locks_insert_block(blocker, waiter); } /** * posix_unblock_lock - stop waiting for a file lock * @waiter: the lock which was waiting * * lockd needs to block waiting for locks. */ void 1716 posix_unblock_lock(struct file_lock *waiter) { 1718 if (!list_empty(&waiter->fl_block)) locks_delete_block(waiter); } 1722 static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx) { struct inode *inode = NULL; 1726 if (fl->fl_file != NULL) inode = fl->fl_file->f_dentry->d_inode; out += sprintf(out, "%d:%s ", id, pfx); 1730 if (fl->fl_flags & FL_POSIX) { out += sprintf(out, "%6s %s ", (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ", (inode == NULL) ? "*NOINODE*" : (IS_MANDLOCK(inode) && (inode->i_mode & (S_IXGRP | S_ISGID)) == S_ISGID) ? "MANDATORY" : "ADVISORY "); 1737 } else if (fl->fl_flags & FL_FLOCK) { #ifdef MSNFS 1739 if (fl->fl_type & LOCK_MAND) { out += sprintf(out, "FLOCK MSNFS "); 1741 } else #endif out += sprintf(out, "FLOCK ADVISORY "); 1744 } else if (fl->fl_flags & FL_LEASE) { out += sprintf(out, "LEASE MANDATORY "); 1746 } else { out += sprintf(out, "UNKNOWN UNKNOWN "); } #ifdef MSNFS 1750 if (fl->fl_type & LOCK_MAND) { out += sprintf(out, "%s ", (fl->fl_type & LOCK_READ) ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ " : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE "); 1755 } else #endif out += sprintf(out, "%s ", (fl->fl_type & F_WRLCK) ? "WRITE" : "READ "); out += sprintf(out, "%d %s:%ld ", fl->fl_pid, inode ? kdevname(inode->i_dev) : "<none>", inode ? inode->i_ino : 0); out += sprintf(out, "%Ld ", fl->fl_start); 1764 if (fl->fl_end == OFFSET_MAX) out += sprintf(out, "EOF "); 1766 else out += sprintf(out, "%Ld ", fl->fl_end); sprintf(out, "%08lx %08lx %08lx %08lx %08lx\n", (long)fl, (long)fl->fl_link.prev, (long)fl->fl_link.next, (long)fl->fl_next, (long)fl->fl_block.next); } 1773 static void move_lock_status(char **p, off_t* pos, off_t offset) { int len; len = strlen(*p); 1777 if(*pos >= offset) { /* the complete line is valid */ *p += len; *pos += len; 1781 return; } 1783 if(*pos+len > offset) { /* use the second part of the line */ int i = offset-*pos; memmove(*p,*p+i,len-i); *p += len-i; *pos += len; 1789 return; } /* discard the complete line */ *pos += len; } /** * get_locks_status - reports lock usage in /proc/locks * @buffer: address in userspace to write into * @start: ? * @offset: how far we are through the buffer * @length: how much to read */ 1803 int get_locks_status(char *buffer, char **start, off_t offset, int length) { struct list_head *tmp; char *q = buffer; off_t pos = 0; int i = 0; 1810 lock_kernel(); 1811 list_for_each(tmp, &file_lock_list) { struct list_head *btmp; struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link); lock_get_status(q, fl, ++i, ""); move_lock_status(&q, &pos, offset); 1817 if(pos >= offset+length) 1818 goto done; 1820 list_for_each(btmp, &fl->fl_block) { struct file_lock *bfl = list_entry(btmp, struct file_lock, fl_block); lock_get_status(q, bfl, i, " ->"); move_lock_status(&q, &pos, offset); 1826 if(pos >= offset+length) 1827 goto done; } } done: 1831 unlock_kernel(); *start = buffer; 1833 if(q-buffer < length) 1834 return (q-buffer); 1835 return length; } #ifdef MSNFS /** * lock_may_read - checks that the region is free of locks * @inode: the inode that is being read * @start: the first byte to read * @len: the number of bytes to read * * Emulates Windows locking requirements. Whole-file * mandatory locks (share modes) can prohibit a read and * byte-range POSIX locks can prohibit a read if they overlap. * * N.B. this function is only ever called * from knfsd and ownership of locks is never checked. */ 1852 int lock_may_read(struct inode *inode, loff_t start, unsigned long len) { struct file_lock *fl; int result = 1; 1856 lock_kernel(); 1857 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 1858 if (fl->fl_flags == FL_POSIX) { 1859 if (fl->fl_type == F_RDLCK) 1860 continue; 1861 if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 1862 continue; 1863 } else if (fl->fl_flags == FL_FLOCK) { 1864 if (!(fl->fl_type & LOCK_MAND)) 1865 continue; 1866 if (fl->fl_type & LOCK_READ) 1867 continue; 1868 } else 1869 continue; result = 0; 1871 break; } 1873 unlock_kernel(); 1874 return result; } /** * lock_may_write - checks that the region is free of locks * @inode: the inode that is being written * @start: the first byte to write * @len: the number of bytes to write * * Emulates Windows locking requirements. Whole-file * mandatory locks (share modes) can prohibit a write and * byte-range POSIX locks can prohibit a write if they overlap. * * N.B. this function is only ever called * from knfsd and ownership of locks is never checked. */ 1890 int lock_may_write(struct inode *inode, loff_t start, unsigned long len) { struct file_lock *fl; int result = 1; 1894 lock_kernel(); 1895 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 1896 if (fl->fl_flags == FL_POSIX) { 1897 if ((fl->fl_end < start) || (fl->fl_start > (start + len))) 1898 continue; 1899 } else if (fl->fl_flags == FL_FLOCK) { 1900 if (!(fl->fl_type & LOCK_MAND)) 1901 continue; 1902 if (fl->fl_type & LOCK_WRITE) 1903 continue; 1904 } else 1905 continue; result = 0; 1907 break; } 1909 unlock_kernel(); 1910 return result; } #endif 1914 static int __init filelock_init(void) { filelock_cache = kmem_cache_create("file lock cache", sizeof(struct file_lock), 0, 0, init_once, NULL); 1918 if (!filelock_cache) panic("cannot create file lock slab cache"); 1920 return 0; } module_init(filelock_init)