Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 324d003b authored by Weston Andros Adamson's avatar Weston Andros Adamson Committed by Trond Myklebust
Browse files

NFS: add nfs_sb_deactive_async to avoid deadlock 



Use nfs_sb_deactive_async instead of nfs_sb_deactive when in a workqueue
context.  This avoids a deadlock where rpc_shutdown_client loops forever
in a workqueue kworker context, trying to kill all RPC tasks associated with
the client, while one or more of these tasks have already been assigned to the
same kworker (and will never run rpc_exit_task).

This approach is needed because RPC tasks that have already been assigned
to a kworker by queue_work cannot be canceled, as explained in the comment
for workqueue.c:insert_wq_barrier.

Signed-off-by: default avatarWeston Andros Adamson <dros@netapp.com>
[Trond: add module_get/put.]
Signed-off-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent 97a54868

fs/nfs/inode.c

+4 −1
Original line number Diff line number Diff line
@@ -685,7 +685,10 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync) 
	if (ctx->cred != NULL)

		put_rpccred(ctx->cred);

	dput(ctx->dentry);

	if (is_sync)

		nfs_sb_deactive(sb);

	else

		nfs_sb_deactive_async(sb);

	kfree(ctx->mdsthreshold);

	kfree(ctx);

}

fs/nfs/internal.h

+1 −0
Original line number Diff line number Diff line
@@ -351,6 +351,7 @@ extern int __init register_nfs_fs(void); 
extern void __exit unregister_nfs_fs(void);

extern void nfs_sb_active(struct super_block *sb);

extern void nfs_sb_deactive(struct super_block *sb);

extern void nfs_sb_deactive_async(struct super_block *sb);



/* namespace.c */

#define NFS_PATH_CANONICAL 1

fs/nfs/nfs4proc.c

+1 −1
Original line number Diff line number Diff line
@@ -2197,7 +2197,7 @@ static void nfs4_free_closedata(void *data) 
	nfs4_put_open_state(calldata->state);

	nfs_free_seqid(calldata->arg.seqid);

	nfs4_put_state_owner(sp);

	nfs_sb_deactive(sb);

	nfs_sb_deactive_async(sb);

	kfree(calldata);

}

fs/nfs/super.c

+49 −0
Original line number Diff line number Diff line
@@ -54,6 +54,7 @@ 
#include <linux/parser.h>

#include <linux/nsproxy.h>

#include <linux/rcupdate.h>

#include <linux/kthread.h>



#include <asm/uaccess.h>
@@ -415,6 +416,54 @@ void nfs_sb_deactive(struct super_block *sb) 
}

EXPORT_SYMBOL_GPL(nfs_sb_deactive);



static int nfs_deactivate_super_async_work(void *ptr)

{

	struct super_block *sb = ptr;



	deactivate_super(sb);

	module_put_and_exit(0);

	return 0;

}



/*

 * same effect as deactivate_super, but will do final unmount in kthread

 * context

 */

static void nfs_deactivate_super_async(struct super_block *sb)

{

	struct task_struct *task;

	char buf[INET6_ADDRSTRLEN + 1];

	struct nfs_server *server = NFS_SB(sb);

	struct nfs_client *clp = server->nfs_client;



	if (!atomic_add_unless(&sb->s_active, -1, 1)) {

		rcu_read_lock();

		snprintf(buf, sizeof(buf),

			rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));

		rcu_read_unlock();



		__module_get(THIS_MODULE);

		task = kthread_run(nfs_deactivate_super_async_work, sb,

				"%s-deactivate-super", buf);

		if (IS_ERR(task)) {

			pr_err("%s: kthread_run: %ld\n",

				__func__, PTR_ERR(task));

			/* make synchronous call and hope for the best */

			deactivate_super(sb);

			module_put(THIS_MODULE);

		}

	}

}



void nfs_sb_deactive_async(struct super_block *sb)

{

	struct nfs_server *server = NFS_SB(sb);



	if (atomic_dec_and_test(&server->active))

		nfs_deactivate_super_async(sb);

}

EXPORT_SYMBOL_GPL(nfs_sb_deactive_async);



/*

 * Deliver file system statistics to userspace

 */

fs/nfs/unlink.c

+1 −1
Original line number Diff line number Diff line
@@ -95,7 +95,7 @@ static void nfs_async_unlink_release(void *calldata) 


	nfs_dec_sillycount(data->dir);

	nfs_free_unlinkdata(data);

	nfs_sb_deactive(sb);

	nfs_sb_deactive_async(sb);

}



static void nfs_unlink_prepare(struct rpc_task *task, void *calldata)