SUNRPC: clean up rpc_call_async/rpc_call_sync/rpc_run_task (6e5b70e9) · Commits · e / devices / android_kernel_oneplus_sm8150

net/sunrpc/clnt.c

+69 −46

Original line number	Diff line number	Diff line
		@@ -474,73 +474,96 @@ void rpc_clnt_sigunmask(struct rpc_clnt clnt, sigset_t oldset)
		rpc_restore_sigmask(oldset);
		}

		/*
		* New rpc_call implementation
		*/
		int rpc_call_sync(struct rpc_clnt clnt, struct rpc_message msg, int flags)
		static
		struct rpc_task rpc_do_run_task(struct rpc_clnt clnt,
		struct rpc_message *msg,
		int flags,
		const struct rpc_call_ops *ops,
		void *data)
		{
		struct rpc_task *task;
		struct rpc_task task, ret;
		sigset_t oldset;
		int status;

		BUG_ON(flags & RPC_TASK_ASYNC);

		task = rpc_new_task(clnt, flags, &rpc_default_ops, NULL);
		if (task == NULL)
		return -ENOMEM;
		task = rpc_new_task(clnt, flags, ops, data);
		if (task == NULL) {
		rpc_release_calldata(ops, data);
		return ERR_PTR(-ENOMEM);
		}

		/* Mask signals on RPC calls _and_ GSS_AUTH upcalls */
		/* Mask signals on synchronous RPC calls and RPCSEC_GSS upcalls */
		rpc_task_sigmask(task, &oldset);

		/* Set up the call info struct and execute the task */
		if (msg != NULL) {
		rpc_call_setup(task, msg, 0);
		if (task->tk_status == 0) {
		if (task->tk_status != 0) {
		ret = ERR_PTR(task->tk_status);
		rpc_put_task(task);
		goto out;
		}
		}
		atomic_inc(&task->tk_count);
		rpc_execute(task);
		ret = task;
		out:
		rpc_restore_sigmask(&oldset);
		return ret;
		}

		/**
		* rpc_call_sync - Perform a synchronous RPC call
		* @clnt: pointer to RPC client
		* @msg: RPC call parameters
		* @flags: RPC call flags
		*/
		int rpc_call_sync(struct rpc_clnt clnt, struct rpc_message msg, int flags)
		{
		struct rpc_task *task;
		int status;

		BUG_ON(flags & RPC_TASK_ASYNC);

		task = rpc_do_run_task(clnt, msg, flags, &rpc_default_ops, NULL);
		if (IS_ERR(task))
		return PTR_ERR(task);
		status = task->tk_status;
		rpc_put_task(task);
		rpc_restore_sigmask(&oldset);
		return status;
		}

		/*
		* New rpc_call implementation
		/**
		* rpc_call_async - Perform an asynchronous RPC call
		* @clnt: pointer to RPC client
		* @msg: RPC call parameters
		* @flags: RPC call flags
		* @ops: RPC call ops
		* @data: user call data
		*/
		int
		rpc_call_async(struct rpc_clnt clnt, struct rpc_message msg, int flags,
		const struct rpc_call_ops tk_ops, void data)
		{
		struct rpc_task *task;
		sigset_t oldset;
		int status;

		flags \|= RPC_TASK_ASYNC;

		/* Create/initialize a new RPC task */
		status = -ENOMEM;
		if (!(task = rpc_new_task(clnt, flags, tk_ops, data)))
		goto out_release;

		/* Mask signals on GSS_AUTH upcalls */
		rpc_task_sigmask(task, &oldset);

		rpc_call_setup(task, msg, 0);

		/* Set up the call info struct and execute the task */
		status = task->tk_status;
		if (status == 0)
		rpc_execute(task);
		else
		task = rpc_do_run_task(clnt, msg, flags\|RPC_TASK_ASYNC, tk_ops, data);
		if (IS_ERR(task))
		return PTR_ERR(task);
		rpc_put_task(task);

		rpc_restore_sigmask(&oldset);
		return status;
		out_release:
		rpc_release_calldata(tk_ops, data);
		return status;
		return 0;
		}

		/**
		* rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
		* @clnt: pointer to RPC client
		* @flags: RPC flags
		* @ops: RPC call ops
		* @data: user call data
		*/
		struct rpc_task rpc_run_task(struct rpc_clnt clnt, int flags,
		const struct rpc_call_ops *tk_ops,
		void *data)
		{
		return rpc_do_run_task(clnt, NULL, flags, tk_ops, data);
		}
		EXPORT_SYMBOL(rpc_run_task);

		void
		rpc_call_setup(struct rpc_task task, struct rpc_message msg, int flags)

net/sunrpc/sched.c

+0 −23

Original line number	Diff line number	Diff line
		@@ -933,29 +933,6 @@ static void rpc_release_task(struct rpc_task *task)
		rpc_put_task(task);
		}

		/**
		* rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
		* @clnt: pointer to RPC client
		* @flags: RPC flags
		* @ops: RPC call ops
		* @data: user call data
		*/
		struct rpc_task rpc_run_task(struct rpc_clnt clnt, int flags,
		const struct rpc_call_ops *ops,
		void *data)
		{
		struct rpc_task *task;
		task = rpc_new_task(clnt, flags, ops, data);
		if (task == NULL) {
		rpc_release_calldata(ops, data);
		return ERR_PTR(-ENOMEM);
		}
		atomic_inc(&task->tk_count);
		rpc_execute(task);
		return task;
		}
		EXPORT_SYMBOL(rpc_run_task);

		/*
		* Kill all tasks for the given client.
		* XXX: kill their descendants as well?