lkml.org 
[lkml]   [2018]   [Jul]   [24]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Date
    Subject[PATCH 20/20] signal: Don't restart fork when signals come in.
    Wen Yang <wen.yang99@zte.com.cn> and majiang <ma.jiang@zte.com.cn>
    report that a periodic signal received during fork can cause fork to
    continually restart preventing an application from making progress.

    The code was being overly pesimistic. Fork needs to guarantee that a
    signal sent to multiple processes is logically delivered before the
    fork and just to the forking process or logically delivered after the
    fork to both the forking process and it's newly spawned child. For
    signals like periodic timers that are always delivered to a single
    process fork can safely complete and let them appear to logically
    delivered after the fork().

    While examining this issue I also discovered that fork today will miss
    signals delivered to multiple processes during the fork and handled by
    another thread. Similarly the current code will also miss blocked
    signals that are delivered to multiple process, as those signals will
    not appear pending during fork.

    Add a list of each thread that is currently forking, and keep on that
    list a signal set that records all of the signals sent to multiple
    processes. When fork completes initialize the new processes
    shared_pending signal set with it. The calculate_sigpending function
    will see those signals and set TIF_SIGPENDING causing the new task to
    take the slow path to userspace to handle those signals. Making it
    appear as if those signals were received immediately after the fork.

    It is not possible to send real time signals to multiple processes and
    exceptions don't go to multiple processes, which means that that are
    no signals sent to multiple processes that require siginfo. This
    means it is safe to not bother collecting siginfo on signals sent
    during fork.

    The sigaction of a child of fork is initially the same as the
    sigaction of the parent process. So a signal the parent ignores the
    child will also initially ignore. Therefore it is safe to ignore
    signals sent to multiple processes and ignored by the forking process.

    Signals sent to only a single process or only a single thread and delivered
    during fork are treated as if they are received after the fork, and generally
    not dealt with. They won't cause any problems.

    Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=200447
    Reported-by: Wen Yang <wen.yang99@zte.com.cn> and
    Reported-by: majiang <ma.jiang@zte.com.cn>
    Fixes: 4a2c7a7837da ("[PATCH] make fork() atomic wrt pgrp/session signals")
    Signed-off-by: "Eric W. Biederman" <ebiederm@xmission.com>
    ---
    include/linux/sched/signal.h | 8 ++++++++
    kernel/fork.c | 37 ++++++++++++++++++++----------------
    kernel/signal.c | 9 +++++++++
    3 files changed, 38 insertions(+), 16 deletions(-)

    diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h
    index f3507bf165d0..62262021cf7e 100644
    --- a/include/linux/sched/signal.h
    +++ b/include/linux/sched/signal.h
    @@ -69,6 +69,11 @@ struct thread_group_cputimer {
    bool checking_timer;
    };

    +struct multiprocess_signals {
    + sigset_t signal;
    + struct hlist_node node;
    +};
    +
    /*
    * NOTE! "signal_struct" does not have its own
    * locking, because a shared signal_struct always
    @@ -90,6 +95,9 @@ struct signal_struct {
    /* shared signal handling: */
    struct sigpending shared_pending;

    + /* For collecting multiprocess signals during fork */
    + struct hlist_head multiprocess;
    +
    /* thread group exit support */
    int group_exit_code;
    /* overloaded:
    diff --git a/kernel/fork.c b/kernel/fork.c
    index 6c358846a8b8..6ee5822f0085 100644
    --- a/kernel/fork.c
    +++ b/kernel/fork.c
    @@ -1456,6 +1456,7 @@ static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
    init_waitqueue_head(&sig->wait_chldexit);
    sig->curr_target = tsk;
    init_sigpending(&sig->shared_pending);
    + INIT_HLIST_HEAD(&sig->multiprocess);
    seqlock_init(&sig->stats_lock);
    prev_cputime_init(&sig->prev_cputime);

    @@ -1602,6 +1603,24 @@ static __latent_entropy struct task_struct *copy_process(
    {
    int retval;
    struct task_struct *p;
    + struct multiprocess_signals delayed;
    +
    + /*
    + * Force any signals received before this point to be delivered
    + * before the fork happens. Collect up signals sent to multiple
    + * processes that happen during the fork and delay them so that
    + * they appear to happen after the fork.
    + */
    + sigemptyset(&delayed.signal);
    + INIT_HLIST_NODE(&delayed.node);
    +
    + spin_lock_irq(&current->sighand->siglock);
    + if (!(clone_flags & CLONE_THREAD))
    + hlist_add_head(&delayed.node, &current->signal->multiprocess);
    + recalc_sigpending();
    + spin_unlock_irq(&current->sighand->siglock);
    + if (signal_pending(current))
    + return ERR_PTR(restart_syscall());

    /*
    * Don't allow sharing the root directory with processes in a different
    @@ -1934,22 +1953,6 @@ static __latent_entropy struct task_struct *copy_process(
    goto bad_fork_cancel_cgroup;
    }

    - if (!(clone_flags & CLONE_THREAD)) {
    - /*
    - * Process group and session signals need to be delivered to just the
    - * parent before the fork or both the parent and the child after the
    - * fork. Restart if a signal comes in before we add the new process to
    - * it's process group.
    - * A fatal signal pending means that current will exit, so the new
    - * thread can't slip out of an OOM kill (or normal SIGKILL).
    - */
    - recalc_sigpending();
    - if (signal_pending(current)) {
    - retval = -ERESTARTNOINTR;
    - goto bad_fork_cancel_cgroup;
    - }
    - }
    -

    init_task_pid_links(p);
    if (likely(p->pid)) {
    @@ -1979,6 +1982,8 @@ static __latent_entropy struct task_struct *copy_process(
    attach_pid(p, PIDTYPE_TGID);
    attach_pid(p, PIDTYPE_PGID);
    attach_pid(p, PIDTYPE_SID);
    + p->signal->shared_pending.signal = delayed.signal;
    + hlist_del(&delayed.node);
    __this_cpu_inc(process_counts);
    } else {
    current->signal->nr_threads++;
    diff --git a/kernel/signal.c b/kernel/signal.c
    index 78e2d5d196f3..5b1aab94daf6 100644
    --- a/kernel/signal.c
    +++ b/kernel/signal.c
    @@ -1123,6 +1123,15 @@ static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
    out_set:
    signalfd_notify(t, sig);
    sigaddset(&pending->signal, sig);
    +
    + /* Let multiprocess signals appear after on-going forks */
    + if (type > PIDTYPE_TGID) {
    + struct multiprocess_signals *delayed;
    + hlist_for_each_entry(delayed, &t->signal->multiprocess, node) {
    + sigaddset(&delayed->signal, sig);
    + }
    + }
    +
    complete_signal(sig, t, type);
    ret:
    trace_signal_generate(sig, info, t, type != PIDTYPE_PID, result);
    --
    2.17.1
    \
     
     \ /
      Last update: 2018-07-24 05:28    [W:4.107 / U:0.092 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site