[kernel/signal] fix: respect suspend state when delivering signals

Native signal delivery resumed every suspended thread, including
RT_UNINTERRUPTIBLE IPC waiters. This could remove a waiter from a
semaphore, mutex, event, mailbox, or message queue wait list without
granting the corresponding resource, causing -RT_EINTR or inconsistent
higher-level state.

Inspect pending signals and suspend state under scheduler ownership.
Wake interruptible waiters for common signals, and wake killable waiters
only for SIGKILL and SIGSTOP according to RT-Thread suspend semantics.
Defer signals not allowed by the current wait mode. Release the signal
lock before waking the target thread. Also make scheduler-side
pending-signal preprocessing respect the suspend mode, preventing SMP
suspend-to-schedule races.

Keep rt_signal_wait() blocked for non-matching signals and preserve the
remaining timeout. Allow masked signals and NULL siginfo, handle suspend
failures without starting a timer, and preserve the outer interrupted
wait result when a signal handler invokes other kernel APIs.

Add regression coverage for RT-Thread native signal semantics,
including masked signals, non-matching signal waits, NULL siginfo,
and RT_KILLABLE SIGSTOP handling. The parent implementation fails the
regression test because uninterruptible and killable waits complete early
after SIGUSR1, and signal_wait returns early for a non-matching signal.

Validation:
- UP QEMU: core.signal passed.
- Dual-core SMP QEMU: core.signal passed.
- scons -C bsp/qemu-vexpress-a9 -j$(nproc) passed.

Signed-off-by: Hui Su <3164683437@qq.com>

Author: liulangrenaaa

include/rtdef.h

@@ -587,6 +587,11 @@ typedef struct rt_timer *rt_timer_t;
 typedef unsigned long rt_sigset_t;
 typedef siginfo_t rt_siginfo_t;
 typedef void (*rt_sighandler_t)(int signo);
+#ifdef RT_USING_MUSLLIBC
+#define RT_SIG_MASK(signo) ((rt_sigset_t)1 << ((signo) - 1))
+#else
+#define RT_SIG_MASK(signo) ((rt_sigset_t)1 << (signo))
+#endif
 #endif /* RT_USING_SIGNALS */
 /**@}*/
 

src/scheduler_mp.c

@@ -713,6 +713,30 @@ static rt_thread_t _prepare_context_switch_locked(int cpu_id,
 }
 
 #ifdef RT_USING_SIGNALS
+/* Check whether a signal may wake the thread in its suspend state. */
+static rt_bool_t _sched_signal_wakeup_allowed(struct rt_thread *thread)
+{
+    rt_uint8_t stat;
+    rt_sigset_t pending;
+
+    stat = RT_SCHED_CTX(thread).stat;
+    pending = thread->sig_pending & thread->sig_mask;
+
+    if (stat & RT_THREAD_STAT_SIGNAL_WAIT)
+    {
+        return RT_TRUE;
+    }
+
+    if (!(stat & RT_SIGNAL_COMMON_WAKEUP_MASK))
+    {
+        return RT_TRUE;
+    }
+
+    return !(stat & RT_SIGNAL_KILL_WAKEUP_MASK) &&
+           (pending & (RT_SIG_MASK(SIGKILL) |
+                       RT_SIG_MASK(SIGSTOP)));
+}
+
 /**
  * @brief Preprocess pending signals for a suspended thread
  *
@@ -727,7 +751,9 @@ static void _sched_thread_preprocess_signal(struct rt_thread *current_thread)
     if (rt_sched_thread_is_suspended(current_thread))
     {
         /* if current_thread signal is in pending */
-        if ((RT_SCHED_CTX(current_thread).stat & RT_THREAD_STAT_SIGNAL_MASK) & RT_THREAD_STAT_SIGNAL_PENDING)
+        if (((RT_SCHED_CTX(current_thread).stat & RT_THREAD_STAT_SIGNAL_MASK) &
+             RT_THREAD_STAT_SIGNAL_PENDING) &&
+            _sched_signal_wakeup_allowed(current_thread))
         {
 #ifdef RT_USING_SMART
             rt_thread_wakeup(current_thread);