libs/rt-thread
libs/rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/components/lwp/lwp_signal.c
Shell dc3270f14e feat: add signal kill all functionality 
This change introduces the `lwp_signal_kill_all` function, which allows a
signal to be sent to all processes in the system. The function iterates
over all PIDs and sends the specified signal to each process, except those
that are protected from signals. This enhancement provides a convenient way
to broadcast signals across all processes in the system.

Changes:
- Added `lwp_signal_kill_all` function in `lwp_signal.c` to broadcast a
  signal to all processes by iterating over all PIDs using the existing
  `lwp_pid_for_each` function.
- Introduced a new `kill_all_param` structure to encapsulate the signal
  information needed for killing processes.
- Added internal `_kill_each` helper function for sending the signal to each
  PID.
- Updated `lwp_signal.h` with the new function prototype for `lwp_signal_kill_all`.
- Modified `sys_kill` in `lwp_syscall.c` to call `lwp_signal_kill_all` when
  a process is not specified.

Signed-off-by: Shell <smokewood@qq.com>
2025-01-06 19:34:16 +08:00

1483 lines
40 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2019-11-12 Jesven first version
* 2023-02-23 Shell Support sigtimedwait
* 2023-07-04 Shell Support siginfo, sigqueue
* remove lwp_signal_backup/restore() to reduce architecture codes
* update the generation, pending and delivery routines
* 2023-11-22 Shell Support for job control signal. Fixup of signal catch while
* some of the signals is blocked, but no more further dequeue is applied.
* Add itimer support
*/
#define __RT_IPC_SOURCE__
#define DBG_TAG "lwp.signal"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>
#include <rthw.h>
#include <rtthread.h>
#include <string.h>
#include "lwp_internal.h"
#include "sys/signal.h"
#include "syscall_generic.h"
static lwp_siginfo_t siginfo_create(rt_thread_t current, int signo, int code, lwp_siginfo_ext_t ext)
{
lwp_siginfo_t siginfo;
struct rt_lwp *self_lwp;
rt_thread_t self_thr;
siginfo = rt_malloc(sizeof(*siginfo));
if (siginfo)
{
siginfo->ksiginfo.signo = signo;
siginfo->ksiginfo.code = code;
siginfo->ext = ext;
self_thr = current;
self_lwp = current->lwp;
if (self_lwp)
{
siginfo->ksiginfo.from_pid = self_lwp->pid;
siginfo->ksiginfo.from_tid = self_thr->tid;
}
else
{
siginfo->ksiginfo.from_pid = 0;
siginfo->ksiginfo.from_tid = 0;
}
}
return siginfo;
}
rt_inline void siginfo_delete(lwp_siginfo_t siginfo)
{
if (siginfo->ext)
{
rt_free(siginfo->ext);
siginfo->ext = RT_NULL;
}
rt_free(siginfo);
}
rt_inline void _sigorsets(lwp_sigset_t *dset, const lwp_sigset_t *set0, const lwp_sigset_t *set1)
{
switch (_LWP_NSIG_WORDS)
{
case 4:
dset->sig[3] = set0->sig[3] | set1->sig[3];
dset->sig[2] = set0->sig[2] | set1->sig[2];
case 2:
dset->sig[1] = set0->sig[1] | set1->sig[1];
case 1:
dset->sig[0] = set0->sig[0] | set1->sig[0];
default:
return;
}
}
rt_inline void _sigandsets(lwp_sigset_t *dset, const lwp_sigset_t *set0, const lwp_sigset_t *set1)
{
switch (_LWP_NSIG_WORDS)
{
case 4:
dset->sig[3] = set0->sig[3] & set1->sig[3];
dset->sig[2] = set0->sig[2] & set1->sig[2];
case 2:
dset->sig[1] = set0->sig[1] & set1->sig[1];
case 1:
dset->sig[0] = set0->sig[0] & set1->sig[0];
default:
return;
}
}
rt_inline void _signotsets(lwp_sigset_t *dset, const lwp_sigset_t *set)
{
switch (_LWP_NSIG_WORDS)
{
case 4:
dset->sig[3] = ~set->sig[3];
dset->sig[2] = ~set->sig[2];
case 2:
dset->sig[1] = ~set->sig[1];
case 1:
dset->sig[0] = ~set->sig[0];
default:
return;
}
}
rt_inline void _sigaddset(lwp_sigset_t *set, int _sig)
{
unsigned long sig = _sig - 1;
if (_LWP_NSIG_WORDS == 1)
{
set->sig[0] |= 1UL << sig;
}
else
{
set->sig[sig / _LWP_NSIG_BPW] |= 1UL << (sig % _LWP_NSIG_BPW);
}
}
rt_inline void _sigdelset(lwp_sigset_t *set, int _sig)
{
unsigned long sig = _sig - 1;
if (_LWP_NSIG_WORDS == 1)
{
set->sig[0] &= ~(1UL << sig);
}
else
{
set->sig[sig / _LWP_NSIG_BPW] &= ~(1UL << (sig % _LWP_NSIG_BPW));
}
}
rt_inline int _sigisemptyset(lwp_sigset_t *set)
{
switch (_LWP_NSIG_WORDS)
{
case 4:
return (set->sig[3] | set->sig[2] |
set->sig[1] | set->sig[0]) == 0;
case 2:
return (set->sig[1] | set->sig[0]) == 0;
case 1:
return set->sig[0] == 0;
default:
return 1;
}
}
rt_inline int _sigismember(lwp_sigset_t *set, int _sig)
{
unsigned long sig = _sig - 1;
if (_LWP_NSIG_WORDS == 1)
{
return 1 & (set->sig[0] >> sig);
}
else
{
return 1 & (set->sig[sig / _LWP_NSIG_BPW] >> (sig % _LWP_NSIG_BPW));
}
}
rt_inline int _next_signal(lwp_sigset_t *pending, lwp_sigset_t *mask)
{
unsigned long i, *s, *m, x;
int sig = 0;
s = pending->sig;
m = mask->sig;
x = *s & ~*m;
if (x)
{
sig = rt_hw_ffz(~x) + 1;
return sig;
}
switch (_LWP_NSIG_WORDS)
{
default:
for (i = 1; i < _LWP_NSIG_WORDS; ++i)
{
x = *++s &~ *++m;
if (!x)
continue;
sig = rt_hw_ffz(~x) + i*_LWP_NSIG_BPW + 1;
break;
}
break;
case 2:
x = s[1] &~ m[1];
if (!x)
break;
sig = rt_hw_ffz(~x) + _LWP_NSIG_BPW + 1;
break;
case 1:
/* Nothing to do */
break;
}
return sig;
}
#define _SIGQ(tp) (&(tp)->signal.sig_queue)
rt_inline int sigqueue_isempty(lwp_sigqueue_t sigqueue)
{
return _sigisemptyset(&sigqueue->sigset_pending);
}
rt_inline int sigqueue_ismember(lwp_sigqueue_t sigqueue, int signo)
{
return _sigismember(&sigqueue->sigset_pending, signo);
}
rt_inline int sigqueue_peek(lwp_sigqueue_t sigqueue, lwp_sigset_t *mask)
{
return _next_signal(&sigqueue->sigset_pending, mask);
}
rt_inline int sigqueue_examine(lwp_sigqueue_t sigqueue, lwp_sigset_t *pending)
{
int is_empty = sigqueue_isempty(sigqueue);
if (!is_empty)
{
_sigorsets(pending, &sigqueue->sigset_pending, &sigqueue->sigset_pending);
}
return is_empty;
}
static void sigqueue_enqueue(lwp_sigqueue_t sigqueue, lwp_siginfo_t siginfo)
{
lwp_siginfo_t idx;
rt_bool_t inserted = RT_FALSE;
rt_list_for_each_entry(idx, &sigqueue->siginfo_list, node)
{
if (idx->ksiginfo.signo >= siginfo->ksiginfo.signo)
{
rt_list_insert_after(&idx->node, &siginfo->node);
inserted = RT_TRUE;
break;
}
}
if (!inserted)
rt_list_insert_before(&sigqueue->siginfo_list, &siginfo->node);
_sigaddset(&sigqueue->sigset_pending, siginfo->ksiginfo.signo);
return ;
}
/**
* dequeue a siginfo matching the signo which is likely to be existed, and
* test if any other siblings remains
*/
static lwp_siginfo_t sigqueue_dequeue(lwp_sigqueue_t sigqueue, int signo)
{
lwp_siginfo_t found;
lwp_siginfo_t candidate;
lwp_siginfo_t next;
rt_bool_t is_empty;
found = RT_NULL;
is_empty = RT_TRUE;
rt_list_for_each_entry_safe(candidate, next, &sigqueue->siginfo_list, node)
{
if (candidate->ksiginfo.signo == signo)
{
if (found)
{
/* already found */
is_empty = RT_FALSE;
break;
}
else
{
/* found first */
found = candidate;
rt_list_remove(&found->node);
}
}
else if (candidate->ksiginfo.signo > signo)
break;
}
if (found && is_empty)
_sigdelset(&sigqueue->sigset_pending, signo);
return found;
}
/**
* Discard all the signal matching `signo` in sigqueue
*/
static void sigqueue_discard(lwp_sigqueue_t sigqueue, int signo)
{
lwp_siginfo_t queuing_si;
while (sigqueue_ismember(sigqueue, signo))
{
queuing_si = sigqueue_dequeue(sigqueue, signo);
siginfo_delete(queuing_si);
}
}
/**
* Discard all the queuing signals in sigset
*/
static void sigqueue_discard_sigset(lwp_sigqueue_t sigqueue, lwp_sigset_t *sigset)
{
lwp_siginfo_t queuing_si;
lwp_sigset_t mask;
int signo;
_signotsets(&mask, sigset);
while ((signo = sigqueue_peek(sigqueue, &mask)) != 0)
{
queuing_si = sigqueue_dequeue(sigqueue, signo);
siginfo_delete(queuing_si);
}
}
/* assuming that (void *) is compatible to long at length */
RT_STATIC_ASSERT(lp_width_same, sizeof(void *) == sizeof(long));
/** translate lwp siginfo to user siginfo_t */
rt_inline void siginfo_k2u(lwp_siginfo_t ksigi, siginfo_t *usigi)
{
int signo = ksigi->ksiginfo.signo;
usigi->si_code = ksigi->ksiginfo.code;
usigi->si_signo = signo;
usigi->si_pid = ksigi->ksiginfo.from_pid;
if (ksigi->ext)
{
if (signo == SIGCHLD)
{
usigi->si_status = ksigi->ext->sigchld.status;
usigi->si_utime = ksigi->ext->sigchld.stime;
usigi->si_stime = ksigi->ext->sigchld.utime;
}
}
/* deprecated field */
usigi->si_errno = 0;
}
/* must called in locked context */
rt_inline lwp_sighandler_t _get_sighandler_locked(struct rt_lwp *lwp, int signo)
{
return lwp->signal.sig_action[signo - 1];
}
static lwp_sigset_t *_mask_block_fn(rt_thread_t thread, const lwp_sigset_t *sigset, lwp_sigset_t *new_set)
{
_sigorsets(new_set, &thread->signal.sigset_mask, sigset);
return new_set;
}
static lwp_sigset_t *_mask_unblock_fn(rt_thread_t thread, const lwp_sigset_t *sigset, lwp_sigset_t *new_set)
{
lwp_sigset_t complement;
_signotsets(&complement, sigset);
_sigandsets(new_set, &thread->signal.sigset_mask, &complement);
return new_set;
}
static lwp_sigset_t *_mask_set_fn(rt_thread_t thread, const lwp_sigset_t *sigset, lwp_sigset_t *new_set)
{
memcpy(new_set, sigset, sizeof(*sigset));
return new_set;
}
static lwp_sigset_t *(*_sig_mask_fn[__LWP_SIG_MASK_CMD_WATERMARK])
(rt_thread_t thread, const lwp_sigset_t *sigset, lwp_sigset_t *new_set) = {
[LWP_SIG_MASK_CMD_BLOCK] = _mask_block_fn,
[LWP_SIG_MASK_CMD_UNBLOCK] = _mask_unblock_fn,
[LWP_SIG_MASK_CMD_SET_MASK] = _mask_set_fn,
};
static void _thread_signal_mask(rt_thread_t thread, lwp_sig_mask_cmd_t how,
const lwp_sigset_t *sigset, lwp_sigset_t *oset)
{
lwp_sigset_t new_set;
/**
* Note: POSIX wants this API to be capable to query the current mask
* by passing NULL in `sigset`
*/
if (oset)
memcpy(oset, &thread->signal.sigset_mask, sizeof(lwp_sigset_t));
if (sigset)
{
_sig_mask_fn[how](thread, sigset, &new_set);
/* remove un-maskable signal from set */
_sigdelset(&new_set, SIGKILL);
_sigdelset(&new_set, SIGSTOP);
memcpy(&thread->signal.sigset_mask, &new_set, sizeof(lwp_sigset_t));
}
}
void lwp_sigqueue_clear(lwp_sigqueue_t sigq)
{
lwp_siginfo_t this, next;
if (!sigqueue_isempty(sigq))
{
rt_list_for_each_entry_safe(this, next, &sigq->siginfo_list, node)
{
siginfo_delete(this);
}
}
}
static void lwp_signal_notify(rt_slist_t *list_head, lwp_siginfo_t siginfo)
{
rt_slist_t *node;
rt_slist_for_each(node, list_head)
{
struct rt_lwp_notify *n = rt_slist_entry(node, struct rt_lwp_notify, list_node);
if (n->notify)
{
n->notify(n->signalfd_queue, siginfo->ksiginfo.signo);
}
}
}
rt_err_t lwp_signal_init(struct lwp_signal *sig)
{
rt_err_t rc = RT_EOK;
sig->real_timer = LWP_SIG_INVALID_TIMER;
memset(&sig->sig_dispatch_thr, 0, sizeof(sig->sig_dispatch_thr));
memset(&sig->sig_action, 0, sizeof(sig->sig_action));
memset(&sig->sig_action_nodefer, 0, sizeof(sig->sig_action_nodefer));
memset(&sig->sig_action_onstack, 0, sizeof(sig->sig_action_onstack));
memset(&sig->sig_action_restart, 0, sizeof(sig->sig_action_restart));
memset(&sig->sig_action_siginfo, 0, sizeof(sig->sig_action_siginfo));
memset(&sig->sig_action_nocldstop, 0, sizeof(sig->sig_action_nocldstop));
memset(&sig->sig_action_nocldwait, 0, sizeof(sig->sig_action_nocldwait));
lwp_sigqueue_init(&sig->sig_queue);
return rc;
}
rt_err_t lwp_signal_detach(struct lwp_signal *signal)
{
rt_err_t ret = RT_EOK;
timer_delete(signal->real_timer);
lwp_sigqueue_clear(&signal->sig_queue);
return ret;
}
int lwp_thread_signal_suspend_check(rt_thread_t thread, int suspend_flag)
{
struct rt_lwp *lwp = (struct rt_lwp *)thread->lwp;
lwp_sigset_t sigmask = thread->signal.sigset_mask;
int ret = 0;
_sigaddset(&sigmask, SIGCONT);
switch (suspend_flag)
{
case RT_INTERRUPTIBLE:
if (sigqueue_peek(_SIGQ(thread), &sigmask))
{
break;
}
if (thread->lwp && sigqueue_peek(_SIGQ(lwp), &sigmask))
{
break;
}
ret = 1;
break;
case RT_KILLABLE:
if (sigqueue_ismember(_SIGQ(thread), SIGKILL))
{
break;
}
if (thread->lwp && sigqueue_ismember(_SIGQ(lwp), SIGKILL))
{
break;
}
ret = 1;
break;
case RT_UNINTERRUPTIBLE:
ret = 1;
break;
default:
RT_ASSERT(0);
break;
}
return ret;
}
rt_inline rt_bool_t _is_jobctl_signal(rt_lwp_t lwp, int signo)
{
lwp_sigset_t jobctl_sigset = lwp_sigset_init(LWP_SIG_JOBCTL_SET);
return lwp_sigismember(&jobctl_sigset, signo);
}
rt_inline rt_bool_t _is_stop_signal(rt_lwp_t lwp, int signo)
{
lwp_sigset_t stop_sigset = lwp_sigset_init(LWP_SIG_STOP_SET);
return lwp_sigismember(&stop_sigset, signo);
}
rt_inline rt_bool_t _need_notify_status_changed(rt_lwp_t lwp, int signo)
{
RT_ASSERT(lwp_sigismember(&lwp_sigset_init(LWP_SIG_JOBCTL_SET), signo));
return !lwp_sigismember(&lwp->signal.sig_action_nocldstop, SIGCHLD);
}
/**
* wakeup the waitpid_waiters if any, and try to generate SIGCHLD if they are
* not disable explicitly by user.
*
* TODO: This event is always per-process and doesn't make whole lot of
* sense for ptracers, who shouldn't consume the state via wait(2) either,
* but, for backward compatibility, notify the ptracer of the group leader
* too unless it's gonna be a duplicate.
*/
static void _notify_parent_and_leader(rt_lwp_t child_lwp, rt_thread_t child_thr, int trig_signo, rt_bool_t is_stop)
{
int si_code;
lwp_siginfo_ext_t ext;
rt_lwp_t parent_lwp = child_lwp->parent;
if (!parent_lwp)
return ;
/* prepare the event data for parent to query */
if (is_stop)
{
si_code = CLD_STOPPED;
child_lwp->lwp_status = LWP_CREATE_STAT_STOPPED(trig_signo);
}
else
{
si_code = CLD_CONTINUED;
child_lwp->lwp_status = LWP_CREATE_STAT_CONTINUED;
}
/* wakeup waiter on waitpid(2) */
lwp_waitpid_kick(parent_lwp, child_lwp);
if (_need_notify_status_changed(parent_lwp, trig_signo))
{
ext = rt_malloc(sizeof(struct lwp_siginfo_ext));
if (ext)
{
ext->sigchld.status = trig_signo;
/* TODO: signal usage is not supported */
ext->sigchld.stime = child_thr->system_time;
ext->sigchld.utime = child_thr->user_time;
}
/* generate SIGCHLD for parent */
lwp_signal_kill(parent_lwp, SIGCHLD, si_code, ext);
}
}
static int _do_signal_wakeup(rt_thread_t thread, int sig);
static rt_err_t _stop_thread_locked(rt_lwp_t self_lwp, rt_thread_t cur_thr, int signo,
lwp_siginfo_t si, lwp_sigqueue_t sq)
{
rt_err_t error;
int jobctl_stopped = self_lwp->jobctl_stopped;
rt_thread_t iter;
/* race to setup jobctl stopped flags */
if (!jobctl_stopped)
{
self_lwp->jobctl_stopped = RT_TRUE;
self_lwp->wait_reap_stp = RT_FALSE;
rt_list_for_each_entry(iter, &self_lwp->t_grp, sibling)
{
if (iter != cur_thr)
_do_signal_wakeup(iter, signo);
}
}
/**
* raise the event again so siblings is able to catch it again.
* `si` will be discarded while SIGCONT is generatd
*/
sigqueue_enqueue(sq, si);
/* release the lwp lock so we can happily suspend */
LWP_UNLOCK(self_lwp);
rt_set_errno(RT_EOK);
/* After suspension, only the SIGKILL and SIGCONT will wake this thread up */
error = rt_thread_suspend_with_flag(cur_thr, RT_KILLABLE);
if (error == RT_EOK)
{
rt_schedule();
error = rt_get_errno();
error = error > 0 ? -error : error;
}
if (!jobctl_stopped &&
(sigqueue_ismember(_SIGQ(self_lwp), SIGCONT) ||
sigqueue_ismember(_SIGQ(cur_thr), SIGCONT)))
{
/**
* if we are resumed by a SIGCONT and we are the winner of racing
* notify parent of the incoming event
*/
_notify_parent_and_leader(self_lwp, cur_thr, SIGCONT, RT_FALSE);
}
/* reacquire the lock since we release it before */
LWP_LOCK(self_lwp);
return error;
}
static void _catch_signal_locked(rt_lwp_t lwp, rt_thread_t thread, int signo,
lwp_siginfo_t siginfo, lwp_sighandler_t handler,
void *exp_frame)
{
lwp_sigset_t new_sig_mask;
lwp_sigset_t save_sig_mask;
siginfo_t usiginfo;
siginfo_t *p_usi;
/* siginfo is need for signal action */
if (_sigismember(&lwp->signal.sig_action_siginfo, signo))
{
siginfo_k2u(siginfo, &usiginfo);
p_usi = &usiginfo;
}
else
{
p_usi = RT_NULL;
}
/**
* lock is acquired by caller. Release it so that we can happily go to the
* signal handler in user space
*/
LWP_UNLOCK(lwp);
siginfo_delete(siginfo);
/* signal default handler */
if (handler == LWP_SIG_ACT_DFL)
{
lwp_sigset_t ign_sigset;
ign_sigset = lwp_sigset_init(LWP_SIG_IGNORE_SET);
if (signo == SIGCONT)
{
arch_syscall_set_errno(exp_frame, EINTR, ERESTART);
arch_thread_signal_enter(signo, p_usi, exp_frame, 0, &thread->signal.sigset_mask);
}
else if (!lwp_sigismember(&ign_sigset, signo) && !lwp->sig_protected)
{
/* for those defautl handler is to terminate process */
LOG_D("%s: default handler; and exit", __func__);
/* TODO: coredump if neccessary */
lwp_exit(lwp, LWP_CREATE_STAT_SIGNALED(signo, 0));
}
/**
* otherwise is to ignore the signal,
* -> then reacquire the lock and return
*/
}
else if (handler == LWP_SIG_ACT_IGN)
{
/* do nothing */
}
else
{
/* copy the blocked signal mask from the registered signal action */
memcpy(&new_sig_mask, &lwp->signal.sig_action_mask[signo - 1], sizeof(new_sig_mask));
if (!_sigismember(&lwp->signal.sig_action_nodefer, signo))
_sigaddset(&new_sig_mask, signo);
_thread_signal_mask(thread, LWP_SIG_MASK_CMD_BLOCK, &new_sig_mask, &save_sig_mask);
if (_sigismember(&lwp->signal.sig_action_restart, signo))
{
arch_syscall_set_errno(exp_frame, EINTR, ERESTART);
}
/**
* enter signal action of user
* Note: that the p_usi is release before entering signal action by
* reseting the kernel sp.
*/
LOG_D("%s: enter signal handler(signo=%d) at %p", __func__, signo, handler);
arch_thread_signal_enter(signo, p_usi, exp_frame, handler, &save_sig_mask);
/* the arch_thread_signal_enter() never return */
RT_ASSERT(0);
}
/* reacquire the lock because we release it before */
LWP_LOCK(lwp);
}
void lwp_thread_signal_catch(void *exp_frame)
{
struct rt_thread *thread;
struct rt_lwp *lwp;
lwp_sigqueue_t pending;
lwp_sigset_t *sig_mask;
int retry_signal_catch;
int signo;
thread = rt_thread_self();
lwp = (struct rt_lwp *)thread->lwp;
RT_ASSERT(!!lwp);
LWP_LOCK(lwp);
do {
/* if stopped process resume, we will retry to catch the signal */
retry_signal_catch = 0;
signo = 0;
/* try to peek a signal which is pending and not blocked by this thread */
if (!sigqueue_isempty(_SIGQ(thread)))
{
pending = _SIGQ(thread);
sig_mask = &thread->signal.sigset_mask;
signo = sigqueue_peek(pending, sig_mask);
}
if (!signo && !sigqueue_isempty(_SIGQ(lwp)))
{
pending = _SIGQ(lwp);
sig_mask = &thread->signal.sigset_mask;
signo = sigqueue_peek(pending, sig_mask);
}
if (signo)
{
lwp_siginfo_t siginfo;
lwp_sighandler_t handler;
LOG_D("%s(signo=%d)", __func__, signo);
siginfo = sigqueue_dequeue(pending, signo);
RT_ASSERT(siginfo != RT_NULL);
handler = _get_sighandler_locked(lwp, signo);
if (_is_stop_signal(lwp, signo) && handler == LWP_SIG_ACT_DFL)
{
/* notify the status update for parent process */
_notify_parent_and_leader(lwp, thread, signo, RT_TRUE);
LOG_D("%s: pid=%d stopped", __func__, lwp->pid);
_stop_thread_locked(lwp, thread, signo, siginfo, pending);
LOG_D("%s: pid=%d continued", __func__, lwp->pid);
/* wakeup and retry to catch signals send to us */
retry_signal_catch = 1;
}
else
{
/* do a normal, non-jobctl signal handling */
_catch_signal_locked(lwp, thread, signo, siginfo, handler, exp_frame);
}
}
} while (retry_signal_catch);
LWP_UNLOCK(lwp);
}
static int _do_signal_wakeup(rt_thread_t thread, int sig)
{
int need_schedule;
rt_sched_lock_level_t slvl;
if (!_sigismember(&thread->signal.sigset_mask, sig))
{
int stat;
rt_sched_lock(&slvl);
stat = rt_sched_thread_get_stat(thread);
if ((stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK)
{
if ((stat & RT_SIGNAL_COMMON_WAKEUP_MASK) != RT_SIGNAL_COMMON_WAKEUP_MASK)
{
thread->error = RT_EINTR;
rt_sched_unlock(slvl);
rt_thread_wakeup(thread);
need_schedule = 1;
}
else if ((sig == SIGKILL || sig == SIGSTOP) &&
((stat & RT_SIGNAL_KILL_WAKEUP_MASK) != RT_SIGNAL_KILL_WAKEUP_MASK))
{
thread->error = RT_EINTR;
rt_sched_unlock(slvl);
rt_thread_wakeup(thread);
need_schedule = 1;
}
else
{
rt_sched_unlock(slvl);
need_schedule = 0;
}
}
else
{
rt_sched_unlock(slvl);
need_schedule = 0;
}
RT_SCHED_DEBUG_IS_UNLOCKED;
}
else
need_schedule = 0;
return need_schedule;
}
/** find a candidate to be notified of the arrival */
static rt_thread_t _signal_find_catcher(struct rt_lwp *lwp, int signo)
{
rt_thread_t catcher = RT_NULL;
rt_thread_t candidate;
candidate = lwp->signal.sig_dispatch_thr[signo - 1];
if (candidate != RT_NULL && !_sigismember(&candidate->signal.sigset_mask, signo))
{
catcher = candidate;
}
else
{
candidate = rt_thread_self();
/** Note: lwp of current is a const value that can be safely read */
if (candidate->lwp == lwp &&
!_sigismember(&candidate->signal.sigset_mask, signo))
{
catcher = candidate;
}
else
{
rt_list_for_each_entry(candidate, &lwp->t_grp, sibling)
{
if (!_sigismember(&candidate->signal.sigset_mask, signo))
{
catcher = candidate;
break;
}
}
/* fall back to main thread */
if (catcher == RT_NULL)
catcher = rt_list_entry(lwp->t_grp.prev, struct rt_thread, sibling);
}
/* reset the cache thread to catcher (even if catcher is main thread) */
lwp->signal.sig_dispatch_thr[signo - 1] = catcher;
}
return catcher;
}
static int _siginfo_deliver_to_lwp(struct rt_lwp *lwp, lwp_siginfo_t siginfo)
{
rt_thread_t catcher;
catcher = _signal_find_catcher(lwp, siginfo->ksiginfo.signo);
sigqueue_enqueue(&lwp->signal.sig_queue, siginfo);
return _do_signal_wakeup(catcher, siginfo->ksiginfo.signo);
}
static int _siginfo_deliver_to_thread(rt_thread_t thread, lwp_siginfo_t siginfo)
{
sigqueue_enqueue(_SIGQ(thread), siginfo);
return _do_signal_wakeup(thread, siginfo->ksiginfo.signo);
}
rt_inline rt_bool_t _sighandler_is_ignored(struct rt_lwp *lwp, int signo)
{
rt_bool_t is_ignored;
lwp_sighandler_t action;
lwp_sigset_t ign_set = lwp_sigset_init(LWP_SIG_IGNORE_SET);
action = _get_sighandler_locked(lwp, signo);
if (action == LWP_SIG_ACT_IGN)
is_ignored = RT_TRUE;
else if (action == LWP_SIG_ACT_DFL && _sigismember(&ign_set, signo))
is_ignored = RT_TRUE;
else
is_ignored = RT_FALSE;
return is_ignored;
}
rt_inline rt_bool_t _sighandler_cannot_caught(struct rt_lwp *lwp, int signo)
{
return signo == SIGKILL || signo == SIGSTOP;
}
/* before signal is killed to target process/thread */
static void _before_sending_jobctl_signal(int signo, rt_lwp_t target_lwp, lwp_siginfo_t si)
{
rt_thread_t thr_iter;
rt_sched_lock_level_t slvl;
lwp_sigset_t jobctl_sigset = lwp_sigset_init(LWP_SIG_JOBCTL_SET);
LWP_ASSERT_LOCKED(target_lwp);
/**
* dequeue all the pending jobctl signals (including
* the one we are adding, since we don't want to pend it)
*/
sigqueue_discard_sigset(_SIGQ(target_lwp), &jobctl_sigset);
if (signo == SIGCONT)
{
target_lwp->jobctl_stopped = RT_FALSE;
rt_list_for_each_entry(thr_iter, &target_lwp->t_grp, sibling)
{
rt_base_t stat;
sigqueue_discard_sigset(_SIGQ(thr_iter), &jobctl_sigset);
/**
* Note: all stopped thread will be resumed
*/
rt_sched_lock(&slvl);
stat = rt_sched_thread_get_stat(thr_iter);
if ((stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK &&
(stat & RT_SIGNAL_KILL_WAKEUP_MASK) == 0)
{
thr_iter->error = RT_EINTR;
/**
* don't matter if we failed to resume the thread, since we
* only care about the event passing, but not ordering here
*/
rt_sched_unlock(slvl);
rt_thread_wakeup(thr_iter);
}
else
{
rt_sched_unlock(slvl);
}
}
}
else
{
rt_list_for_each_entry(thr_iter, &target_lwp->t_grp, sibling)
{
sigqueue_discard_sigset(_SIGQ(thr_iter), &jobctl_sigset);
}
}
}
rt_err_t lwp_signal_kill(struct rt_lwp *lwp, long signo, long code, lwp_siginfo_ext_t value)
{
rt_err_t ret = -1;
lwp_siginfo_t siginfo;
rt_bool_t terminated;
rt_bool_t need_schedule;
/** must be able to be suspended */
RT_DEBUG_SCHEDULER_AVAILABLE(RT_TRUE);
if (!lwp || signo < 0 || signo > _LWP_NSIG)
{
ret = -RT_EINVAL;
}
else if (signo == 0)
{
/* process exist and current process have privileges */
ret = 0;
}
else
{
LOG_D("%s(lwp=%p \"%s\",signo=%ld,code=%ld,value=%ld)",
__func__, lwp, lwp->cmd, signo, code, value);
need_schedule = RT_FALSE;
LWP_LOCK(lwp);
terminated = lwp->terminated;
/* short-circuit code for inactive task, ignored signals */
if (terminated)
{
/* no one rely on this, then free the resource */
if (value)
rt_free(value);
ret = 0;
}
else
{
siginfo = siginfo_create(rt_thread_self(), signo, code, value);
if (siginfo)
{
if (_is_jobctl_signal(lwp, signo))
_before_sending_jobctl_signal(signo, lwp, siginfo);
need_schedule = _siginfo_deliver_to_lwp(lwp, siginfo);
lwp_signal_notify(&lwp->signalfd_notify_head, siginfo);
ret = 0;
}
else
{
LOG_I("%s: siginfo malloc failed", __func__);
ret = -RT_ENOMEM;
}
}
LWP_UNLOCK(lwp);
if (need_schedule)
rt_schedule();
}
return ret;
}
static void _signal_action_flag_k2u(int signo, struct lwp_signal *signal, struct lwp_sigaction *act)
{
long flags = 0;
if (_sigismember(&signal->sig_action_nodefer, signo))
flags |= SA_NODEFER;
if (_sigismember(&signal->sig_action_onstack, signo))
flags |= SA_ONSTACK;
if (_sigismember(&signal->sig_action_restart, signo))
flags |= SA_RESTART;
if (_sigismember(&signal->sig_action_siginfo, signo))
flags |= SA_SIGINFO;
if (_sigismember(&signal->sig_action_nocldstop, signo))
flags |= SA_NOCLDSTOP;
if (_sigismember(&signal->sig_action_nocldwait, signo))
flags |= SA_NOCLDWAIT;
act->sa_flags = flags;
}
static void _signal_action_flag_u2k(int signo, struct lwp_signal *signal, const struct lwp_sigaction *act)
{
long flags = act->sa_flags;
if (flags & SA_NODEFER)
_sigaddset(&signal->sig_action_nodefer, signo);
if (flags & SA_ONSTACK)
_sigaddset(&signal->sig_action_onstack, signo);
if (flags & SA_RESTART)
_sigaddset(&signal->sig_action_restart, signo);
if (flags & SA_SIGINFO)
_sigaddset(&signal->sig_action_siginfo, signo);
if (signo == SIGCHLD)
{
/* These flags are meaningful only when establishing a handler for SIGCHLD */
if (flags & SA_NOCLDSTOP)
_sigaddset(&signal->sig_action_nocldstop, signo);
if (flags & SA_NOCLDWAIT)
_sigaddset(&signal->sig_action_nocldwait, signo);
}
#define _HANDLE_FLAGS (SA_RESTORER | SA_NODEFER | SA_ONSTACK | SA_RESTART | SA_SIGINFO | SA_NOCLDSTOP | SA_NOCLDWAIT)
if (flags & ~_HANDLE_FLAGS)
LOG_W("Unhandled flags: 0x%lx", flags & ~_HANDLE_FLAGS);
}
rt_bool_t lwp_sigisign(struct rt_lwp *lwp, int _sig)
{
unsigned long sig = _sig - 1;
return lwp->signal.sig_action[sig] == LWP_SIG_ACT_IGN;
}
rt_err_t lwp_signal_action(struct rt_lwp *lwp, int signo,
const struct lwp_sigaction *restrict act,
struct lwp_sigaction *restrict oact)
{
lwp_sighandler_t prev_handler;
lwp_sigqueue_t thread_sigq;
rt_list_t *thread_list;
rt_err_t ret = RT_EOK;
if (lwp)
{
/** acquire READ access to lwp */
LWP_LOCK(lwp);
if (oact)
{
oact->sa_mask = lwp->signal.sig_action_mask[signo - 1];
oact->__sa_handler._sa_handler = lwp->signal.sig_action[signo - 1];
oact->sa_restorer = RT_NULL;
_signal_action_flag_k2u(signo, &lwp->signal, oact);
}
if (act)
{
/**
* Note: POSIX.1-2017 requires calls to sigaction() that supply a NULL act
* argument succeed, even in the case of signals that cannot be caught or ignored
*/
if (_sighandler_cannot_caught(lwp, signo))
ret = -EINVAL;
else
{
prev_handler = _get_sighandler_locked(lwp, signo);
lwp->signal.sig_action_mask[signo - 1] = act->sa_mask;
if (act->__sa_handler._sa_handler == SIG_IGN)
{
lwp_sigset_t no_ign_set = lwp_sigset_init(LWP_SIG_NO_IGN_SET);
if (!lwp_sigismember(&no_ign_set, signo))
{
/* except those unignorable signals, discard them for proc */
lwp->signal.sig_action[signo - 1] = LWP_SIG_ACT_IGN;
}
else
{
/* POSIX.1: SIG_IGN and SIG_DFL are equivalent for SIGCONT */
lwp->signal.sig_action[signo - 1] = LWP_SIG_ACT_DFL;
}
}
else
{
lwp->signal.sig_action[signo - 1] = act->__sa_handler._sa_handler;
}
_signal_action_flag_u2k(signo, &lwp->signal, act);
/**
* Brief: Discard the pending signal if signal action is set to SIG_IGN
*
* Note: POSIX.1-2017: Setting a signal action to SIG_IGN for a signal
* that is pending shall cause the pending signal to be discarded,
* whether or not it is blocked.
*/
if (prev_handler != LWP_SIG_ACT_IGN &&
_get_sighandler_locked(lwp, signo) == LWP_SIG_ACT_IGN)
{
sigqueue_discard(_SIGQ(lwp), signo);
for (thread_list = lwp->t_grp.next;
thread_list != &lwp->t_grp;
thread_list = thread_list->next)
{
thread_sigq = _SIGQ(rt_list_entry(thread_list, struct rt_thread, sibling));
sigqueue_discard(thread_sigq, signo);
}
}
}
}
LWP_UNLOCK(lwp);
}
else
ret = -EINVAL;
return ret;
}
rt_err_t lwp_thread_signal_kill(rt_thread_t thread, long signo, long code, lwp_siginfo_ext_t value)
{
rt_err_t ret = -1;
struct rt_lwp *lwp;
lwp_siginfo_t siginfo;
rt_bool_t need_schedule;
/** must be able to be suspended */
RT_DEBUG_SCHEDULER_AVAILABLE(RT_TRUE);
LOG_D("%s(signo=%d)", __func__, signo);
if (!thread || signo < 0 || signo >= _LWP_NSIG)
{
ret = -RT_EINVAL;
}
else if (signo == 0)
{
/* thread exist and current thread have privileges */
ret = 0;
}
else
{
lwp = thread->lwp;
need_schedule = RT_FALSE;
RT_ASSERT(lwp);
LWP_LOCK(lwp);
if (!lwp)
ret = -RT_EPERM;
else if (lwp->terminated || _sighandler_is_ignored(lwp, signo))
ret = 0;
else
{
siginfo = siginfo_create(rt_thread_self(), signo, code, value);
if (siginfo)
{
need_schedule = _siginfo_deliver_to_thread(thread, siginfo);
lwp_signal_notify(&lwp->signalfd_notify_head, siginfo);
ret = 0;
}
else
{
LOG_I("%s: siginfo malloc failed", __func__);
ret = -RT_ENOMEM;
}
}
LWP_UNLOCK(lwp);
if (need_schedule)
rt_schedule();
}
return ret;
}
#ifndef ARCH_MM_MMU
void lwp_thread_sighandler_set(int sig, lwp_sighandler_t func)
{
rt_base_t level;
if (sig == 0 || sig > _LWP_NSIG)
return;
level = rt_hw_interrupt_disable();
rt_thread_self()->signal_handler[sig - 1] = func;
rt_hw_interrupt_enable(level);
}
#endif
rt_err_t lwp_thread_signal_mask(rt_thread_t thread, lwp_sig_mask_cmd_t how,
const lwp_sigset_t *sigset, lwp_sigset_t *oset)
{
rt_err_t ret = -1;
struct rt_lwp *lwp;
if (thread)
{
lwp = (struct rt_lwp *)thread->lwp;
LWP_LOCK(lwp);
if (!lwp)
{
ret = -RT_EPERM;
}
else
{
ret = 0;
_thread_signal_mask(thread, how, sigset, oset);
}
LWP_UNLOCK(lwp);
}
else
ret = -RT_EINVAL;
return ret;
}
static int _dequeue_signal(rt_thread_t thread, lwp_sigset_t *mask, siginfo_t *usi)
{
int signo;
lwp_siginfo_t si;
struct rt_lwp *lwp;
lwp_sigset_t *pending;
lwp_sigqueue_t sigqueue;
lwp = thread->lwp;
RT_ASSERT(lwp);
sigqueue = _SIGQ(thread);
pending = &sigqueue->sigset_pending;
signo = _next_signal(pending, mask);
if (!signo)
{
sigqueue = _SIGQ(lwp);
pending = &sigqueue->sigset_pending;
signo = _next_signal(pending, mask);
}
if (!signo)
return signo;
si = sigqueue_dequeue(sigqueue, signo);
RT_ASSERT(!!si);
siginfo_k2u(si, usi);
siginfo_delete(si);
return signo;
}
rt_err_t lwp_thread_signal_timedwait(rt_thread_t thread, lwp_sigset_t *sigset,
siginfo_t *usi, struct timespec *timeout)
{
rt_err_t ret;
lwp_sigset_t saved_sigset;
lwp_sigset_t blocked_sigset;
lwp_sigset_t dontwait_sigset;
int sig;
struct rt_lwp *lwp = thread->lwp;
/**
* Brief: POSIX
* If one of the signals in set is already pending for the calling thread,
* sigwaitinfo() will return immediately
*/
/* Create a mask of signals user dont want or cannot catch */
_sigdelset(sigset, SIGKILL);
_sigdelset(sigset, SIGSTOP);
_signotsets(&dontwait_sigset, sigset);
LWP_LOCK(lwp);
sig = _dequeue_signal(thread, &dontwait_sigset, usi);
LWP_UNLOCK(lwp);
if (sig)
return sig;
/**
* Brief: POSIX
* if none of the signals specified by set are pending, sigtimedwait() shall
* wait for the time interval specified in the timespec structure referenced
* by timeout.
*
* Note: If the pending signal arrives before thread suspend, the suspend
* operation will return a failure
*/
_sigandsets(&blocked_sigset, &thread->signal.sigset_mask, &dontwait_sigset);
_thread_signal_mask(thread, LWP_SIG_MASK_CMD_SET_MASK, &blocked_sigset, &saved_sigset);
if (timeout)
{
rt_tick_t time;
time = (timeout->tv_sec * RT_TICK_PER_SECOND) + ((timeout->tv_nsec * RT_TICK_PER_SECOND) / NANOSECOND_PER_SECOND);
/**
* Brief: POSIX
* If the timespec structure pointed to by timeout is zero-valued and
* if none of the signals specified by set are pending, then
* sigtimedwait() shall return immediately with an error
*/
if (time == 0)
return -EAGAIN;
rt_enter_critical();
ret = rt_thread_suspend_with_flag(thread, RT_INTERRUPTIBLE);
rt_timer_control(&(thread->thread_timer),
RT_TIMER_CTRL_SET_TIME,
&time);
rt_timer_start(&(thread->thread_timer));
rt_exit_critical();
}
else
{
/* suspend kernel forever until signal was received */
ret = rt_thread_suspend_with_flag(thread, RT_INTERRUPTIBLE);
}
if (ret == RT_EOK)
{
rt_schedule();
/* If thread->error reliable? */
if (thread->error == RT_EINTR)
ret = -EINTR;
else
ret = -EAGAIN;
}
/* else ret == -EINTR */
_thread_signal_mask(thread, LWP_SIG_MASK_CMD_SET_MASK, &saved_sigset, RT_NULL);
LWP_LOCK(lwp);
sig = _dequeue_signal(thread, &dontwait_sigset, usi);
LWP_UNLOCK(lwp);
return sig ? sig : ret;
}
void lwp_thread_signal_pending(rt_thread_t thread, lwp_sigset_t *pending)
{
struct rt_lwp *lwp;
lwp = thread->lwp;
if (lwp)
{
memset(pending, 0, sizeof(*pending));
LWP_LOCK(lwp);
sigqueue_examine(_SIGQ(thread), pending);
sigqueue_examine(_SIGQ(lwp), pending);
LWP_UNLOCK(lwp);
_sigandsets(pending, pending, &thread->signal.sigset_mask);
}
}
rt_err_t lwp_pgrp_signal_kill(rt_processgroup_t pgrp, long signo, long code,
lwp_siginfo_ext_t value)
{
struct rt_lwp *lwp;
rt_err_t rc = 0;
PGRP_ASSERT_LOCKED(pgrp);
if (pgrp)
{
rt_list_for_each_entry(lwp, &pgrp->process, pgrp_node)
{
lwp_signal_kill(lwp, signo, code, value);
}
}
return rc;
}
struct kill_all_param
{
long signo;
long code;
lwp_siginfo_ext_t value;
};
static int _kill_each(pid_t pid, void *data)
{
struct kill_all_param *param = data;
rt_lwp_t lwp;
rt_err_t error;
lwp = lwp_from_pid_locked(pid);
if (lwp && !lwp->sig_protected)
{
error = lwp_signal_kill(lwp, param->signo, param->code, param->value);
}
else
{
error = RT_EOK;
}
return error;
}
rt_err_t lwp_signal_kill_all(long signo, long code, lwp_siginfo_ext_t value)
{
struct kill_all_param buf =
{
.signo = signo,
.code = code,
.value = value,
};
return lwp_pid_for_each(_kill_each, &buf);
}
View Git Blame Copy Permalink