1 files changed, 88 insertions, 23 deletions

diff --git a/kernel/signal.c b/kernel/signal.c
index 0af8868525d6..7aaa51d8e5b8 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -31,6 +31,7 @@
 #include <linux/nsproxy.h>
 #include <linux/user_namespace.h>
 #include <linux/uprobes.h>
+#include <linux/compat.h>
 #define CREATE_TRACE_POINTS
 #include <trace/events/signal.h>
 
@@ -1159,8 +1160,9 @@ static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
         return __send_signal(sig, info, t, group, from_ancestor_ns);
 }
 
-static void print_fatal_signal(struct pt_regs *regs, int signr)
+static void print_fatal_signal(int signr)
 {
+        struct pt_regs *regs = signal_pt_regs();
         printk("%s/%d: potentially unexpected fatal signal %d.\n",
                 current->comm, task_pid_nr(current), signr);
 
@@ -1752,7 +1754,7 @@ static void do_notify_parent_cldstop(struct task_struct *tsk,
          * see comment in do_notify_parent() about the following 4 lines
          */
         rcu_read_lock();
-        info.si_pid = task_pid_nr_ns(tsk, parent->nsproxy->pid_ns);
+        info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
         info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
         rcu_read_unlock();
 
@@ -1908,7 +1910,7 @@ static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
                 preempt_disable();
                 read_unlock(&tasklist_lock);
                 preempt_enable_no_resched();
-                schedule();
+                freezable_schedule();
         } else {
                 /*
                  * By the time we got the lock, our tracer went away.
@@ -1930,13 +1932,6 @@ static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
         }
 
         /*
-         * While in TASK_TRACED, we were considered "frozen enough".
-         * Now that we woke up, it's crucial if we're supposed to be
-         * frozen that we freeze now before running anything substantial.
-         */
-        try_to_freeze();
-
-        /*
          * We are back.  Now reacquire the siglock before touching
          * last_siginfo, so that we are sure to have synchronized with
          * any signal-sending on another CPU that wants to examine it.
@@ -2092,7 +2087,7 @@ static bool do_signal_stop(int signr)
                 }
 
                 /* Now we don't run again until woken by SIGCONT or SIGKILL */
-                schedule();
+                freezable_schedule();
                 return true;
         } else {
                 /*
@@ -2138,10 +2133,9 @@ static void do_jobctl_trap(void)
         }
 }
 
-static int ptrace_signal(int signr, siginfo_t *info,
-                         struct pt_regs *regs, void *cookie)
+static int ptrace_signal(int signr, siginfo_t *info)
 {
-        ptrace_signal_deliver(regs, cookie);
+        ptrace_signal_deliver();
         /*
          * We do not check sig_kernel_stop(signr) but set this marker
          * unconditionally because we do not know whether debugger will
@@ -2200,15 +2194,14 @@ int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
         if (unlikely(uprobe_deny_signal()))
                 return 0;
 
-relock:
         /*
-         * We'll jump back here after any time we were stopped in TASK_STOPPED.
-         * While in TASK_STOPPED, we were considered "frozen enough".
-         * Now that we woke up, it's crucial if we're supposed to be
-         * frozen that we freeze now before running anything substantial.
+         * Do this once, we can't return to user-mode if freezing() == T.
+         * do_signal_stop() and ptrace_stop() do freezable_schedule() and
+         * thus do not need another check after return.
          */
         try_to_freeze();
 
+relock:
         spin_lock_irq(&sighand->siglock);
         /*
          * Every stopped thread goes here after wakeup. Check to see if
@@ -2265,8 +2258,7 @@ relock:
                         break; /* will return 0 */
 
                 if (unlikely(current->ptrace) && signr != SIGKILL) {
-                        signr = ptrace_signal(signr, info,
-                                              regs, cookie);
+                        signr = ptrace_signal(signr, info);
                         if (!signr)
                                 continue;
                 }
@@ -2351,7 +2343,7 @@ relock:
 
                 if (sig_kernel_coredump(signr)) {
                         if (print_fatal_signals)
-                                print_fatal_signal(regs, info->si_signo);
+                                print_fatal_signal(info->si_signo);
                         /*
                          * If it was able to dump core, this kills all
                          * other threads in the group and synchronizes with
@@ -2360,7 +2352,7 @@ relock:
                          * first and our do_group_exit call below will use
                          * that value and ignore the one we pass it.
                          */
-                        do_coredump(info, regs);
+                        do_coredump(info);
                 }
 
                 /*
@@ -3103,6 +3095,79 @@ do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long s
 out:
         return error;
 }
+#ifdef CONFIG_GENERIC_SIGALTSTACK
+SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
+{
+        return do_sigaltstack(uss, uoss, current_user_stack_pointer());
+}
+#endif
+
+int restore_altstack(const stack_t __user *uss)
+{
+        int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
+        /* squash all but EFAULT for now */
+        return err == -EFAULT ? err : 0;
+}
+
+int __save_altstack(stack_t __user *uss, unsigned long sp)
+{
+        struct task_struct *t = current;
+        return  __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
+                __put_user(sas_ss_flags(sp), &uss->ss_flags) |
+                __put_user(t->sas_ss_size, &uss->ss_size);
+}
+
+#ifdef CONFIG_COMPAT
+#ifdef CONFIG_GENERIC_SIGALTSTACK
+asmlinkage long compat_sys_sigaltstack(const compat_stack_t __user *uss_ptr,
+                                       compat_stack_t __user *uoss_ptr)
+{
+        stack_t uss, uoss;
+        int ret;
+        mm_segment_t seg;
+
+        if (uss_ptr) {
+                compat_stack_t uss32;
+
+                memset(&uss, 0, sizeof(stack_t));
+                if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
+                        return -EFAULT;
+                uss.ss_sp = compat_ptr(uss32.ss_sp);
+                uss.ss_flags = uss32.ss_flags;
+                uss.ss_size = uss32.ss_size;
+        }
+        seg = get_fs();
+        set_fs(KERNEL_DS);
+        ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
+                             (stack_t __force __user *) &uoss,
+                             compat_user_stack_pointer());
+        set_fs(seg);
+        if (ret >= 0 && uoss_ptr)  {
+                if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
+                    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
+                    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
+                    __put_user(uoss.ss_size, &uoss_ptr->ss_size))
+                        ret = -EFAULT;
+        }
+        return ret;
+}
+
+int compat_restore_altstack(const compat_stack_t __user *uss)
+{
+        int err = compat_sys_sigaltstack(uss, NULL);
+        /* squash all but -EFAULT for now */
+        return err == -EFAULT ? err : 0;
+}
+
+int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
+{
+        struct task_struct *t = current;
+        return  __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), &uss->ss_sp) |
+                __put_user(sas_ss_flags(sp), &uss->ss_flags) |
+                __put_user(t->sas_ss_size, &uss->ss_size);
+}
+#endif
+#endif
 
 #ifdef __ARCH_WANT_SYS_SIGPENDING