/* *  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/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> #define CREATE_TRACE_POINTS#include <trace/events/filelock.h> #include <linux/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 inline bool is_remote_lock(struct file *filp){	return likely(!(filp->f_path.dentry->d_sb->s_flags & MS_NOREMOTELOCK));} 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. * Global serialization is done using file_rwsem. * * Note that alterations to the list also require that the relevant flc_lock is * held. */struct file_lock_list_struct {	spinlock_t		lock;	struct hlist_head	hlist;};static DEFINE_PER_CPU(struct file_lock_list_struct, file_lock_list);DEFINE_STATIC_PERCPU_RWSEM(file_rwsem); /* * 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 *ctx; 	/* paired with cmpxchg() below */	ctx = smp_load_acquire(&inode->i_flctx);	if (likely(ctx) || type == F_UNLCK)		goto out; 	ctx = kmem_cache_alloc(flctx_cache, GFP_KERNEL);	if (!ctx)		goto out; 	spin_lock_init(&ctx->flc_lock);	INIT_LIST_HEAD(&ctx->flc_flock);	INIT_LIST_HEAD(&ctx->flc_posix);	INIT_LIST_HEAD(&ctx->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, ctx)) {		kmem_cache_free(flctx_cache, ctx);		ctx = smp_load_acquire(&inode->i_flctx);	}out:	trace_locks_get_lock_context(inode, type, ctx);	return ctx;} static voidlocks_dump_ctx_list(struct list_head *list, char *list_type){	struct file_lock *fl; 	list_for_each_entry(fl, list, fl_list) {		pr_warn("%s: fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n", list_type, fl->fl_owner, fl->fl_flags, fl->fl_type, fl->fl_pid);	}} static voidlocks_check_ctx_lists(struct inode *inode){	struct file_lock_context *ctx = inode->i_flctx; 	if (unlikely(!list_empty(&ctx->flc_flock) ||		     !list_empty(&ctx->flc_posix) ||		     !list_empty(&ctx->flc_lease))) {		pr_warn("Leaked locks on dev=0x%x:0x%x ino=0x%lx:\n",			MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),			inode->i_ino);		locks_dump_ctx_list(&ctx->flc_flock, "FLOCK");		locks_dump_ctx_list(&ctx->flc_posix, "POSIX");		locks_dump_ctx_list(&ctx->flc_lease, "LEASE");	}} voidlocks_free_lock_context(struct inode *inode){	struct file_lock_context *ctx = inode->i_flctx; 	if (unlikely(ctx)) {		locks_check_ctx_lists(inode);		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 = {

Lines 1–500 of 2795. Load more