SUNRPC: Support for RPC child tasks no longer needed (5b1eacbc) · Commits · e / devices / android_kernel_teracube_mt6765

include/linux/sunrpc/sched.h

+0 −5

net/sunrpc/sched.c

+0 −82

Original line number	Original line	Diff line number	Diff line
	@@ -44,12 +44,6 @@ static void __rpc_default_timer(struct rpc_task *task);
	static void rpciod_killall(void);		static void rpciod_killall(void);
	static void rpc_async_schedule(void *);		static void rpc_async_schedule(void *);

	/*
	* RPC tasks that create another task (e.g. for contacting the portmapper)
	* will wait on this queue for their child's completion
	*/
	static RPC_WAITQ(childq, "childq");

	/*		/*
	* RPC tasks sit here while waiting for conditions to improve.		* RPC tasks sit here while waiting for conditions to improve.
	*/		*/
	@@ -323,16 +317,6 @@ static void rpc_make_runnable(struct rpc_task *task)
	wake_up_bit(&task->tk_runstate, RPC_TASK_QUEUED);		wake_up_bit(&task->tk_runstate, RPC_TASK_QUEUED);
	}		}

	/*
	* Place a newly initialized task on the workqueue.
	*/
	static inline void
	rpc_schedule_run(struct rpc_task *task)
	{
	rpc_set_active(task);
	rpc_make_runnable(task);
	}

	/*		/*
	* Prepare for sleeping on a wait queue.		* Prepare for sleeping on a wait queue.
	* By always appending tasks to the list we ensure FIFO behavior.		* By always appending tasks to the list we ensure FIFO behavior.
	@@ -933,72 +917,6 @@ struct rpc_task rpc_run_task(struct rpc_clnt clnt, int flags,
	}		}
	EXPORT_SYMBOL(rpc_run_task);		EXPORT_SYMBOL(rpc_run_task);

	/**
	* rpc_find_parent - find the parent of a child task.
	* @child: child task
	* @parent: parent task
	*
	* Checks that the parent task is still sleeping on the
	* queue 'childq'. If so returns a pointer to the parent.
	* Upon failure returns NULL.
	*
	* Caller must hold childq.lock
	*/
	static inline struct rpc_task rpc_find_parent(struct rpc_task child, struct rpc_task *parent)
	{
	struct rpc_task *task;
	struct list_head *le;

	task_for_each(task, le, &childq.tasks[0])
	if (task == parent)
	return parent;

	return NULL;
	}

	static void rpc_child_exit(struct rpc_task child, void calldata)
	{
	struct rpc_task *parent;

	spin_lock_bh(&childq.lock);
	if ((parent = rpc_find_parent(child, calldata)) != NULL) {
	parent->tk_status = child->tk_status;
	__rpc_wake_up_task(parent);
	}
	spin_unlock_bh(&childq.lock);
	}

	static const struct rpc_call_ops rpc_child_ops = {
	.rpc_call_done = rpc_child_exit,
	};

	/*
	* Note: rpc_new_task releases the client after a failure.
	*/
	struct rpc_task *
	rpc_new_child(struct rpc_clnt clnt, struct rpc_task parent)
	{
	struct rpc_task *task;

	task = rpc_new_task(clnt, RPC_TASK_ASYNC \| RPC_TASK_CHILD, &rpc_child_ops, parent);
	if (!task)
	goto fail;
	return task;

	fail:
	parent->tk_status = -ENOMEM;
	return NULL;
	}

	void rpc_run_child(struct rpc_task task, struct rpc_task child, rpc_action func)
	{
	spin_lock_bh(&childq.lock);
	/* N.B. Is it possible for the child to have already finished? */
	__rpc_sleep_on(&childq, task, func, NULL);
	rpc_schedule_run(child);
	spin_unlock_bh(&childq.lock);
	}

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

Original line number	Original line	Diff line number	Diff line
	@@ -127,7 +127,6 @@ struct rpc_call_ops {
	*/		*/
	#define RPC_TASK_ASYNC 0x0001 /* is an async task */		#define RPC_TASK_ASYNC 0x0001 /* is an async task */
	#define RPC_TASK_SWAPPER 0x0002 /* is swapping in/out */		#define RPC_TASK_SWAPPER 0x0002 /* is swapping in/out */
	#define RPC_TASK_CHILD 0x0008 /* is child of other task */
	#define RPC_CALL_MAJORSEEN 0x0020 /* major timeout seen */		#define RPC_CALL_MAJORSEEN 0x0020 /* major timeout seen */
	#define RPC_TASK_ROOTCREDS 0x0040 /* force root creds */		#define RPC_TASK_ROOTCREDS 0x0040 /* force root creds */
	#define RPC_TASK_DYNAMIC 0x0080 /* task was kmalloc'ed */		#define RPC_TASK_DYNAMIC 0x0080 /* task was kmalloc'ed */
	@@ -136,7 +135,6 @@ struct rpc_call_ops {
	#define RPC_TASK_NOINTR 0x0400 /* uninterruptible task */		#define RPC_TASK_NOINTR 0x0400 /* uninterruptible task */

	#define RPC_IS_ASYNC(t) ((t)->tk_flags & RPC_TASK_ASYNC)		#define RPC_IS_ASYNC(t) ((t)->tk_flags & RPC_TASK_ASYNC)
	#define RPC_IS_CHILD(t) ((t)->tk_flags & RPC_TASK_CHILD)
	#define RPC_IS_SWAPPER(t) ((t)->tk_flags & RPC_TASK_SWAPPER)		#define RPC_IS_SWAPPER(t) ((t)->tk_flags & RPC_TASK_SWAPPER)
	#define RPC_DO_ROOTOVERRIDE(t) ((t)->tk_flags & RPC_TASK_ROOTCREDS)		#define RPC_DO_ROOTOVERRIDE(t) ((t)->tk_flags & RPC_TASK_ROOTCREDS)
	#define RPC_ASSASSINATED(t) ((t)->tk_flags & RPC_TASK_KILLED)		#define RPC_ASSASSINATED(t) ((t)->tk_flags & RPC_TASK_KILLED)
	@@ -253,7 +251,6 @@ struct rpc_task rpc_new_task(struct rpc_clnt , int flags,
	const struct rpc_call_ops ops, void data);		const struct rpc_call_ops ops, void data);
	struct rpc_task rpc_run_task(struct rpc_clnt clnt, int flags,		struct rpc_task rpc_run_task(struct rpc_clnt clnt, int flags,
	const struct rpc_call_ops ops, void data);		const struct rpc_call_ops ops, void data);
	struct rpc_task rpc_new_child(struct rpc_clnt , struct rpc_task *parent);
	void rpc_init_task(struct rpc_task task, struct rpc_clnt clnt,		void rpc_init_task(struct rpc_task task, struct rpc_clnt clnt,
	int flags, const struct rpc_call_ops *ops,		int flags, const struct rpc_call_ops *ops,
	void *data);		void *data);
	@@ -261,8 +258,6 @@ void rpc_release_task(struct rpc_task *);
	void rpc_exit_task(struct rpc_task *);		void rpc_exit_task(struct rpc_task *);
	void rpc_killall_tasks(struct rpc_clnt *);		void rpc_killall_tasks(struct rpc_clnt *);
	int rpc_execute(struct rpc_task *);		int rpc_execute(struct rpc_task *);
	void rpc_run_child(struct rpc_task parent, struct rpc_task child,
	rpc_action action);
	void rpc_init_priority_wait_queue(struct rpc_wait_queue , const char );		void rpc_init_priority_wait_queue(struct rpc_wait_queue , const char );
	void rpc_init_wait_queue(struct rpc_wait_queue , const char );		void rpc_init_wait_queue(struct rpc_wait_queue , const char );
	void rpc_sleep_on(struct rpc_wait_queue , struct rpc_task ,		void rpc_sleep_on(struct rpc_wait_queue , struct rpc_task ,