/* *  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> #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)) 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; #define for_each_lock(inode, lockp) \	for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next) /* * 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 i_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 i_lock as well. In certain cases, when reading the fields * protected by this lock, we can skip acquiring it iff we already hold the * i_lock. * * In particular, adding an entry to the fl_block list requires that you hold * both the i_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 *filelock_cache __read_mostly; static void locks_init_lock_heads(struct file_lock *fl){	INIT_HLIST_NODE(&fl->fl_link);	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;	}	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_block));	BUG_ON(!hlist_unhashed(&fl->fl_link)); 	locks_release_private(fl);	kmem_cache_free(filelock_cache, fl);}EXPORT_SYMBOL(locks_free_lock); 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); static void locks_copy_private(struct file_lock *new, struct file_lock *fl){	if (fl->fl_ops) {		if (fl->fl_ops->fl_copy_lock)			fl->fl_ops->fl_copy_lock(new, fl);		new->fl_ops = fl->fl_ops;	}	if (fl->fl_lmops)		new->fl_lmops = fl->fl_lmops;} /* * Initialize a new lock from an existing file_lock structure. */void __locks_copy_lock(struct file_lock *new, const 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_ops = NULL;	new->fl_lmops = NULL;}EXPORT_SYMBOL(__locks_copy_lock); void locks_copy_lock(struct file_lock *new, struct file_lock *fl){	locks_release_private(new); 	__locks_copy_lock(new, fl);	new->fl_file = fl->fl_file;	new->fl_ops = fl->fl_ops;	new->fl_lmops = fl->fl_lmops; 	locks_copy_private(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 int flock_make_lock(struct file *filp, struct file_lock **lock,		unsigned int cmd){	struct file_lock *fl;	int type = flock_translate_cmd(cmd);	if (type < 0)		return type;		fl = locks_alloc_lock();	if (fl == NULL)		return -ENOMEM; 	fl->fl_file = filp;	fl->fl_pid = current->tgid;	fl->fl_flags = FL_FLOCK;	fl->fl_type = type;	fl->fl_end = OFFSET_MAX;		*lock = fl;	return 0;} 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;} /* 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){	off_t start, end; 	switch (l->l_whence) {	case SEEK_SET:		start = 0;		break;	case SEEK_CUR:		start = filp->f_pos;		break;	case SEEK_END:		start = i_size_read(file_inode(filp));		break;	default:		return -EINVAL;	} 	/* POSIX-1996 leaves the case l->l_len < 0 undefined;	   POSIX-2001 defines it. */	start += l->l_start;	if (start < 0)		return -EINVAL;	fl->fl_end = OFFSET_MAX;	if (l->l_len > 0) {		end = start + l->l_len - 1;		fl->fl_end = end;	} else if (l->l_len < 0) {		end = start - 1;		fl->fl_end = end;		start += l->l_len;		if (start < 0)			return -EINVAL;	}	fl->fl_start = start;	/* we record the absolute position */	if (fl->fl_end < fl->fl_start)		return -EOVERFLOW;		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);} #if BITS_PER_LONG == 32static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,				 struct flock64 *l){	loff_t start; 	switch (l->l_whence) {	case SEEK_SET:		start = 0;		break;	case SEEK_CUR:		start = filp->f_pos;		break;	case SEEK_END:		start = i_size_read(file_inode(filp));		break;	default:		return -EINVAL;	} 	start += l->l_start;	if (start < 0)		return -EINVAL;	fl->fl_end = OFFSET_MAX;	if (l->l_len > 0) {		fl->fl_end = start + l->l_len - 1;	} else if (l->l_len < 0) {		fl->fl_end = start - 1;		start += l->l_len;		if (start < 0)			return -EINVAL;	}	fl->fl_start = start;	/* we record the absolute position */	if (fl->fl_end < fl->fl_start)		return -EOVERFLOW;		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);}#endif /* default lease lock manager operations */static void lease_break_callback(struct file_lock *fl){	kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG);} static const struct lock_manager_operations lease_manager_ops = {	.lm_break = lease_break_callback,	.lm_change = lease_modify,}; /* * Initialize a lease, use the default lock manager operations */static int lease_init(struct file *filp, long type, struct file_lock *fl) {	if (assign_type(fl, type) != 0)		return -EINVAL; 	fl->fl_owner = current->files;	fl->fl_pid = current->tgid; 	fl->fl_file = filp;	fl->fl_flags = FL_LEASE;	fl->fl_start = 0;	fl->fl_end = OFFSET_MAX;	fl->fl_ops = NULL;	fl->fl_lmops = &lease_manager_ops;	return 0;} /* Allocate a file_lock initialised to this type of lease */static struct file_lock *lease_alloc(struct file *filp, long type){	struct file_lock *fl = locks_alloc_lock();	int error = -ENOMEM; 	if (fl == NULL)		return ERR_PTR(error); 	error = lease_init(filp, type, fl);	if (error) {		locks_free_lock(fl);		return ERR_PTR(error);	}	return fl;} /* Check if two locks overlap each other. */static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2){	return ((fl1->fl_end >= fl2->fl_start) &&		(fl2->fl_end >= fl1->fl_start));}

Lines 1–500 of 2534. Load more