From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Fri, 1 Feb 2008 00:45:47 +0000 (+1100)
Subject: Merge branch 'task_killable' of git://git.kernel.org/pub/scm/linux/kernel/git/willy... 
X-Git-Tag: v2.6.25-rc1~1125
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=75659ca0c10992dcb39258518368a0f6f56e935d;p=platform%2Fkernel%2Flinux-3.10.git

Merge branch 'task_killable' of git://git./linux/kernel/git/willy/misc

* 'task_killable' of git://git.kernel.org/pub/scm/linux/kernel/git/willy/misc: (22 commits)
  Remove commented-out code copied from NFS
  NFS: Switch from intr mount option to TASK_KILLABLE
  Add wait_for_completion_killable
  Add wait_event_killable
  Add schedule_timeout_killable
  Use mutex_lock_killable in vfs_readdir
  Add mutex_lock_killable
  Use lock_page_killable
  Add lock_page_killable
  Add fatal_signal_pending
  Add TASK_WAKEKILL
  exit: Use task_is_*
  signal: Use task_is_*
  sched: Use task_contributes_to_load, TASK_ALL and TASK_NORMAL
  ptrace: Use task_is_*
  power: Use task_is_*
  wait: Use TASK_NORMAL
  proc/base.c: Use task_is_*
  proc/array.c: Use TASK_REPORT
  perfmon: Use task_is_*
  ...

Fixed up conflicts in NFS/sunrpc manually..
---

75659ca0c10992dcb39258518368a0f6f56e935d
diff --cc fs/nfs/pagelist.c
index 3b3dbb9,2dff469..7f07920
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@@ -58,7 -58,7 +58,6 @@@ nfs_create_request(struct nfs_open_cont
  		   struct page *page,
  		   unsigned int offset, unsigned int count)
  {
--	struct nfs_server *server = NFS_SERVER(inode);
  	struct nfs_page		*req;
  
  	for (;;) {
diff --cc fs/proc/base.c
index 91fa8e6,e88ee1a..9fa9708
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@@ -199,29 -199,9 +199,29 @@@ static int proc_root_link(struct inode 
  	(task == current || \
  	(task->parent == current && \
  	(task->ptrace & PT_PTRACED) && \
- 	 (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \
+ 	 (task_is_stopped_or_traced(task)) && \
  	 security_ptrace(current,task) == 0))
  
 +struct mm_struct *mm_for_maps(struct task_struct *task)
 +{
 +	struct mm_struct *mm = get_task_mm(task);
 +	if (!mm)
 +		return NULL;
 +	down_read(&mm->mmap_sem);
 +	task_lock(task);
 +	if (task->mm != mm)
 +		goto out;
 +	if (task->mm != current->mm && __ptrace_may_attach(task) < 0)
 +		goto out;
 +	task_unlock(task);
 +	return mm;
 +out:
 +	task_unlock(task);
 +	up_read(&mm->mmap_sem);
 +	mmput(mm);
 +	return NULL;
 +}
 +
  static int proc_pid_cmdline(struct task_struct *task, char * buffer)
  {
  	int res = 0;
diff --cc include/linux/sunrpc/clnt.h
index 3e9addc,0187936..129a86e
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@@ -137,8 -134,8 +135,6 @@@ int		rpc_call_sync(struct rpc_clnt *cln
  struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred,
  			       int flags);
  void		rpc_restart_call(struct rpc_task *);
--void		rpc_clnt_sigmask(struct rpc_clnt *clnt, sigset_t *oldset);
--void		rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset);
  void		rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int);
  size_t		rpc_max_payload(struct rpc_clnt *);
  void		rpc_force_rebind(struct rpc_clnt *);
diff --cc net/sunrpc/clnt.c
index 924916c,a99729f..0998e6d
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@@ -515,76 -478,32 +513,29 @@@ static const struct rpc_call_ops rpc_de
  	.rpc_call_done = rpc_default_callback,
  };
  
- /*
-  *	Export the signal mask handling for synchronous code that
-  *	sleeps on RPC calls
-  */
- #define RPC_INTR_SIGNALS (sigmask(SIGHUP) | sigmask(SIGINT) | sigmask(SIGQUIT) | sigmask(SIGTERM))
- 
- static void rpc_save_sigmask(sigset_t *oldset, int intr)
- {
- 	unsigned long	sigallow = sigmask(SIGKILL);
- 	sigset_t sigmask;
- 
- 	/* Block all signals except those listed in sigallow */
- 	if (intr)
- 		sigallow |= RPC_INTR_SIGNALS;
- 	siginitsetinv(&sigmask, sigallow);
- 	sigprocmask(SIG_BLOCK, &sigmask, oldset);
- }
- 
- static void rpc_task_sigmask(struct rpc_task *task, sigset_t *oldset)
- {
- 	rpc_save_sigmask(oldset, !RPC_TASK_UNINTERRUPTIBLE(task));
- }
- 
- static void rpc_restore_sigmask(sigset_t *oldset)
- {
- 	sigprocmask(SIG_SETMASK, oldset, NULL);
- }
- 
- void rpc_clnt_sigmask(struct rpc_clnt *clnt, sigset_t *oldset)
- {
- 	rpc_save_sigmask(oldset, clnt->cl_intr);
- }
- EXPORT_SYMBOL_GPL(rpc_clnt_sigmask);
- 
- void rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset)
- {
- 	rpc_restore_sigmask(oldset);
- }
- EXPORT_SYMBOL_GPL(rpc_clnt_sigunmask);
- 
 -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)
 +/**
 + * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
 + * @task_setup_data: pointer to task initialisation data
 + */
 +struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
  {
  	struct rpc_task *task, *ret;
- 	sigset_t oldset;
  
 -	task = rpc_new_task(clnt, flags, ops, data);
 +	task = rpc_new_task(task_setup_data);
  	if (task == NULL) {
 -		rpc_release_calldata(ops, data);
 -		return ERR_PTR(-ENOMEM);
 +		rpc_release_calldata(task_setup_data->callback_ops,
 +				task_setup_data->callback_data);
 +		ret = ERR_PTR(-ENOMEM);
 +		goto out;
  	}
  
 -	/* Mask signals on synchronous RPC calls and RPCSEC_GSS upcalls */
 -	if (msg != NULL) {
 -		rpc_call_setup(task, msg, 0);
 -		if (task->tk_status != 0) {
 -			ret = ERR_PTR(task->tk_status);
 -			rpc_put_task(task);
 -			goto out;
 -		}
 +	if (task->tk_status != 0) {
 +		ret = ERR_PTR(task->tk_status);
 +		rpc_put_task(task);
 +		goto out;
  	}
  	atomic_inc(&task->tk_count);
- 	/* Mask signals on synchronous RPC calls and RPCSEC_GSS upcalls */
- 	if (!RPC_IS_ASYNC(task)) {
- 		rpc_task_sigmask(task, &oldset);
- 		rpc_execute(task);
- 		rpc_restore_sigmask(&oldset);
- 	} else
- 		rpc_execute(task);
+ 	rpc_execute(task);
  	ret = task;
  out:
  	return ret;
diff --cc net/sunrpc/sched.c
index 40ce6f6,4b22910..4c66912
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@@ -241,13 -241,13 +241,13 @@@ void rpc_init_priority_wait_queue(struc
  
  void rpc_init_wait_queue(struct rpc_wait_queue *queue, const char *qname)
  {
 -	__rpc_init_priority_wait_queue(queue, qname, 0);
 +	__rpc_init_priority_wait_queue(queue, qname, 1);
  }
 -EXPORT_SYMBOL(rpc_init_wait_queue);
 +EXPORT_SYMBOL_GPL(rpc_init_wait_queue);
  
- static int rpc_wait_bit_interruptible(void *word)
+ static int rpc_wait_bit_killable(void *word)
  {
- 	if (signal_pending(current))
+ 	if (fatal_signal_pending(current))
  		return -ERESTARTSYS;
  	schedule();
  	return 0;
@@@ -299,11 -299,11 +299,11 @@@ static void rpc_mark_complete_task(stru
  int __rpc_wait_for_completion_task(struct rpc_task *task, int (*action)(void *))
  {
  	if (action == NULL)
- 		action = rpc_wait_bit_interruptible;
+ 		action = rpc_wait_bit_killable;
  	return wait_on_bit(&task->tk_runstate, RPC_TASK_ACTIVE,
- 			action, TASK_INTERRUPTIBLE);
+ 			action, TASK_KILLABLE);
  }
 -EXPORT_SYMBOL(__rpc_wait_for_completion_task);
 +EXPORT_SYMBOL_GPL(__rpc_wait_for_completion_task);
  
  /*
   * Make an RPC task runnable.
@@@ -835,28 -832,13 +834,26 @@@ static void rpc_init_task(struct rpc_ta
  	/* Initialize workqueue for async tasks */
  	task->tk_workqueue = rpciod_workqueue;
  
 -	if (clnt) {
 -		kref_get(&clnt->cl_kref);
 -		if (clnt->cl_softrtry)
 +	task->tk_client = task_setup_data->rpc_client;
 +	if (task->tk_client != NULL) {
 +		kref_get(&task->tk_client->cl_kref);
 +		if (task->tk_client->cl_softrtry)
  			task->tk_flags |= RPC_TASK_SOFT;
- 		if (!task->tk_client->cl_intr)
- 			task->tk_flags |= RPC_TASK_NOINTR;
  	}
  
 -	BUG_ON(task->tk_ops == NULL);
 +	if (task->tk_ops->rpc_call_prepare != NULL)
 +		task->tk_action = rpc_prepare_task;
 +
 +	if (task_setup_data->rpc_message != NULL) {
 +		memcpy(&task->tk_msg, task_setup_data->rpc_message, sizeof(task->tk_msg));
 +		/* Bind the user cred */
 +		if (task->tk_msg.rpc_cred != NULL)
 +			rpcauth_holdcred(task);
 +		else
 +			rpcauth_bindcred(task);
 +		if (task->tk_action == NULL)
 +			rpc_call_start(task);
 +	}
  
  	/* starting timestamp */
  	task->tk_start = jiffies;