Commit 2005f5b9 authored by Jeff Layton's avatar Jeff Layton Committed by Chuck Lever
Browse files

lockd: fix races in client GRANTED_MSG wait logic 



After the wait for a grant is done (for whatever reason), nlmclnt_block
updates the status of the nlm_rqst with the status of the block. At the
point it does this, however, the block is still queued its status could
change at any time.

This is particularly a problem when the waiting task is signaled during
the wait. We can end up giving up on the lock just before the GRANTED_MSG
callback comes in, and accept it even though the lock request gets back
an error, leaving a dangling lock on the server.

Since the nlm_wait never lives beyond the end of nlmclnt_lock, put it on
the stack and add functions to allow us to enqueue and dequeue the
block. Enqueue it just before the lock/wait loop, and dequeue it
just after we exit the loop instead of waiting until the end of
the function. Also, scrape the status at the time that we dequeue it to
ensure that it's final.

Reported-by: default avatarYongcheng Yang <yoyang@redhat.com>
Link: https://bugzilla.redhat.com/show_bug.cgi?id=2063818


Signed-off-by: default avatarJeff Layton <jlayton@kernel.org>
Signed-off-by: default avatarChuck Lever <chuck.lever@oracle.com>
parent f0aa4852

fs/lockd/clntlock.c

+21 −21
Original line number Diff line number Diff line
@@ -82,41 +82,42 @@ void nlmclnt_done(struct nlm_host *host) 
}

EXPORT_SYMBOL_GPL(nlmclnt_done);



/*

 * Queue up a lock for blocking so that the GRANTED request can see it

 */

struct nlm_wait *nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl)

void nlmclnt_prepare_block(struct nlm_wait *block, struct nlm_host *host, struct file_lock *fl)

{

	struct nlm_wait *block;



	block = kmalloc(sizeof(*block), GFP_KERNEL);

	if (block != NULL) {

	block->b_host = host;

	block->b_lock = fl;

	init_waitqueue_head(&block->b_wait);

	block->b_status = nlm_lck_blocked;

}



/*

 * Queue up a lock for blocking so that the GRANTED request can see it

 */

void nlmclnt_queue_block(struct nlm_wait *block)

{

	spin_lock(&nlm_blocked_lock);

	list_add(&block->b_list, &nlm_blocked);

	spin_unlock(&nlm_blocked_lock);

}

	return block;

}



void nlmclnt_finish_block(struct nlm_wait *block)

/*

 * Dequeue the block and return its final status

 */

__be32 nlmclnt_dequeue_block(struct nlm_wait *block)

{

	if (block == NULL)

		return;

	__be32 status;



	spin_lock(&nlm_blocked_lock);

	list_del(&block->b_list);

	status = block->b_status;

	spin_unlock(&nlm_blocked_lock);

	kfree(block);

	return status;

}



/*

 * Block on a lock

 */

int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout)

int nlmclnt_wait(struct nlm_wait *block, struct nlm_rqst *req, long timeout)

{

	long ret;
@@ -142,7 +143,6 @@ int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout) 
	/* Reset the lock status after a server reboot so we resend */

	if (block->b_status == nlm_lck_denied_grace_period)

		block->b_status = nlm_lck_blocked;

	req->a_res.status = block->b_status;

	return 0;

}

fs/lockd/clntproc.c

+18 −10
Original line number Diff line number Diff line
@@ -516,9 +516,10 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
	const struct cred *cred = nfs_file_cred(fl->fl_file);

	struct nlm_host	*host = req->a_host;

	struct nlm_res	*resp = &req->a_res;

	struct nlm_wait *block = NULL;

	struct nlm_wait block;

	unsigned char fl_flags = fl->fl_flags;

	unsigned char fl_type;

	__be32 b_status;

	int status = -ENOLCK;



	if (nsm_monitor(host) < 0)
@@ -531,13 +532,20 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
	if (status < 0)

		goto out;



	block = nlmclnt_prepare_block(host, fl);

	nlmclnt_prepare_block(&block, host, fl);

again:

	/*

	 * Initialise resp->status to a valid non-zero value,

	 * since 0 == nlm_lck_granted

	 */

	resp->status = nlm_lck_blocked;



	/*

	 * A GRANTED callback can come at any time -- even before the reply

	 * to the LOCK request arrives, so we queue the wait before

	 * requesting the lock.

	 */

	nlmclnt_queue_block(&block);

	for (;;) {

		/* Reboot protection */

		fl->fl_u.nfs_fl.state = host->h_state;
@@ -550,12 +558,15 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
		if (resp->status != nlm_lck_blocked)

			break;

		/* Wait on an NLM blocking lock */

		status = nlmclnt_block(block, req, NLMCLNT_POLL_TIMEOUT);

		status = nlmclnt_wait(&block, req, NLMCLNT_POLL_TIMEOUT);

		if (status < 0)

			break;

		if (resp->status != nlm_lck_blocked)

		if (block.b_status != nlm_lck_blocked)

			break;

	}

	b_status = nlmclnt_dequeue_block(&block);

	if (resp->status == nlm_lck_blocked)

		resp->status = b_status;



	/* if we were interrupted while blocking, then cancel the lock request

	 * and exit
@@ -564,7 +575,7 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
		if (!req->a_args.block)

			goto out_unlock;

		if (nlmclnt_cancel(host, req->a_args.block, fl) == 0)

			goto out_unblock;

			goto out;

	}



	if (resp->status == nlm_granted) {
@@ -593,8 +604,6 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
		status = -ENOLCK;

	else

		status = nlm_stat_to_errno(resp->status);

out_unblock:

	nlmclnt_finish_block(block);

out:

	nlmclnt_release_call(req);

	return status;
@@ -602,7 +611,6 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
	/* Fatal error: ensure that we remove the lock altogether */

	dprintk("lockd: lock attempt ended in fatal error.\n"

		"       Attempting to unlock.\n");

	nlmclnt_finish_block(block);

	fl_type = fl->fl_type;

	fl->fl_type = F_UNLCK;

	down_read(&host->h_rwsem);

include/linux/lockd/lockd.h

+5 −3
Original line number Diff line number Diff line
@@ -211,9 +211,11 @@ struct nlm_rqst * nlm_alloc_call(struct nlm_host *host); 
int		  nlm_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *);

int		  nlm_async_reply(struct nlm_rqst *, u32, const struct rpc_call_ops *);

void		  nlmclnt_release_call(struct nlm_rqst *);

struct nlm_wait * nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl);

void		  nlmclnt_finish_block(struct nlm_wait *block);

int		  nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout);

void		  nlmclnt_prepare_block(struct nlm_wait *block, struct nlm_host *host,

					struct file_lock *fl);

void		  nlmclnt_queue_block(struct nlm_wait *block);

__be32		  nlmclnt_dequeue_block(struct nlm_wait *block);

int		  nlmclnt_wait(struct nlm_wait *block, struct nlm_rqst *req, long timeout);

__be32		  nlmclnt_grant(const struct sockaddr *addr,

				const struct nlm_lock *lock);

void		  nlmclnt_recovery(struct nlm_host *);