lkml.org 
[lkml]   [2021]   [Nov]   [24]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.15 256/279] signal: Implement force_fatal_sig
    Date
    From: Eric W. Biederman <ebiederm@xmission.com>

    commit 26d5badbccddcc063dc5174a2baffd13a23322aa upstream.

    Add a simple helper force_fatal_sig that causes a signal to be
    delivered to a process as if the signal handler was set to SIG_DFL.

    Reimplement force_sigsegv based upon this new helper. This fixes
    force_sigsegv so that when it forces the default signal handler
    to be used the code now forces the signal to be unblocked as well.

    Reusing the tested logic in force_sig_info_to_task that was built for
    force_sig_seccomp this makes the implementation trivial.

    This is interesting both because it makes force_sigsegv simpler and
    because there are a couple of buggy places in the kernel that call
    do_exit(SIGILL) or do_exit(SIGSYS) because there is no straight
    forward way today for those places to simply force the exit of a
    process with the chosen signal. Creating force_fatal_sig allows
    those places to be implemented with normal signal exits.

    Link: https://lkml.kernel.org/r/20211020174406.17889-13-ebiederm@xmission.com
    Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
    Cc: Thomas Backlund <tmb@iki.fi>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    ---
    include/linux/sched/signal.h | 1 +
    kernel/signal.c | 26 +++++++++++++++++---------
    2 files changed, 18 insertions(+), 9 deletions(-)

    --- a/include/linux/sched/signal.h
    +++ b/include/linux/sched/signal.h
    @@ -338,6 +338,7 @@ extern int kill_pid(struct pid *pid, int
    extern __must_check bool do_notify_parent(struct task_struct *, int);
    extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
    extern void force_sig(int);
    +extern void force_fatal_sig(int);
    extern int send_sig(int, struct task_struct *, int);
    extern int zap_other_threads(struct task_struct *p);
    extern struct sigqueue *sigqueue_alloc(void);
    --- a/kernel/signal.c
    +++ b/kernel/signal.c
    @@ -1650,6 +1650,19 @@ void force_sig(int sig)
    }
    EXPORT_SYMBOL(force_sig);

    +void force_fatal_sig(int sig)
    +{
    + struct kernel_siginfo info;
    +
    + clear_siginfo(&info);
    + info.si_signo = sig;
    + info.si_errno = 0;
    + info.si_code = SI_KERNEL;
    + info.si_pid = 0;
    + info.si_uid = 0;
    + force_sig_info_to_task(&info, current, true);
    +}
    +
    /*
    * When things go south during signal handling, we
    * will force a SIGSEGV. And if the signal that caused
    @@ -1658,15 +1671,10 @@ EXPORT_SYMBOL(force_sig);
    */
    void force_sigsegv(int sig)
    {
    - struct task_struct *p = current;
    -
    - if (sig == SIGSEGV) {
    - unsigned long flags;
    - spin_lock_irqsave(&p->sighand->siglock, flags);
    - p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
    - spin_unlock_irqrestore(&p->sighand->siglock, flags);
    - }
    - force_sig(SIGSEGV);
    + if (sig == SIGSEGV)
    + force_fatal_sig(SIGSEGV);
    + else
    + force_sig(SIGSEGV);
    }

    int force_sig_fault_to_task(int sig, int code, void __user *addr

    \
     
     \ /
      Last update: 2021-11-24 15:05    [W:4.891 / U:0.016 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site