Commit 6d50ff91 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'locks-v4.1-1' of git://git.samba.org/jlayton/linux 

Pull file locking related changes from Jeff Layton:
 "This set is mostly minor cleanups to the overhaul that went in last
  cycle.  The other noticeable items are the changes to the lm_get_owner
  and lm_put_owner prototypes, and the fact that we no longer need to
  use the i_lock to protect the i_flctx pointer"

* tag 'locks-v4.1-1' of git://git.samba.org/jlayton/linux:
  locks: use cmpxchg to assign i_flctx pointer
  locks: get rid of WE_CAN_BREAK_LSLK_NOW dead code
  locks: change lm_get_owner and lm_put_owner prototypes
  locks: don't allocate a lock context for an F_UNLCK request
  locks: Add lockdep assertion for blocked_lock_lock
  locks: remove extraneous IS_POSIX and IS_FLOCK tests
  locks: Remove unnecessary IS_POSIX test
parents eccd02f3 0429c2b5

fs/locks.c

+27 −29
Original line number Diff line number Diff line
@@ -203,11 +203,11 @@ 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)

locks_get_lock_context(struct inode *inode, int type)

{

	struct file_lock_context *new;



	if (likely(inode->i_flctx))

	if (likely(inode->i_flctx) || type == F_UNLCK)

		goto out;



	new = kmem_cache_alloc(flctx_cache, GFP_KERNEL);
@@ -223,14 +223,7 @@ locks_get_lock_context(struct inode *inode) 
	 * Assign the pointer if it's not already assigned. If it is, then

	 * free the context we just allocated.

	 */

	spin_lock(&inode->i_lock);

	if (likely(!inode->i_flctx)) {

		inode->i_flctx = new;

		new = NULL;

	}

	spin_unlock(&inode->i_lock);



	if (new)

	if (cmpxchg(&inode->i_flctx, NULL, new))

		kmem_cache_free(flctx_cache, new);

out:

	return inode->i_flctx;
@@ -276,8 +269,10 @@ void locks_release_private(struct file_lock *fl) 
	}



	if (fl->fl_lmops) {

		if (fl->fl_lmops->lm_put_owner)

			fl->fl_lmops->lm_put_owner(fl);

		if (fl->fl_lmops->lm_put_owner) {

			fl->fl_lmops->lm_put_owner(fl->fl_owner);

			fl->fl_owner = NULL;

		}

		fl->fl_lmops = NULL;

	}

}
@@ -333,7 +328,7 @@ void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) 


	if (fl->fl_lmops) {

		if (fl->fl_lmops->lm_get_owner)

			fl->fl_lmops->lm_get_owner(new, fl);

			fl->fl_lmops->lm_get_owner(fl->fl_owner);

	}

}

EXPORT_SYMBOL(locks_copy_conflock);
@@ -592,11 +587,15 @@ posix_owner_key(struct file_lock *fl) 


static void locks_insert_global_blocked(struct file_lock *waiter)

{

	lockdep_assert_held(&blocked_lock_lock);



	hash_add(blocked_hash, &waiter->fl_link, posix_owner_key(waiter));

}



static void locks_delete_global_blocked(struct file_lock *waiter)

{

	lockdep_assert_held(&blocked_lock_lock);



	hash_del(&waiter->fl_link);

}
@@ -730,7 +729,7 @@ static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *s 
	/* POSIX locks owned by the same process do not conflict with

	 * each other.

	 */

	if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl))

	if (posix_same_owner(caller_fl, sys_fl))

		return (0);



	/* Check whether they overlap */
@@ -748,7 +747,7 @@ static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *s 
	/* FLOCK locks referring to the same filp do not conflict with

	 * each other.

	 */

	if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file))

	if (caller_fl->fl_file == sys_fl->fl_file)

		return (0);

	if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))

		return 0;
@@ -838,6 +837,8 @@ static int posix_locks_deadlock(struct file_lock *caller_fl, 
{

	int i = 0;



	lockdep_assert_held(&blocked_lock_lock);



	/*

	 * This deadlock detector can't reasonably detect deadlocks with

	 * FL_OFDLCK locks, since they aren't owned by a process, per-se.
@@ -871,9 +872,12 @@ static int flock_lock_file(struct file *filp, struct file_lock *request) 
	bool found = false;

	LIST_HEAD(dispose);



	ctx = locks_get_lock_context(inode);

	if (!ctx)

	ctx = locks_get_lock_context(inode, request->fl_type);

	if (!ctx) {

		if (request->fl_type != F_UNLCK)

			return -ENOMEM;

		return (request->fl_flags & FL_EXISTS) ? -ENOENT : 0;

	}



	if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) {

		new_fl = locks_alloc_lock();
@@ -939,9 +943,9 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request, str 
	bool added = false;

	LIST_HEAD(dispose);



	ctx = locks_get_lock_context(inode);

	ctx = locks_get_lock_context(inode, request->fl_type);

	if (!ctx)

		return -ENOMEM;

		return (request->fl_type == F_UNLCK) ? 0 : -ENOMEM;



	/*

	 * We may need two file_lock structures for this operation,
@@ -964,8 +968,6 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request, str 
	 */

	if (request->fl_type != F_UNLCK) {

		list_for_each_entry(fl, &ctx->flc_posix, fl_list) {

			if (!IS_POSIX(fl))

				continue;

			if (!posix_locks_conflict(request, fl))

				continue;

			if (conflock)
@@ -1605,7 +1607,8 @@ generic_add_lease(struct file *filp, long arg, struct file_lock **flp, void **pr 
	lease = *flp;

	trace_generic_add_lease(inode, lease);



	ctx = locks_get_lock_context(inode);

	/* Note that arg is never F_UNLCK here */

	ctx = locks_get_lock_context(inode, arg);

	if (!ctx)

		return -ENOMEM;
@@ -2555,15 +2558,10 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl, 
			       : (fl->fl_type == F_WRLCK) ? "WRITE" : "READ ");

	}

	if (inode) {

#ifdef WE_CAN_BREAK_LSLK_NOW

		seq_printf(f, "%d %s:%ld ", fl_pid,

				inode->i_sb->s_id, inode->i_ino);

#else

		/* userspace relies on this representation of dev_t ;-( */

		/* userspace relies on this representation of dev_t */

		seq_printf(f, "%d %02x:%02x:%ld ", fl_pid,

				MAJOR(inode->i_sb->s_dev),

				MINOR(inode->i_sb->s_dev), inode->i_ino);

#endif

	} else {

		seq_printf(f, "%d <none>:0 ", fl_pid);

	}

fs/nfsd/nfs4state.c

+10 −8
Original line number Diff line number Diff line
@@ -4932,20 +4932,22 @@ nfs4_transform_lock_offset(struct file_lock *lock) 
		lock->fl_end = OFFSET_MAX;

}



static void nfsd4_fl_get_owner(struct file_lock *dst, struct file_lock *src)

static fl_owner_t

nfsd4_fl_get_owner(fl_owner_t owner)

{

	struct nfs4_lockowner *lo = (struct nfs4_lockowner *)src->fl_owner;

	dst->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lo->lo_owner));

	struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;



	nfs4_get_stateowner(&lo->lo_owner);

	return owner;

}



static void nfsd4_fl_put_owner(struct file_lock *fl)

static void

nfsd4_fl_put_owner(fl_owner_t owner)

{

	struct nfs4_lockowner *lo = (struct nfs4_lockowner *)fl->fl_owner;

	struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;



	if (lo) {

	if (lo)

		nfs4_put_stateowner(&lo->lo_owner);

		fl->fl_owner = NULL;

	}

}



static const struct lock_manager_operations nfsd_posix_mng_ops  = {

include/linux/fs.h

+2 −2
Original line number Diff line number Diff line
@@ -915,8 +915,8 @@ struct file_lock_operations { 
struct lock_manager_operations {

	int (*lm_compare_owner)(struct file_lock *, struct file_lock *);

	unsigned long (*lm_owner_key)(struct file_lock *);

	void (*lm_get_owner)(struct file_lock *, struct file_lock *);

	void (*lm_put_owner)(struct file_lock *);

	fl_owner_t (*lm_get_owner)(fl_owner_t);

	void (*lm_put_owner)(fl_owner_t);

	void (*lm_notify)(struct file_lock *);	/* unblock callback */

	int (*lm_grant)(struct file_lock *, int);

	bool (*lm_break)(struct file_lock *);

CRA Git | Maintained and supported by SUSTech CRA and CCSE