Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux...

[platform/adaptation/renesas_rcar/renesas_kernel.git] / kernel / signal.c

diff --git a/kernel/signal.c b/kernel/signal.c
index 0af8868..580a91e 100644 (file)
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1159,8 +1159,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 +1753,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 +1909,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 +1931,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 +2086,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 +2132,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 +2193,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 +2257,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 +2342,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 +2351,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);
                }
 
                /*