locks: add a dedicated spinlock to protect i_flctx lists

	ctx = inode->i_flctx;

	if (ctx) {

		spin_lock(&inode->i_lock);

		spin_lock(&ctx->flc_lock);

		list_for_each_entry(lock, &ctx->flc_posix, fl_list)

			++(*fcntl_count);

		list_for_each_entry(lock, &ctx->flc_flock, fl_list)

			++(*flock_count);

		spin_unlock(&inode->i_lock);

		spin_unlock(&ctx->flc_lock);

	}

	dout("counted %d flock locks and %d fcntl locks",

	     *flock_count, *fcntl_count);

	if (!ctx)

		return 0;

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

	list_for_each_entry(lock, &ctx->flc_flock, fl_list) {

		++seen_fcntl;

		if (seen_fcntl > num_fcntl_locks) {

		++l;

	}

fail:

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	return err;

}

	if (!flctx)

		goto out;

	spin_lock(&inode->i_lock);

	spin_lock(&flctx->flc_lock);

	list_for_each(el, &flctx->flc_posix) {

		count++;

	}

	spin_unlock(&inode->i_lock);

	spin_unlock(&flctx->flc_lock);

	INIT_LIST_HEAD(&locks_to_send);

	}

	el = locks_to_send.next;

	spin_lock(&inode->i_lock);

	spin_lock(&flctx->flc_lock);

	list_for_each_entry(flock, &flctx->flc_posix, fl_list) {

		if (el == &locks_to_send) {

			/*

		lck->type = type;

		lck->offset = flock->fl_start;

	}

	spin_unlock(&inode->i_lock);

	spin_unlock(&flctx->flc_lock);

	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {

		int stored_rc;

		return 0;

again:

	file->f_locks = 0;

	spin_lock(&inode->i_lock);

	spin_lock(&flctx->flc_lock);

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

		if (fl->fl_lmops != &nlmsvc_lock_operations)

			continue;

		if (match(lockhost, host)) {

			struct file_lock lock = *fl;

			spin_unlock(&inode->i_lock);

			spin_unlock(&flctx->flc_lock);

			lock.fl_type  = F_UNLCK;

			lock.fl_start = 0;

			lock.fl_end   = OFFSET_MAX;

			goto again;

		}

	}

	spin_unlock(&inode->i_lock);

	spin_unlock(&flctx->flc_lock);

	return 0;

}

		return 1;

	if (flctx && !list_empty_careful(&flctx->flc_posix)) {

		spin_lock(&inode->i_lock);

		spin_lock(&flctx->flc_lock);

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

			if (fl->fl_lmops == &nlmsvc_lock_operations) {

				spin_unlock(&inode->i_lock);

				spin_unlock(&flctx->flc_lock);

				return 1;

			}

		}

		spin_unlock(&inode->i_lock);

		spin_unlock(&flctx->flc_lock);

	}

	file->f_locks = 0;

	return 0;

 * 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.

 * the relevant flc_lock is held.

 */

DEFINE_STATIC_LGLOCK(file_lock_lglock);

static DEFINE_PER_CPU(struct hlist_head, file_lock_list);

 * 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

 * 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

 * i_lock.

 * flc_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.

 * 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);

	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);

	return fl1->fl_owner == fl2->fl_owner;

}

/* Must be called with the i_lock held! */

/* Must be called with the flc_lock held! */

static void locks_insert_global_locks(struct file_lock *fl)

{

	lg_local_lock(&file_lock_lglock);

	lg_local_unlock(&file_lock_lglock);

}

/* Must be called with the i_lock held! */

/* Must be called with the flc_lock held! */

static void locks_delete_global_locks(struct file_lock *fl)

{

	/*

	 * Avoid taking lock if already unhashed. This is safe since this check

	 * is done while holding the i_lock, and new insertions into the list

	 * is done while holding the flc_lock, and new insertions into the list

	 * also require that it be held.

	 */

	if (hlist_unhashed(&fl->fl_link))

 * the order they blocked. The documentation doesn't require this but

 * it seems like the reasonable thing to do.

 *

 * Must be called with both the i_lock and blocked_lock_lock held. The fl_block

 * list itself is protected by the blocked_lock_lock, but by ensuring that the

 * i_lock is also held on insertions we can avoid taking the blocked_lock_lock

 * in some cases when we see that the fl_block list is empty.

 * Must be called with both the flc_lock and blocked_lock_lock held. The

 * fl_block list itself is protected by the blocked_lock_lock, but by ensuring

 * that the flc_lock is also held on insertions we can avoid taking the

 * blocked_lock_lock in some cases when we see that the fl_block list is empty.

 */

static void __locks_insert_block(struct file_lock *blocker,

					struct file_lock *waiter)

		locks_insert_global_blocked(waiter);

}

/* Must be called with i_lock held. */

/* Must be called with flc_lock held. */

static void locks_insert_block(struct file_lock *blocker,

					struct file_lock *waiter)

{

/*

 * Wake up processes blocked waiting for blocker.

 *

 * Must be called with the inode->i_lock held!

 * Must be called with the inode->flc_lock held!

 */

static void locks_wake_up_blocks(struct file_lock *blocker)

{

	/*

	 * Avoid taking global lock if list is empty. This is safe since new

	 * blocked requests are only added to the list under the i_lock, and

	 * the i_lock is always held here. Note that removal from the fl_block

	 * list does not require the i_lock, so we must recheck list_empty()

	 * blocked requests are only added to the list under the flc_lock, and

	 * the flc_lock is always held here. Note that removal from the fl_block

	 * list does not require the flc_lock, so we must recheck list_empty()

	 * after acquiring the blocked_lock_lock.

	 */

	if (list_empty(&blocker->fl_block))

		return;

	}

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

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

		if (posix_locks_conflict(fl, cfl)) {

			locks_copy_conflock(fl, cfl);

	}

	fl->fl_type = F_UNLCK;

out:

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	return;

}

EXPORT_SYMBOL(posix_test_lock);

			return -ENOMEM;

	}

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

	if (request->fl_flags & FL_ACCESS)

		goto find_conflict;

	 * give it the opportunity to lock the file.

	 */

	if (found) {

		spin_unlock(&inode->i_lock);

		spin_unlock(&ctx->flc_lock);

		cond_resched();

		spin_lock(&inode->i_lock);

		spin_lock(&ctx->flc_lock);

	}

find_conflict:

	error = 0;

out:

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	if (new_fl)

		locks_free_lock(new_fl);

	locks_dispose_list(&dispose);

		new_fl2 = locks_alloc_lock();

	}

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

	/*

	 * New lock request. Walk all POSIX locks and look for conflicts. If

	 * there are any, either return error or put the request on the

		locks_wake_up_blocks(left);

	}

 out:

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	/*

	 * Free any unused locks.

	 */

	/*

	 * Search the lock list for this inode for any POSIX locks.

	 */

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

	ret = 0;

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

		if (fl->fl_owner != current->files &&

			break;

		}

	}

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	return ret;

}

	struct file_lock_context *ctx = inode->i_flctx;

	struct file_lock *fl, *tmp;

	lockdep_assert_held(&inode->i_lock);

	lockdep_assert_held(&ctx->flc_lock);

	list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) {

		trace_time_out_leases(inode, fl);

	struct file_lock_context *ctx = inode->i_flctx;

	struct file_lock *fl;

	lockdep_assert_held(&inode->i_lock);

	lockdep_assert_held(&ctx->flc_lock);

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

		if (leases_conflict(fl, breaker))

		return error;

	}

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

	time_out_leases(inode, &dispose);

		break_time++;

	locks_insert_block(fl, new_fl);

	trace_break_lease_block(inode, new_fl);

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	locks_dispose_list(&dispose);

	error = wait_event_interruptible_timeout(new_fl->fl_wait,

						!new_fl->fl_next, break_time);

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

	trace_break_lease_unblock(inode, new_fl);

	locks_delete_block(new_fl);

	if (error >= 0) {

		error = 0;

	}

out:

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	locks_dispose_list(&dispose);

	locks_free_lock(new_fl);

	return error;

	struct file_lock *fl;

	if (ctx && !list_empty_careful(&ctx->flc_lease)) {

		spin_lock(&inode->i_lock);

		spin_lock(&ctx->flc_lock);

		if (!list_empty(&ctx->flc_lease)) {

			fl = list_first_entry(&ctx->flc_lease,

						struct file_lock, fl_list);

			if (fl->fl_type == F_WRLCK)

				has_lease = true;

		}

		spin_unlock(&inode->i_lock);

		spin_unlock(&ctx->flc_lock);

	}

	if (has_lease)

	LIST_HEAD(dispose);

	if (ctx && !list_empty_careful(&ctx->flc_lease)) {

		spin_lock(&inode->i_lock);

		spin_lock(&ctx->flc_lock);

		time_out_leases(file_inode(filp), &dispose);

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

			if (fl->fl_file != filp)

			type = target_leasetype(fl);

			break;

		}

		spin_unlock(&inode->i_lock);

		spin_unlock(&ctx->flc_lock);

		locks_dispose_list(&dispose);

	}

	return type;

		return -EINVAL;

	}

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

	time_out_leases(inode, &dispose);

	error = check_conflicting_open(dentry, arg);

	if (error)

	if (lease->fl_lmops->lm_setup)

		lease->fl_lmops->lm_setup(lease, priv);

out:

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	locks_dispose_list(&dispose);

	if (is_deleg)

		mutex_unlock(&inode->i_mutex);

		return error;

	}

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

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

		if (fl->fl_file == filp) {

			victim = fl;

	trace_generic_delete_lease(inode, fl);

	if (victim)

		error = fl->fl_lmops->lm_change(&victim, F_UNLCK, &dispose);

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	locks_dispose_list(&dispose);

	return error;

}

	if (!ctx || list_empty(&ctx->flc_lease))

		return;

	spin_lock(&inode->i_lock);

	spin_lock(&ctx->flc_lock);

	list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list)

		lease_modify(&fl, F_UNLCK, &dispose);

	spin_unlock(&inode->i_lock);

	spin_unlock(&ctx->flc_lock);

	locks_dispose_list(&dispose);

}

		goto out;

	list = &flctx->flc_posix;

	spin_lock(&inode->i_lock);

	spin_lock(&flctx->flc_lock);

restart:

	list_for_each_entry(fl, list, fl_list) {

		if (nfs_file_open_context(fl->fl_file) != ctx)

			continue;

		spin_unlock(&inode->i_lock);

		spin_unlock(&flctx->flc_lock);

		status = nfs4_lock_delegation_recall(fl, state, stateid);

		if (status < 0)

			goto out;

		spin_lock(&inode->i_lock);

		spin_lock(&flctx->flc_lock);

	}

	if (list == &flctx->flc_posix) {

		list = &flctx->flc_flock;

		goto restart;

	}

	spin_unlock(&inode->i_lock);

	spin_unlock(&flctx->flc_lock);

out:

	return status;

}