/* *  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 'Documentation/filesystems/mandatory-locking.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@debian.org>, March, 2000. * *  Leases and LOCK_MAND *  Matthew Wilcox <willy@debian.org>, June, 2000. *  Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000. */ #include <linux/capability.h>#include <linux/file.h>#include <linux/fdtable.h>#include <linux/fs.h>#include <linux/init.h>#include <linux/module.h>#include <linux/security.h>#include <linux/slab.h>#include <linux/syscalls.h>#include <linux/time.h>#include <linux/rcupdate.h>#include <linux/pid_namespace.h>#include <linux/hashtable.h>#include <linux/percpu.h>#include <linux/lglock.h> #define CREATE_TRACE_POINTS#include <trace/events/filelock.h> #include <asm/uaccess.h> #define IS_POSIX(fl)	(fl->fl_flags & FL_POSIX)#define IS_FLOCK(fl)	(fl->fl_flags & FL_FLOCK)#define IS_LEASE(fl)	(fl->fl_flags & (FL_LEASE|FL_DELEG|FL_LAYOUT))#define IS_OFDLCK(fl)	(fl->fl_flags & FL_OFDLCK) static bool lease_breaking(struct file_lock *fl){	return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING);} static int target_leasetype(struct file_lock *fl){	if (fl->fl_flags & FL_UNLOCK_PENDING)		return F_UNLCK;	if (fl->fl_flags & FL_DOWNGRADE_PENDING)		return F_RDLCK;	return fl->fl_type;} int leases_enable = 1;int lease_break_time = 45; /* * The global file_lock_list is only used for displaying /proc/locks, so we * keep a list on each CPU, with each list protected by its own spinlock via * the file_lock_lglock. Note that alterations to the list also require that * the relevant flc_lock is held. */DEFINE_STATIC_LGLOCK(file_lock_lglock);static DEFINE_PER_CPU(struct hlist_head, file_lock_list); /* * The blocked_hash is used to find POSIX lock loops for deadlock detection. * It is protected by blocked_lock_lock. * * We hash locks by lockowner in order to optimize searching for the lock a * particular lockowner is waiting on. * * FIXME: make this value scale via some heuristic? We generally will want more * buckets when we have more lockowners holding locks, but that's a little * difficult to determine without knowing what the workload will look like. */#define BLOCKED_HASH_BITS	7static DEFINE_HASHTABLE(blocked_hash, BLOCKED_HASH_BITS); /* * This lock protects the blocked_hash. Generally, if you're accessing it, you * want to be holding this lock. * * In addition, it also protects the fl->fl_block list, and the fl->fl_next * pointer for file_lock structures that are acting as lock requests (in * contrast to those that are acting as records of acquired locks). * * Note that when we acquire this lock in order to change the above fields, * we often hold the flc_lock as well. In certain cases, when reading the fields * protected by this lock, we can skip acquiring it iff we already hold the * flc_lock. * * In particular, adding an entry to the fl_block list requires that you hold * both the flc_lock and the blocked_lock_lock (acquired in that order). * Deleting an entry from the list however only requires the file_lock_lock. */static DEFINE_SPINLOCK(blocked_lock_lock); static struct kmem_cache *flctx_cache __read_mostly;static struct kmem_cache *filelock_cache __read_mostly; static struct file_lock_context *locks_get_lock_context(struct inode *inode, int type){	struct file_lock_context *new; 	if (likely(inode->i_flctx) || type == F_UNLCK)		goto out; 	new = kmem_cache_alloc(flctx_cache, GFP_KERNEL);	if (!new)		goto out; 	spin_lock_init(&new->flc_lock);	INIT_LIST_HEAD(&new->flc_flock);	INIT_LIST_HEAD(&new->flc_posix);	INIT_LIST_HEAD(&new->flc_lease); 	/*	 * Assign the pointer if it's not already assigned. If it is, then	 * free the context we just allocated.	 */	if (cmpxchg(&inode->i_flctx, NULL, new))		kmem_cache_free(flctx_cache, new);out:	return inode->i_flctx;} voidlocks_free_lock_context(struct file_lock_context *ctx){	if (ctx) {		WARN_ON_ONCE(!list_empty(&ctx->flc_flock));		WARN_ON_ONCE(!list_empty(&ctx->flc_posix));		WARN_ON_ONCE(!list_empty(&ctx->flc_lease));		kmem_cache_free(flctx_cache, ctx);	}} static void locks_init_lock_heads(struct file_lock *fl){	INIT_HLIST_NODE(&fl->fl_link);	INIT_LIST_HEAD(&fl->fl_list);	INIT_LIST_HEAD(&fl->fl_block);	init_waitqueue_head(&fl->fl_wait);} /* Allocate an empty lock structure. */struct file_lock *locks_alloc_lock(void){	struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL); 	if (fl)		locks_init_lock_heads(fl); 	return fl;}EXPORT_SYMBOL_GPL(locks_alloc_lock); void locks_release_private(struct file_lock *fl){	if (fl->fl_ops) {		if (fl->fl_ops->fl_release_private)			fl->fl_ops->fl_release_private(fl);		fl->fl_ops = NULL;	} 	if (fl->fl_lmops) {		if (fl->fl_lmops->lm_put_owner) {			fl->fl_lmops->lm_put_owner(fl->fl_owner);			fl->fl_owner = NULL;		}		fl->fl_lmops = NULL;	}}EXPORT_SYMBOL_GPL(locks_release_private); /* Free a lock which is not in use. */void locks_free_lock(struct file_lock *fl){	BUG_ON(waitqueue_active(&fl->fl_wait));	BUG_ON(!list_empty(&fl->fl_list));	BUG_ON(!list_empty(&fl->fl_block));	BUG_ON(!hlist_unhashed(&fl->fl_link)); 	locks_release_private(fl);	kmem_cache_free(filelock_cache, fl);}EXPORT_SYMBOL(locks_free_lock); static voidlocks_dispose_list(struct list_head *dispose){	struct file_lock *fl; 	while (!list_empty(dispose)) {		fl = list_first_entry(dispose, struct file_lock, fl_list);		list_del_init(&fl->fl_list);		locks_free_lock(fl);	}} void locks_init_lock(struct file_lock *fl){	memset(fl, 0, sizeof(struct file_lock));	locks_init_lock_heads(fl);} EXPORT_SYMBOL(locks_init_lock); /* * Initialize a new lock from an existing file_lock structure. */void locks_copy_conflock(struct file_lock *new, struct file_lock *fl){	new->fl_owner = fl->fl_owner;	new->fl_pid = fl->fl_pid;	new->fl_file = NULL;	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_lmops = fl->fl_lmops;	new->fl_ops = NULL; 	if (fl->fl_lmops) {		if (fl->fl_lmops->lm_get_owner)			fl->fl_lmops->lm_get_owner(fl->fl_owner);	}}EXPORT_SYMBOL(locks_copy_conflock); void locks_copy_lock(struct file_lock *new, struct file_lock *fl){	/* "new" must be a freshly-initialized lock */	WARN_ON_ONCE(new->fl_ops); 	locks_copy_conflock(new, fl); 	new->fl_file = fl->fl_file;	new->fl_ops = fl->fl_ops; 	if (fl->fl_ops) {		if (fl->fl_ops->fl_copy_lock)			fl->fl_ops->fl_copy_lock(new, fl);	}} EXPORT_SYMBOL(locks_copy_lock); static inline int flock_translate_cmd(int cmd) {	if (cmd & LOCK_MAND)		return cmd & (LOCK_MAND | LOCK_RW);	switch (cmd) {	case LOCK_SH:		return F_RDLCK;	case LOCK_EX:		return F_WRLCK;	case LOCK_UN:		return F_UNLCK;	}	return -EINVAL;} /* Fill in a file_lock structure with an appropriate FLOCK lock. */static struct file_lock *flock_make_lock(struct file *filp, unsigned int cmd){	struct file_lock *fl;	int type = flock_translate_cmd(cmd); 	if (type < 0)		return ERR_PTR(type);		fl = locks_alloc_lock();	if (fl == NULL)		return ERR_PTR(-ENOMEM); 	fl->fl_file = filp;	fl->fl_owner = filp;	fl->fl_pid = current->tgid;	fl->fl_flags = FL_FLOCK;	fl->fl_type = type;	fl->fl_end = OFFSET_MAX;		return fl;} static int assign_type(struct file_lock *fl, long type){	switch (type) {	case F_RDLCK:	case F_WRLCK:	case F_UNLCK:		fl->fl_type = type;		break;	default:		return -EINVAL;	}	return 0;} static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,				 struct flock64 *l){	switch (l->l_whence) {	case SEEK_SET:		fl->fl_start = 0;		break;	case SEEK_CUR:		fl->fl_start = filp->f_pos;		break;	case SEEK_END:		fl->fl_start = i_size_read(file_inode(filp));		break;	default:		return -EINVAL;	}	if (l->l_start > OFFSET_MAX - fl->fl_start)		return -EOVERFLOW;	fl->fl_start += l->l_start;	if (fl->fl_start < 0)		return -EINVAL; 	/* POSIX-1996 leaves the case l->l_len < 0 undefined;	   POSIX-2001 defines it. */	if (l->l_len > 0) {		if (l->l_len - 1 > OFFSET_MAX - fl->fl_start)			return -EOVERFLOW;		fl->fl_end = fl->fl_start + l->l_len - 1; 	} else if (l->l_len < 0) {		if (fl->fl_start + l->l_len < 0)			return -EINVAL;		fl->fl_end = fl->fl_start - 1;		fl->fl_start += l->l_len;	} else		fl->fl_end = OFFSET_MAX; 	fl->fl_owner = current->files;	fl->fl_pid = current->tgid;	fl->fl_file = filp;	fl->fl_flags = FL_POSIX;	fl->fl_ops = NULL;	fl->fl_lmops = NULL; 	return assign_type(fl, l->l_type);} /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX * style lock. */static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,			       struct flock *l){	struct flock64 ll = {		.l_type = l->l_type,		.l_whence = l->l_whence,		.l_start = l->l_start,		.l_len = l->l_len,	}; 	return flock64_to_posix_lock(filp, fl, &ll);} /* default lease lock manager operations */static boollease_break_callback(struct file_lock *fl){	kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG);	return false;} static voidlease_setup(struct file_lock *fl, void **priv){	struct file *filp = fl->fl_file;	struct fasync_struct *fa = *priv; 	/*	 * fasync_insert_entry() returns the old entry if any. If there was no	 * old entry, then it used "priv" and inserted it into the fasync list.	 * Clear the pointer to indicate that it shouldn't be freed.	 */	if (!fasync_insert_entry(fa->fa_fd, filp, &fl->fl_fasync, fa))		*priv = NULL; 	__f_setown(filp, task_pid(current), PIDTYPE_PID, 0);} static const struct lock_manager_operations lease_manager_ops = {	.lm_break = lease_break_callback,	.lm_change = lease_modify,	.lm_setup = lease_setup,}; /*

Lines 1–500 of 2701. Load more