Add/drop patches to fix build failures

28 files changed, 5253 insertions, 89 deletions

diff --git a/queue-3.16/arc-use-get_signal-signal_setup_done.patch b/queue-3.16/arc-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..043ee626
--- /dev/null
+++ b/queue-3.16/arc-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,119 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 6 Oct 2013 22:42:38 +0200
+Subject: arc: Use get_signal() signal_setup_done()
+
+commit f6dd2a3f1f8d8df640cfa2d60f85c0b818af1593 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+Acked-by: Vineet Gupta <vgupta@synopsys.com>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"
+ - Adjust to apply after "ARC: signal handling robustify"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/arc/kernel/signal.c | 39 +++++++++++++++------------------------
+ 1 file changed, 15 insertions(+), 24 deletions(-)
+
+--- a/arch/arc/kernel/signal.c
++++ b/arch/arc/kernel/signal.c
+@@ -189,14 +189,13 @@ static inline int map_sig(int sig)
+ }
+ 
+ static int
+-setup_rt_frame(int signo, struct k_sigaction *ka, siginfo_t *info,
+-	       sigset_t *set, struct pt_regs *regs)
++setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *sf;
+ 	unsigned int magic = 0;
+ 	int err = 0;
+ 
+-	sf = get_sigframe(ka, regs, sizeof(struct rt_sigframe));
++	sf = get_sigframe(&ksig->ka, regs, sizeof(struct rt_sigframe));
+ 	if (!sf)
+ 		return 1;
+ 
+@@ -215,8 +214,8 @@ setup_rt_frame(int signo, struct k_sigac
+ 	 *  #2: struct siginfo
+ 	 *  #3: struct ucontext (completely populated)
+ 	 */
+-	if (unlikely(ka->sa.sa_flags & SA_SIGINFO)) {
+-		err |= copy_siginfo_to_user(&sf->info, info);
++	if (unlikely(ksig->ka.sa.sa_flags & SA_SIGINFO)) {
++		err |= copy_siginfo_to_user(&sf->info, &ksig->info);
+ 		err |= __put_user(0, &sf->uc.uc_flags);
+ 		err |= __put_user(NULL, &sf->uc.uc_link);
+ 		err |= __save_altstack(&sf->uc.uc_stack, regs->sp);
+@@ -237,19 +236,19 @@ setup_rt_frame(int signo, struct k_sigac
+ 		return err;
+ 
+ 	/* #1 arg to the user Signal handler */
+-	regs->r0 = map_sig(signo);
++	regs->r0 = map_sig(ksig->sig);
+ 
+ 	/* setup PC of user space signal handler */
+-	regs->ret = (unsigned long)ka->sa.sa_handler;
++	regs->ret = (unsigned long)ksig->ka.sa.sa_handler;
+ 
+ 	/*
+ 	 * handler returns using sigreturn stub provided already by userpsace
+ 	 * If not, nuke the process right away
+ 	 */
+-	if(!(ka->sa.sa_flags & SA_RESTORER))
++	if(!(ksig->ka.sa.sa_flags & SA_RESTORER))
+ 		return 1;
+ 
+-	regs->blink = (unsigned long)ka->sa.sa_restorer;
++	regs->blink = (unsigned long)ksig->ka.sa.sa_restorer;
+ 
+ 	/* User Stack for signal handler will be above the frame just carved */
+ 	regs->sp = (unsigned long)sf;
+@@ -311,38 +310,30 @@ static void arc_restart_syscall(struct k
+  * OK, we're invoking a handler
+  */
+ static void
+-handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
+-	      struct pt_regs *regs)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int failed;
+ 
+ 	/* Set up the stack frame */
+-	failed = setup_rt_frame(sig, ka, info, oldset, regs);
++	failed = setup_rt_frame(ksig, oldset, regs);
+ 
+-	if (failed)
+-		force_sigsegv(sig, current);
+-	else
+-		signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(failed, ksig, 0);
+ }
+ 
+ void do_signal(struct pt_regs *regs)
+ {
+-	struct k_sigaction ka;
+-	siginfo_t info;
+-	int signr;
++	struct ksignal ksig;
+ 	int restart_scall;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-
+ 	restart_scall = in_syscall(regs) && syscall_restartable(regs);
+ 
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		if (restart_scall) {
+-			arc_restart_syscall(&ka, regs);
++			arc_restart_syscall(&ksig.ka, regs);
+ 			syscall_wont_restart(regs);	/* No more restarts */
+ 		}
+-		handle_signal(signr, &ka, &info, regs);
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/arm64-use-get_signal-signal_setup_done.patch b/queue-3.16/arm64-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..6d4cd55e
--- /dev/null
+++ b/queue-3.16/arm64-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,233 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 6 Oct 2013 22:52:44 +0200
+Subject: arm64: Use get_signal() signal_setup_done()
+
+commit 00554fa4f80279db92f82c4f52c8ae72711f173e upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/arm64/include/asm/signal32.h | 11 ++++---
+ arch/arm64/kernel/signal.c        | 48 +++++++++++++------------------
+ arch/arm64/kernel/signal32.c      | 14 ++++-----
+ 3 files changed, 32 insertions(+), 41 deletions(-)
+
+--- a/arch/arm64/include/asm/signal32.h
++++ b/arch/arm64/include/asm/signal32.h
+@@ -24,22 +24,21 @@
+ 
+ extern const compat_ulong_t aarch32_sigret_code[6];
+ 
+-int compat_setup_frame(int usig, struct k_sigaction *ka, sigset_t *set,
++int compat_setup_frame(int usig, struct ksignal *ksig, sigset_t *set,
+ 		       struct pt_regs *regs);
+-int compat_setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
+-			  sigset_t *set, struct pt_regs *regs);
++int compat_setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs);
+ 
+ void compat_setup_restart_syscall(struct pt_regs *regs);
+ #else
+ 
+-static inline int compat_setup_frame(int usid, struct k_sigaction *ka,
++static inline int compat_setup_frame(int usid, struct ksignal *ksig,
+ 				     sigset_t *set, struct pt_regs *regs)
+ {
+ 	return -ENOSYS;
+ }
+ 
+-static inline int compat_setup_rt_frame(int usig, struct k_sigaction *ka,
+-					siginfo_t *info, sigset_t *set,
++static inline int compat_setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set,
+ 					struct pt_regs *regs)
+ {
+ 	return -ENOSYS;
+--- a/arch/arm64/kernel/signal.c
++++ b/arch/arm64/kernel/signal.c
+@@ -253,13 +253,13 @@ static void setup_return(struct pt_regs
+ 	regs->regs[30] = (unsigned long)sigtramp;
+ }
+ 
+-static int setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
+-			  sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs);
++	frame = get_sigframe(&ksig->ka, regs);
+ 	if (!frame)
+ 		return 1;
+ 
+@@ -269,9 +269,9 @@ static int setup_rt_frame(int usig, stru
+ 	err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
+ 	err |= setup_sigframe(frame, regs, set);
+ 	if (err == 0) {
+-		setup_return(regs, ka, frame, usig);
+-		if (ka->sa.sa_flags & SA_SIGINFO) {
+-			err |= copy_siginfo_to_user(&frame->info, info);
++		setup_return(regs, &ksig->ka, frame, usig);
++		if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
++			err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 			regs->regs[1] = (unsigned long)&frame->info;
+ 			regs->regs[2] = (unsigned long)&frame->uc;
+ 		}
+@@ -291,13 +291,12 @@ static void setup_restart_syscall(struct
+ /*
+  * OK, we're invoking a handler
+  */
+-static void handle_signal(unsigned long sig, struct k_sigaction *ka,
+-			  siginfo_t *info, struct pt_regs *regs)
++static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	struct thread_info *thread = current_thread_info();
+ 	struct task_struct *tsk = current;
+ 	sigset_t *oldset = sigmask_to_save();
+-	int usig = sig;
++	int usig = ksig->sig;
+ 	int ret;
+ 
+ 	/*
+@@ -310,13 +309,12 @@ static void handle_signal(unsigned long
+ 	 * Set up the stack frame
+ 	 */
+ 	if (is_compat_task()) {
+-		if (ka->sa.sa_flags & SA_SIGINFO)
+-			ret = compat_setup_rt_frame(usig, ka, info, oldset,
+-						    regs);
++		if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++			ret = compat_setup_rt_frame(usig, ksig, oldset, regs);
+ 		else
+-			ret = compat_setup_frame(usig, ka, oldset, regs);
++			ret = compat_setup_frame(usig, ksig, oldset, regs);
+ 	} else {
+-		ret = setup_rt_frame(usig, ka, info, oldset, regs);
++		ret = setup_rt_frame(usig, ksig, oldset, regs);
+ 	}
+ 
+ 	/*
+@@ -324,18 +322,14 @@ static void handle_signal(unsigned long
+ 	 */
+ 	ret |= !valid_user_regs(&regs->user_regs, current);
+ 
+-	if (ret != 0) {
+-		force_sigsegv(sig, tsk);
+-		return;
+-	}
+-
+ 	/*
+ 	 * Fast forward the stepping logic so we step into the signal
+ 	 * handler.
+ 	 */
+-	user_fastforward_single_step(tsk);
++	if (!ret)
++		user_fastforward_single_step(tsk);
+ 
+-	signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ /*
+@@ -350,10 +344,9 @@ static void handle_signal(unsigned long
+ static void do_signal(struct pt_regs *regs)
+ {
+ 	unsigned long continue_addr = 0, restart_addr = 0;
+-	struct k_sigaction ka;
+-	siginfo_t info;
+-	int signr, retval = 0;
++	int retval = 0;
+ 	int syscall = (int)regs->syscallno;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * If we were from a system call, check for system call restarting...
+@@ -387,8 +380,7 @@ static void do_signal(struct pt_regs *re
+ 	 * Get the signal to deliver. When running under ptrace, at this point
+ 	 * the debugger may change all of our registers.
+ 	 */
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/*
+ 		 * Depending on the signal settings, we may need to revert the
+ 		 * decision to restart the system call, but skip this if a
+@@ -398,12 +390,12 @@ static void do_signal(struct pt_regs *re
+ 		    (retval == -ERESTARTNOHAND ||
+ 		     retval == -ERESTART_RESTARTBLOCK ||
+ 		     (retval == -ERESTARTSYS &&
+-		      !(ka.sa.sa_flags & SA_RESTART)))) {
++		      !(ksig.ka.sa.sa_flags & SA_RESTART)))) {
+ 			regs->regs[0] = -EINTR;
+ 			regs->pc = continue_addr;
+ 		}
+ 
+-		handle_signal(signr, &ka, &info, regs);
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
+--- a/arch/arm64/kernel/signal32.c
++++ b/arch/arm64/kernel/signal32.c
+@@ -543,18 +543,18 @@ static int compat_setup_sigframe(struct
+ /*
+  * 32-bit signal handling routines called from signal.c
+  */
+-int compat_setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
++int compat_setup_rt_frame(int usig, struct ksignal *ksig,
+ 			  sigset_t *set, struct pt_regs *regs)
+ {
+ 	struct compat_rt_sigframe __user *frame;
+ 	int err = 0;
+ 
+-	frame = compat_get_sigframe(ka, regs, sizeof(*frame));
++	frame = compat_get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!frame)
+ 		return 1;
+ 
+-	err |= copy_siginfo_to_user32(&frame->info, info);
++	err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
+ 
+ 	__put_user_error(0, &frame->sig.uc.uc_flags, err);
+ 	__put_user_error(0, &frame->sig.uc.uc_link, err);
+@@ -564,7 +564,7 @@ int compat_setup_rt_frame(int usig, stru
+ 	err |= compat_setup_sigframe(&frame->sig, regs, set);
+ 
+ 	if (err == 0) {
+-		compat_setup_return(regs, ka, frame->sig.retcode, frame, usig);
++		compat_setup_return(regs, &ksig->ka, frame->sig.retcode, frame, usig);
+ 		regs->regs[1] = (compat_ulong_t)(unsigned long)&frame->info;
+ 		regs->regs[2] = (compat_ulong_t)(unsigned long)&frame->sig.uc;
+ 	}
+@@ -572,13 +572,13 @@ int compat_setup_rt_frame(int usig, stru
+ 	return err;
+ }
+ 
+-int compat_setup_frame(int usig, struct k_sigaction *ka, sigset_t *set,
++int compat_setup_frame(int usig, struct ksignal *ksig, sigset_t *set,
+ 		       struct pt_regs *regs)
+ {
+ 	struct compat_sigframe __user *frame;
+ 	int err = 0;
+ 
+-	frame = compat_get_sigframe(ka, regs, sizeof(*frame));
++	frame = compat_get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!frame)
+ 		return 1;
+@@ -587,7 +587,7 @@ int compat_setup_frame(int usig, struct
+ 
+ 	err |= compat_setup_sigframe(frame, regs, set);
+ 	if (err == 0)
+-		compat_setup_return(regs, ka, frame->retcode, frame, usig);
++		compat_setup_return(regs, &ksig->ka, frame->retcode, frame, usig);
+ 
+ 	return err;
+ }
diff --git a/queue-3.16/avr32-use-get_signal-signal_setup_done.patch b/queue-3.16/avr32-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..d17c2111
--- /dev/null
+++ b/queue-3.16/avr32-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,154 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 6 Oct 2013 23:00:56 +0200
+Subject: avr32: Use get_signal() signal_setup_done()
+
+commit d809709a8845954a95c2ac86c13bd0dfd549c1ae upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+Acked-by: Hans-Christian Egtvedt <egtvedt@samfundet.no>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/avr32/kernel/signal.c | 43 ++++++++++++++++----------------------
+ 1 file changed, 18 insertions(+), 25 deletions(-)
+
+--- a/arch/avr32/kernel/signal.c
++++ b/arch/avr32/kernel/signal.c
+@@ -138,13 +138,12 @@ get_sigframe(struct k_sigaction *ka, str
+ }
+ 
+ static int
+-setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-	       sigset_t *set, struct pt_regs *regs)
++setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	err = -EFAULT;
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+ 		goto out;
+@@ -164,7 +163,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	err = __put_user(0x3008d733 | (__NR_rt_sigreturn << 20),
+ 			 &frame->retcode);
+ 
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	/* Set up the ucontext */
+ 	err |= __put_user(0, &frame->uc.uc_flags);
+@@ -176,12 +175,12 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	if (err)
+ 		goto out;
+ 
+-	regs->r12 = sig;
++	regs->r12 = ksig->sig;
+ 	regs->r11 = (unsigned long) &frame->info;
+ 	regs->r10 = (unsigned long) &frame->uc;
+ 	regs->sp = (unsigned long) frame;
+-	if (ka->sa.sa_flags & SA_RESTORER)
+-		regs->lr = (unsigned long)ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER)
++		regs->lr = (unsigned long)ksig->ka.sa.sa_restorer;
+ 	else {
+ 		printk(KERN_NOTICE "[%s:%d] did not set SA_RESTORER\n",
+ 		       current->comm, current->pid);
+@@ -189,10 +188,10 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	}
+ 
+ 	pr_debug("SIG deliver [%s:%d]: sig=%d sp=0x%lx pc=0x%lx->0x%p lr=0x%lx\n",
+-		 current->comm, current->pid, sig, regs->sp,
+-		 regs->pc, ka->sa.sa_handler, regs->lr);
++		 current->comm, current->pid, ksig->sig, regs->sp,
++		 regs->pc, ksig->ka.sa.sa_handler, regs->lr);
+ 
+-	regs->pc = (unsigned long) ka->sa.sa_handler;
++	regs->pc = (unsigned long)ksig->ka.sa.sa_handler;
+ 
+ out:
+ 	return err;
+@@ -208,15 +207,14 @@ static inline void setup_syscall_restart
+ }
+ 
+ static inline void
+-handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
+-	      struct pt_regs *regs, int syscall)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs, int syscall)
+ {
+ 	int ret;
+ 
+ 	/*
+ 	 * Set up the stack frame
+ 	 */
+-	ret = setup_rt_frame(sig, ka, info, sigmask_to_save(), regs);
++	ret = setup_rt_frame(ksig, sigmask_to_save(), regs);
+ 
+ 	/*
+ 	 * Check that the resulting registers are sane
+@@ -226,10 +224,7 @@ handle_signal(unsigned long sig, struct
+ 	/*
+ 	 * Block the signal if we were successful.
+ 	 */
+-	if (ret != 0)
+-		force_sigsegv(sig, current);
+-	else
+-		signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ /*
+@@ -239,9 +234,7 @@ handle_signal(unsigned long sig, struct
+  */
+ static void do_signal(struct pt_regs *regs, int syscall)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * We want the common case to go fast, which is why we may in
+@@ -251,18 +244,18 @@ static void do_signal(struct pt_regs *re
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
++	get_signal(&ksig);
+ 	if (syscall) {
+ 		switch (regs->r12) {
+ 		case -ERESTART_RESTARTBLOCK:
+ 		case -ERESTARTNOHAND:
+-			if (signr > 0) {
++			if (ksig.sig > 0) {
+ 				regs->r12 = -EINTR;
+ 				break;
+ 			}
+ 			/* fall through */
+ 		case -ERESTARTSYS:
+-			if (signr > 0 && !(ka.sa.sa_flags & SA_RESTART)) {
++			if (ksig.sig > 0 && !(ksig.ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->r12 = -EINTR;
+ 				break;
+ 			}
+@@ -272,13 +265,13 @@ static void do_signal(struct pt_regs *re
+ 		}
+ 	}
+ 
+-	if (signr == 0) {
++	if (!ksig.sig) {
+ 		/* No signal to deliver -- put the saved sigmask back */
+ 		restore_saved_sigmask();
+ 		return;
+ 	}
+ 
+-	handle_signal(signr, &ka, &info, regs, syscall);
++	handle_signal(&ksig, regs, syscall);
+ }
+ 
+ asmlinkage void do_notify_resume(struct pt_regs *regs, struct thread_info *ti)
diff --git a/queue-3.16/blackfin-use-get_signal-signal_setup_done.patch b/queue-3.16/blackfin-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..ea84c9da
--- /dev/null
+++ b/queue-3.16/blackfin-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,115 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 6 Oct 2013 23:06:08 +0200
+Subject: blackfin: Use get_signal() signal_setup_done()
+
+commit 1270cff147a39f7da5b25225dca6ca3132ca6130 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+Acked-by: Steven Miao <realmz6@gmail.com>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/blackfin/kernel/signal.c | 39 +++++++++++++++--------------------
+ 1 file changed, 17 insertions(+), 22 deletions(-)
+
+--- a/arch/blackfin/kernel/signal.c
++++ b/arch/blackfin/kernel/signal.c
+@@ -152,23 +152,22 @@ static inline void *get_sigframe(struct
+ }
+ 
+ static int
+-setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t * info,
+-	       sigset_t * set, struct pt_regs *regs)
++setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
+ {
+ 	struct rt_sigframe *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	err |= __put_user((current_thread_info()->exec_domain
+ 			   && current_thread_info()->exec_domain->signal_invmap
+-			   && sig < 32
++			   && ksig->sig < 32
+ 			   ? current_thread_info()->exec_domain->
+-			   signal_invmap[sig] : sig), &frame->sig);
++			   signal_invmap[ksig->sig] : ksig->sig), &frame->sig);
+ 
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	/* Create the ucontext.  */
+ 	err |= __put_user(0, &frame->uc.uc_flags);
+@@ -183,7 +182,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	/* Set up registers for signal handler */
+ 	if (current->personality & FDPIC_FUNCPTRS) {
+ 		struct fdpic_func_descriptor __user *funcptr =
+-			(struct fdpic_func_descriptor *) ka->sa.sa_handler;
++			(struct fdpic_func_descriptor *) ksig->ka.sa.sa_handler;
+ 		u32 pc, p3;
+ 		err |= __get_user(pc, &funcptr->text);
+ 		err |= __get_user(p3, &funcptr->GOT);
+@@ -192,7 +191,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 		regs->pc = pc;
+ 		regs->p3 = p3;
+ 	} else
+-		regs->pc = (unsigned long)ka->sa.sa_handler;
++		regs->pc = (unsigned long)ksig->ka.sa.sa_handler;
+ 	wrusp((unsigned long)frame);
+ 	regs->rets = SIGRETURN_STUB;
+ 
+@@ -237,20 +236,19 @@ handle_restart(struct pt_regs *regs, str
+  * OK, we're invoking a handler
+  */
+ static void
+-handle_signal(int sig, siginfo_t *info, struct k_sigaction *ka,
+-	      struct pt_regs *regs)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
++	int ret;
++
+ 	/* are we from a system call? to see pt_regs->orig_p0 */
+ 	if (regs->orig_p0 >= 0)
+ 		/* If so, check system call restarting.. */
+-		handle_restart(regs, ka, 1);
++		handle_restart(regs, &ksig->ka, 1);
+ 
+ 	/* set up the stack frame */
+-	if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs) < 0)
+-		force_sigsegv(sig, current);
+-	else 
+-		signal_delivered(sig, info, ka, regs,
+-				test_thread_flag(TIF_SINGLESTEP));
++	ret = setup_rt_frame(ksig, sigmask_to_save(), regs);
++
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ }
+ 
+ /*
+@@ -264,16 +262,13 @@ handle_signal(int sig, siginfo_t *info,
+  */
+ asmlinkage void do_signal(struct pt_regs *regs)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	current->thread.esp0 = (unsigned long)regs;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Whee!  Actually deliver the signal.  */
+-		handle_signal(signr, &info, &ka, regs);
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/c6x-use-get_signal-signal_setup_done.patch b/queue-3.16/c6x-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..f9954a9a
--- /dev/null
+++ b/queue-3.16/c6x-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,139 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 6 Oct 2013 23:09:48 +0200
+Subject: c6x: Use get_signal() signal_setup_done()
+
+commit e19c025bc9a184ed9c5daf06ffb89abc81d1696a upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Tested-by: Mark Salter <msalter@redhat.com>
+Acked-by: Mark Salter <msalter@redhat.com>
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/c6x/kernel/signal.c | 43 +++++++++++++++++-----------------------
+ 1 file changed, 18 insertions(+), 25 deletions(-)
+
+--- a/arch/c6x/kernel/signal.c
++++ b/arch/c6x/kernel/signal.c
+@@ -146,21 +146,21 @@ static inline void __user *get_sigframe(
+ 	return (void __user *)((sp - framesize) & ~7);
+ }
+ 
+-static int setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info,
+-			   sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	unsigned long __user *retcode;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto segv_and_exit;
++		return -EFAULT;
+ 
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	/* Clear all the bits of the ucontext we don't use.  */
+ 	err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
+@@ -188,7 +188,7 @@ static int setup_rt_frame(int signr, str
+ #undef COPY
+ 
+ 	if (err)
+-		goto segv_and_exit;
++		return -EFAULT;
+ 
+ 	flush_icache_range((unsigned long) &frame->retcode,
+ 			   (unsigned long) &frame->retcode + RETCODE_SIZE);
+@@ -198,10 +198,10 @@ static int setup_rt_frame(int signr, str
+ 	/* Change user context to branch to signal handler */
+ 	regs->sp = (unsigned long) frame - 8;
+ 	regs->b3 = (unsigned long) retcode;
+-	regs->pc = (unsigned long) ka->sa.sa_handler;
++	regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
+ 
+ 	/* Give the signal number to the handler */
+-	regs->a4 = signr;
++	regs->a4 = ksig->sig;
+ 
+ 	/*
+ 	 * For realtime signals we must also set the second and third
+@@ -212,10 +212,6 @@ static int setup_rt_frame(int signr, str
+ 	regs->a6 = (unsigned long)&frame->uc;
+ 
+ 	return 0;
+-
+-segv_and_exit:
+-	force_sigsegv(signr, current);
+-	return -EFAULT;
+ }
+ 
+ static inline void
+@@ -245,10 +241,11 @@ do_restart:
+ /*
+  * handle the actual delivery of a signal to userspace
+  */
+-static void handle_signal(int sig,
+-			 siginfo_t *info, struct k_sigaction *ka,
+-			 struct pt_regs *regs, int syscall)
++static void handle_signal(struct ksignal *ksig, struct pt_regs *regs,
++			  int syscall)
+ {
++	int ret;
++
+ 	/* Are we from a system call? */
+ 	if (syscall) {
+ 		/* If so, check system call restarting.. */
+@@ -259,7 +256,7 @@ static void handle_signal(int sig,
+ 			break;
+ 
+ 		case -ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->a4 = -EINTR;
+ 				break;
+ 			}
+@@ -272,9 +269,8 @@ static void handle_signal(int sig,
+ 	}
+ 
+ 	/* Set up the stack frame */
+-	if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs) < 0)
+-		return;
+-	signal_delivered(sig, info, ka, regs, 0);
++	ret = setup_rt_frame(ksig, sigmask_to_save(), regs);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ /*
+@@ -282,18 +278,15 @@ static void handle_signal(int sig,
+  */
+ static void do_signal(struct pt_regs *regs, int syscall)
+ {
+-	struct k_sigaction ka;
+-	siginfo_t info;
+-	int signr;
++	struct ksignal ksig;
+ 
+ 	/* we want the common case to go fast, which is why we may in certain
+ 	 * cases get here from kernel mode */
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
+-		handle_signal(signr, &info, &ka, regs, syscall);
++	if (get_signal(&ksig)) {
++		handle_signal(&ksig, regs, syscall);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/cris-use-get_signal-signal_setup_done.patch b/queue-3.16/cris-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..04d21806
--- /dev/null
+++ b/queue-3.16/cris-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,442 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 12:56:24 +0200
+Subject: cris: Use get_signal() signal_setup_done()
+
+commit fa0197722eb7559a6a9733881bbb8d9e76364f33 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/cris/arch-v10/kernel/signal.c | 79 +++++++++++++-----------------
+ arch/cris/arch-v32/kernel/signal.c | 77 ++++++++++++-----------------
+ 2 files changed, 63 insertions(+), 93 deletions(-)
+
+--- a/arch/cris/arch-v10/kernel/signal.c
++++ b/arch/cris/arch-v10/kernel/signal.c
+@@ -228,33 +228,33 @@ get_sigframe(struct k_sigaction *ka, str
+  * user-mode trampoline.
+  */
+ 
+-static int setup_frame(int sig, struct k_sigaction *ka,
+-		       sigset_t *set, struct pt_regs *regs)
++static int setup_frame(struct ksignal *ksig, sigset_t *set,
++		       struct pt_regs *regs)
+ {
+ 	struct sigframe __user *frame;
+ 	unsigned long return_ip;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (_NSIG_WORDS > 1) {
+ 		err |= __copy_to_user(frame->extramask, &set->sig[1],
+ 				      sizeof(frame->extramask));
+ 	}
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		return_ip = (unsigned long)ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		return_ip = (unsigned long)ksig->ka.sa.sa_restorer;
+ 	} else {
+ 		/* trampoline - the desired return ip is the retcode itself */
+ 		return_ip = (unsigned long)&frame->retcode;
+@@ -265,42 +265,38 @@ static int setup_frame(int sig, struct k
+ 	}
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up registers for signal handler */
+ 
+-	regs->irp = (unsigned long) ka->sa.sa_handler;  /* what we enter NOW   */
++	regs->irp = (unsigned long) ksig->ka.sa.sa_handler;  /* what we enter NOW   */
+ 	regs->srp = return_ip;                          /* what we enter LATER */
+-	regs->r10 = sig;                                /* first argument is signo */
++	regs->r10 = ksig->sig;                                /* first argument is signo */
+ 
+ 	/* actually move the usp to reflect the stacked frame */
+ 
+ 	wrusp((unsigned long)frame);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-	sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	unsigned long return_ip;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Clear all the bits of the ucontext we don't use.  */
+         err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
+@@ -312,12 +308,12 @@ static int setup_rt_frame(int sig, struc
+ 	err |= __save_altstack(&frame->uc.uc_stack, rdusp());
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		return_ip = (unsigned long)ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		return_ip = (unsigned long)ksig->ka.sa.sa_restorer;
+ 	} else {
+ 		/* trampoline - the desired return ip is the retcode itself */
+ 		return_ip = (unsigned long)&frame->retcode;
+@@ -329,18 +325,18 @@ static int setup_rt_frame(int sig, struc
+ 	}
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* TODO what is the current->exec_domain stuff and invmap ? */
+ 
+ 	/* Set up registers for signal handler */
+ 
+ 	/* What we enter NOW   */
+-	regs->irp = (unsigned long) ka->sa.sa_handler;
++	regs->irp = (unsigned long) ksig->ka.sa.sa_handler;
+ 	/* What we enter LATER */
+ 	regs->srp = return_ip;
+ 	/* First argument is signo */
+-	regs->r10 = sig;
++	regs->r10 = ksig->sig;
+ 	/* Second argument is (siginfo_t *) */
+ 	regs->r11 = (unsigned long)&frame->info;
+ 	/* Third argument is unused */
+@@ -350,19 +346,14 @@ static int setup_rt_frame(int sig, struc
+ 	wrusp((unsigned long)frame);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ /*
+  * OK, we're invoking a handler
+  */
+ 
+-static inline void handle_signal(int canrestart, unsigned long sig,
+-	siginfo_t *info, struct k_sigaction *ka,
+-	struct pt_regs *regs)
++static inline void handle_signal(int canrestart, struct ksignal *ksig,
++				 struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+@@ -383,7 +374,7 @@ static inline void handle_signal(int can
+ 			/* ERESTARTSYS means to restart the syscall if
+ 			 * there is no handler or the handler was
+ 			 * registered with SA_RESTART */
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->r10 = -EINTR;
+ 				break;
+ 			}
+@@ -396,13 +387,12 @@ static inline void handle_signal(int can
+ 	}
+ 
+ 	/* Set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(sig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame(ksig, oldset, regs);
+ 	else
+-		ret = setup_frame(sig, ka, oldset, regs);
++		ret = setup_frame(ksig, oldset, regs);
+ 
+-	if (ret == 0)
+-		signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ /*
+@@ -419,9 +409,7 @@ static inline void handle_signal(int can
+ 
+ void do_signal(int canrestart, struct pt_regs *regs)
+ {
+-	siginfo_t info;
+-	int signr;
+-        struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * We want the common case to go fast, which
+@@ -432,10 +420,9 @@ void do_signal(int canrestart, struct pt
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Whee!  Actually deliver the signal.  */
+-		handle_signal(canrestart, signr, &info, &ka, regs);
++		handle_signal(canrestart, &ksig, regs);
+ 		return;
+ 	}
+ 
+--- a/arch/cris/arch-v32/kernel/signal.c
++++ b/arch/cris/arch-v32/kernel/signal.c
+@@ -215,23 +215,22 @@ get_sigframe(struct k_sigaction *ka, str
+  * trampoline.
+   */
+ static int
+-setup_frame(int sig, struct k_sigaction *ka,  sigset_t *set,
+-	    struct pt_regs * regs)
++setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
+ {
+ 	int err;
+ 	unsigned long return_ip;
+ 	struct signal_frame __user *frame;
+ 
+ 	err = 0;
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (_NSIG_WORDS > 1) {
+ 		err |= __copy_to_user(frame->extramask, &set->sig[1],
+@@ -239,14 +238,14 @@ setup_frame(int sig, struct k_sigaction
+ 	}
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Set up to return from user-space. If provided, use a stub
+ 	 * already located in user-space.
+ 	 */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		return_ip = (unsigned long)ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		return_ip = (unsigned long)ksig->ka.sa.sa_restorer;
+ 	} else {
+ 		/* Trampoline - the desired return ip is in the signal return page. */
+ 		return_ip = cris_signal_return_page;
+@@ -264,7 +263,7 @@ setup_frame(int sig, struct k_sigaction
+ 	}
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Set up registers for signal handler.
+@@ -273,42 +272,37 @@ setup_frame(int sig, struct k_sigaction
+ 	 * Where the code enter later.
+ 	 * First argument, signo.
+ 	 */
+-	regs->erp = (unsigned long) ka->sa.sa_handler;
++	regs->erp = (unsigned long) ksig->ka.sa.sa_handler;
+ 	regs->srp = return_ip;
+-	regs->r10 = sig;
++	regs->r10 = ksig->sig;
+ 
+ 	/* Actually move the USP to reflect the stacked frame. */
+ 	wrusp((unsigned long)frame);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ static int
+-setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-	       sigset_t *set, struct pt_regs * regs)
++setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
+ {
+ 	int err;
+ 	unsigned long return_ip;
+ 	struct rt_signal_frame __user *frame;
+ 
+ 	err = 0;
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* TODO: what is the current->exec_domain stuff and invmap ? */
+ 
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Clear all the bits of the ucontext we don't use.  */
+ 	err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
+@@ -317,14 +311,14 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	err |= __save_altstack(&frame->uc.uc_stack, rdusp());
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Set up to return from user-space. If provided, use a stub
+ 	 * already located in user-space.
+ 	 */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		return_ip = (unsigned long) ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		return_ip = (unsigned long) ksig->ka.sa.sa_restorer;
+ 	} else {
+ 		/* Trampoline - the desired return ip is in the signal return page. */
+ 		return_ip = cris_signal_return_page + 6;
+@@ -345,7 +339,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	}
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Set up registers for signal handler.
+@@ -356,9 +350,9 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	 * Second argument is (siginfo_t *).
+ 	 * Third argument is unused.
+ 	 */
+-	regs->erp = (unsigned long) ka->sa.sa_handler;
++	regs->erp = (unsigned long) ksig->ka.sa.sa_handler;
+ 	regs->srp = return_ip;
+-	regs->r10 = sig;
++	regs->r10 = ksig->sig;
+ 	regs->r11 = (unsigned long) &frame->info;
+ 	regs->r12 = 0;
+ 
+@@ -366,17 +360,11 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	wrusp((unsigned long)frame);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ /* Invoke a signal handler to, well, handle the signal. */
+ static inline void
+-handle_signal(int canrestart, unsigned long sig,
+-	      siginfo_t *info, struct k_sigaction *ka,
+-              struct pt_regs * regs)
++handle_signal(int canrestart, struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+@@ -404,7 +392,7 @@ handle_signal(int canrestart, unsigned l
+                                  * there is no handler, or the handler
+                                  * was registered with SA_RESTART.
+ 				 */
+-				if (!(ka->sa.sa_flags & SA_RESTART)) {
++				if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 					regs->r10 = -EINTR;
+ 					break;
+ 				}
+@@ -423,13 +411,12 @@ handle_signal(int canrestart, unsigned l
+         }
+ 
+ 	/* Set up the stack frame. */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(sig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame(ksig, oldset, regs);
+ 	else
+-		ret = setup_frame(sig, ka, oldset, regs);
++		ret = setup_frame(ksig, oldset, regs);
+ 
+-	if (ret == 0)
+-		signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ /*
+@@ -446,9 +433,7 @@ handle_signal(int canrestart, unsigned l
+ void
+ do_signal(int canrestart, struct pt_regs *regs)
+ {
+-	int signr;
+-	siginfo_t info;
+-        struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * The common case should go fast, which is why this point is
+@@ -458,11 +443,9 @@ do_signal(int canrestart, struct pt_regs
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Whee!  Actually deliver the signal.  */
+-		handle_signal(canrestart, signr, &info, &ka, regs);
++		handle_signal(canrestart, &ksig, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/dmaengine-bcm2835-add-additional-defines-for-dma-registers.patch b/queue-3.16/dmaengine-bcm2835-add-additional-defines-for-dma-registers.patch
new file mode 100644
index 00000000..4d9d980e
--- /dev/null
+++ b/queue-3.16/dmaengine-bcm2835-add-additional-defines-for-dma-registers.patch
@@ -0,0 +1,97 @@
+From: Martin Sperl <kernel@martin.sperl.org>
+Date: Wed, 16 Mar 2016 12:24:57 -0700
+Subject: dmaengine: bcm2835: add additional defines for DMA-registers
+
+commit e42685d7a7d5afa6278561ffd85c475eae246be3 upstream.
+
+Add additional defines describing the DMA registers
+as well as adding some more documentation to those registers.
+
+Signed-off-by: Martin Sperl <kernel@martin.sperl.org>
+Reviewed-by: Eric Anholt <eric@anholt.net>
+Signed-off-by: Eric Anholt <eric@anholt.net>
+Signed-off-by: Vinod Koul <vinod.koul@intel.com>
+[bwh: Backported to 3.16 as dependency of commit 9e528c799d17
+ "dmaengine: bcm2835: Fix abort of transactions"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ drivers/dma/bcm2835-dma.c | 57 +++++++++++++++++++++++++++++++++------
+ 1 file changed, 49 insertions(+), 8 deletions(-)
+
+--- a/drivers/dma/bcm2835-dma.c
++++ b/drivers/dma/bcm2835-dma.c
+@@ -91,26 +91,67 @@ struct bcm2835_desc {
+ 
+ #define BCM2835_DMA_CS		0x00
+ #define BCM2835_DMA_ADDR	0x04
++#define BCM2835_DMA_TI		0x08
+ #define BCM2835_DMA_SOURCE_AD	0x0c
+ #define BCM2835_DMA_DEST_AD	0x10
+-#define BCM2835_DMA_NEXTCB	0x1C
++#define BCM2835_DMA_LEN		0x14
++#define BCM2835_DMA_STRIDE	0x18
++#define BCM2835_DMA_NEXTCB	0x1c
++#define BCM2835_DMA_DEBUG	0x20
+ 
+ /* DMA CS Control and Status bits */
+-#define BCM2835_DMA_ACTIVE	BIT(0)
+-#define BCM2835_DMA_INT	BIT(2)
++#define BCM2835_DMA_ACTIVE	BIT(0)  /* activate the DMA */
++#define BCM2835_DMA_END		BIT(1)  /* current CB has ended */
++#define BCM2835_DMA_INT		BIT(2)  /* interrupt status */
++#define BCM2835_DMA_DREQ	BIT(3)  /* DREQ state */
+ #define BCM2835_DMA_ISPAUSED	BIT(4)  /* Pause requested or not active */
+ #define BCM2835_DMA_ISHELD	BIT(5)  /* Is held by DREQ flow control */
+-#define BCM2835_DMA_ERR	BIT(8)
++#define BCM2835_DMA_WAITING_FOR_WRITES BIT(6) /* waiting for last
++					       * AXI-write to ack
++					       */
++#define BCM2835_DMA_ERR		BIT(8)
++#define BCM2835_DMA_PRIORITY(x) ((x & 15) << 16) /* AXI priority */
++#define BCM2835_DMA_PANIC_PRIORITY(x) ((x & 15) << 20) /* panic priority */
++/* current value of TI.BCM2835_DMA_WAIT_RESP */
++#define BCM2835_DMA_WAIT_FOR_WRITES BIT(28)
++#define BCM2835_DMA_DIS_DEBUG	BIT(29) /* disable debug pause signal */
+ #define BCM2835_DMA_ABORT	BIT(30) /* Stop current CB, go to next, WO */
+ #define BCM2835_DMA_RESET	BIT(31) /* WO, self clearing */
+ 
++/* Transfer information bits - also bcm2835_cb.info field */
+ #define BCM2835_DMA_INT_EN	BIT(0)
++#define BCM2835_DMA_TDMODE	BIT(1) /* 2D-Mode */
++#define BCM2835_DMA_WAIT_RESP	BIT(3) /* wait for AXI-write to be acked */
+ #define BCM2835_DMA_D_INC	BIT(4)
+-#define BCM2835_DMA_D_DREQ	BIT(6)
++#define BCM2835_DMA_D_WIDTH	BIT(5) /* 128bit writes if set */
++#define BCM2835_DMA_D_DREQ	BIT(6) /* enable DREQ for destination */
++#define BCM2835_DMA_D_IGNORE	BIT(7) /* ignore destination writes */
+ #define BCM2835_DMA_S_INC	BIT(8)
+-#define BCM2835_DMA_S_DREQ	BIT(10)
++#define BCM2835_DMA_S_WIDTH	BIT(9) /* 128bit writes if set */
++#define BCM2835_DMA_S_DREQ	BIT(10) /* enable SREQ for source */
++#define BCM2835_DMA_S_IGNORE	BIT(11) /* ignore source reads - read 0 */
++#define BCM2835_DMA_BURST_LENGTH(x) ((x & 15) << 12)
++#define BCM2835_DMA_PER_MAP(x)	((x & 31) << 16) /* REQ source */
++#define BCM2835_DMA_WAIT(x)	((x & 31) << 21) /* add DMA-wait cycles */
++#define BCM2835_DMA_NO_WIDE_BURSTS BIT(26) /* no 2 beat write bursts */
+ 
+-#define BCM2835_DMA_PER_MAP(x)	((x) << 16)
++/* debug register bits */
++#define BCM2835_DMA_DEBUG_LAST_NOT_SET_ERR	BIT(0)
++#define BCM2835_DMA_DEBUG_FIFO_ERR		BIT(1)
++#define BCM2835_DMA_DEBUG_READ_ERR		BIT(2)
++#define BCM2835_DMA_DEBUG_OUTSTANDING_WRITES_SHIFT 4
++#define BCM2835_DMA_DEBUG_OUTSTANDING_WRITES_BITS 4
++#define BCM2835_DMA_DEBUG_ID_SHIFT		16
++#define BCM2835_DMA_DEBUG_ID_BITS		9
++#define BCM2835_DMA_DEBUG_STATE_SHIFT		16
++#define BCM2835_DMA_DEBUG_STATE_BITS		9
++#define BCM2835_DMA_DEBUG_VERSION_SHIFT		25
++#define BCM2835_DMA_DEBUG_VERSION_BITS		3
++#define BCM2835_DMA_DEBUG_LITE			BIT(28)
++
++/* shared registers for all dma channels */
++#define BCM2835_DMA_INT_STATUS         0xfe0
++#define BCM2835_DMA_ENABLE             0xff0
+ 
+ #define BCM2835_DMA_DATA_TYPE_S8	1
+ #define BCM2835_DMA_DATA_TYPE_S16	2
diff --git a/queue-3.16/dmaengine-bcm2835-fix-abort-of-transactions.patch b/queue-3.16/dmaengine-bcm2835-fix-abort-of-transactions.patch
index a900cf54..c86490d1 100644
--- a/queue-3.16/dmaengine-bcm2835-fix-abort-of-transactions.patch
+++ b/queue-3.16/dmaengine-bcm2835-fix-abort-of-transactions.patch
@@ -79,7 +79,7 @@ Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
 
 --- a/drivers/dma/bcm2835-dma.c
 +++ b/drivers/dma/bcm2835-dma.c
-@@ -150,13 +150,11 @@ static void bcm2835_dma_desc_free(struct
+@@ -191,13 +191,11 @@ static void bcm2835_dma_desc_free(struct
  	kfree(desc);
  }
  
@@ -95,7 +95,7 @@ Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
  	/*
  	 * A zero control block address means the channel is idle.
  	 * (The ACTIVE flag in the CS register is not a reliable indicator.)
-@@ -168,25 +166,16 @@ static int bcm2835_dma_abort(void __iome
+@@ -209,25 +207,16 @@ static int bcm2835_dma_abort(void __iome
  	writel(0, chan_base + BCM2835_DMA_CS);
  
  	/* Wait for any current AXI transfer to complete */
@@ -127,7 +127,7 @@ Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
  	return 0;
  }
  
-@@ -465,7 +454,6 @@ static int bcm2835_dma_terminate_all(str
+@@ -506,7 +495,6 @@ static int bcm2835_dma_terminate_all(str
  {
  	struct bcm2835_dmadev *d = to_bcm2835_dma_dev(c->vc.chan.device);
  	unsigned long flags;
@@ -135,7 +135,7 @@ Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
  	LIST_HEAD(head);
  
  	spin_lock_irqsave(&c->vc.lock, flags);
-@@ -478,18 +466,7 @@ static int bcm2835_dma_terminate_all(str
+@@ -519,18 +507,7 @@ static int bcm2835_dma_terminate_all(str
  	/* stop DMA activity */
  	if (c->desc) {
  		c->desc = NULL;
diff --git a/queue-3.16/dmaengine-bcm2835-fix-interrupt-race-on-rt.patch b/queue-3.16/dmaengine-bcm2835-fix-interrupt-race-on-rt.patch
index 879997b4..e9791249 100644
--- a/queue-3.16/dmaengine-bcm2835-fix-interrupt-race-on-rt.patch
+++ b/queue-3.16/dmaengine-bcm2835-fix-interrupt-race-on-rt.patch
@@ -81,7 +81,7 @@ Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
 
 --- a/drivers/dma/bcm2835-dma.c
 +++ b/drivers/dma/bcm2835-dma.c
-@@ -156,7 +156,12 @@ static int bcm2835_dma_abort(void __iome
+@@ -197,7 +197,12 @@ static int bcm2835_dma_abort(void __iome
  	long int timeout = 10000;
  
  	cs = readl(chan_base + BCM2835_DMA_CS);
@@ -95,7 +95,7 @@ Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
  		return 0;
  
  	/* Write 0 to the active bit - Pause the DMA */
-@@ -211,8 +216,15 @@ static irqreturn_t bcm2835_dma_callback(
+@@ -252,8 +257,15 @@ static irqreturn_t bcm2835_dma_callback(
  
  	spin_lock_irqsave(&c->vc.lock, flags);
  
@@ -113,7 +113,7 @@ Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
  
  	d = c->desc;
  
-@@ -221,9 +233,6 @@ static irqreturn_t bcm2835_dma_callback(
+@@ -262,9 +274,6 @@ static irqreturn_t bcm2835_dma_callback(
  		vchan_cyclic_callback(&d->vd);
  	}
  
@@ -123,7 +123,7 @@ Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
  	spin_unlock_irqrestore(&c->vc.lock, flags);
  
  	return IRQ_HANDLED;
-@@ -466,19 +475,14 @@ static int bcm2835_dma_terminate_all(str
+@@ -507,19 +516,14 @@ static int bcm2835_dma_terminate_all(str
  	list_del_init(&c->node);
  	spin_unlock(&d->lock);
  
diff --git a/queue-3.16/frv-use-get_signal-signal_setup_done.patch b/queue-3.16/frv-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..ab8d9fe5
--- /dev/null
+++ b/queue-3.16/frv-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,267 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 13:46:11 +0200
+Subject: frv: Use get_signal() signal_setup_done()
+
+commit 720f36b983224ac52b6acdd8b646ce30f6b38763 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/frv/kernel/signal.c | 99 ++++++++++++++++------------------------
+ 1 file changed, 40 insertions(+), 59 deletions(-)
+
+--- a/arch/frv/kernel/signal.c
++++ b/arch/frv/kernel/signal.c
+@@ -180,17 +180,17 @@ static inline void __user *get_sigframe(
+ /*
+  *
+  */
+-static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set)
++static int setup_frame(struct ksignal *ksig, sigset_t *set)
+ {
+ 	struct sigframe __user *frame;
+-	int rsig;
++	int rsig, sig = ksig->sig;
+ 
+ 	set_fs(USER_DS);
+ 
+-	frame = get_sigframe(ka, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	rsig = sig;
+ 	if (sig < 32 &&
+@@ -199,22 +199,22 @@ static int setup_frame(int sig, struct k
+ 		rsig = __current_thread_info->exec_domain->signal_invmap[sig];
+ 
+ 	if (__put_user(rsig, &frame->sig) < 0)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (setup_sigcontext(&frame->sc, set->sig[0]))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (_NSIG_WORDS > 1) {
+ 		if (__copy_to_user(frame->extramask, &set->sig[1],
+ 				   sizeof(frame->extramask)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 	}
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	 * already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		if (__put_user(ka->sa.sa_restorer, &frame->pretcode) < 0)
+-			goto give_sigsegv;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		if (__put_user(ksig->ka.sa.sa_restorer, &frame->pretcode) < 0)
++			return -EFAULT;
+ 	}
+ 	else {
+ 		/* Set up the following code on the stack:
+@@ -224,7 +224,7 @@ static int setup_frame(int sig, struct k
+ 		if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) ||
+ 		    __put_user(0x8efc0000|__NR_sigreturn, &frame->retcode[0]) ||
+ 		    __put_user(0xc0700000, &frame->retcode[1]))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 
+ 		flush_icache_range((unsigned long) frame->retcode,
+ 				   (unsigned long) (frame->retcode + 2));
+@@ -233,14 +233,14 @@ static int setup_frame(int sig, struct k
+ 	/* Set up registers for the signal handler */
+ 	if (current->personality & FDPIC_FUNCPTRS) {
+ 		struct fdpic_func_descriptor __user *funcptr =
+-			(struct fdpic_func_descriptor __user *) ka->sa.sa_handler;
++			(struct fdpic_func_descriptor __user *) ksig->ka.sa.sa_handler;
+ 		struct fdpic_func_descriptor desc;
+ 		if (copy_from_user(&desc, funcptr, sizeof(desc)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 		__frame->pc = desc.text;
+ 		__frame->gr15 = desc.GOT;
+ 	} else {
+-		__frame->pc   = (unsigned long) ka->sa.sa_handler;
++		__frame->pc   = (unsigned long) ksig->ka.sa.sa_handler;
+ 		__frame->gr15 = 0;
+ 	}
+ 
+@@ -255,29 +255,23 @@ static int setup_frame(int sig, struct k
+ #endif
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+-
+ } /* end setup_frame() */
+ 
+ /*****************************************************************************/
+ /*
+  *
+  */
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			  sigset_t *set)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set)
+ {
+ 	struct rt_sigframe __user *frame;
+-	int rsig;
++	int rsig, sig = ksig->sig;
+ 
+ 	set_fs(USER_DS);
+ 
+-	frame = get_sigframe(ka, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	rsig = sig;
+ 	if (sig < 32 &&
+@@ -288,28 +282,28 @@ static int setup_rt_frame(int sig, struc
+ 	if (__put_user(rsig,		&frame->sig) ||
+ 	    __put_user(&frame->info,	&frame->pinfo) ||
+ 	    __put_user(&frame->uc,	&frame->puc))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+-	if (copy_siginfo_to_user(&frame->info, info))
+-		goto give_sigsegv;
++	if (copy_siginfo_to_user(&frame->info, &ksig->info))
++		return -EFAULT;
+ 
+ 	/* Create the ucontext.  */
+ 	if (__put_user(0, &frame->uc.uc_flags) ||
+ 	    __put_user(NULL, &frame->uc.uc_link) ||
+ 	    __save_altstack(&frame->uc.uc_stack, __frame->sp))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (setup_sigcontext(&frame->uc.uc_mcontext, set->sig[0]))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (__copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	 * already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		if (__put_user(ka->sa.sa_restorer, &frame->pretcode))
+-			goto give_sigsegv;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		if (__put_user(ksig->ka.sa.sa_restorer, &frame->pretcode))
++			return -EFAULT;
+ 	}
+ 	else {
+ 		/* Set up the following code on the stack:
+@@ -319,7 +313,7 @@ static int setup_rt_frame(int sig, struc
+ 		if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) ||
+ 		    __put_user(0x8efc0000|__NR_rt_sigreturn, &frame->retcode[0]) ||
+ 		    __put_user(0xc0700000, &frame->retcode[1]))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 
+ 		flush_icache_range((unsigned long) frame->retcode,
+ 				   (unsigned long) (frame->retcode + 2));
+@@ -328,14 +322,14 @@ static int setup_rt_frame(int sig, struc
+ 	/* Set up registers for signal handler */
+ 	if (current->personality & FDPIC_FUNCPTRS) {
+ 		struct fdpic_func_descriptor __user *funcptr =
+-			(struct fdpic_func_descriptor __user *) ka->sa.sa_handler;
++			(struct fdpic_func_descriptor __user *) ksig->ka.sa.sa_handler;
+ 		struct fdpic_func_descriptor desc;
+ 		if (copy_from_user(&desc, funcptr, sizeof(desc)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 		__frame->pc = desc.text;
+ 		__frame->gr15 = desc.GOT;
+ 	} else {
+-		__frame->pc   = (unsigned long) ka->sa.sa_handler;
++		__frame->pc   = (unsigned long) ksig->ka.sa.sa_handler;
+ 		__frame->gr15 = 0;
+ 	}
+ 
+@@ -349,21 +343,15 @@ static int setup_rt_frame(int sig, struc
+ 	       sig, current->comm, current->pid, frame, __frame->pc,
+ 	       frame->pretcode);
+ #endif
+-
+ 	return 0;
+ 
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+-
+ } /* end setup_rt_frame() */
+ 
+ /*****************************************************************************/
+ /*
+  * OK, we're invoking a handler
+  */
+-static void handle_signal(unsigned long sig, siginfo_t *info,
+-			 struct k_sigaction *ka)
++static void handle_signal(struct ksignal *ksig)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+@@ -378,7 +366,7 @@ static void handle_signal(unsigned long
+ 			break;
+ 
+ 		case -ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				__frame->gr8 = -EINTR;
+ 				break;
+ 			}
+@@ -392,16 +380,12 @@ static void handle_signal(unsigned long
+ 	}
+ 
+ 	/* Set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(sig, ka, info, oldset);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame(ksig, oldset);
+ 	else
+-		ret = setup_frame(sig, ka, oldset);
++		ret = setup_frame(ksig, oldset);
+ 
+-	if (ret)
+-		return;
+-
+-	signal_delivered(sig, info, ka, __frame,
+-				 test_thread_flag(TIF_SINGLESTEP));
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ } /* end handle_signal() */
+ 
+ /*****************************************************************************/
+@@ -412,13 +396,10 @@ static void handle_signal(unsigned long
+  */
+ static void do_signal(void)
+ {
+-	struct k_sigaction ka;
+-	siginfo_t info;
+-	int signr;
+-
+-	signr = get_signal_to_deliver(&info, &ka, __frame, NULL);
+-	if (signr > 0) {
+-		handle_signal(signr, &info, &ka);
++	struct ksignal ksig;
++
++	if (get_signal(&ksig)) {
++		handle_signal(&ksig);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/hexagon-use-get_signal-signal_setup_done.patch b/queue-3.16/hexagon-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..f7178bbc
--- /dev/null
+++ b/queue-3.16/hexagon-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,127 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 13:50:08 +0200
+Subject: hexagon: Use get_signal() signal_setup_done()
+
+commit ac443624490f7033aefd06713e7761aee5977de3 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Acked-by: Richard Kuo <rkuo@codeaurora.org>
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/hexagon/kernel/signal.c | 45 +++++++++++++++---------------------
+ 1 file changed, 18 insertions(+), 27 deletions(-)
+
+--- a/arch/hexagon/kernel/signal.c
++++ b/arch/hexagon/kernel/signal.c
+@@ -112,20 +112,20 @@ static int restore_sigcontext(struct pt_
+ /*
+  * Setup signal stack frame with siginfo structure
+  */
+-static int setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info,
+-			  sigset_t *set,  struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	int err = 0;
+ 	struct rt_sigframe __user *frame;
+ 	struct hexagon_vdso *vdso = current->mm->context.vdso;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(struct rt_sigframe));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(struct rt_sigframe));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(struct rt_sigframe)))
+-		goto	sigsegv;
++		return -EFAULT;
+ 
+-	if (copy_siginfo_to_user(&frame->info, info))
+-		goto	sigsegv;
++	if (copy_siginfo_to_user(&frame->info, &ksig->info))
++		return -EFAULT;
+ 
+ 	/* The on-stack signal trampoline is no longer executed;
+ 	 * however, the libgcc signal frame unwinding code checks for
+@@ -137,29 +137,26 @@ static int setup_rt_frame(int signr, str
+ 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
+ 	err |= __save_altstack(&frame->uc.uc_stack, user_stack_pointer(regs));
+ 	if (err)
+-		goto sigsegv;
++		return -EFAULT;
+ 
+ 	/* Load r0/r1 pair with signumber/siginfo pointer... */
+ 	regs->r0100 = ((unsigned long long)((unsigned long)&frame->info) << 32)
+-		| (unsigned long long)signr;
++		| (unsigned long long)ksig->sig;
+ 	regs->r02 = (unsigned long) &frame->uc;
+ 	regs->r31 = (unsigned long) vdso->rt_signal_trampoline;
+ 	pt_psp(regs) = (unsigned long) frame;
+-	pt_set_elr(regs, (unsigned long)ka->sa.sa_handler);
++	pt_set_elr(regs, (unsigned long)ksig->ka.sa.sa_handler);
+ 
+ 	return 0;
+-
+-sigsegv:
+-	force_sigsegv(signr, current);
+-	return -EFAULT;
+ }
+ 
+ /*
+  * Setup invocation of signal handler
+  */
+-static void handle_signal(int sig, siginfo_t *info, struct k_sigaction *ka,
+-			 struct pt_regs *regs)
++static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
++	int ret;
++
+ 	/*
+ 	 * If we're handling a signal that aborted a system call,
+ 	 * set up the error return value before adding the signal
+@@ -173,7 +170,7 @@ static void handle_signal(int sig, sigin
+ 			regs->r00 = -EINTR;
+ 			break;
+ 		case -ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->r00 = -EINTR;
+ 				break;
+ 			}
+@@ -193,11 +190,9 @@ static void handle_signal(int sig, sigin
+ 	 * only set up the rt_frame flavor.
+ 	 */
+ 	/* If there was an error on setup, no signal was delivered. */
+-	if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs) < 0)
+-		return;
++	ret = setup_rt_frame(ksig, sigmask_to_save(), regs);
+ 
+-	signal_delivered(sig, info, ka, regs,
+-			test_thread_flag(TIF_SINGLESTEP));
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ }
+ 
+ /*
+@@ -205,17 +200,13 @@ static void handle_signal(int sig, sigin
+  */
+ void do_signal(struct pt_regs *regs)
+ {
+-	struct k_sigaction sigact;
+-	siginfo_t info;
+-	int signo;
++	struct ksignal ksig;
+ 
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signo = get_signal_to_deliver(&info, &sigact, regs, NULL);
+-
+-	if (signo > 0) {
+-		handle_signal(signo, &info, &sigact, regs);
++	if (get_signal(&ksig)) {
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/ia64-use-get_signal-signal_setup_done.patch b/queue-3.16/ia64-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..976b5277
--- /dev/null
+++ b/queue-3.16/ia64-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,158 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 23:07:51 +0200
+Subject: ia64: Use get_signal() signal_setup_done()
+
+commit 98c20309b97fc30001adf643cf876125f334fd8a upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+This inverts also the return codes of force_sigsegv_info()
+and setup_frame() to follow the kernel convention.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/ia64/kernel/signal.c | 46 ++++++++++++++++++---------------------
+ 1 file changed, 21 insertions(+), 25 deletions(-)
+
+--- a/arch/ia64/kernel/signal.c
++++ b/arch/ia64/kernel/signal.c
+@@ -309,12 +309,11 @@ force_sigsegv_info (int sig, void __user
+ 	si.si_uid = from_kuid_munged(current_user_ns(), current_uid());
+ 	si.si_addr = addr;
+ 	force_sig_info(SIGSEGV, &si, current);
+-	return 0;
++	return 1;
+ }
+ 
+ static long
+-setup_frame (int sig, struct k_sigaction *ka, siginfo_t *info, sigset_t *set,
+-	     struct sigscratch *scr)
++setup_frame(struct ksignal *ksig, sigset_t *set, struct sigscratch *scr)
+ {
+ 	extern char __kernel_sigtramp[];
+ 	unsigned long tramp_addr, new_rbs = 0, new_sp;
+@@ -323,7 +322,7 @@ setup_frame (int sig, struct k_sigaction
+ 
+ 	new_sp = scr->pt.r12;
+ 	tramp_addr = (unsigned long) __kernel_sigtramp;
+-	if (ka->sa.sa_flags & SA_ONSTACK) {
++	if (ksig->ka.sa.sa_flags & SA_ONSTACK) {
+ 		int onstack = sas_ss_flags(new_sp);
+ 
+ 		if (onstack == 0) {
+@@ -347,29 +346,29 @@ setup_frame (int sig, struct k_sigaction
+ 			 */
+ 			check_sp = (new_sp - sizeof(*frame)) & -STACK_ALIGN;
+ 			if (!likely(on_sig_stack(check_sp)))
+-				return force_sigsegv_info(sig, (void __user *)
++				return force_sigsegv_info(ksig->sig, (void __user *)
+ 							  check_sp);
+ 		}
+ 	}
+ 	frame = (void __user *) ((new_sp - sizeof(*frame)) & -STACK_ALIGN);
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		return force_sigsegv_info(sig, frame);
++		return force_sigsegv_info(ksig->sig, frame);
+ 
+-	err  = __put_user(sig, &frame->arg0);
++	err  = __put_user(ksig->sig, &frame->arg0);
+ 	err |= __put_user(&frame->info, &frame->arg1);
+ 	err |= __put_user(&frame->sc, &frame->arg2);
+ 	err |= __put_user(new_rbs, &frame->sc.sc_rbs_base);
+ 	err |= __put_user(0, &frame->sc.sc_loadrs);	/* initialize to zero */
+-	err |= __put_user(ka->sa.sa_handler, &frame->handler);
++	err |= __put_user(ksig->ka.sa.sa_handler, &frame->handler);
+ 
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	err |= __save_altstack(&frame->sc.sc_stack, scr->pt.r12);
+ 	err |= setup_sigcontext(&frame->sc, set, scr);
+ 
+ 	if (unlikely(err))
+-		return force_sigsegv_info(sig, frame);
++		return force_sigsegv_info(ksig->sig, frame);
+ 
+ 	scr->pt.r12 = (unsigned long) frame - 16;	/* new stack pointer */
+ 	scr->pt.ar_fpsr = FPSR_DEFAULT;			/* reset fpsr for signal handler */
+@@ -394,22 +393,20 @@ setup_frame (int sig, struct k_sigaction
+ 
+ #if DEBUG_SIG
+ 	printk("SIG deliver (%s:%d): sig=%d sp=%lx ip=%lx handler=%p\n",
+-	       current->comm, current->pid, sig, scr->pt.r12, frame->sc.sc_ip, frame->handler);
++	       current->comm, current->pid, ksig->sig, scr->pt.r12, frame->sc.sc_ip, frame->handler);
+ #endif
+-	return 1;
++	return 0;
+ }
+ 
+ static long
+-handle_signal (unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
+-	       struct sigscratch *scr)
++handle_signal (struct ksignal *ksig, struct sigscratch *scr)
+ {
+-	if (!setup_frame(sig, ka, info, sigmask_to_save(), scr))
+-		return 0;
++	int ret = setup_frame(ksig, sigmask_to_save(), scr);
+ 
+-	signal_delivered(sig, info, ka, &scr->pt,
+-				 test_thread_flag(TIF_SINGLESTEP));
++	if (!ret)
++		signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ 
+-	return 1;
++	return ret;
+ }
+ 
+ /*
+@@ -419,17 +416,16 @@ handle_signal (unsigned long sig, struct
+ void
+ ia64_do_signal (struct sigscratch *scr, long in_syscall)
+ {
+-	struct k_sigaction ka;
+-	siginfo_t info;
+ 	long restart = in_syscall;
+ 	long errno = scr->pt.r8;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * This only loops in the rare cases of handle_signal() failing, in which case we
+ 	 * need to push through a forced SIGSEGV.
+ 	 */
+ 	while (1) {
+-		int signr = get_signal_to_deliver(&info, &ka, &scr->pt, NULL);
++		get_signal(&ksig);
+ 
+ 		/*
+ 		 * get_signal_to_deliver() may have run a debugger (via notify_parent())
+@@ -446,7 +442,7 @@ ia64_do_signal (struct sigscratch *scr,
+ 			 */
+ 			restart = 0;
+ 
+-		if (signr <= 0)
++		if (ksig.sig <= 0)
+ 			break;
+ 
+ 		if (unlikely(restart)) {
+@@ -458,7 +454,7 @@ ia64_do_signal (struct sigscratch *scr,
+ 				break;
+ 
+ 			      case ERESTARTSYS:
+-				if ((ka.sa.sa_flags & SA_RESTART) == 0) {
++				if ((ksig.ka.sa.sa_flags & SA_RESTART) == 0) {
+ 					scr->pt.r8 = EINTR;
+ 					/* note: scr->pt.r10 is already -1 */
+ 					break;
+@@ -473,7 +469,7 @@ ia64_do_signal (struct sigscratch *scr,
+ 		 * Whee!  Actually deliver the signal.  If the delivery failed, we need to
+ 		 * continue to iterate in this loop so we can deliver the SIGSEGV...
+ 		 */
+-		if (handle_signal(signr, &ka, &info, scr))
++		if (handle_signal(&ksig, scr))
+ 			return;
+ 	}
+ 
diff --git a/queue-3.16/m32r-use-get_signal-signal_setup_done.patch b/queue-3.16/m32r-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..287286e7
--- /dev/null
+++ b/queue-3.16/m32r-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,156 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 13:54:22 +0200
+Subject: m32r: Use get_signal() signal_setup_done()
+
+commit 0f5bef660a7c3b030eb60ceb29e3b2d89f894f56 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/m32r/kernel/signal.c | 47 +++++++++++++++++----------------------
+ 1 file changed, 20 insertions(+), 27 deletions(-)
+
+--- a/arch/m32r/kernel/signal.c
++++ b/arch/m32r/kernel/signal.c
+@@ -173,17 +173,17 @@ get_sigframe(struct k_sigaction *ka, uns
+ 	return (void __user *)((sp - frame_size) & -8ul);
+ }
+ 
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			   sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	int err = 0;
+-	int signal;
++	int signal, sig = ksig->sig;
+ 
+-	frame = get_sigframe(ka, regs->spu, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs->spu, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	signal = current_thread_info()->exec_domain
+ 		&& current_thread_info()->exec_domain->signal_invmap
+@@ -193,13 +193,13 @@ static int setup_rt_frame(int sig, struc
+ 
+ 	err |= __put_user(signal, &frame->sig);
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Create the ucontext.  */
+ 	err |= __put_user(0, &frame->uc.uc_flags);
+@@ -208,17 +208,17 @@ static int setup_rt_frame(int sig, struc
+ 	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
+ 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  */
+-	regs->lr = (unsigned long)ka->sa.sa_restorer;
++	regs->lr = (unsigned long)ksig->ka.sa.sa_restorer;
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->spu = (unsigned long)frame;
+ 	regs->r0 = signal;	/* Arg for signal handler */
+ 	regs->r1 = (unsigned long)&frame->info;
+ 	regs->r2 = (unsigned long)&frame->uc;
+-	regs->bpc = (unsigned long)ka->sa.sa_handler;
++	regs->bpc = (unsigned long)ksig->ka.sa.sa_handler;
+ 
+ 	set_fs(USER_DS);
+ 
+@@ -228,10 +228,6 @@ static int setup_rt_frame(int sig, struc
+ #endif
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ static int prev_insn(struct pt_regs *regs)
+@@ -252,9 +248,10 @@ static int prev_insn(struct pt_regs *reg
+  */
+ 
+ static void
+-handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
+-	      struct pt_regs *regs)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
++	int ret;
++
+ 	/* Are we from a system call? */
+ 	if (regs->syscall_nr >= 0) {
+ 		/* If so, check system call restarting.. */
+@@ -265,7 +262,7 @@ handle_signal(unsigned long sig, struct
+ 				break;
+ 
+ 			case -ERESTARTSYS:
+-				if (!(ka->sa.sa_flags & SA_RESTART)) {
++				if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 					regs->r0 = -EINTR;
+ 					break;
+ 				}
+@@ -278,10 +275,9 @@ handle_signal(unsigned long sig, struct
+ 	}
+ 
+ 	/* Set up the stack frame */
+-	if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs))
+-		return;
++	ret = setup_rt_frame(ksig, sigmask_to_save(), regs);
+ 
+-	signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ /*
+@@ -291,9 +287,7 @@ handle_signal(unsigned long sig, struct
+  */
+ static void do_signal(struct pt_regs *regs)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * We want the common case to go fast, which
+@@ -304,8 +298,7 @@ static void do_signal(struct pt_regs *re
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Re-enable any watchpoints before delivering the
+ 		 * signal to user space. The processor register will
+ 		 * have been cleared if the watchpoint triggered
+@@ -313,7 +306,7 @@ static void do_signal(struct pt_regs *re
+ 		 */
+ 
+ 		/* Whee!  Actually deliver the signal.  */
+-		handle_signal(signr, &ka, &info, regs);
++		handle_signal(&ksig, regs);
+ 
+ 		return;
+ 	}
diff --git a/queue-3.16/m68k-use-get_signal-signal_setup_done.patch b/queue-3.16/m68k-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..5ba8ff96
--- /dev/null
+++ b/queue-3.16/m68k-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,191 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 22:55:48 +0200
+Subject: m68k: Use get_signal() signal_setup_done()
+
+commit 0d97500d393012690f3579056629bea0369e6554 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/m68k/kernel/signal.c | 63 +++++++++++++++------------------------
+ 1 file changed, 24 insertions(+), 39 deletions(-)
+
+--- a/arch/m68k/kernel/signal.c
++++ b/arch/m68k/kernel/signal.c
+@@ -850,23 +850,23 @@ get_sigframe(struct k_sigaction *ka, str
+ 	return (void __user *)((usp - frame_size) & -8UL);
+ }
+ 
+-static int setup_frame (int sig, struct k_sigaction *ka,
+-			 sigset_t *set, struct pt_regs *regs)
++static int setup_frame(struct ksignal *ksig, sigset_t *set,
++			struct pt_regs *regs)
+ {
+ 	struct sigframe __user *frame;
+ 	int fsize = frame_extra_sizes(regs->format);
+ 	struct sigcontext context;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 
+ 	if (fsize < 0) {
+ #ifdef DEBUG
+ 		printk ("setup_frame: Unknown frame format %#x\n",
+ 			regs->format);
+ #endif
+-		goto give_sigsegv;
++		return -EFAULT;
+ 	}
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame) + fsize);
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame) + fsize);
+ 
+ 	if (fsize)
+ 		err |= copy_to_user (frame + 1, regs + 1, fsize);
+@@ -899,7 +899,7 @@ static int setup_frame (int sig, struct
+ #endif
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	push_cache ((unsigned long) &frame->retcode);
+ 
+@@ -908,7 +908,7 @@ static int setup_frame (int sig, struct
+ 	 * to destroy is successfully copied to sigframe.
+ 	 */
+ 	wrusp ((unsigned long) frame);
+-	regs->pc = (unsigned long) ka->sa.sa_handler;
++	regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
+ 	adjustformat(regs);
+ 
+ 	/*
+@@ -934,28 +934,24 @@ static int setup_frame (int sig, struct
+ 		tregs->sr = regs->sr;
+ 	}
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return err;
+ }
+ 
+-static int setup_rt_frame (int sig, struct k_sigaction *ka, siginfo_t *info,
+-			    sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			   struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	int fsize = frame_extra_sizes(regs->format);
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 
+ 	if (fsize < 0) {
+ #ifdef DEBUG
+ 		printk ("setup_frame: Unknown frame format %#x\n",
+ 			regs->format);
+ #endif
+-		goto give_sigsegv;
++		return -EFAULT;
+ 	}
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (fsize)
+ 		err |= copy_to_user (&frame->uc.uc_extra, regs + 1, fsize);
+@@ -968,7 +964,7 @@ static int setup_rt_frame (int sig, stru
+ 			  &frame->sig);
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	/* Create the ucontext.  */
+ 	err |= __put_user(0, &frame->uc.uc_flags);
+@@ -996,7 +992,7 @@ static int setup_rt_frame (int sig, stru
+ #endif /* CONFIG_MMU */
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	push_cache ((unsigned long) &frame->retcode);
+ 
+@@ -1005,7 +1001,7 @@ static int setup_rt_frame (int sig, stru
+ 	 * to destroy is successfully copied to sigframe.
+ 	 */
+ 	wrusp ((unsigned long) frame);
+-	regs->pc = (unsigned long) ka->sa.sa_handler;
++	regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
+ 	adjustformat(regs);
+ 
+ 	/*
+@@ -1031,10 +1027,6 @@ static int setup_rt_frame (int sig, stru
+ 		tregs->sr = regs->sr;
+ 	}
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return err;
+ }
+ 
+ static inline void
+@@ -1074,26 +1066,22 @@ handle_restart(struct pt_regs *regs, str
+  * OK, we're invoking a handler
+  */
+ static void
+-handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
+-	      struct pt_regs *regs)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int err;
+ 	/* are we from a system call? */
+ 	if (regs->orig_d0 >= 0)
+ 		/* If so, check system call restarting.. */
+-		handle_restart(regs, ka, 1);
++		handle_restart(regs, &ksig->ka, 1);
+ 
+ 	/* set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		err = setup_rt_frame(sig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		err = setup_rt_frame(ksig, oldset, regs);
+ 	else
+-		err = setup_frame(sig, ka, oldset, regs);
+-
+-	if (err)
+-		return;
++		err = setup_frame(ksig, oldset, regs);
+ 
+-	signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(err, ksig, 0);
+ 
+ 	if (test_thread_flag(TIF_DELAYED_TRACE)) {
+ 		regs->sr &= ~0x8000;
+@@ -1108,16 +1096,13 @@ handle_signal(int sig, struct k_sigactio
+  */
+ static void do_signal(struct pt_regs *regs)
+ {
+-	siginfo_t info;
+-	struct k_sigaction ka;
+-	int signr;
++	struct ksignal ksig;
+ 
+ 	current->thread.esp0 = (unsigned long) regs;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Whee!  Actually deliver the signal.  */
+-		handle_signal(signr, &ka, &info, regs);
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/microblaze-use-get_signal-signal_setup_done.patch b/queue-3.16/microblaze-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..9c4bda95
--- /dev/null
+++ b/queue-3.16/microblaze-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,141 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 14:14:38 +0200
+Subject: microblaze: Use get_signal() signal_setup_done()
+
+commit 9c53c7ec14a5738ae3117d7d71b7abf630526c9f upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/microblaze/kernel/signal.c | 48 ++++++++++++---------------------
+ 1 file changed, 17 insertions(+), 31 deletions(-)
+
+--- a/arch/microblaze/kernel/signal.c
++++ b/arch/microblaze/kernel/signal.c
+@@ -156,11 +156,11 @@ get_sigframe(struct k_sigaction *ka, str
+ 	return (void __user *)((sp - frame_size) & -8UL);
+ }
+ 
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 	int signal;
+ 	unsigned long address = 0;
+ #ifdef CONFIG_MMU
+@@ -168,10 +168,10 @@ static int setup_rt_frame(int sig, struc
+ 	pte_t *ptep;
+ #endif
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	signal = current_thread_info()->exec_domain
+ 		&& current_thread_info()->exec_domain->signal_invmap
+@@ -179,8 +179,8 @@ static int setup_rt_frame(int sig, struc
+ 		? current_thread_info()->exec_domain->signal_invmap[sig]
+ 		: sig;
+ 
+-	if (info)
+-		err |= copy_siginfo_to_user(&frame->info, info);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	/* Create the ucontext. */
+ 	err |= __put_user(0, &frame->uc.uc_flags);
+@@ -227,7 +227,7 @@ static int setup_rt_frame(int sig, struc
+ 	flush_dcache_range(address, address + 8);
+ #endif
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->r1 = (unsigned long) frame;
+@@ -237,7 +237,7 @@ static int setup_rt_frame(int sig, struc
+ 	regs->r6 = (unsigned long) &frame->info; /* arg 1: siginfo */
+ 	regs->r7 = (unsigned long) &frame->uc; /* arg2: ucontext */
+ 	/* Offset to handle microblaze rtid r14, 0 */
+-	regs->pc = (unsigned long)ka->sa.sa_handler;
++	regs->pc = (unsigned long)ksig->ka.sa.sa_handler;
+ 
+ 	set_fs(USER_DS);
+ 
+@@ -247,10 +247,6 @@ static int setup_rt_frame(int sig, struc
+ #endif
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ /* Handle restarting system calls */
+@@ -283,23 +279,15 @@ do_restart:
+  */
+ 
+ static void
+-handle_signal(unsigned long sig, struct k_sigaction *ka,
+-		siginfo_t *info, struct pt_regs *regs)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+ 
+ 	/* Set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(sig, ka, info, oldset, regs);
+-	else
+-		ret = setup_rt_frame(sig, ka, NULL, oldset, regs);
+-
+-	if (ret)
+-		return;
++	ret = setup_rt_frame(ksig, oldset, regs);
+ 
+-	signal_delivered(sig, info, ka, regs,
+-			test_thread_flag(TIF_SINGLESTEP));
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ }
+ 
+ /*
+@@ -313,21 +301,19 @@ handle_signal(unsigned long sig, struct
+  */
+ static void do_signal(struct pt_regs *regs, int in_syscall)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
++
+ #ifdef DEBUG_SIG
+ 	pr_info("do signal: %p %d\n", regs, in_syscall);
+ 	pr_info("do signal2: %lx %lx %ld [%lx]\n", regs->pc, regs->r1,
+ 			regs->r12, current_thread_info()->flags);
+ #endif
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Whee! Actually deliver the signal. */
+ 		if (in_syscall)
+-			handle_restart(regs, &ka, 1);
+-		handle_signal(signr, &ka, &info, regs);
++			handle_restart(regs, &ksig.ka, 1);
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/mips-use-get_signal-signal_setup_done.patch b/queue-3.16/mips-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..7a931052
--- /dev/null
+++ b/queue-3.16/mips-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,384 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 6 Oct 2013 22:25:42 +0200
+Subject: mips: Use get_signal() signal_setup_done()
+
+commit 81d103bf80678669c56658185e758fc3f9845d71 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/mips/include/asm/abi.h      | 10 ++---
+ arch/mips/kernel/signal-common.h |  2 +-
+ arch/mips/kernel/signal.c        | 66 ++++++++++++--------------------
+ arch/mips/kernel/signal32.c      | 39 ++++++++-----------
+ arch/mips/kernel/signal_n32.c    | 20 ++++------
+ 5 files changed, 53 insertions(+), 84 deletions(-)
+
+--- a/arch/mips/include/asm/abi.h
++++ b/arch/mips/include/asm/abi.h
+@@ -13,13 +13,11 @@
+ #include <asm/siginfo.h>
+ 
+ struct mips_abi {
+-	int (* const setup_frame)(void *sig_return, struct k_sigaction *ka,
+-				  struct pt_regs *regs, int signr,
+-				  sigset_t *set);
++	int (* const setup_frame)(void *sig_return, struct ksignal *ksig,
++				  struct pt_regs *regs, sigset_t *set);
+ 	const unsigned long	signal_return_offset;
+-	int (* const setup_rt_frame)(void *sig_return, struct k_sigaction *ka,
+-			       struct pt_regs *regs, int signr,
+-			       sigset_t *set, siginfo_t *info);
++	int (* const setup_rt_frame)(void *sig_return, struct ksignal *ksig,
++				     struct pt_regs *regs, sigset_t *set);
+ 	const unsigned long	rt_signal_return_offset;
+ 	const unsigned long	restart;
+ };
+--- a/arch/mips/kernel/signal-common.h
++++ b/arch/mips/kernel/signal-common.h
+@@ -22,7 +22,7 @@
+ /*
+  * Determine which stack to use..
+  */
+-extern void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
++extern void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
+ 				 size_t frame_size);
+ /* Check and clear pending FPU exceptions in saved CSR */
+ extern int fpcsr_pending(unsigned int __user *fpcsr);
+--- a/arch/mips/kernel/signal.c
++++ b/arch/mips/kernel/signal.c
+@@ -428,20 +428,20 @@ badframe:
+ }
+ 
+ #ifdef CONFIG_TRAD_SIGNALS
+-static int setup_frame(void *sig_return, struct k_sigaction *ka,
+-		       struct pt_regs *regs, int signr, sigset_t *set)
++static int setup_frame(void *sig_return, struct ksignal *ksig,
++		       struct pt_regs *regs, sigset_t *set)
+ {
+ 	struct sigframe __user *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	err |= setup_sigcontext(regs, &frame->sf_sc);
+ 	err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Arguments to signal handler:
+@@ -453,37 +453,32 @@ static int setup_frame(void *sig_return,
+ 	 * $25 and c0_epc point to the signal handler, $29 points to the
+ 	 * struct sigframe.
+ 	 */
+-	regs->regs[ 4] = signr;
++	regs->regs[ 4] = ksig->sig;
+ 	regs->regs[ 5] = 0;
+ 	regs->regs[ 6] = (unsigned long) &frame->sf_sc;
+ 	regs->regs[29] = (unsigned long) frame;
+ 	regs->regs[31] = (unsigned long) sig_return;
+-	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
++	regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
+ 
+ 	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
+ 	       current->comm, current->pid,
+ 	       frame, regs->cp0_epc, regs->regs[31]);
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(signr, current);
+-	return -EFAULT;
+ }
+ #endif
+ 
+-static int setup_rt_frame(void *sig_return, struct k_sigaction *ka,
+-			  struct pt_regs *regs, int signr, sigset_t *set,
+-			  siginfo_t *info)
++static int setup_rt_frame(void *sig_return, struct ksignal *ksig,
++			  struct pt_regs *regs, sigset_t *set)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Create siginfo.  */
+-	err |= copy_siginfo_to_user(&frame->rs_info, info);
++	err |= copy_siginfo_to_user(&frame->rs_info, &ksig->info);
+ 
+ 	/* Create the ucontext.	 */
+ 	err |= __put_user(0, &frame->rs_uc.uc_flags);
+@@ -493,7 +488,7 @@ static int setup_rt_frame(void *sig_retu
+ 	err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Arguments to signal handler:
+@@ -505,22 +500,18 @@ static int setup_rt_frame(void *sig_retu
+ 	 * $25 and c0_epc point to the signal handler, $29 points to
+ 	 * the struct rt_sigframe.
+ 	 */
+-	regs->regs[ 4] = signr;
++	regs->regs[ 4] = ksig->sig;
+ 	regs->regs[ 5] = (unsigned long) &frame->rs_info;
+ 	regs->regs[ 6] = (unsigned long) &frame->rs_uc;
+ 	regs->regs[29] = (unsigned long) frame;
+ 	regs->regs[31] = (unsigned long) sig_return;
+-	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
++	regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
+ 
+ 	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
+ 	       current->comm, current->pid,
+ 	       frame, regs->cp0_epc, regs->regs[31]);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(signr, current);
+-	return -EFAULT;
+ }
+ 
+ struct mips_abi mips_abi = {
+@@ -534,8 +525,7 @@ struct mips_abi mips_abi = {
+ 	.restart	= __NR_restart_syscall
+ };
+ 
+-static void handle_signal(unsigned long sig, siginfo_t *info,
+-	struct k_sigaction *ka, struct pt_regs *regs)
++static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+@@ -557,7 +547,7 @@ static void handle_signal(unsigned long
+ 			regs->regs[2] = EINTR;
+ 			break;
+ 		case ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->regs[2] = EINTR;
+ 				break;
+ 			}
+@@ -571,29 +561,23 @@ static void handle_signal(unsigned long
+ 		regs->regs[0] = 0;		/* Don't deal with this again.	*/
+ 	}
+ 
+-	if (sig_uses_siginfo(ka))
++	if (sig_uses_siginfo(&ksig->ka))
+ 		ret = abi->setup_rt_frame(vdso + abi->rt_signal_return_offset,
+-					  ka, regs, sig, oldset, info);
++					  ksig, regs, oldset);
+ 	else
+-		ret = abi->setup_frame(vdso + abi->signal_return_offset,
+-				       ka, regs, sig, oldset);
+-
+-	if (ret)
+-		return;
++		ret = abi->setup_frame(vdso + abi->signal_return_offset, ksig,
++				       regs, oldset);
+ 
+-	signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ static void do_signal(struct pt_regs *regs)
+ {
+-	struct k_sigaction ka;
+-	siginfo_t info;
+-	int signr;
++	struct ksignal ksig;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Whee!  Actually deliver the signal.	*/
+-		handle_signal(signr, &info, &ka, regs);
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
+--- a/arch/mips/kernel/signal32.c
++++ b/arch/mips/kernel/signal32.c
+@@ -488,21 +488,21 @@ badframe:
+ 	force_sig(SIGSEGV, current);
+ }
+ 
+-static int setup_frame_32(void *sig_return, struct k_sigaction *ka,
+-			  struct pt_regs *regs, int signr, sigset_t *set)
++static int setup_frame_32(void *sig_return, struct ksignal *ksig,
++			  struct pt_regs *regs, sigset_t *set)
+ {
+ 	struct sigframe32 __user *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	err |= setup_sigcontext32(regs, &frame->sf_sc);
+ 	err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Arguments to signal handler:
+@@ -514,37 +514,32 @@ static int setup_frame_32(void *sig_retu
+ 	 * $25 and c0_epc point to the signal handler, $29 points to the
+ 	 * struct sigframe.
+ 	 */
+-	regs->regs[ 4] = signr;
++	regs->regs[ 4] = ksig->sig;
+ 	regs->regs[ 5] = 0;
+ 	regs->regs[ 6] = (unsigned long) &frame->sf_sc;
+ 	regs->regs[29] = (unsigned long) frame;
+ 	regs->regs[31] = (unsigned long) sig_return;
+-	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
++	regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
+ 
+ 	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
+ 	       current->comm, current->pid,
+ 	       frame, regs->cp0_epc, regs->regs[31]);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(signr, current);
+-	return -EFAULT;
+ }
+ 
+-static int setup_rt_frame_32(void *sig_return, struct k_sigaction *ka,
+-			     struct pt_regs *regs, int signr, sigset_t *set,
+-			     siginfo_t *info)
++static int setup_rt_frame_32(void *sig_return, struct ksignal *ksig,
++			     struct pt_regs *regs, sigset_t *set)
+ {
+ 	struct rt_sigframe32 __user *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
+-	err |= copy_siginfo_to_user32(&frame->rs_info, info);
++	err |= copy_siginfo_to_user32(&frame->rs_info, &ksig->info);
+ 
+ 	/* Create the ucontext.	 */
+ 	err |= __put_user(0, &frame->rs_uc.uc_flags);
+@@ -554,7 +549,7 @@ static int setup_rt_frame_32(void *sig_r
+ 	err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Arguments to signal handler:
+@@ -566,22 +561,18 @@ static int setup_rt_frame_32(void *sig_r
+ 	 * $25 and c0_epc point to the signal handler, $29 points to
+ 	 * the struct rt_sigframe32.
+ 	 */
+-	regs->regs[ 4] = signr;
++	regs->regs[ 4] = ksig->sig;
+ 	regs->regs[ 5] = (unsigned long) &frame->rs_info;
+ 	regs->regs[ 6] = (unsigned long) &frame->rs_uc;
+ 	regs->regs[29] = (unsigned long) frame;
+ 	regs->regs[31] = (unsigned long) sig_return;
+-	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
++	regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
+ 
+ 	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
+ 	       current->comm, current->pid,
+ 	       frame, regs->cp0_epc, regs->regs[31]);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(signr, current);
+-	return -EFAULT;
+ }
+ 
+ /*
+--- a/arch/mips/kernel/signal_n32.c
++++ b/arch/mips/kernel/signal_n32.c
+@@ -102,18 +102,18 @@ badframe:
+ 	force_sig(SIGSEGV, current);
+ }
+ 
+-static int setup_rt_frame_n32(void *sig_return, struct k_sigaction *ka,
+-	struct pt_regs *regs, int signr, sigset_t *set, siginfo_t *info)
++static int setup_rt_frame_n32(void *sig_return, struct ksignal *ksig,
++			      struct pt_regs *regs, sigset_t *set)
+ {
+ 	struct rt_sigframe_n32 __user *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Create siginfo.  */
+-	err |= copy_siginfo_to_user32(&frame->rs_info, info);
++	err |= copy_siginfo_to_user32(&frame->rs_info, &ksig->info);
+ 
+ 	/* Create the ucontext.	 */
+ 	err |= __put_user(0, &frame->rs_uc.uc_flags);
+@@ -123,7 +123,7 @@ static int setup_rt_frame_n32(void *sig_
+ 	err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Arguments to signal handler:
+@@ -135,22 +135,18 @@ static int setup_rt_frame_n32(void *sig_
+ 	 * $25 and c0_epc point to the signal handler, $29 points to
+ 	 * the struct rt_sigframe.
+ 	 */
+-	regs->regs[ 4] = signr;
++	regs->regs[ 4] = ksig->sig;
+ 	regs->regs[ 5] = (unsigned long) &frame->rs_info;
+ 	regs->regs[ 6] = (unsigned long) &frame->rs_uc;
+ 	regs->regs[29] = (unsigned long) frame;
+ 	regs->regs[31] = (unsigned long) sig_return;
+-	regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
++	regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
+ 
+ 	DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
+ 	       current->comm, current->pid,
+ 	       frame, regs->cp0_epc, regs->regs[31]);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(signr, current);
+-	return -EFAULT;
+ }
+ 
+ struct mips_abi mips_abi_n32 = {
diff --git a/queue-3.16/mn10300-use-get_signal-signal_setup_done.patch b/queue-3.16/mn10300-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..718e1e55
--- /dev/null
+++ b/queue-3.16/mn10300-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,239 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 14:22:50 +0200
+Subject: mn10300: Use get_signal() signal_setup_done()
+
+commit 8b166553a9aaf39774bc22f5e93c965584303929 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/mn10300/kernel/signal.c | 89 +++++++++++++++---------------------
+ 1 file changed, 36 insertions(+), 53 deletions(-)
+
+--- a/arch/mn10300/kernel/signal.c
++++ b/arch/mn10300/kernel/signal.c
+@@ -207,16 +207,16 @@ static inline void __user *get_sigframe(
+ /*
+  * set up a normal signal frame
+  */
+-static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
++static int setup_frame(struct ksignal *ksig, sigset_t *set,
+ 		       struct pt_regs *regs)
+ {
+ 	struct sigframe __user *frame;
+-	int rsig;
++	int rsig, sig = ksig->sig;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	rsig = sig;
+ 	if (sig < 32 &&
+@@ -226,40 +226,40 @@ static int setup_frame(int sig, struct k
+ 
+ 	if (__put_user(rsig, &frame->sig) < 0 ||
+ 	    __put_user(&frame->sc, &frame->psc) < 0)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (setup_sigcontext(&frame->sc, &frame->fpuctx, regs, set->sig[0]))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (_NSIG_WORDS > 1) {
+ 		if (__copy_to_user(frame->extramask, &set->sig[1],
+ 				   sizeof(frame->extramask)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 	}
+ 
+ 	/* set up to return from userspace.  If provided, use a stub already in
+ 	 * userspace */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		if (__put_user(ka->sa.sa_restorer, &frame->pretcode))
+-			goto give_sigsegv;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		if (__put_user(ksig->ka.sa.sa_restorer, &frame->pretcode))
++			return -EFAULT;
+ 	} else {
+ 		if (__put_user((void (*)(void))frame->retcode,
+ 			       &frame->pretcode))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 		/* this is mov $,d0; syscall 0 */
+ 		if (__put_user(0x2c, (char *)(frame->retcode + 0)) ||
+ 		    __put_user(__NR_sigreturn, (char *)(frame->retcode + 1)) ||
+ 		    __put_user(0x00, (char *)(frame->retcode + 2)) ||
+ 		    __put_user(0xf0, (char *)(frame->retcode + 3)) ||
+ 		    __put_user(0xe0, (char *)(frame->retcode + 4)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 		flush_icache_range((unsigned long) frame->retcode,
+ 				   (unsigned long) frame->retcode + 5);
+ 	}
+ 
+ 	/* set up registers for signal handler */
+ 	regs->sp = (unsigned long) frame;
+-	regs->pc = (unsigned long) ka->sa.sa_handler;
++	regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
+ 	regs->d0 = sig;
+ 	regs->d1 = (unsigned long) &frame->sc;
+ 
+@@ -270,25 +270,21 @@ static int setup_frame(int sig, struct k
+ #endif
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ /*
+  * set up a realtime signal frame
+  */
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			  sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+-	int rsig;
++	int rsig, sig = ksig->sig;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	rsig = sig;
+ 	if (sig < 32 &&
+@@ -299,8 +295,8 @@ static int setup_rt_frame(int sig, struc
+ 	if (__put_user(rsig, &frame->sig) ||
+ 	    __put_user(&frame->info, &frame->pinfo) ||
+ 	    __put_user(&frame->uc, &frame->puc) ||
+-	    copy_siginfo_to_user(&frame->info, info))
+-		goto give_sigsegv;
++	    copy_siginfo_to_user(&frame->info, &ksig->info))
++		return -EFAULT;
+ 
+ 	/* create the ucontext.  */
+ 	if (__put_user(0, &frame->uc.uc_flags) ||
+@@ -309,13 +305,14 @@ static int setup_rt_frame(int sig, struc
+ 	    setup_sigcontext(&frame->uc.uc_mcontext,
+ 			     &frame->fpuctx, regs, set->sig[0]) ||
+ 	    __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* set up to return from userspace.  If provided, use a stub already in
+ 	 * userspace */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		if (__put_user(ka->sa.sa_restorer, &frame->pretcode))
+-			goto give_sigsegv;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		if (__put_user(ksig->ka.sa.sa_restorer, &frame->pretcode))
++			return -EFAULT;
++
+ 	} else {
+ 		if (__put_user((void(*)(void))frame->retcode,
+ 			       &frame->pretcode) ||
+@@ -326,7 +323,7 @@ static int setup_rt_frame(int sig, struc
+ 		    __put_user(0x00, (char *)(frame->retcode + 2)) ||
+ 		    __put_user(0xf0, (char *)(frame->retcode + 3)) ||
+ 		    __put_user(0xe0, (char *)(frame->retcode + 4)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 
+ 		flush_icache_range((u_long) frame->retcode,
+ 				   (u_long) frame->retcode + 5);
+@@ -334,7 +331,7 @@ static int setup_rt_frame(int sig, struc
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->sp = (unsigned long) frame;
+-	regs->pc = (unsigned long) ka->sa.sa_handler;
++	regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
+ 	regs->d0 = sig;
+ 	regs->d1 = (long) &frame->info;
+ 
+@@ -345,10 +342,6 @@ static int setup_rt_frame(int sig, struc
+ #endif
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ static inline void stepback(struct pt_regs *regs)
+@@ -360,9 +353,7 @@ static inline void stepback(struct pt_re
+ /*
+  * handle the actual delivery of a signal to userspace
+  */
+-static int handle_signal(int sig,
+-			 siginfo_t *info, struct k_sigaction *ka,
+-			 struct pt_regs *regs)
++static int handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+@@ -377,7 +368,7 @@ static int handle_signal(int sig,
+ 			break;
+ 
+ 		case -ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->d0 = -EINTR;
+ 				break;
+ 			}
+@@ -390,15 +381,12 @@ static int handle_signal(int sig,
+ 	}
+ 
+ 	/* Set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(sig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame(ksig, oldset, regs);
+ 	else
+-		ret = setup_frame(sig, ka, oldset, regs);
+-	if (ret)
+-		return ret;
++		ret = setup_frame(ksig, oldset, regs);
+ 
+-	signal_delivered(sig, info, ka, regs,
+-			 test_thread_flag(TIF_SINGLESTEP));
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ 	return 0;
+ }
+ 
+@@ -407,15 +395,10 @@ static int handle_signal(int sig,
+  */
+ static void do_signal(struct pt_regs *regs)
+ {
+-	struct k_sigaction ka;
+-	siginfo_t info;
+-	int signr;
+-
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
+-		if (handle_signal(signr, &info, &ka, regs) == 0) {
+-		}
++	struct ksignal ksig;
+ 
++	if (get_signal(&ksig)) {
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/net-dp83640-expire-old-tx-skb.patch b/queue-3.16/net-dp83640-expire-old-tx-skb.patch
deleted file mode 100644
index 6eb359d9..00000000
--- a/queue-3.16/net-dp83640-expire-old-tx-skb.patch
+++ /dev/null
@@ -1,80 +0,0 @@
-From: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
-Date: Mon, 4 Feb 2019 11:20:29 +0100
-Subject: net: dp83640: expire old TX-skb
-
-commit 53bc8d2af08654659abfadfd3e98eb9922ff787c upstream.
-
-During sendmsg() a cloned skb is saved via dp83640_txtstamp() in
-->tx_queue. After the NIC sends this packet, the PHY will reply with a
-timestamp for that TX packet. If the cable is pulled at the right time I
-don't see that packet. It might gets flushed as part of queue shutdown
-on NIC's side.
-Once the link is up again then after the next sendmsg() we enqueue
-another skb in dp83640_txtstamp() and have two on the list. Then the PHY
-will send a reply and decode_txts() attaches it to the first skb on the
-list.
-No crash occurs since refcounting works but we are one packet behind.
-linuxptp/ptp4l usually closes the socket and opens a new one (in such a
-timeout case) so those "stale" replies never get there. However it does
-not resume normal operation anymore.
-
-Purge old skbs in decode_txts().
-
-Fixes: cb646e2b02b2 ("ptp: Added a clock driver for the National Semiconductor PHYTER.")
-Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
-Reviewed-by: Kurt Kanzenbach <kurt@linutronix.de>
-Acked-by: Richard Cochran <richardcochran@gmail.com>
-Signed-off-by: David S. Miller <davem@davemloft.net>
-Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
----
- drivers/net/phy/dp83640.c | 13 ++++++++++---
- 1 file changed, 10 insertions(+), 3 deletions(-)
-
---- a/drivers/net/phy/dp83640.c
-+++ b/drivers/net/phy/dp83640.c
-@@ -785,14 +785,14 @@ static void decode_txts(struct dp83640_p
- 			struct phy_txts *phy_txts)
- {
- 	struct skb_shared_hwtstamps shhwtstamps;
-+	struct dp83640_skb_info *skb_info;
- 	struct sk_buff *skb;
--	u64 ns;
- 	u8 overflow;
-+	u64 ns;
- 
- 	/* We must already have the skb that triggered this. */
--
-+again:
- 	skb = skb_dequeue(&dp83640->tx_queue);
--
- 	if (!skb) {
- 		pr_debug("have timestamp but tx_queue empty\n");
- 		return;
-@@ -807,6 +807,11 @@ static void decode_txts(struct dp83640_p
- 		}
- 		return;
- 	}
-+	skb_info = (struct dp83640_skb_info *)skb->cb;
-+	if (time_after(jiffies, skb_info->tmo)) {
-+		kfree_skb(skb);
-+		goto again;
-+	}
- 
- 	ns = phy2txts(phy_txts);
- 	memset(&shhwtstamps, 0, sizeof(shhwtstamps));
-@@ -1374,6 +1379,7 @@ static bool dp83640_rxtstamp(struct phy_
- static void dp83640_txtstamp(struct phy_device *phydev,
- 			     struct sk_buff *skb, int type)
- {
-+	struct dp83640_skb_info *skb_info = (struct dp83640_skb_info *)skb->cb;
- 	struct dp83640_private *dp83640 = phydev->priv;
- 
- 	switch (dp83640->hwts_tx_en) {
-@@ -1386,6 +1392,7 @@ static void dp83640_txtstamp(struct phy_
- 		/* fall through */
- 	case HWTSTAMP_TX_ON:
- 		skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
-+		skb_info->tmo = jiffies + SKB_TIMESTAMP_TIMEOUT;
- 		skb_queue_tail(&dp83640->tx_queue, skb);
- 		schedule_work(&dp83640->ts_work);
- 		break;
diff --git a/queue-3.16/parisc-use-get_signal-signal_setup_done.patch b/queue-3.16/parisc-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..61a647c1
--- /dev/null
+++ b/queue-3.16/parisc-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,178 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 14:34:10 +0200
+Subject: parisc: Use get_signal() signal_setup_done()
+
+commit e4dc894b61776733629b24507031dd46f5ba5efc upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+Acked-by: Helge Deller <deller@gmx.de>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/parisc/kernel/signal.c | 58 +++++++++++++++----------------------
+ 1 file changed, 24 insertions(+), 34 deletions(-)
+
+--- a/arch/parisc/kernel/signal.c
++++ b/arch/parisc/kernel/signal.c
+@@ -227,8 +227,8 @@ setup_sigcontext(struct sigcontext __use
+ }
+ 
+ static long
+-setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-	       sigset_t *set, struct pt_regs *regs, int in_syscall)
++setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs,
++	       int in_syscall)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	unsigned long rp, usp;
+@@ -241,10 +241,10 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	
+ 	usp = (regs->gr[30] & ~(0x01UL));
+ 	/*FIXME: frame_size parameter is unused, remove it. */
+-	frame = get_sigframe(ka, usp, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, usp, sizeof(*frame));
+ 
+ 	DBG(1,"SETUP_RT_FRAME: START\n");
+-	DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
++	DBG(1,"setup_rt_frame: frame %p info %p\n", frame, ksig->info);
+ 
+ 	
+ #ifdef CONFIG_64BIT
+@@ -253,7 +253,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	
+ 	if (is_compat_task()) {
+ 		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
+-		err |= copy_siginfo_to_user32(&compat_frame->info, info);
++		err |= copy_siginfo_to_user32(&compat_frame->info, &ksig->info);
+ 		err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
+ 		DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
+ 		DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
+@@ -265,7 +265,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ #endif
+ 	{	
+ 		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
+-		err |= copy_siginfo_to_user(&frame->info, info);
++		err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 		err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
+ 		DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
+ 		DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
+@@ -275,7 +275,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	}
+ 	
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace. The first words of tramp are used to
+@@ -312,9 +312,9 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+-	haddr = A(ka->sa.sa_handler);
++	haddr = A(ksig->ka.sa.sa_handler);
+ 	/* The sa_handler may be a pointer to a function descriptor */
+ #ifdef CONFIG_64BIT
+ 	if (is_compat_task()) {
+@@ -326,7 +326,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 			err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
+ 
+ 			if (err)
+-				goto give_sigsegv;
++				return -EFAULT;
+ 
+ 			haddr = fdesc.addr;
+ 			regs->gr[19] = fdesc.gp;
+@@ -339,7 +339,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 		err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
+ 		
+ 		if (err)
+-			goto give_sigsegv;
++			return -EFAULT;
+ 		
+ 		haddr = fdesc.addr;
+ 		regs->gr[19] = fdesc.gp;
+@@ -386,7 +386,7 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	}
+ 
+ 	regs->gr[2]  = rp;                /* userland return pointer */
+-	regs->gr[26] = sig;               /* signal number */
++	regs->gr[26] = ksig->sig;               /* signal number */
+ 	
+ #ifdef CONFIG_64BIT
+ 	if (is_compat_task()) {
+@@ -410,11 +410,6 @@ setup_rt_frame(int sig, struct k_sigacti
+ 	       current->comm, current->pid, frame, regs->gr[30],
+ 	       regs->iaoq[0], regs->iaoq[1], rp);
+ 
+-	return 1;
+-
+-give_sigsegv:
+-	DBG(1,"setup_rt_frame: sending SIGSEGV\n");
+-	force_sigsegv(sig, current);
+ 	return 0;
+ }
+ 
+@@ -423,20 +418,19 @@ give_sigsegv:
+  */	
+ 
+ static void
+-handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
+-		struct pt_regs *regs, int in_syscall)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
+ {
++	int ret;
+ 	sigset_t *oldset = sigmask_to_save();
++
+ 	DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
+-	       sig, ka, info, oldset, regs);
++	       ksig->sig, ksig->ka, ksig->info, oldset, regs);
+ 	
+ 	/* Set up the stack frame */
+-	if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
+-		return;
++	ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
+ 
+-	signal_delivered(sig, info, ka, regs, 
+-		test_thread_flag(TIF_SINGLESTEP) ||
+-		test_thread_flag(TIF_BLOCKSTEP));
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
++			  test_thread_flag(TIF_BLOCKSTEP));
+ 
+ 	DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
+ 		regs->gr[28]);
+@@ -584,22 +578,18 @@ insert_restart_trampoline(struct pt_regs
+ asmlinkage void
+ do_signal(struct pt_regs *regs, long in_syscall)
+ {
+-	siginfo_t info;
+-	struct k_sigaction ka;
+-	int signr;
++	struct ksignal ksig;
+ 
+ 	DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
+ 	       regs, regs->sr[7], in_syscall);
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 
+-	
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
++		DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
+ 		/* Restart a system call if necessary. */
+ 		if (in_syscall)
+-			syscall_restart(regs, &ka);
++			syscall_restart(regs, &ksig.ka);
+ 
+-		handle_signal(signr, &info, &ka, regs, in_syscall);
++		handle_signal(&ksig, regs, in_syscall);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/powerpc-use-get_signal-signal_setup_done.patch b/queue-3.16/powerpc-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..5513fe58
--- /dev/null
+++ b/queue-3.16/powerpc-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,338 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 2 Mar 2014 14:46:11 +0100
+Subject: powerpc: Use get_signal() signal_setup_done()
+
+commit 129b69df9c9074750245fca8aa92df5cc1a86ef4 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+This inverts also the return codes of setup_*frame() to follow the
+kernel convention.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/powerpc/kernel/signal.c    | 31 ++++++++++------------------
+ arch/powerpc/kernel/signal.h    | 14 +++++--------
+ arch/powerpc/kernel/signal_32.c | 36 +++++++++++++++------------------
+ arch/powerpc/kernel/signal_64.c | 28 ++++++++++++-------------
+ 4 files changed, 45 insertions(+), 64 deletions(-)
+
+--- a/arch/powerpc/kernel/signal.c
++++ b/arch/powerpc/kernel/signal.c
+@@ -105,25 +105,23 @@ static void check_syscall_restart(struct
+ 	}
+ }
+ 
+-static int do_signal(struct pt_regs *regs)
++static void do_signal(struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 	int ret;
+ 	int is32 = is_32bit_task();
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
++	get_signal(&ksig);
+ 
+ 	/* Is there any syscall restart business here ? */
+-	check_syscall_restart(regs, &ka, signr > 0);
++	check_syscall_restart(regs, &ksig.ka, ksig.sig > 0);
+ 
+-	if (signr <= 0) {
++	if (ksig.sig <= 0) {
+ 		/* No signal to deliver -- put the saved sigmask back */
+ 		restore_saved_sigmask();
+ 		regs->trap = 0;
+-		return 0;               /* no signals delivered */
++		return;               /* no signals delivered */
+ 	}
+ 
+ #ifndef CONFIG_PPC_ADV_DEBUG_REGS
+@@ -140,23 +138,16 @@ static int do_signal(struct pt_regs *reg
+ 	thread_change_pc(current, regs);
+ 
+ 	if (is32) {
+-        	if (ka.sa.sa_flags & SA_SIGINFO)
+-			ret = handle_rt_signal32(signr, &ka, &info, oldset,
+-					regs);
++        	if (ksig.ka.sa.sa_flags & SA_SIGINFO)
++			ret = handle_rt_signal32(&ksig, oldset, regs);
+ 		else
+-			ret = handle_signal32(signr, &ka, &info, oldset,
+-					regs);
++			ret = handle_signal32(&ksig, oldset, regs);
+ 	} else {
+-		ret = handle_rt_signal64(signr, &ka, &info, oldset, regs);
++		ret = handle_rt_signal64(&ksig, oldset, regs);
+ 	}
+ 
+ 	regs->trap = 0;
+-	if (ret) {
+-		signal_delivered(signr, &info, &ka, regs,
+-					 test_thread_flag(TIF_SINGLESTEP));
+-	}
+-
+-	return ret;
++	signal_setup_done(ret, &ksig, test_thread_flag(TIF_SINGLESTEP));
+ }
+ 
+ void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
+--- a/arch/powerpc/kernel/signal.h
++++ b/arch/powerpc/kernel/signal.h
+@@ -12,15 +12,13 @@
+ 
+ extern void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags);
+ 
+-extern void __user * get_sigframe(struct k_sigaction *ka, unsigned long sp,
++extern void __user *get_sigframe(struct ksignal *ksig, unsigned long sp,
+ 				  size_t frame_size, int is_32);
+ 
+-extern int handle_signal32(unsigned long sig, struct k_sigaction *ka,
+-			   siginfo_t *info, sigset_t *oldset,
++extern int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
+ 			   struct pt_regs *regs);
+ 
+-extern int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
+-			      siginfo_t *info, sigset_t *oldset,
++extern int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
+ 			      struct pt_regs *regs);
+ 
+ extern unsigned long copy_fpr_to_user(void __user *to,
+@@ -44,14 +42,12 @@ extern unsigned long copy_transact_vsx_f
+ 
+ #ifdef CONFIG_PPC64
+ 
+-extern int handle_rt_signal64(int signr, struct k_sigaction *ka,
+-			      siginfo_t *info, sigset_t *set,
++extern int handle_rt_signal64(struct ksignal *ksig, sigset_t *set,
+ 			      struct pt_regs *regs);
+ 
+ #else /* CONFIG_PPC64 */
+ 
+-static inline int handle_rt_signal64(int signr, struct k_sigaction *ka,
+-				     siginfo_t *info, sigset_t *set,
++static inline int handle_rt_signal64(struct ksignal *ksig, sigset_t *set,
+ 				     struct pt_regs *regs)
+ {
+ 	return -EFAULT;
+--- a/arch/powerpc/kernel/signal_32.c
++++ b/arch/powerpc/kernel/signal_32.c
+@@ -1001,9 +1001,8 @@ int copy_siginfo_from_user32(siginfo_t *
+  * Set up a signal frame for a "real-time" signal handler
+  * (one which gets siginfo).
+  */
+-int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
+-		siginfo_t *info, sigset_t *oldset,
+-		struct pt_regs *regs)
++int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
++		       struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *rt_sf;
+ 	struct mcontext __user *frame;
+@@ -1015,13 +1014,13 @@ int handle_rt_signal32(unsigned long sig
+ 
+ 	/* Set up Signal Frame */
+ 	/* Put a Real Time Context onto stack */
+-	rt_sf = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
++	rt_sf = get_sigframe(&ksig->ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
+ 	addr = rt_sf;
+ 	if (unlikely(rt_sf == NULL))
+ 		goto badframe;
+ 
+ 	/* Put the siginfo & fill in most of the ucontext */
+-	if (copy_siginfo_to_user(&rt_sf->info, info)
++	if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
+ 	    || __put_user(0, &rt_sf->uc.uc_flags)
+ 	    || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
+ 	    || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
+@@ -1071,15 +1070,15 @@ int handle_rt_signal32(unsigned long sig
+ 
+ 	/* Fill registers for signal handler */
+ 	regs->gpr[1] = newsp;
+-	regs->gpr[3] = sig;
++	regs->gpr[3] = ksig->sig;
+ 	regs->gpr[4] = (unsigned long) &rt_sf->info;
+ 	regs->gpr[5] = (unsigned long) &rt_sf->uc;
+ 	regs->gpr[6] = (unsigned long) rt_sf;
+-	regs->nip = (unsigned long) ka->sa.sa_handler;
++	regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
+ 	/* enter the signal handler in native-endian mode */
+ 	regs->msr &= ~MSR_LE;
+ 	regs->msr |= (MSR_KERNEL & MSR_LE);
+-	return 1;
++	return 0;
+ 
+ badframe:
+ 	if (show_unhandled_signals)
+@@ -1089,8 +1088,7 @@ badframe:
+ 				   current->comm, current->pid,
+ 				   addr, regs->nip, regs->link);
+ 
+-	force_sigsegv(sig, current);
+-	return 0;
++	return 1;
+ }
+ 
+ static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
+@@ -1437,8 +1435,7 @@ int sys_debug_setcontext(struct ucontext
+ /*
+  * OK, we're invoking a handler
+  */
+-int handle_signal32(unsigned long sig, struct k_sigaction *ka,
+-		    siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
++int handle_signal32(struct ksignal *ksig, sigset_t *oldset, struct pt_regs *regs)
+ {
+ 	struct sigcontext __user *sc;
+ 	struct sigframe __user *frame;
+@@ -1448,7 +1445,7 @@ int handle_signal32(unsigned long sig, s
+ 	unsigned long tramp;
+ 
+ 	/* Set up Signal Frame */
+-	frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 1);
++	frame = get_sigframe(&ksig->ka, get_tm_stackpointer(regs), sizeof(*frame), 1);
+ 	if (unlikely(frame == NULL))
+ 		goto badframe;
+ 	sc = (struct sigcontext __user *) &frame->sctx;
+@@ -1456,7 +1453,7 @@ int handle_signal32(unsigned long sig, s
+ #if _NSIG != 64
+ #error "Please adjust handle_signal()"
+ #endif
+-	if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
++	if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
+ 	    || __put_user(oldset->sig[0], &sc->oldmask)
+ #ifdef CONFIG_PPC64
+ 	    || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
+@@ -1464,7 +1461,7 @@ int handle_signal32(unsigned long sig, s
+ 	    || __put_user(oldset->sig[1], &sc->_unused[3])
+ #endif
+ 	    || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
+-	    || __put_user(sig, &sc->signal))
++	    || __put_user(ksig->sig, &sc->signal))
+ 		goto badframe;
+ 
+ 	if (vdso32_sigtramp && current->mm->context.vdso_base) {
+@@ -1499,12 +1496,12 @@ int handle_signal32(unsigned long sig, s
+ 		goto badframe;
+ 
+ 	regs->gpr[1] = newsp;
+-	regs->gpr[3] = sig;
++	regs->gpr[3] = ksig->sig;
+ 	regs->gpr[4] = (unsigned long) sc;
+-	regs->nip = (unsigned long) ka->sa.sa_handler;
++	regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
+ 	/* enter the signal handler in big-endian mode */
+ 	regs->msr &= ~MSR_LE;
+-	return 1;
++	return 0;
+ 
+ badframe:
+ 	if (show_unhandled_signals)
+@@ -1514,8 +1511,7 @@ badframe:
+ 				   current->comm, current->pid,
+ 				   frame, regs->nip, regs->link);
+ 
+-	force_sigsegv(sig, current);
+-	return 0;
++	return 1;
+ }
+ 
+ /*
+--- a/arch/powerpc/kernel/signal_64.c
++++ b/arch/powerpc/kernel/signal_64.c
+@@ -743,20 +743,19 @@ badframe:
+ 	return 0;
+ }
+ 
+-int handle_rt_signal64(int signr, struct k_sigaction *ka, siginfo_t *info,
+-		sigset_t *set, struct pt_regs *regs)
++int handle_rt_signal64(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	unsigned long newsp = 0;
+ 	long err = 0;
+ 
+-	frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 0);
++	frame = get_sigframe(&ksig->ka, get_tm_stackpointer(regs), sizeof(*frame), 0);
+ 	if (unlikely(frame == NULL))
+ 		goto badframe;
+ 
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 	if (err)
+ 		goto badframe;
+ 
+@@ -771,15 +770,15 @@ int handle_rt_signal64(int signr, struct
+ 		err |= __put_user(&frame->uc_transact, &frame->uc.uc_link);
+ 		err |= setup_tm_sigcontexts(&frame->uc.uc_mcontext,
+ 					    &frame->uc_transact.uc_mcontext,
+-					    regs, signr,
++					    regs, ksig->sig,
+ 					    NULL,
+-					    (unsigned long)ka->sa.sa_handler);
++					    (unsigned long)ksig->ka.sa.sa_handler);
+ 	} else
+ #endif
+ 	{
+ 		err |= __put_user(0, &frame->uc.uc_link);
+-		err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, signr,
+-					NULL, (unsigned long)ka->sa.sa_handler,
++		err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, ksig->sig,
++					NULL, (unsigned long)ksig->ka.sa.sa_handler,
+ 					1);
+ 	}
+ 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
+@@ -805,7 +804,7 @@ int handle_rt_signal64(int signr, struct
+ 
+ 	/* Set up "regs" so we "return" to the signal handler. */
+ 	if (is_elf2_task()) {
+-		regs->nip = (unsigned long) ka->sa.sa_handler;
++		regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
+ 		regs->gpr[12] = regs->nip;
+ 	} else {
+ 		/* Handler is *really* a pointer to the function descriptor for
+@@ -814,7 +813,7 @@ int handle_rt_signal64(int signr, struct
+ 		 * entry is the TOC value we need to use.
+ 		 */
+ 		func_descr_t __user *funct_desc_ptr =
+-			(func_descr_t __user *) ka->sa.sa_handler;
++			(func_descr_t __user *) ksig->ka.sa.sa_handler;
+ 
+ 		err |= get_user(regs->nip, &funct_desc_ptr->entry);
+ 		err |= get_user(regs->gpr[2], &funct_desc_ptr->toc);
+@@ -824,9 +823,9 @@ int handle_rt_signal64(int signr, struct
+ 	regs->msr &= ~MSR_LE;
+ 	regs->msr |= (MSR_KERNEL & MSR_LE);
+ 	regs->gpr[1] = newsp;
+-	regs->gpr[3] = signr;
++	regs->gpr[3] = ksig->sig;
+ 	regs->result = 0;
+-	if (ka->sa.sa_flags & SA_SIGINFO) {
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
+ 		err |= get_user(regs->gpr[4], (unsigned long __user *)&frame->pinfo);
+ 		err |= get_user(regs->gpr[5], (unsigned long __user *)&frame->puc);
+ 		regs->gpr[6] = (unsigned long) frame;
+@@ -836,7 +835,7 @@ int handle_rt_signal64(int signr, struct
+ 	if (err)
+ 		goto badframe;
+ 
+-	return 1;
++	return 0;
+ 
+ badframe:
+ 	if (show_unhandled_signals)
+@@ -844,6 +843,5 @@ badframe:
+ 				   current->comm, current->pid, "setup_rt_frame",
+ 				   (long)frame, regs->nip, regs->link);
+ 
+-	force_sigsegv(signr, current);
+-	return 0;
++	return 1;
+ }
diff --git a/queue-3.16/s390-use-get_signal-signal_setup_done.patch b/queue-3.16/s390-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..9b4c09c2
--- /dev/null
+++ b/queue-3.16/s390-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,391 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 13 Jul 2014 22:21:03 +0200
+Subject: s390: Use get_signal() signal_setup_done()
+
+commit 067bf2d4d3a7aedc5982f6a58716054e5004b801 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/s390/kernel/compat_signal.c | 79 ++++++++++++++------------------
+ arch/s390/kernel/entry.h         |  4 +-
+ arch/s390/kernel/signal.c        | 78 +++++++++++++------------------
+ 3 files changed, 69 insertions(+), 92 deletions(-)
+
+--- a/arch/s390/kernel/compat_signal.c
++++ b/arch/s390/kernel/compat_signal.c
+@@ -320,38 +320,39 @@ static inline int map_signal(int sig)
+ 		return sig;
+ }
+ 
+-static int setup_frame32(int sig, struct k_sigaction *ka,
+-			sigset_t *set, struct pt_regs * regs)
++static int setup_frame32(struct ksignal *ksig, sigset_t *set,
++			 struct pt_regs *regs)
+ {
+-	sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
++	int sig = ksig->sig;
++	sigframe32 __user *frame = get_sigframe(&ksig->ka, regs, sizeof(sigframe32));
+ 
+ 	if (frame == (void __user *) -1UL)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (save_sigregs32(regs, &frame->sregs))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 	if (save_sigregs_gprs_high(regs, frame->gprs_high))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 	if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		regs->gprs[14] = (__u64 __force) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		regs->gprs[14] = (__u64 __force) ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
+ 	} else {
+ 		regs->gprs[14] = (__u64 __force) frame->retcode | PSW32_ADDR_AMODE;
+ 		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
+ 			       (u16 __force __user *)(frame->retcode)))
+-			goto give_sigsegv;
++			return -EFAULT;
+         }
+ 
+ 	/* Set up backchain. */
+ 	if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->gprs[15] = (__force __u64) frame;
+@@ -359,7 +360,7 @@ static int setup_frame32(int sig, struct
+ 	regs->psw.mask = PSW_MASK_BA |
+ 		(PSW_USER_BITS & PSW_MASK_ASC) |
+ 		(regs->psw.mask & ~PSW_MASK_ASC);
+-	regs->psw.addr = (__force __u64) ka->sa.sa_handler;
++	regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler;
+ 
+ 	regs->gprs[2] = map_signal(sig);
+ 	regs->gprs[3] = (__force __u64) &frame->sc;
+@@ -376,25 +377,21 @@ static int setup_frame32(int sig, struct
+ 
+ 	/* Place signal number on stack to allow backtrace from handler.  */
+ 	if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+-static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			   sigset_t *set, struct pt_regs * regs)
++static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set,
++			    struct pt_regs *regs)
+ {
+ 	int err = 0;
+-	rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
++	rt_sigframe32 __user *frame = get_sigframe(&ksig->ka, regs, sizeof(rt_sigframe32));
+ 
+ 	if (frame == (void __user *) -1UL)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+-	if (copy_siginfo_to_user32(&frame->info, info))
+-		goto give_sigsegv;
++	if (copy_siginfo_to_user32(&frame->info, &ksig->info))
++		return -EFAULT;
+ 
+ 	/* Create the ucontext.  */
+ 	err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
+@@ -404,22 +401,22 @@ static int setup_rt_frame32(int sig, str
+ 	err |= save_sigregs_gprs_high(regs, frame->gprs_high);
+ 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		regs->gprs[14] = (__u64 __force) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		regs->gprs[14] = (__u64 __force) ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
+ 	} else {
+ 		regs->gprs[14] = (__u64 __force) frame->retcode | PSW32_ADDR_AMODE;
+ 		if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
+ 			       (u16 __force __user *)(frame->retcode)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 	}
+ 
+ 	/* Set up backchain. */
+ 	if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->gprs[15] = (__force __u64) frame;
+@@ -427,36 +424,30 @@ static int setup_rt_frame32(int sig, str
+ 	regs->psw.mask = PSW_MASK_BA |
+ 		(PSW_USER_BITS & PSW_MASK_ASC) |
+ 		(regs->psw.mask & ~PSW_MASK_ASC);
+-	regs->psw.addr = (__u64 __force) ka->sa.sa_handler;
++	regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
+ 
+-	regs->gprs[2] = map_signal(sig);
++	regs->gprs[2] = map_signal(ksig->sig);
+ 	regs->gprs[3] = (__force __u64) &frame->info;
+ 	regs->gprs[4] = (__force __u64) &frame->uc;
+ 	regs->gprs[5] = task_thread_info(current)->last_break;
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ /*
+  * OK, we're invoking a handler
+  */	
+ 
+-void handle_signal32(unsigned long sig, struct k_sigaction *ka,
+-		    siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
++void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
++		     struct pt_regs *regs)
+ {
+ 	int ret;
+ 
+ 	/* Set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame32(sig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame32(ksig, oldset, regs);
+ 	else
+-		ret = setup_frame32(sig, ka, oldset, regs);
+-	if (ret)
+-		return;
+-	signal_delivered(sig, info, ka, regs,
+-				 test_thread_flag(TIF_SINGLE_STEP));
++		ret = setup_frame32(ksig, oldset, regs);
++
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
+ }
+ 
+--- a/arch/s390/kernel/entry.h
++++ b/arch/s390/kernel/entry.h
+@@ -48,8 +48,8 @@ void do_per_trap(struct pt_regs *regs);
+ void syscall_trace(struct pt_regs *regs, int entryexit);
+ void kernel_stack_overflow(struct pt_regs * regs);
+ void do_signal(struct pt_regs *regs);
+-void handle_signal32(unsigned long sig, struct k_sigaction *ka,
+-		    siginfo_t *info, sigset_t *oldset, struct pt_regs *regs);
++void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
++		     struct pt_regs *regs);
+ void do_notify_resume(struct pt_regs *regs);
+ 
+ void __init init_IRQ(void);
+--- a/arch/s390/kernel/signal.c
++++ b/arch/s390/kernel/signal.c
+@@ -200,15 +200,15 @@ static int setup_frame(int sig, struct k
+ 	frame = get_sigframe(ka, regs, sizeof(sigframe));
+ 
+ 	if (frame == (void __user *) -1UL)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (save_sigregs(regs, &frame->sregs))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 	if (__put_user(&frame->sregs, &frame->sc.sregs))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+@@ -220,12 +220,12 @@ static int setup_frame(int sig, struct k
+ 			frame->retcode | PSW_ADDR_AMODE;
+ 		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
+ 	                       (u16 __user *)(frame->retcode)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 	}
+ 
+ 	/* Set up backchain. */
+ 	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->gprs[15] = (unsigned long) frame;
+@@ -250,27 +250,23 @@ static int setup_frame(int sig, struct k
+ 
+ 	/* Place signal number on stack to allow backtrace from handler.  */
+ 	if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			   sigset_t *set, struct pt_regs * regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	int err = 0;
+ 	rt_sigframe __user *frame;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(rt_sigframe));
+ 
+ 	if (frame == (void __user *) -1UL)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+-	if (copy_siginfo_to_user(&frame->info, info))
+-		goto give_sigsegv;
++	if (copy_siginfo_to_user(&frame->info, &ksig->info))
++		return -EFAULT;
+ 
+ 	/* Create the ucontext.  */
+ 	err |= __put_user(0, &frame->uc.uc_flags);
+@@ -279,24 +275,24 @@ static int setup_rt_frame(int sig, struc
+ 	err |= save_sigregs(regs, &frame->uc.uc_mcontext);
+ 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
+                 regs->gprs[14] = (unsigned long)
+-			ka->sa.sa_restorer | PSW_ADDR_AMODE;
++			ksig->ka.sa.sa_restorer | PSW_ADDR_AMODE;
+ 	} else {
+                 regs->gprs[14] = (unsigned long)
+ 			frame->retcode | PSW_ADDR_AMODE;
+ 		if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
+ 			       (u16 __user *)(frame->retcode)))
+-			goto give_sigsegv;
++			return -EFAULT;
+ 	}
+ 
+ 	/* Set up backchain. */
+ 	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->gprs[15] = (unsigned long) frame;
+@@ -304,34 +300,27 @@ static int setup_rt_frame(int sig, struc
+ 	regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
+ 		(PSW_USER_BITS & PSW_MASK_ASC) |
+ 		(regs->psw.mask & ~PSW_MASK_ASC);
+-	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
++	regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler | PSW_ADDR_AMODE;
+ 
+-	regs->gprs[2] = map_signal(sig);
++	regs->gprs[2] = map_signal(ksig->sig);
+ 	regs->gprs[3] = (unsigned long) &frame->info;
+ 	regs->gprs[4] = (unsigned long) &frame->uc;
+ 	regs->gprs[5] = task_thread_info(current)->last_break;
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+-static void handle_signal(unsigned long sig, struct k_sigaction *ka,
+-			 siginfo_t *info, sigset_t *oldset,
+-			 struct pt_regs *regs)
++static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
++			  struct pt_regs *regs)
+ {
+ 	int ret;
+ 
+ 	/* Set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(sig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame(ksig, oldset, regs);
+ 	else
+-		ret = setup_frame(sig, ka, oldset, regs);
+-	if (ret)
+-		return;
+-	signal_delivered(sig, info, ka, regs,
+-				 test_thread_flag(TIF_SINGLE_STEP));
++		ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs);
++
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
+ }
+ 
+ /*
+@@ -345,9 +334,7 @@ static void handle_signal(unsigned long
+  */
+ void do_signal(struct pt_regs *regs)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 	sigset_t *oldset = sigmask_to_save();
+ 
+ 	/*
+@@ -357,9 +344,8 @@ void do_signal(struct pt_regs *regs)
+ 	 */
+ 	current_thread_info()->system_call =
+ 		test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+ 
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Whee!  Actually deliver the signal.  */
+ 		if (current_thread_info()->system_call) {
+ 			regs->int_code = current_thread_info()->system_call;
+@@ -370,7 +356,7 @@ void do_signal(struct pt_regs *regs)
+ 				regs->gprs[2] = -EINTR;
+ 				break;
+ 			case -ERESTARTSYS:
+-				if (!(ka.sa.sa_flags & SA_RESTART)) {
++				if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
+ 					regs->gprs[2] = -EINTR;
+ 					break;
+ 				}
+@@ -387,9 +373,9 @@ void do_signal(struct pt_regs *regs)
+ 		clear_pt_regs_flag(regs, PIF_SYSCALL);
+ 
+ 		if (is_compat_task())
+-			handle_signal32(signr, &ka, &info, oldset, regs);
++			handle_signal32(&ksig, oldset, regs);
+ 		else
+-			handle_signal(signr, &ka, &info, oldset, regs);
++			handle_signal(&ksig, oldset, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/score-use-get_signal-signal_setup_done.patch b/queue-3.16/score-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..28c17032
--- /dev/null
+++ b/queue-3.16/score-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,126 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 14:37:50 +0200
+Subject: score: Use get_signal() signal_setup_done()
+
+commit 2bb12b773feb3e792145961e57ab356e6134d4a5 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Acked-by: Lennox Wu <lennox.wu@gmail.com>
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/score/kernel/signal.c | 43 ++++++++++++++++----------------------
+ 1 file changed, 18 insertions(+), 25 deletions(-)
+
+--- a/arch/score/kernel/signal.c
++++ b/arch/score/kernel/signal.c
+@@ -173,15 +173,15 @@ badframe:
+ 	return 0;
+ }
+ 
+-static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
+-		int signr, sigset_t *set, siginfo_t *info)
++static int setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs,
++			  sigset_t *set)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	int err = 0;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/*
+ 	 * Set up the return code ...
+@@ -194,7 +194,7 @@ static int setup_rt_frame(struct k_sigac
+ 	err |= __put_user(0x80008002, frame->rs_code + 1);
+ 	flush_cache_sigtramp((unsigned long) frame->rs_code);
+ 
+-	err |= copy_siginfo_to_user(&frame->rs_info, info);
++	err |= copy_siginfo_to_user(&frame->rs_info, &ksig->info);
+ 	err |= __put_user(0, &frame->rs_uc.uc_flags);
+ 	err |= __put_user(NULL, &frame->rs_uc.uc_link);
+ 	err |= __save_altstack(&frame->rs_uc.uc_stack, regs->regs[0]);
+@@ -202,26 +202,23 @@ static int setup_rt_frame(struct k_sigac
+ 	err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	regs->regs[0] = (unsigned long) frame;
+ 	regs->regs[3] = (unsigned long) frame->rs_code;
+-	regs->regs[4] = signr;
++	regs->regs[4] = ksig->sig;
+ 	regs->regs[5] = (unsigned long) &frame->rs_info;
+ 	regs->regs[6] = (unsigned long) &frame->rs_uc;
+-	regs->regs[29] = (unsigned long) ka->sa.sa_handler;
+-	regs->cp0_epc = (unsigned long) ka->sa.sa_handler;
++	regs->regs[29] = (unsigned long) ksig->ka.sa.sa_handler;
++	regs->cp0_epc = (unsigned long) ksig->ka.sa.sa_handler;
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(signr, current);
+-	return -EFAULT;
+ }
+ 
+-static void handle_signal(unsigned long sig, siginfo_t *info,
+-	struct k_sigaction *ka, struct pt_regs *regs)
++static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
++	int ret;
++
+ 	if (regs->is_syscall) {
+ 		switch (regs->regs[4]) {
+ 		case ERESTART_RESTARTBLOCK:
+@@ -229,7 +226,7 @@ static void handle_signal(unsigned long
+ 			regs->regs[4] = EINTR;
+ 			break;
+ 		case ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->regs[4] = EINTR;
+ 				break;
+ 			}
+@@ -245,17 +242,14 @@ static void handle_signal(unsigned long
+ 	/*
+ 	 * Set up the stack frame
+ 	 */
+-	if (setup_rt_frame(ka, regs, sig, sigmask_to_save(), info) < 0)
+-		return;
++	ret = setup_rt_frame(ksig, regs, sigmask_to_save());
+ 
+-	signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ static void do_signal(struct pt_regs *regs)
+ {
+-	struct k_sigaction ka;
+-	siginfo_t info;
+-	int signr;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * We want the common case to go fast, which is why we may in certain
+@@ -265,10 +259,9 @@ static void do_signal(struct pt_regs *re
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Actually deliver the signal.  */
+-		handle_signal(signr, &info, &ka, regs);
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/series b/queue-3.16/series
index 8d3c1a1d..5d976da9 100644
--- a/queue-3.16/series
+++ b/queue-3.16/series
@@ -85,6 +85,7 @@ mm-oom-fix-use-after-free-in-oom_kill_process.patch
 mm-hwpoison-use-do_send_sig_info-instead-of-force_sig.patch
 mm-migrate-don-t-rely-on-__pagemovable-of-newpage-after-unlocking.patch
 dmaengine-imx-dma-fix-wrong-callback-invoke.patch
+dmaengine-bcm2835-add-additional-defines-for-dma-registers.patch
 dmaengine-bcm2835-fix-interrupt-race-on-rt.patch
 dmaengine-bcm2835-fix-abort-of-transactions.patch
 perf-x86-intel-uncore-add-node-id-mask.patch
@@ -93,7 +94,6 @@ dmaengine-dmatest-unmap-data-on-a-single-code-path-when-xfer-done.patch
 dmaengine-dmatest-abort-test-in-case-of-mapping-error.patch
 perf-tests-evsel-tp-sched-fix-bitwise-operator.patch
 perf-test-fix-failure-of-evsel-tp-sched-test-on-s390.patch
-net-dp83640-expire-old-tx-skb.patch
 s390-qeth-fix-use-after-free-in-error-path.patch
 s390-qeth-cancel-close_dev-work-before-removing-a-card.patch
 s390-qeth-conclude-all-event-processing-before-offlining-a-card.patch
@@ -105,6 +105,29 @@ alsa-compress-fix-stop-handling-on-compressed-capture-streams.patch
 mtd-rawnand-gpmi-fix-mx28-bus-master-lockup-problem.patch
 input-bma150-register-input-device-after-setting-private-data.patch
 libata-add-nolpm-quirk-for-samsung-mz7te512hmhp-000l1-ssd.patch
+arc-use-get_signal-signal_setup_done.patch
+arm64-use-get_signal-signal_setup_done.patch
+avr32-use-get_signal-signal_setup_done.patch
+blackfin-use-get_signal-signal_setup_done.patch
+c6x-use-get_signal-signal_setup_done.patch
+cris-use-get_signal-signal_setup_done.patch
+frv-use-get_signal-signal_setup_done.patch
+hexagon-use-get_signal-signal_setup_done.patch
+ia64-use-get_signal-signal_setup_done.patch
+m32r-use-get_signal-signal_setup_done.patch
+m68k-use-get_signal-signal_setup_done.patch
+microblaze-use-get_signal-signal_setup_done.patch
+mips-use-get_signal-signal_setup_done.patch
+mn10300-use-get_signal-signal_setup_done.patch
+parisc-use-get_signal-signal_setup_done.patch
+powerpc-use-get_signal-signal_setup_done.patch
+s390-use-get_signal-signal_setup_done.patch
+score-use-get_signal-signal_setup_done.patch
+sh-use-get_signal-signal_setup_done.patch
+tile-use-get_signal-signal_setup_done.patch
+um-use-get_signal-signal_setup_done.patch
+unicore32-use-get_signal-signal_setup_done.patch
+xtensa-use-get_signal-signal_setup_done.patch
 tracehook_signal_handler-remove-sig-info-ka-and-regs.patch
 clean-up-signal_delivered.patch
 rip-out-get_signal_to_deliver.patch
diff --git a/queue-3.16/sh-use-get_signal-signal_setup_done.patch b/queue-3.16/sh-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..d35fc651
--- /dev/null
+++ b/queue-3.16/sh-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,453 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 14:51:14 +0200
+Subject: sh: Use get_signal() signal_setup_done()
+
+commit b46e848768acc458ba94feef162b8901592dbb9c upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/sh/kernel/signal_32.c | 79 +++++++++++++++---------------------
+ arch/sh/kernel/signal_64.c | 82 +++++++++++++++-----------------------
+ 2 files changed, 64 insertions(+), 97 deletions(-)
+
+--- a/arch/sh/kernel/signal_32.c
++++ b/arch/sh/kernel/signal_32.c
+@@ -262,17 +262,17 @@ get_sigframe(struct k_sigaction *ka, uns
+ extern void __kernel_sigreturn(void);
+ extern void __kernel_rt_sigreturn(void);
+ 
+-static int setup_frame(int sig, struct k_sigaction *ka,
+-			sigset_t *set, struct pt_regs *regs)
++static int setup_frame(struct ksignal *ksig, sigset_t *set,
++		       struct pt_regs *regs)
+ {
+ 	struct sigframe __user *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 	int signal;
+ 
+-	frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs->regs[15], sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	signal = current_thread_info()->exec_domain
+ 		&& current_thread_info()->exec_domain->signal_invmap
+@@ -288,8 +288,8 @@ static int setup_frame(int sig, struct k
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		regs->pr = (unsigned long) ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		regs->pr = (unsigned long) ksig->ka.sa.sa_restorer;
+ #ifdef CONFIG_VSYSCALL
+ 	} else if (likely(current->mm->context.vdso)) {
+ 		regs->pr = VDSO_SYM(&__kernel_sigreturn);
+@@ -309,7 +309,7 @@ static int setup_frame(int sig, struct k
+ 	}
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->regs[15] = (unsigned long) frame;
+@@ -319,15 +319,15 @@ static int setup_frame(int sig, struct k
+ 
+ 	if (current->personality & FDPIC_FUNCPTRS) {
+ 		struct fdpic_func_descriptor __user *funcptr =
+-			(struct fdpic_func_descriptor __user *)ka->sa.sa_handler;
++			(struct fdpic_func_descriptor __user *)ksig->ka.sa.sa_handler;
+ 
+ 		err |= __get_user(regs->pc, &funcptr->text);
+ 		err |= __get_user(regs->regs[12], &funcptr->GOT);
+ 	} else
+-		regs->pc = (unsigned long)ka->sa.sa_handler;
++		regs->pc = (unsigned long)ksig->ka.sa.sa_handler;
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	set_fs(USER_DS);
+ 
+@@ -335,23 +335,19 @@ static int setup_frame(int sig, struct k
+ 		 current->comm, task_pid_nr(current), frame, regs->pc, regs->pr);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			   sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 	int signal;
+ 
+-	frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs->regs[15], sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	signal = current_thread_info()->exec_domain
+ 		&& current_thread_info()->exec_domain->signal_invmap
+@@ -359,7 +355,7 @@ static int setup_rt_frame(int sig, struc
+ 		? current_thread_info()->exec_domain->signal_invmap[sig]
+ 		: sig;
+ 
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	/* Create the ucontext.  */
+ 	err |= __put_user(0, &frame->uc.uc_flags);
+@@ -371,8 +367,8 @@ static int setup_rt_frame(int sig, struc
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		regs->pr = (unsigned long) ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		regs->pr = (unsigned long) ksig->ka.sa.sa_restorer;
+ #ifdef CONFIG_VSYSCALL
+ 	} else if (likely(current->mm->context.vdso)) {
+ 		regs->pr = VDSO_SYM(&__kernel_rt_sigreturn);
+@@ -392,7 +388,7 @@ static int setup_rt_frame(int sig, struc
+ 	}
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up registers for signal handler */
+ 	regs->regs[15] = (unsigned long) frame;
+@@ -402,15 +398,15 @@ static int setup_rt_frame(int sig, struc
+ 
+ 	if (current->personality & FDPIC_FUNCPTRS) {
+ 		struct fdpic_func_descriptor __user *funcptr =
+-			(struct fdpic_func_descriptor __user *)ka->sa.sa_handler;
++			(struct fdpic_func_descriptor __user *)ksig->ka.sa.sa_handler;
+ 
+ 		err |= __get_user(regs->pc, &funcptr->text);
+ 		err |= __get_user(regs->regs[12], &funcptr->GOT);
+ 	} else
+-		regs->pc = (unsigned long)ka->sa.sa_handler;
++		regs->pc = (unsigned long)ksig->ka.sa.sa_handler;
+ 
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	set_fs(USER_DS);
+ 
+@@ -418,10 +414,6 @@ static int setup_rt_frame(int sig, struc
+ 		 current->comm, task_pid_nr(current), frame, regs->pc, regs->pr);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ static inline void
+@@ -455,22 +447,18 @@ handle_syscall_restart(unsigned long sav
+  * OK, we're invoking a handler
+  */
+ static void
+-handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
+-	      struct pt_regs *regs, unsigned int save_r0)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs, unsigned int save_r0)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+ 
+ 	/* Set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(sig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame(ksig, oldset, regs);
+ 	else
+-		ret = setup_frame(sig, ka, oldset, regs);
++		ret = setup_frame(ksig, oldset, regs);
+ 
+-	if (ret)
+-		return;
+-	signal_delivered(sig, info, ka, regs,
+-			test_thread_flag(TIF_SINGLESTEP));
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ }
+ 
+ /*
+@@ -484,9 +472,7 @@ handle_signal(unsigned long sig, struct
+  */
+ static void do_signal(struct pt_regs *regs, unsigned int save_r0)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * We want the common case to go fast, which
+@@ -497,12 +483,11 @@ static void do_signal(struct pt_regs *re
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
+-		handle_syscall_restart(save_r0, regs, &ka.sa);
++	if (get_signal(&ksig)) {
++		handle_syscall_restart(save_r0, regs, &ksig.ka.sa);
+ 
+ 		/* Whee!  Actually deliver the signal.  */
+-		handle_signal(signr, &ka, &info, regs, save_r0);
++		handle_signal(&ksig, regs, save_r0);
+ 		return;
+ 	}
+ 
+--- a/arch/sh/kernel/signal_64.c
++++ b/arch/sh/kernel/signal_64.c
+@@ -41,8 +41,7 @@
+ #define DEBUG_SIG 0
+ 
+ static void
+-handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
+-		struct pt_regs * regs);
++handle_signal(struct ksignal *ksig, struct pt_regs *regs);
+ 
+ static inline void
+ handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
+@@ -82,9 +81,7 @@ handle_syscall_restart(struct pt_regs *r
+  */
+ static void do_signal(struct pt_regs *regs)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * We want the common case to go fast, which
+@@ -95,12 +92,11 @@ static void do_signal(struct pt_regs *re
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, 0);
+-	if (signr > 0) {
+-		handle_syscall_restart(regs, &ka.sa);
++	if (get_signal(&ksig)) {
++		handle_syscall_restart(regs, &ksig.ka.sa);
+ 
+ 		/* Whee!  Actually deliver the signal.  */
+-		handle_signal(signr, &info, &ka, regs);
++		handle_signal(&ksig, regs);
+ 		return;
+ 	}
+ 
+@@ -378,17 +374,16 @@ get_sigframe(struct k_sigaction *ka, uns
+ void sa_default_restorer(void);		/* See comments below */
+ void sa_default_rt_restorer(void);	/* See comments below */
+ 
+-static int setup_frame(int sig, struct k_sigaction *ka,
+-		       sigset_t *set, struct pt_regs *regs)
++static int setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
+ {
+ 	struct sigframe __user *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 	int signal;
+ 
+-	frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	signal = current_thread_info()->exec_domain
+ 		&& current_thread_info()->exec_domain->signal_invmap
+@@ -400,7 +395,7 @@ static int setup_frame(int sig, struct k
+ 
+ 	/* Give up earlier as i386, in case */
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	if (_NSIG_WORDS > 1) {
+ 		err |= __copy_to_user(frame->extramask, &set->sig[1],
+@@ -408,16 +403,16 @@ static int setup_frame(int sig, struct k
+ 
+ 	/* Give up earlier as i386, in case */
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
+ 		/*
+ 		 * On SH5 all edited pointers are subject to NEFF
+ 		 */
+ 		DEREF_REG_PR = neff_sign_extend((unsigned long)
+-			ka->sa.sa_restorer | 0x1);
++			ksig->ka->sa.sa_restorer | 0x1);
+ 	} else {
+ 		/*
+ 		 * Different approach on SH5.
+@@ -435,7 +430,7 @@ static int setup_frame(int sig, struct k
+ 
+ 		if (__copy_to_user(frame->retcode,
+ 			(void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
+-			goto give_sigsegv;
++			return -EFAULT;
+ 
+ 		/* Cohere the trampoline with the I-cache. */
+ 		flush_cache_sigtramp(DEREF_REG_PR-1);
+@@ -460,7 +455,7 @@ static int setup_frame(int sig, struct k
+ 	regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
+ 	regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
+ 
+-	regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
++	regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
+ 
+ 	set_fs(USER_DS);
+ 
+@@ -471,23 +466,19 @@ static int setup_frame(int sig, struct k
+ 		 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			  sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *kig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 	int signal;
+ 
+-	frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	signal = current_thread_info()->exec_domain
+ 		&& current_thread_info()->exec_domain->signal_invmap
+@@ -497,11 +488,11 @@ static int setup_rt_frame(int sig, struc
+ 
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	/* Give up earlier as i386, in case */
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Create the ucontext.  */
+ 	err |= __put_user(0, &frame->uc.uc_flags);
+@@ -513,16 +504,16 @@ static int setup_rt_frame(int sig, struc
+ 
+ 	/* Give up earlier as i386, in case */
+ 	if (err)
+-		goto give_sigsegv;
++		return -EFAULT;
+ 
+ 	/* Set up to return from userspace.  If provided, use a stub
+ 	   already in userspace.  */
+-	if (ka->sa.sa_flags & SA_RESTORER) {
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
+ 		/*
+ 		 * On SH5 all edited pointers are subject to NEFF
+ 		 */
+ 		DEREF_REG_PR = neff_sign_extend((unsigned long)
+-			ka->sa.sa_restorer | 0x1);
++			ksig->ka.sa.sa_restorer | 0x1);
+ 	} else {
+ 		/*
+ 		 * Different approach on SH5.
+@@ -540,7 +531,7 @@ static int setup_rt_frame(int sig, struc
+ 
+ 		if (__copy_to_user(frame->retcode,
+ 			(void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
+-			goto give_sigsegv;
++			return -EFAULT;
+ 
+ 		/* Cohere the trampoline with the I-cache. */
+ 		flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
+@@ -554,7 +545,7 @@ static int setup_rt_frame(int sig, struc
+ 	regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
+ 	regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
+ 	regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
+-	regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
++	regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
+ 
+ 	set_fs(USER_DS);
+ 
+@@ -564,33 +555,24 @@ static int setup_rt_frame(int sig, struc
+ 		 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ /*
+  * OK, we're invoking a handler
+  */
+ static void
+-handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
+-		struct pt_regs * regs)
++handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+ 
+ 	/* Set up the stack frame */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(sig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame(ksig, oldset, regs);
+ 	else
+-		ret = setup_frame(sig, ka, oldset, regs);
+-
+-	if (ret)
+-		return;
++		ret = setup_frame(ksig, oldset, regs);
+ 
+-	signal_delivered(sig, info, ka, regs,
+-			test_thread_flag(TIF_SINGLESTEP));
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ }
+ 
+ asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
diff --git a/queue-3.16/tile-use-get_signal-signal_setup_done.patch b/queue-3.16/tile-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..ab061d56
--- /dev/null
+++ b/queue-3.16/tile-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,250 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 15:01:08 +0200
+Subject: tile: Use get_signal() signal_setup_done()
+
+commit b3707c7ed013d36752272ca2f9ed20dc8aed92e4 upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+Acked-by: Chris Metcalf <cmetcalf@tilera.com>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/tile/include/asm/compat.h   |  3 +-
+ arch/tile/kernel/compat_signal.c | 29 ++++++++---------
+ arch/tile/kernel/signal.c        | 54 ++++++++++++++------------------
+ 3 files changed, 40 insertions(+), 46 deletions(-)
+
+--- a/arch/tile/include/asm/compat.h
++++ b/arch/tile/include/asm/compat.h
+@@ -267,8 +267,7 @@ static inline int is_compat_task(void)
+ 	return current_thread_info()->status & TS_COMPAT;
+ }
+ 
+-extern int compat_setup_rt_frame(int sig, struct k_sigaction *ka,
+-				 siginfo_t *info, sigset_t *set,
++extern int compat_setup_rt_frame(struct ksignal *ksig, sigset_t *set,
+ 				 struct pt_regs *regs);
+ 
+ /* Compat syscalls. */
+--- a/arch/tile/kernel/compat_signal.c
++++ b/arch/tile/kernel/compat_signal.c
+@@ -190,18 +190,18 @@ static inline void __user *compat_get_si
+ 	return (void __user *) sp;
+ }
+ 
+-int compat_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			  sigset_t *set, struct pt_regs *regs)
++int compat_setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	unsigned long restorer;
+ 	struct compat_rt_sigframe __user *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 	int usig;
+ 
+-	frame = compat_get_sigframe(ka, regs, sizeof(*frame));
++	frame = compat_get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		goto err;
+ 
+ 	usig = current_thread_info()->exec_domain
+ 		&& current_thread_info()->exec_domain->signal_invmap
+@@ -210,12 +210,12 @@ int compat_setup_rt_frame(int sig, struc
+ 		: sig;
+ 
+ 	/* Always write at least the signal number for the stack backtracer. */
+-	if (ka->sa.sa_flags & SA_SIGINFO) {
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
+ 		/* At sigreturn time, restore the callee-save registers too. */
+-		err |= copy_siginfo_to_user32(&frame->info, info);
++		err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
+ 		regs->flags |= PT_FLAGS_RESTORE_REGS;
+ 	} else {
+-		err |= __put_user(info->si_signo, &frame->info.si_signo);
++		err |= __put_user(ksig->info.si_signo, &frame->info.si_signo);
+ 	}
+ 
+ 	/* Create the ucontext.  */
+@@ -226,11 +226,11 @@ int compat_setup_rt_frame(int sig, struc
+ 	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs);
+ 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
+ 	if (err)
+-		goto give_sigsegv;
++		goto err;
+ 
+ 	restorer = VDSO_SYM(&__vdso_rt_sigreturn);
+-	if (ka->sa.sa_flags & SA_RESTORER)
+-		restorer = ptr_to_compat_reg(ka->sa.sa_restorer);
++	if (ksig->ka.sa.sa_flags & SA_RESTORER)
++		restorer = ptr_to_compat_reg(ksig->ka.sa.sa_restorer);
+ 
+ 	/*
+ 	 * Set up registers for signal handler.
+@@ -239,7 +239,7 @@ int compat_setup_rt_frame(int sig, struc
+ 	 * We always pass siginfo and mcontext, regardless of SA_SIGINFO,
+ 	 * since some things rely on this (e.g. glibc's debug/segfault.c).
+ 	 */
+-	regs->pc = ptr_to_compat_reg(ka->sa.sa_handler);
++	regs->pc = ptr_to_compat_reg(ksig->ka.sa.sa_handler);
+ 	regs->ex1 = PL_ICS_EX1(USER_PL, 1); /* set crit sec in handler */
+ 	regs->sp = ptr_to_compat_reg(frame);
+ 	regs->lr = restorer;
+@@ -249,7 +249,8 @@ int compat_setup_rt_frame(int sig, struc
+ 	regs->flags |= PT_FLAGS_CALLER_SAVES;
+ 	return 0;
+ 
+-give_sigsegv:
+-	signal_fault("bad setup frame", regs, frame, sig);
++err:
++	trace_unhandled_signal("bad sigreturn frame", regs,
++			      (unsigned long)frame, SIGSEGV);
+ 	return -EFAULT;
+ }
+--- a/arch/tile/kernel/signal.c
++++ b/arch/tile/kernel/signal.c
+@@ -153,18 +153,18 @@ static inline void __user *get_sigframe(
+ 	return (void __user *) sp;
+ }
+ 
+-static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-			   sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	unsigned long restorer;
+ 	struct rt_sigframe __user *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 	int usig;
+ 
+-	frame = get_sigframe(ka, regs, sizeof(*frame));
++	frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+-		goto give_sigsegv;
++		goto err;
+ 
+ 	usig = current_thread_info()->exec_domain
+ 		&& current_thread_info()->exec_domain->signal_invmap
+@@ -173,12 +173,12 @@ static int setup_rt_frame(int sig, struc
+ 		: sig;
+ 
+ 	/* Always write at least the signal number for the stack backtracer. */
+-	if (ka->sa.sa_flags & SA_SIGINFO) {
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
+ 		/* At sigreturn time, restore the callee-save registers too. */
+-		err |= copy_siginfo_to_user(&frame->info, info);
++		err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 		regs->flags |= PT_FLAGS_RESTORE_REGS;
+ 	} else {
+-		err |= __put_user(info->si_signo, &frame->info.si_signo);
++		err |= __put_user(ksig->info.si_signo, &frame->info.si_signo);
+ 	}
+ 
+ 	/* Create the ucontext.  */
+@@ -189,11 +189,11 @@ static int setup_rt_frame(int sig, struc
+ 	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs);
+ 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
+ 	if (err)
+-		goto give_sigsegv;
++		goto err;
+ 
+ 	restorer = VDSO_SYM(&__vdso_rt_sigreturn);
+-	if (ka->sa.sa_flags & SA_RESTORER)
+-		restorer = (unsigned long) ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER)
++		restorer = (unsigned long) ksig->ka.sa.sa_restorer;
+ 
+ 	/*
+ 	 * Set up registers for signal handler.
+@@ -202,7 +202,7 @@ static int setup_rt_frame(int sig, struc
+ 	 * We always pass siginfo and mcontext, regardless of SA_SIGINFO,
+ 	 * since some things rely on this (e.g. glibc's debug/segfault.c).
+ 	 */
+-	regs->pc = (unsigned long) ka->sa.sa_handler;
++	regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
+ 	regs->ex1 = PL_ICS_EX1(USER_PL, 1); /* set crit sec in handler */
+ 	regs->sp = (unsigned long) frame;
+ 	regs->lr = restorer;
+@@ -212,8 +212,9 @@ static int setup_rt_frame(int sig, struc
+ 	regs->flags |= PT_FLAGS_CALLER_SAVES;
+ 	return 0;
+ 
+-give_sigsegv:
+-	signal_fault("bad setup frame", regs, frame, sig);
++err:
++	trace_unhandled_signal("bad sigreturn frame", regs,
++			      (unsigned long)frame, SIGSEGV);
+ 	return -EFAULT;
+ }
+ 
+@@ -221,9 +222,7 @@ give_sigsegv:
+  * OK, we're invoking a handler
+  */
+ 
+-static void handle_signal(unsigned long sig, siginfo_t *info,
+-			 struct k_sigaction *ka,
+-			 struct pt_regs *regs)
++static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int ret;
+@@ -238,7 +237,7 @@ static void handle_signal(unsigned long
+ 			break;
+ 
+ 		case -ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->regs[0] = -EINTR;
+ 				break;
+ 			}
+@@ -254,14 +253,12 @@ static void handle_signal(unsigned long
+ 	/* Set up the stack frame */
+ #ifdef CONFIG_COMPAT
+ 	if (is_compat_task())
+-		ret = compat_setup_rt_frame(sig, ka, info, oldset, regs);
++		ret = compat_setup_rt_frame(ksig, oldset, regs);
+ 	else
+ #endif
+-		ret = setup_rt_frame(sig, ka, info, oldset, regs);
+-	if (ret)
+-		return;
+-	signal_delivered(sig, info, ka, regs,
+-			test_thread_flag(TIF_SINGLESTEP));
++		ret = setup_rt_frame(ksig, oldset, regs);
++
++	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
+ }
+ 
+ /*
+@@ -271,9 +268,7 @@ static void handle_signal(unsigned long
+  */
+ void do_signal(struct pt_regs *regs)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * i386 will check if we're coming from kernel mode and bail out
+@@ -282,10 +277,9 @@ void do_signal(struct pt_regs *regs)
+ 	 * helpful, we can reinstate the check on "!user_mode(regs)".
+ 	 */
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		/* Whee! Actually deliver the signal.  */
+-		handle_signal(signr, &info, &ka, regs);
++		handle_signal(&ksig, regs);
+ 		goto done;
+ 	}
+ 
diff --git a/queue-3.16/um-use-get_signal-signal_setup_done.patch b/queue-3.16/um-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..22c9c5d8
--- /dev/null
+++ b/queue-3.16/um-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,232 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Sun, 6 Oct 2013 21:57:10 +0200
+Subject: um: Use get_signal() signal_setup_done()
+
+commit 307627eebbb0bc41b21e74d78b932362a6c1b38d upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/um/include/shared/frame_kern.h | 12 +++-----
+ arch/um/kernel/signal.c             | 27 +++++++----------
+ arch/x86/um/signal.c                | 45 ++++++++++++++---------------
+ 3 files changed, 36 insertions(+), 48 deletions(-)
+
+--- a/arch/um/include/shared/frame_kern.h
++++ b/arch/um/include/shared/frame_kern.h
+@@ -6,14 +6,10 @@
+ #ifndef __FRAME_KERN_H_
+ #define __FRAME_KERN_H_
+ 
+-extern int setup_signal_stack_sc(unsigned long stack_top, int sig,
+-				 struct k_sigaction *ka,
+-				 struct pt_regs *regs,
+-				 sigset_t *mask);
+-extern int setup_signal_stack_si(unsigned long stack_top, int sig,
+-				 struct k_sigaction *ka,
+-				 struct pt_regs *regs, struct siginfo *info,
+-				 sigset_t *mask);
++extern int setup_signal_stack_sc(unsigned long stack_top, struct ksignal *ksig,
++				 struct pt_regs *regs, sigset_t *mask);
++extern int setup_signal_stack_si(unsigned long stack_top, struct ksignal *ksig,
++				 struct pt_regs *regs, sigset_t *mask);
+ 
+ #endif
+ 
+--- a/arch/um/kernel/signal.c
++++ b/arch/um/kernel/signal.c
+@@ -18,8 +18,7 @@ EXPORT_SYMBOL(unblock_signals);
+ /*
+  * OK, we're invoking a handler
+  */
+-static void handle_signal(struct pt_regs *regs, unsigned long signr,
+-			 struct k_sigaction *ka, struct siginfo *info)
++static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
+ {
+ 	sigset_t *oldset = sigmask_to_save();
+ 	int singlestep = 0;
+@@ -39,7 +38,7 @@ static void handle_signal(struct pt_regs
+ 			break;
+ 
+ 		case -ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				PT_REGS_SYSCALL_RET(regs) = -EINTR;
+ 				break;
+ 			}
+@@ -52,32 +51,28 @@ static void handle_signal(struct pt_regs
+ 	}
+ 
+ 	sp = PT_REGS_SP(regs);
+-	if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags(sp) == 0))
++	if ((ksig->ka.sa.sa_flags & SA_ONSTACK) && (sas_ss_flags(sp) == 0))
+ 		sp = current->sas_ss_sp + current->sas_ss_size;
+ 
+ #ifdef CONFIG_ARCH_HAS_SC_SIGNALS
+-	if (!(ka->sa.sa_flags & SA_SIGINFO))
+-		err = setup_signal_stack_sc(sp, signr, ka, regs, oldset);
++	if (!(ksig->ka.sa.sa_flags & SA_SIGINFO))
++		err = setup_signal_stack_sc(sp, ksig, regs, oldset);
+ 	else
+ #endif
+-		err = setup_signal_stack_si(sp, signr, ka, regs, info, oldset);
++		err = setup_signal_stack_si(sp, ksig, regs, oldset);
+ 
+-	if (err)
+-		force_sigsegv(signr, current);
+-	else
+-		signal_delivered(signr, info, ka, regs, singlestep);
++	signal_setup_done(err, ksig, singlestep);
+ }
+ 
+ static int kern_do_signal(struct pt_regs *regs)
+ {
+-	struct k_sigaction ka_copy;
+-	struct siginfo info;
+-	int sig, handled_sig = 0;
++	struct ksignal ksig;
++	int handled_sig = 0;
+ 
+-	while ((sig = get_signal_to_deliver(&info, &ka_copy, regs, NULL)) > 0) {
++	while (get_signal(&ksig)) {
+ 		handled_sig = 1;
+ 		/* Whee!  Actually deliver the signal.  */
+-		handle_signal(regs, sig, &ka_copy, &info);
++		handle_signal(&ksig, regs);
+ 	}
+ 
+ 	/* Did we come from a system call? */
+--- a/arch/x86/um/signal.c
++++ b/arch/x86/um/signal.c
+@@ -370,13 +370,12 @@ struct rt_sigframe
+ 	char retcode[8];
+ };
+ 
+-int setup_signal_stack_sc(unsigned long stack_top, int sig,
+-			  struct k_sigaction *ka, struct pt_regs *regs,
+-			  sigset_t *mask)
++int setup_signal_stack_sc(unsigned long stack_top, struct ksignal *ksig,
++			  struct pt_regs *regs, sigset_t *mask)
+ {
+ 	struct sigframe __user *frame;
+ 	void __user *restorer;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 
+ 	/* This is the same calculation as i386 - ((sp + 4) & 15) == 0 */
+ 	stack_top = ((stack_top + 4) & -16UL) - 4;
+@@ -385,8 +384,8 @@ int setup_signal_stack_sc(unsigned long
+ 		return 1;
+ 
+ 	restorer = frame->retcode;
+-	if (ka->sa.sa_flags & SA_RESTORER)
+-		restorer = ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER)
++		restorer = ksig->ka.sa.sa_restorer;
+ 
+ 	err |= __put_user(restorer, &frame->pretcode);
+ 	err |= __put_user(sig, &frame->sig);
+@@ -410,20 +409,19 @@ int setup_signal_stack_sc(unsigned long
+ 		return err;
+ 
+ 	PT_REGS_SP(regs) = (unsigned long) frame;
+-	PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
++	PT_REGS_IP(regs) = (unsigned long) ksig->ka.sa.sa_handler;
+ 	PT_REGS_AX(regs) = (unsigned long) sig;
+ 	PT_REGS_DX(regs) = (unsigned long) 0;
+ 	PT_REGS_CX(regs) = (unsigned long) 0;
+ 	return 0;
+ }
+ 
+-int setup_signal_stack_si(unsigned long stack_top, int sig,
+-			  struct k_sigaction *ka, struct pt_regs *regs,
+-			  siginfo_t *info, sigset_t *mask)
++int setup_signal_stack_si(unsigned long stack_top, struct ksignal *ksig,
++			  struct pt_regs *regs, sigset_t *mask)
+ {
+ 	struct rt_sigframe __user *frame;
+ 	void __user *restorer;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 
+ 	stack_top &= -8UL;
+ 	frame = (struct rt_sigframe __user *) stack_top - 1;
+@@ -431,14 +429,14 @@ int setup_signal_stack_si(unsigned long
+ 		return 1;
+ 
+ 	restorer = frame->retcode;
+-	if (ka->sa.sa_flags & SA_RESTORER)
+-		restorer = ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER)
++		restorer = ksig->ka.sa.sa_restorer;
+ 
+ 	err |= __put_user(restorer, &frame->pretcode);
+ 	err |= __put_user(sig, &frame->sig);
+ 	err |= __put_user(&frame->info, &frame->pinfo);
+ 	err |= __put_user(&frame->uc, &frame->puc);
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 	err |= copy_ucontext_to_user(&frame->uc, &frame->fpstate, mask,
+ 					PT_REGS_SP(regs));
+ 
+@@ -457,7 +455,7 @@ int setup_signal_stack_si(unsigned long
+ 		return err;
+ 
+ 	PT_REGS_SP(regs) = (unsigned long) frame;
+-	PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
++	PT_REGS_IP(regs) = (unsigned long) ksig->ka.sa.sa_handler;
+ 	PT_REGS_AX(regs) = (unsigned long) sig;
+ 	PT_REGS_DX(regs) = (unsigned long) &frame->info;
+ 	PT_REGS_CX(regs) = (unsigned long) &frame->uc;
+@@ -502,12 +500,11 @@ struct rt_sigframe
+ 	struct _fpstate fpstate;
+ };
+ 
+-int setup_signal_stack_si(unsigned long stack_top, int sig,
+-			  struct k_sigaction *ka, struct pt_regs * regs,
+-			  siginfo_t *info, sigset_t *set)
++int setup_signal_stack_si(unsigned long stack_top, struct ksignal *ksig,
++			  struct pt_regs *regs, sigset_t *set)
+ {
+ 	struct rt_sigframe __user *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 
+ 	frame = (struct rt_sigframe __user *)
+ 		round_down(stack_top - sizeof(struct rt_sigframe), 16);
+@@ -517,8 +514,8 @@ int setup_signal_stack_si(unsigned long
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+ 		goto out;
+ 
+-	if (ka->sa.sa_flags & SA_SIGINFO) {
+-		err |= copy_siginfo_to_user(&frame->info, info);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
++		err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 		if (err)
+ 			goto out;
+ 	}
+@@ -543,8 +540,8 @@ int setup_signal_stack_si(unsigned long
+ 	 * already in userspace.
+ 	 */
+ 	/* x86-64 should always use SA_RESTORER. */
+-	if (ka->sa.sa_flags & SA_RESTORER)
+-		err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
++	if (ksig->ka.sa.sa_flags & SA_RESTORER)
++		err |= __put_user(ksig->ka.sa.sa_restorer, &frame->pretcode);
+ 	else
+ 		/* could use a vstub here */
+ 		return err;
+@@ -570,7 +567,7 @@ int setup_signal_stack_si(unsigned long
+ 	 */
+ 	PT_REGS_SI(regs) = (unsigned long) &frame->info;
+ 	PT_REGS_DX(regs) = (unsigned long) &frame->uc;
+-	PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
++	PT_REGS_IP(regs) = (unsigned long) ksig->ka.sa.sa_handler;
+  out:
+ 	return err;
+ }
diff --git a/queue-3.16/unicore32-use-get_signal-signal_setup_done.patch b/queue-3.16/unicore32-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..725d5e18
--- /dev/null
+++ b/queue-3.16/unicore32-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,147 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 15:05:57 +0200
+Subject: unicore32: Use get_signal() signal_setup_done()
+
+commit 649671c90eaf3cbbd0cd03460b6a92c0b674a32e upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/unicore32/kernel/signal.c | 48 ++++++++++++++--------------------
+ 1 file changed, 20 insertions(+), 28 deletions(-)
+
+diff --git a/arch/unicore32/kernel/signal.c b/arch/unicore32/kernel/signal.c
+index 6905f0ebdc77..780d77388dec 100644
+--- a/arch/unicore32/kernel/signal.c
++++ b/arch/unicore32/kernel/signal.c
+@@ -238,10 +238,10 @@ static int setup_return(struct pt_regs *regs, struct k_sigaction *ka,
+ 	return 0;
+ }
+ 
+-static int setup_frame(int usig, struct k_sigaction *ka,
+-		sigset_t *set, struct pt_regs *regs)
++static int setup_frame(struct ksignal *ksig, sigset_t *set,
++		       struct pt_regs *regs)
+ {
+-	struct sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
++	struct sigframe __user *frame = get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	int err = 0;
+ 
+ 	if (!frame)
+@@ -254,29 +254,29 @@ static int setup_frame(int usig, struct k_sigaction *ka,
+ 
+ 	err |= setup_sigframe(frame, regs, set);
+ 	if (err == 0)
+-		err |= setup_return(regs, ka, frame->retcode, frame, usig);
++		err |= setup_return(regs, &ksig->ka, frame->retcode, frame, usig);
+ 
+ 	return err;
+ }
+ 
+-static int setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
+-	       sigset_t *set, struct pt_regs *regs)
++static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
++			  struct pt_regs *regs)
+ {
+ 	struct rt_sigframe __user *frame =
+-			get_sigframe(ka, regs, sizeof(*frame));
++			get_sigframe(&ksig->ka, regs, sizeof(*frame));
+ 	int err = 0;
+ 
+ 	if (!frame)
+ 		return 1;
+ 
+-	err |= copy_siginfo_to_user(&frame->info, info);
++	err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 
+ 	err |= __put_user(0, &frame->sig.uc.uc_flags);
+ 	err |= __put_user(NULL, &frame->sig.uc.uc_link);
+ 	err |= __save_altstack(&frame->sig.uc.uc_stack, regs->UCreg_sp);
+ 	err |= setup_sigframe(&frame->sig, regs, set);
+ 	if (err == 0)
+-		err |= setup_return(regs, ka, frame->sig.retcode, frame, usig);
++		err |= setup_return(regs, &ksig->ka, frame->sig.retcode, frame, usig);
+ 
+ 	if (err == 0) {
+ 		/*
+@@ -299,13 +299,13 @@ static inline void setup_syscall_restart(struct pt_regs *regs)
+ /*
+  * OK, we're invoking a handler
+  */
+-static void handle_signal(unsigned long sig, struct k_sigaction *ka,
+-	      siginfo_t *info, struct pt_regs *regs, int syscall)
++static void handle_signal(struct ksignal *ksig, struct pt_regs *regs,
++			  int syscall)
+ {
+ 	struct thread_info *thread = current_thread_info();
+ 	struct task_struct *tsk = current;
+ 	sigset_t *oldset = sigmask_to_save();
+-	int usig = sig;
++	int usig = ksig->sig;
+ 	int ret;
+ 
+ 	/*
+@@ -318,7 +318,7 @@ static void handle_signal(unsigned long sig, struct k_sigaction *ka,
+ 			regs->UCreg_00 = -EINTR;
+ 			break;
+ 		case -ERESTARTSYS:
+-			if (!(ka->sa.sa_flags & SA_RESTART)) {
++			if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
+ 				regs->UCreg_00 = -EINTR;
+ 				break;
+ 			}
+@@ -338,22 +338,17 @@ static void handle_signal(unsigned long sig, struct k_sigaction *ka,
+ 	/*
+ 	 * Set up the stack frame
+ 	 */
+-	if (ka->sa.sa_flags & SA_SIGINFO)
+-		ret = setup_rt_frame(usig, ka, info, oldset, regs);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
++		ret = setup_rt_frame(ksig, oldset, regs);
+ 	else
+-		ret = setup_frame(usig, ka, oldset, regs);
++		ret = setup_frame(ksig, oldset, regs);
+ 
+ 	/*
+ 	 * Check that the resulting registers are actually sane.
+ 	 */
+ 	ret |= !valid_user_regs(regs);
+ 
+-	if (ret != 0) {
+-		force_sigsegv(sig, tsk);
+-		return;
+-	}
+-
+-	signal_delivered(sig, info, ka, regs, 0);
++	signal_setup_done(ret, ksig, 0);
+ }
+ 
+ /*
+@@ -367,9 +362,7 @@ static void handle_signal(unsigned long sig, struct k_sigaction *ka,
+  */
+ static void do_signal(struct pt_regs *regs, int syscall)
+ {
+-	struct k_sigaction ka;
+-	siginfo_t info;
+-	int signr;
++	struct ksignal ksig;
+ 
+ 	/*
+ 	 * We want the common case to go fast, which
+@@ -380,9 +373,8 @@ static void do_signal(struct pt_regs *regs, int syscall)
+ 	if (!user_mode(regs))
+ 		return;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-	if (signr > 0) {
+-		handle_signal(signr, &ka, &info, regs, syscall);
++	if (get_signsl(&ksig)) {
++		handle_signal(&ksig, regs, syscall);
+ 		return;
+ 	}
+ 
diff --git a/queue-3.16/xtensa-use-get_signal-signal_setup_done.patch b/queue-3.16/xtensa-use-get_signal-signal_setup_done.patch
new file mode 100644
index 00000000..c8b524a4
--- /dev/null
+++ b/queue-3.16/xtensa-use-get_signal-signal_setup_done.patch
@@ -0,0 +1,144 @@
+From: Richard Weinberger <richard@nod.at>
+Date: Mon, 7 Oct 2013 15:09:23 +0200
+Subject: xtensa: Use get_signal() signal_setup_done()
+
+commit 5bdb7611eb7987102f3c0fef1220dd64b6fbd9fd upstream.
+
+Use the more generic functions get_signal() signal_setup_done()
+for signal delivery.
+
+Signed-off-by: Richard Weinberger <richard@nod.at>
+[bwh: Backported to 3.16 as dependency of commit 35634ffa1751
+ "signal: Always notice exiting tasks"]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ arch/xtensa/kernel/signal.c | 43 ++++++++++++++-----------------------
+ 1 file changed, 16 insertions(+), 27 deletions(-)
+
+diff --git a/arch/xtensa/kernel/signal.c b/arch/xtensa/kernel/signal.c
+index 98b67d5f1514..4612321c73cc 100644
+--- a/arch/xtensa/kernel/signal.c
++++ b/arch/xtensa/kernel/signal.c
+@@ -331,17 +331,17 @@ gen_return_code(unsigned char *codemem)
+ }
+ 
+ 
+-static int setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+-		       sigset_t *set, struct pt_regs *regs)
++static int setup_frame(struct ksignal *ksig, sigset_t *set,
++		       struct pt_regs *regs)
+ {
+ 	struct rt_sigframe *frame;
+-	int err = 0;
++	int err = 0, sig = ksig->sig;
+ 	int signal;
+ 	unsigned long sp, ra, tp;
+ 
+ 	sp = regs->areg[1];
+ 
+-	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && sas_ss_flags(sp) == 0) {
++	if ((ksig->ka.sa.sa_flags & SA_ONSTACK) != 0 && sas_ss_flags(sp) == 0) {
+ 		sp = current->sas_ss_sp + current->sas_ss_size;
+ 	}
+ 
+@@ -351,7 +351,7 @@ static int setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+ 		panic ("Double exception sys_sigreturn\n");
+ 
+ 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) {
+-		goto give_sigsegv;
++		return -EFAULT;
+ 	}
+ 
+ 	signal = current_thread_info()->exec_domain
+@@ -360,8 +360,8 @@ static int setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+ 		? current_thread_info()->exec_domain->signal_invmap[sig]
+ 		: sig;
+ 
+-	if (ka->sa.sa_flags & SA_SIGINFO) {
+-		err |= copy_siginfo_to_user(&frame->info, info);
++	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
++		err |= copy_siginfo_to_user(&frame->info, &ksig->info);
+ 	}
+ 
+ 	/* Create the user context.  */
+@@ -372,8 +372,8 @@ static int setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+ 	err |= setup_sigcontext(frame, regs);
+ 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
+ 
+-	if (ka->sa.sa_flags & SA_RESTORER) {
+-		ra = (unsigned long)ka->sa.sa_restorer;
++	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
++		ra = (unsigned long)ksig->ka.sa.sa_restorer;
+ 	} else {
+ 
+ 		/* Create sys_rt_sigreturn syscall in stack frame */
+@@ -381,7 +381,7 @@ static int setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+ 		err |= gen_return_code(frame->retcode);
+ 
+ 		if (err) {
+-			goto give_sigsegv;
++			return -EFAULT;
+ 		}
+ 		ra = (unsigned long) frame->retcode;
+ 	}
+@@ -393,7 +393,7 @@ static int setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+ 
+ 	/* Set up registers for signal handler; preserve the threadptr */
+ 	tp = regs->threadptr;
+-	start_thread(regs, (unsigned long) ka->sa.sa_handler,
++	start_thread(regs, (unsigned long) ksig->ka.sa.sa_handler,
+ 		     (unsigned long) frame);
+ 
+ 	/* Set up a stack frame for a call4
+@@ -416,10 +416,6 @@ static int setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+ #endif
+ 
+ 	return 0;
+-
+-give_sigsegv:
+-	force_sigsegv(sig, current);
+-	return -EFAULT;
+ }
+ 
+ /*
+@@ -433,15 +429,11 @@ static int setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+  */
+ static void do_signal(struct pt_regs *regs)
+ {
+-	siginfo_t info;
+-	int signr;
+-	struct k_sigaction ka;
++	struct ksignal ksig;
+ 
+ 	task_pt_regs(current)->icountlevel = 0;
+ 
+-	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+-
+-	if (signr > 0) {
++	if (get_signal(&ksig)) {
+ 		int ret;
+ 
+ 		/* Are we from a system call? */
+@@ -457,7 +449,7 @@ static void do_signal(struct pt_regs *regs)
+ 					break;
+ 
+ 				case -ERESTARTSYS:
+-					if (!(ka.sa.sa_flags & SA_RESTART)) {
++					if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
+ 						regs->areg[2] = -EINTR;
+ 						break;
+ 					}
+@@ -476,11 +468,8 @@ static void do_signal(struct pt_regs *regs)
+ 
+ 		/* Whee!  Actually deliver the signal.  */
+ 		/* Set up the stack frame */
+-		ret = setup_frame(signr, &ka, &info, sigmask_to_save(), regs);
+-		if (ret)
+-			return;
+-
+-		signal_delivered(signr, &info, &ka, regs, 0);
++		ret = setup_frame(&ksig, sigmask_to_save(), regs);
++		signal_setup_done(ret, &ksig, 0);
+ 		if (current->ptrace & PT_SINGLESTEP)
+ 			task_pt_regs(current)->icountlevel = 1;
+