diff --git a/arch/arm/src/arm/arm_schedulesigaction.c b/arch/arm/src/arm/arm_schedulesigaction.c index bf2c48af9b7..9016c39d2e7 100644 --- a/arch/arm/src/arm/arm_schedulesigaction.c +++ b/arch/arm/src/arm/arm_schedulesigaction.c @@ -35,6 +35,7 @@ #include "arm.h" #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -90,8 +91,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* Otherwise, we are (1) signaling a task is not running diff --git a/arch/arm/src/arm/arm_sigdeliver.c b/arch/arm/src/arm/arm_sigdeliver.c index 276b8a053e2..6a6b6a2465e 100644 --- a/arch/arm/src/arm/arm_sigdeliver.c +++ b/arch/arm/src/arm/arm_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -59,9 +60,9 @@ void arm_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); #ifndef CONFIG_SUPPRESS_INTERRUPTS /* Then make sure that interrupts are enabled. Signal handlers must always @@ -73,7 +74,7 @@ void arm_sigdeliver(void) /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -93,7 +94,9 @@ void arm_sigdeliver(void) * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/arm/src/armv6-m/arm_doirq.c b/arch/arm/src/armv6-m/arm_doirq.c index dbbf25a6e57..10fd627baac 100644 --- a/arch/arm/src/armv6-m/arm_doirq.c +++ b/arch/arm/src/armv6-m/arm_doirq.c @@ -34,6 +34,7 @@ #include #include #include +#include #include "arm_internal.h" #include "exc_return.h" @@ -86,7 +87,7 @@ uint32_t *arm_doirq(int irq, uint32_t *regs) irq_dispatch(irq, regs); #endif - if (tcb->sigdeliver) + if ((tcb->flags & TCB_FLAG_SIGDELIVER) != 0) { /* Pendsv able to access running tcb with no critical section */ diff --git a/arch/arm/src/armv6-m/arm_schedulesigaction.c b/arch/arm/src/armv6-m/arm_schedulesigaction.c index 56af01fe45a..ddf0920df6a 100644 --- a/arch/arm/src/armv6-m/arm_schedulesigaction.c +++ b/arch/arm/src/armv6-m/arm_schedulesigaction.c @@ -37,6 +37,7 @@ #include "psr.h" #include "exc_return.h" #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" #include "irq/irq.h" #include "nvic.h" @@ -96,8 +97,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handle will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else if (tcb == rtcb && ipsr != NVIC_IRQ_PENDSV) { diff --git a/arch/arm/src/armv6-m/arm_sigdeliver.c b/arch/arm/src/armv6-m/arm_sigdeliver.c index d9ce126b9e5..0daf4204e6d 100644 --- a/arch/arm/src/armv6-m/arm_sigdeliver.c +++ b/arch/arm/src/armv6-m/arm_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -69,9 +70,9 @@ void arm_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -103,7 +104,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -150,7 +151,9 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of * execution. diff --git a/arch/arm/src/armv7-a/arm_schedulesigaction.c b/arch/arm/src/armv7-a/arm_schedulesigaction.c index b68276b645e..3a856e1a349 100644 --- a/arch/arm/src/armv7-a/arm_schedulesigaction.c +++ b/arch/arm/src/armv7-a/arm_schedulesigaction.c @@ -36,6 +36,7 @@ #include "arm.h" #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" #include "irq/irq.h" @@ -94,8 +95,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handler will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else { diff --git a/arch/arm/src/armv7-a/arm_sigdeliver.c b/arch/arm/src/armv7-a/arm_sigdeliver.c index fe0696f75d6..d4fd6b8b7b0 100644 --- a/arch/arm/src/armv7-a/arm_sigdeliver.c +++ b/arch/arm/src/armv7-a/arm_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -69,9 +70,9 @@ void arm_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -103,7 +104,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -150,7 +151,9 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/arm/src/armv7-a/arm_syscall.c b/arch/arm/src/armv7-a/arm_syscall.c index ad73ad237ea..be5b3c7f830 100644 --- a/arch/arm/src/armv7-a/arm_syscall.c +++ b/arch/arm/src/armv7-a/arm_syscall.c @@ -410,7 +410,7 @@ uint32_t *arm_syscall(uint32_t *regs) /* Copy "info" into user stack */ - if (rtcb->sigdeliver) + if ((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0) { usp = rtcb->xcp.saved_regs[REG_SP]; } diff --git a/arch/arm/src/armv7-m/arm_doirq.c b/arch/arm/src/armv7-m/arm_doirq.c index 7eff7dd8119..888fab96e54 100644 --- a/arch/arm/src/armv7-m/arm_doirq.c +++ b/arch/arm/src/armv7-m/arm_doirq.c @@ -34,6 +34,7 @@ #include #include #include +#include #include "arm_internal.h" #include "exc_return.h" @@ -86,7 +87,7 @@ uint32_t *arm_doirq(int irq, uint32_t *regs) irq_dispatch(irq, regs); #endif - if (tcb->sigdeliver) + if ((tcb->flags & TCB_FLAG_SIGDELIVER) != 0) { /* Pendsv able to access running tcb with no critical section */ diff --git a/arch/arm/src/armv7-m/arm_schedulesigaction.c b/arch/arm/src/armv7-m/arm_schedulesigaction.c index ad430e44686..4f964fa67b2 100644 --- a/arch/arm/src/armv7-m/arm_schedulesigaction.c +++ b/arch/arm/src/armv7-m/arm_schedulesigaction.c @@ -38,6 +38,7 @@ #include "psr.h" #include "exc_return.h" #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" #include "irq/irq.h" #include "nvic.h" @@ -97,8 +98,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handle will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else if (tcb == rtcb && ipsr != NVIC_IRQ_PENDSV) { diff --git a/arch/arm/src/armv7-m/arm_sigdeliver.c b/arch/arm/src/armv7-m/arm_sigdeliver.c index 7dff72944b2..7b83684b130 100644 --- a/arch/arm/src/armv7-m/arm_sigdeliver.c +++ b/arch/arm/src/armv7-m/arm_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -69,9 +70,9 @@ void arm_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -103,7 +104,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -150,7 +151,9 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of * execution. diff --git a/arch/arm/src/armv7-r/arm_schedulesigaction.c b/arch/arm/src/armv7-r/arm_schedulesigaction.c index c7fce2ab3d8..c7f3495eb0a 100644 --- a/arch/arm/src/armv7-r/arm_schedulesigaction.c +++ b/arch/arm/src/armv7-r/arm_schedulesigaction.c @@ -35,6 +35,7 @@ #include "arm.h" #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -92,8 +93,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handler will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else { diff --git a/arch/arm/src/armv7-r/arm_sigdeliver.c b/arch/arm/src/armv7-r/arm_sigdeliver.c index 6559345a76d..0e19c6d8005 100644 --- a/arch/arm/src/armv7-r/arm_sigdeliver.c +++ b/arch/arm/src/armv7-r/arm_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -69,9 +70,9 @@ void arm_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -103,7 +104,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -147,7 +148,9 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/arm/src/armv7-r/arm_syscall.c b/arch/arm/src/armv7-r/arm_syscall.c index d202e9b5059..2a44657c8ae 100644 --- a/arch/arm/src/armv7-r/arm_syscall.c +++ b/arch/arm/src/armv7-r/arm_syscall.c @@ -407,7 +407,7 @@ uint32_t *arm_syscall(uint32_t *regs) /* Copy "info" into user stack */ - if (rtcb->sigdeliver) + if ((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0) { usp = rtcb->xcp.saved_regs[REG_SP]; } diff --git a/arch/arm/src/armv8-m/arm_doirq.c b/arch/arm/src/armv8-m/arm_doirq.c index 18f6d1097be..4ae8ddac1b1 100644 --- a/arch/arm/src/armv8-m/arm_doirq.c +++ b/arch/arm/src/armv8-m/arm_doirq.c @@ -97,7 +97,7 @@ uint32_t *arm_doirq(int irq, uint32_t *regs) irq_dispatch(irq, regs); #endif - if (tcb->sigdeliver) + if ((tcb->flags & TCB_FLAG_SIGDELIVER) != 0) { /* Pendsv able to access running tcb with no critical section */ diff --git a/arch/arm/src/armv8-m/arm_schedulesigaction.c b/arch/arm/src/armv8-m/arm_schedulesigaction.c index 523082806c9..4482d8f778d 100644 --- a/arch/arm/src/armv8-m/arm_schedulesigaction.c +++ b/arch/arm/src/armv8-m/arm_schedulesigaction.c @@ -38,6 +38,7 @@ #include "psr.h" #include "exc_return.h" #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" #include "irq/irq.h" #include "nvic.h" @@ -97,8 +98,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handle will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else if (tcb == rtcb && ipsr != NVIC_IRQ_PENDSV) { diff --git a/arch/arm/src/armv8-m/arm_sigdeliver.c b/arch/arm/src/armv8-m/arm_sigdeliver.c index 6f5e91814fe..8f2707f871a 100644 --- a/arch/arm/src/armv8-m/arm_sigdeliver.c +++ b/arch/arm/src/armv8-m/arm_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -69,9 +70,9 @@ void arm_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -103,7 +104,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -150,7 +151,9 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of * execution. diff --git a/arch/arm/src/armv8-r/arm_schedulesigaction.c b/arch/arm/src/armv8-r/arm_schedulesigaction.c index fcb18ab9388..2c035496cc9 100644 --- a/arch/arm/src/armv8-r/arm_schedulesigaction.c +++ b/arch/arm/src/armv8-r/arm_schedulesigaction.c @@ -35,6 +35,7 @@ #include "arm.h" #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -92,8 +93,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handler will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else { diff --git a/arch/arm/src/armv8-r/arm_sigdeliver.c b/arch/arm/src/armv8-r/arm_sigdeliver.c index b876d98bda1..8280f419317 100644 --- a/arch/arm/src/armv8-r/arm_sigdeliver.c +++ b/arch/arm/src/armv8-r/arm_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -69,9 +70,9 @@ void arm_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -103,7 +104,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -147,7 +148,9 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/arm/src/armv8-r/arm_syscall.c b/arch/arm/src/armv8-r/arm_syscall.c index 54503400f7e..5cdebccb298 100644 --- a/arch/arm/src/armv8-r/arm_syscall.c +++ b/arch/arm/src/armv8-r/arm_syscall.c @@ -407,7 +407,7 @@ uint32_t *arm_syscall(uint32_t *regs) /* Copy "info" into user stack */ - if (rtcb->sigdeliver) + if ((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0) { usp = rtcb->xcp.saved_regs[REG_SP]; } diff --git a/arch/arm/src/tlsr82/tc32/tc32_schedulesigaction.c b/arch/arm/src/tlsr82/tc32/tc32_schedulesigaction.c index 2e95c6765f5..58235a53e20 100644 --- a/arch/arm/src/tlsr82/tc32/tc32_schedulesigaction.c +++ b/arch/arm/src/tlsr82/tc32/tc32_schedulesigaction.c @@ -35,6 +35,7 @@ #include "tc32.h" #include "sched/sched.h" +#include "signal/signal.h" #include "arm_internal.h" /**************************************************************************** @@ -90,8 +91,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* Otherwise, we are (1) signaling a task is not running diff --git a/arch/arm64/src/common/arm64_schedulesigaction.c b/arch/arm64/src/common/arm64_schedulesigaction.c index a143a05bb8e..2ba5eaad73b 100644 --- a/arch/arm64/src/common/arm64_schedulesigaction.c +++ b/arch/arm64/src/common/arm64_schedulesigaction.c @@ -35,6 +35,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm64_internal.h" #include "arm64_arch.h" #include "irq/irq.h" @@ -130,8 +131,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handler will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else { diff --git a/arch/arm64/src/common/arm64_sigdeliver.c b/arch/arm64/src/common/arm64_sigdeliver.c index 2395aa1e8c6..dac0f0a3c3a 100644 --- a/arch/arm64/src/common/arm64_sigdeliver.c +++ b/arch/arm64/src/common/arm64_sigdeliver.c @@ -35,6 +35,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "arm64_internal.h" #include "arm64_arch.h" #include "irq/irq.h" @@ -69,9 +70,9 @@ void arm64_sigdeliver(void) flags = (rtcb->xcp.saved_regs[REG_SPSR] & SPSR_DAIF_MASK); #endif - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -103,7 +104,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -150,7 +151,9 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; rtcb->xcp.regs = rtcb->xcp.saved_regs; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/avr/src/avr/avr_schedulesigaction.c b/arch/avr/src/avr/avr_schedulesigaction.c index 3e27a221105..4d035dc3fc3 100644 --- a/arch/avr/src/avr/avr_schedulesigaction.c +++ b/arch/avr/src/avr/avr_schedulesigaction.c @@ -35,6 +35,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "avr_internal.h" /**************************************************************************** @@ -98,8 +99,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/avr/src/avr/avr_sigdeliver.c b/arch/avr/src/avr/avr_sigdeliver.c index fb341d5f79a..d9915a7a6ae 100644 --- a/arch/avr/src/avr/avr_sigdeliver.c +++ b/arch/avr/src/avr/avr_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "avr_internal.h" /**************************************************************************** @@ -60,9 +61,9 @@ void avr_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -78,7 +79,7 @@ void avr_sigdeliver(void) /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -98,13 +99,16 @@ void avr_sigdeliver(void) * could be modified by a hostile program. */ - regs[REG_PC0] = rtcb->xcp.saved_pc0; - regs[REG_PC1] = rtcb->xcp.saved_pc1; + regs[REG_PC0] = rtcb->xcp.saved_pc0; + regs[REG_PC1] = rtcb->xcp.saved_pc1; #if defined(REG_PC2) - regs[REG_PC2] = rtcb->xcp.saved_pc2; + regs[REG_PC2] = rtcb->xcp.saved_pc2; #endif - regs[REG_SREG] = rtcb->xcp.saved_sreg; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + regs[REG_SREG] = rtcb->xcp.saved_sreg; + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. This is an * unusual case that must be handled by up_fullcontextresore. This case is diff --git a/arch/avr/src/avr32/avr_initialstate.c b/arch/avr/src/avr32/avr_initialstate.c index 7e4ced382ac..2b666e9f4fb 100644 --- a/arch/avr/src/avr32/avr_initialstate.c +++ b/arch/avr/src/avr32/avr_initialstate.c @@ -89,7 +89,7 @@ void up_initial_state(struct tcb_s *tcb) #else /* No pending signal delivery */ - tcb->sigdeliver = NULL; + tcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Clear the frame pointer and link register since this is the outermost * frame. diff --git a/arch/avr/src/avr32/avr_schedulesigaction.c b/arch/avr/src/avr32/avr_schedulesigaction.c index fc9be71af9f..141e3ecb5cb 100644 --- a/arch/avr/src/avr32/avr_schedulesigaction.c +++ b/arch/avr/src/avr32/avr_schedulesigaction.c @@ -35,6 +35,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "avr_internal.h" /**************************************************************************** @@ -96,8 +97,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/avr/src/avr32/avr_sigdeliver.c b/arch/avr/src/avr32/avr_sigdeliver.c index d799bc420e8..3f2d2408ae6 100644 --- a/arch/avr/src/avr32/avr_sigdeliver.c +++ b/arch/avr/src/avr32/avr_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "avr_internal.h" /**************************************************************************** @@ -64,9 +65,9 @@ void avr_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -82,7 +83,7 @@ void avr_sigdeliver(void) /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -102,9 +103,12 @@ void avr_sigdeliver(void) * could be modified by a hostile program. */ - regs[REG_PC] = rtcb->xcp.saved_pc; - regs[REG_SR] = rtcb->xcp.saved_sr; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + regs[REG_PC] = rtcb->xcp.saved_pc; + regs[REG_SR] = rtcb->xcp.saved_sr; + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. This is an * unusual case that must be handled by up_fullcontextresore. This case is diff --git a/arch/ceva/src/common/ceva_schedulesigaction.c b/arch/ceva/src/common/ceva_schedulesigaction.c index 5a2f62025c4..4345a54f3d2 100644 --- a/arch/ceva/src/common/ceva_schedulesigaction.c +++ b/arch/ceva/src/common/ceva_schedulesigaction.c @@ -33,6 +33,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "ceva_internal.h" #ifndef CONFIG_DISABLE_SIGNALS @@ -100,8 +101,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: The task that needs to receive the signal is running. diff --git a/arch/ceva/src/common/ceva_sigdeliver.c b/arch/ceva/src/common/ceva_sigdeliver.c index 9a61377425a..f13bb9c487b 100644 --- a/arch/ceva/src/common/ceva_sigdeliver.c +++ b/arch/ceva/src/common/ceva_sigdeliver.c @@ -54,7 +54,6 @@ void ceva_sigdeliver(void) { struct tcb_s *rtcb = this_task(); uint32_t *regs = rtcb->xcp.saved_regs; - sig_deliver_t sigdeliver; /* Save the errno. This must be preserved throughout the signal handling * so that the user code final gets the correct errno value (probably @@ -63,21 +62,20 @@ void ceva_sigdeliver(void) int saved_errno = rtcb->pterrno; - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); - /* Get a local copy of the sigdeliver function pointer. We do this so that - * we can nullify the sigdeliver function pointer in the TCB and accept - * more signal deliveries while processing the current pending signals. + /* We do this so that we can nullify the TCB_FLAG_SIGDELIVER in the TCB + * and accept more signal deliveries while processing the current pending + * signals. */ - sigdeliver = rtcb->sigdeliver; - rtcb->sigdeliver = NULL; + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Deliver the signal */ - sigdeliver(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original diff --git a/arch/mips/src/mips32/mips_schedulesigaction.c b/arch/mips/src/mips32/mips_schedulesigaction.c index 5899549b509..a9eb1a2efe0 100644 --- a/arch/mips/src/mips32/mips_schedulesigaction.c +++ b/arch/mips/src/mips32/mips_schedulesigaction.c @@ -36,6 +36,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "mips_internal.h" /**************************************************************************** @@ -99,8 +100,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/mips/src/mips32/mips_sigdeliver.c b/arch/mips/src/mips32/mips_sigdeliver.c index f333adb7043..b4cd103d9d2 100644 --- a/arch/mips/src/mips32/mips_sigdeliver.c +++ b/arch/mips/src/mips32/mips_sigdeliver.c @@ -39,6 +39,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "mips_internal.h" /**************************************************************************** @@ -62,9 +63,9 @@ void mips_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -80,7 +81,7 @@ void mips_sigdeliver(void) /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -104,7 +105,10 @@ void mips_sigdeliver(void) regs[REG_EPC] = rtcb->xcp.saved_epc; regs[REG_STATUS] = rtcb->xcp.saved_status; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of * execution. diff --git a/arch/misoc/src/lm32/lm32_schedulesigaction.c b/arch/misoc/src/lm32/lm32_schedulesigaction.c index 95e42a15c4a..83db54afa98 100644 --- a/arch/misoc/src/lm32/lm32_schedulesigaction.c +++ b/arch/misoc/src/lm32/lm32_schedulesigaction.c @@ -35,6 +35,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "lm32.h" /**************************************************************************** @@ -96,8 +97,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/misoc/src/lm32/lm32_sigdeliver.c b/arch/misoc/src/lm32/lm32_sigdeliver.c index c0fac7e36d9..fc3e807d041 100644 --- a/arch/misoc/src/lm32/lm32_sigdeliver.c +++ b/arch/misoc/src/lm32/lm32_sigdeliver.c @@ -38,6 +38,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "lm32.h" /**************************************************************************** @@ -61,9 +62,9 @@ void lm32_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -79,7 +80,7 @@ void lm32_sigdeliver(void) /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -103,7 +104,10 @@ void lm32_sigdeliver(void) regs[REG_EPC] = rtcb->xcp.saved_epc; regs[REG_INT_CTX] = rtcb->xcp.saved_int_ctx; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of * execution. diff --git a/arch/misoc/src/minerva/minerva_schedulesigaction.c b/arch/misoc/src/minerva/minerva_schedulesigaction.c index e563c485fd5..cd46ee4bdae 100644 --- a/arch/misoc/src/minerva/minerva_schedulesigaction.c +++ b/arch/misoc/src/minerva/minerva_schedulesigaction.c @@ -36,6 +36,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "minerva.h" /**************************************************************************** @@ -97,8 +98,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the interrupted task diff --git a/arch/misoc/src/minerva/minerva_sigdeliver.c b/arch/misoc/src/minerva/minerva_sigdeliver.c index 12053d0fec0..e579b686f7e 100644 --- a/arch/misoc/src/minerva/minerva_sigdeliver.c +++ b/arch/misoc/src/minerva/minerva_sigdeliver.c @@ -59,13 +59,12 @@ void minerva_sigdeliver(void) { struct tcb_s *rtcb = this_task(); uint32_t regs[XCPTCONTEXT_REGS]; - sig_deliver_t sigdeliver; board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the real return state on the stack. */ @@ -73,13 +72,12 @@ void minerva_sigdeliver(void) regs[REG_CSR_MEPC] = rtcb->xcp.saved_epc; regs[REG_CSR_MSTATUS] = rtcb->xcp.saved_int_ctx; - /* Get a local copy of the sigdeliver function pointer. We do this so that - * we can nullify the sigdeliver function pointer in the TCB and accept - * more signal deliveries while processing the current pending signals. + /* We do this so that we can nullify the TCB_FLAG_SIGDELIVER in the TCB + * and accept more signal deliveries while processing the current pending + * signals. */ - sigdeliver = rtcb->sigdeliver; - rtcb->sigdeliver = NULL; + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; # ifndef CONFIG_SUPPRESS_INTERRUPTS /* Then make sure that interrupts are enabled. Signal handlers must always @@ -91,7 +89,7 @@ void minerva_sigdeliver(void) /* Deliver the signals */ - sigdeliver(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original diff --git a/arch/or1k/src/common/or1k_schedulesigaction.c b/arch/or1k/src/common/or1k_schedulesigaction.c index 305e3de998c..af1b9ebdd8e 100644 --- a/arch/or1k/src/common/or1k_schedulesigaction.c +++ b/arch/or1k/src/common/or1k_schedulesigaction.c @@ -34,6 +34,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "or1k_internal.h" /**************************************************************************** @@ -95,8 +96,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/renesas/src/m16c/m16c_schedulesigaction.c b/arch/renesas/src/m16c/m16c_schedulesigaction.c index a71bc1dff13..e33735f56d7 100644 --- a/arch/renesas/src/m16c/m16c_schedulesigaction.c +++ b/arch/renesas/src/m16c/m16c_schedulesigaction.c @@ -34,6 +34,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "renesas_internal.h" /**************************************************************************** @@ -95,8 +96,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/renesas/src/m16c/m16c_sigdeliver.c b/arch/renesas/src/m16c/m16c_sigdeliver.c index 1f9fa0ea0bb..6ab5448b4cb 100644 --- a/arch/renesas/src/m16c/m16c_sigdeliver.c +++ b/arch/renesas/src/m16c/m16c_sigdeliver.c @@ -36,6 +36,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "renesas_internal.h" /**************************************************************************** @@ -59,9 +60,9 @@ void renesas_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -77,7 +78,7 @@ void renesas_sigdeliver(void) /* Deliver the signal */ - (sig_rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -100,7 +101,10 @@ void renesas_sigdeliver(void) regs[REG_PC] = rtcb->xcp.saved_pc[0]; regs[REG_PC + 1] = rtcb->xcp.saved_pc[1]; regs[REG_FLG] = rtcb->xcp.saved_flg; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of * execution. diff --git a/arch/renesas/src/rx65n/rx65n_schedulesigaction.c b/arch/renesas/src/rx65n/rx65n_schedulesigaction.c index 67403ff0893..8e5e3fc5a39 100644 --- a/arch/renesas/src/rx65n/rx65n_schedulesigaction.c +++ b/arch/renesas/src/rx65n/rx65n_schedulesigaction.c @@ -34,6 +34,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "renesas_internal.h" /**************************************************************************** @@ -95,8 +96,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/renesas/src/rx65n/rx65n_sigdeliver.c b/arch/renesas/src/rx65n/rx65n_sigdeliver.c index 300c55dca86..5ebdec8f231 100644 --- a/arch/renesas/src/rx65n/rx65n_sigdeliver.c +++ b/arch/renesas/src/rx65n/rx65n_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "renesas_internal.h" /**************************************************************************** @@ -57,13 +58,12 @@ void renesas_sigdeliver(void) { struct tcb_s *rtcb = this_task(); uint32_t regs[XCPTCONTEXT_REGS]; - sig_deliver_t sigdeliver; board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the real return state on the stack. */ @@ -77,8 +77,7 @@ void renesas_sigdeliver(void) * signals. */ - sigdeliver = rtcb->sigdeliver; - rtcb->sigdeliver = NULL; + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; #ifndef CONFIG_SUPPRESS_INTERRUPTS /* Then make sure that interrupts are enabled. Signal handlers must always @@ -90,7 +89,7 @@ void renesas_sigdeliver(void) /* Deliver the signals */ - sigdeliver(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original diff --git a/arch/renesas/src/sh1/sh1_schedulesigaction.c b/arch/renesas/src/sh1/sh1_schedulesigaction.c index b6ab7721f1d..80db3ee703c 100644 --- a/arch/renesas/src/sh1/sh1_schedulesigaction.c +++ b/arch/renesas/src/sh1/sh1_schedulesigaction.c @@ -34,6 +34,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "renesas_internal.h" /**************************************************************************** @@ -95,8 +96,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/renesas/src/sh1/sh1_sigdeliver.c b/arch/renesas/src/sh1/sh1_sigdeliver.c index d6d6e542d18..0487eed1648 100644 --- a/arch/renesas/src/sh1/sh1_sigdeliver.c +++ b/arch/renesas/src/sh1/sh1_sigdeliver.c @@ -36,6 +36,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "renesas_internal.h" /**************************************************************************** @@ -59,9 +60,9 @@ void renesas_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -77,7 +78,7 @@ void renesas_sigdeliver(void) /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -97,9 +98,12 @@ void renesas_sigdeliver(void) * could be modified by a hostile program. */ - regs[REG_PC] = rtcb->xcp.saved_pc; - regs[REG_SR] = rtcb->xcp.saved_sr; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + regs[REG_PC] = rtcb->xcp.saved_pc; + regs[REG_SR] = rtcb->xcp.saved_sr; + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/risc-v/src/common/riscv_schedulesigaction.c b/arch/risc-v/src/common/riscv_schedulesigaction.c index ffc9d4d17e1..7b3b3ad3023 100644 --- a/arch/risc-v/src/common/riscv_schedulesigaction.c +++ b/arch/risc-v/src/common/riscv_schedulesigaction.c @@ -36,6 +36,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "riscv_internal.h" /**************************************************************************** @@ -95,8 +96,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handler will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else { diff --git a/arch/risc-v/src/common/riscv_sigdeliver.c b/arch/risc-v/src/common/riscv_sigdeliver.c index 6193fb7f2ac..ad6c575ee83 100644 --- a/arch/risc-v/src/common/riscv_sigdeliver.c +++ b/arch/risc-v/src/common/riscv_sigdeliver.c @@ -39,6 +39,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "riscv_internal.h" /**************************************************************************** * Public Functions @@ -70,9 +71,9 @@ void riscv_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -104,7 +105,7 @@ retry: /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -149,7 +150,7 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of * execution. diff --git a/arch/sim/src/sim/sim_schedulesigaction.c b/arch/sim/src/sim/sim_schedulesigaction.c index 32ce5f09e73..d66f7e9bf97 100644 --- a/arch/sim/src/sim/sim_schedulesigaction.c +++ b/arch/sim/src/sim/sim_schedulesigaction.c @@ -32,6 +32,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" /**************************************************************************** * Public Functions @@ -81,7 +82,7 @@ void up_schedule_sigaction(struct tcb_s *tcb) if (tcb == this_task()) { - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } } diff --git a/arch/sim/src/sim/sim_sigdeliver.c b/arch/sim/src/sim/sim_sigdeliver.c index e70ec25dbc1..09cb5b421ad 100644 --- a/arch/sim/src/sim/sim_sigdeliver.c +++ b/arch/sim/src/sim/sim_sigdeliver.c @@ -35,6 +35,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "sim_internal.h" /**************************************************************************** @@ -63,7 +64,7 @@ void sim_sigdeliver(void) int16_t saved_irqcount; irqstate_t flags; #endif - if (NULL == (rtcb->sigdeliver)) + if ((rtcb->flags & TCB_FLAG_SIGDELIVER) == 0) { return; } @@ -76,9 +77,9 @@ void sim_sigdeliver(void) flags = enter_critical_section(); #endif - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* NOTE: we do not save the return state for sim */ @@ -105,7 +106,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -137,7 +138,7 @@ retry: /* Allows next handler to be scheduled */ - rtcb->sigdeliver = NULL; + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* NOTE: we leave a critical section here for sim */ diff --git a/arch/sparc/src/sparc_v8/sparc_v8_schedulesigaction.c b/arch/sparc/src/sparc_v8/sparc_v8_schedulesigaction.c index 543bf7b6cae..d4ec8409ce7 100644 --- a/arch/sparc/src/sparc_v8/sparc_v8_schedulesigaction.c +++ b/arch/sparc/src/sparc_v8/sparc_v8_schedulesigaction.c @@ -34,6 +34,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "sparc_internal.h" /**************************************************************************** @@ -93,8 +94,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the @@ -192,8 +193,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handler will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: The task that needs to receive the signal is running. diff --git a/arch/sparc/src/sparc_v8/sparc_v8_sigdeliver.c b/arch/sparc/src/sparc_v8/sparc_v8_sigdeliver.c index dab8abe8ac7..71da93a4504 100644 --- a/arch/sparc/src/sparc_v8/sparc_v8_sigdeliver.c +++ b/arch/sparc/src/sparc_v8/sparc_v8_sigdeliver.c @@ -38,6 +38,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "sparc_internal.h" /**************************************************************************** @@ -78,9 +79,9 @@ void sparc_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -116,7 +117,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -168,7 +169,7 @@ retry: regs[REG_PC] = rtcb->xcp.saved_pc; regs[REG_NPC] = rtcb->xcp.saved_npc; regs[REG_PSR] = rtcb->xcp.saved_status; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; #ifdef CONFIG_SMP /* Restore the saved 'irqcount' and recover the critical section diff --git a/arch/tricore/src/common/tricore_schedulesigaction.c b/arch/tricore/src/common/tricore_schedulesigaction.c index ffac299f1ac..33d6bba300b 100644 --- a/arch/tricore/src/common/tricore_schedulesigaction.c +++ b/arch/tricore/src/common/tricore_schedulesigaction.c @@ -36,6 +36,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "tricore_internal.h" /**************************************************************************** @@ -94,8 +95,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the diff --git a/arch/tricore/src/common/tricore_sigdeliver.c b/arch/tricore/src/common/tricore_sigdeliver.c index 5149dec75ba..3f950883877 100644 --- a/arch/tricore/src/common/tricore_sigdeliver.c +++ b/arch/tricore/src/common/tricore_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "tricore_internal.h" /**************************************************************************** @@ -60,9 +61,9 @@ void tricore_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: @@ -76,7 +77,7 @@ retry: /* Deliver the signal */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -108,7 +109,7 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of * execution. diff --git a/arch/x86/src/i486/i486_schedulesigaction.c b/arch/x86/src/i486/i486_schedulesigaction.c index 724b7594c28..245eb16409e 100644 --- a/arch/x86/src/i486/i486_schedulesigaction.c +++ b/arch/x86/src/i486/i486_schedulesigaction.c @@ -34,6 +34,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "x86_internal.h" /**************************************************************************** @@ -91,8 +92,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the interrupted task diff --git a/arch/x86/src/i486/i486_sigdeliver.c b/arch/x86/src/i486/i486_sigdeliver.c index a0803a1084a..d25432f385d 100644 --- a/arch/x86/src/i486/i486_sigdeliver.c +++ b/arch/x86/src/i486/i486_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "x86_internal.h" /**************************************************************************** @@ -60,9 +61,9 @@ void x86_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -78,7 +79,7 @@ void x86_sigdeliver(void) /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -100,7 +101,10 @@ void x86_sigdeliver(void) regs[REG_EIP] = rtcb->xcp.saved_eip; regs[REG_EFLAGS] = rtcb->xcp.saved_eflags; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/x86_64/src/intel64/intel64_schedulesigaction.c b/arch/x86_64/src/intel64/intel64_schedulesigaction.c index 797c9f3a69d..6fbddee6fbd 100644 --- a/arch/x86_64/src/intel64/intel64_schedulesigaction.c +++ b/arch/x86_64/src/intel64/intel64_schedulesigaction.c @@ -34,6 +34,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "x86_64_internal.h" /**************************************************************************** @@ -83,8 +84,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) if (tcb == this_task() && !up_interrupt_context()) { - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* Otherwise, we are (1) signaling a task is not running from an diff --git a/arch/x86_64/src/intel64/intel64_sigdeliver.c b/arch/x86_64/src/intel64/intel64_sigdeliver.c index b9c173e8937..11c6abfe0d1 100644 --- a/arch/x86_64/src/intel64/intel64_sigdeliver.c +++ b/arch/x86_64/src/intel64/intel64_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "x86_64_internal.h" /**************************************************************************** @@ -70,9 +71,9 @@ void x86_64_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Align regs to 64 byte boundary for XSAVE */ @@ -115,7 +116,7 @@ void x86_64_sigdeliver(void) /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -143,7 +144,10 @@ void x86_64_sigdeliver(void) regs[REG_RIP] = rtcb->xcp.saved_rip; regs[REG_RSP] = rtcb->xcp.saved_rsp; regs[REG_RFLAGS] = rtcb->xcp.saved_rflags; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; #ifdef CONFIG_SMP /* Restore the saved 'irqcount' and recover the critical section diff --git a/arch/xtensa/src/common/xtensa_schedsigaction.c b/arch/xtensa/src/common/xtensa_schedsigaction.c index 421d8e7e176..f3db7c029ba 100644 --- a/arch/xtensa/src/common/xtensa_schedsigaction.c +++ b/arch/xtensa/src/common/xtensa_schedsigaction.c @@ -36,6 +36,7 @@ #include "irq/irq.h" #include "sched/sched.h" +#include "signal/signal.h" #include "chip.h" #include "xtensa.h" @@ -95,8 +96,8 @@ void up_schedule_sigaction(struct tcb_s *tcb) * REVISIT: Signal handler will run in a critical section! */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } else { diff --git a/arch/xtensa/src/common/xtensa_sigdeliver.c b/arch/xtensa/src/common/xtensa_sigdeliver.c index c0914df6894..c754918504a 100644 --- a/arch/xtensa/src/common/xtensa_sigdeliver.c +++ b/arch/xtensa/src/common/xtensa_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "xtensa.h" /**************************************************************************** @@ -69,9 +70,9 @@ void xtensa_sig_deliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); retry: #ifdef CONFIG_SMP @@ -104,7 +105,7 @@ retry: /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -148,7 +149,9 @@ retry: * could be modified by a hostile program. */ - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/z16/src/common/z16_schedulesigaction.c b/arch/z16/src/common/z16_schedulesigaction.c index 5a628ad5860..fa7d6bb2fbb 100644 --- a/arch/z16/src/common/z16_schedulesigaction.c +++ b/arch/z16/src/common/z16_schedulesigaction.c @@ -34,6 +34,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "z16_internal.h" /**************************************************************************** @@ -95,8 +96,8 @@ void up_schedule_sigaction(FAR struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the interrupted diff --git a/arch/z16/src/common/z16_sigdeliver.c b/arch/z16/src/common/z16_sigdeliver.c index f8203505953..067b7a4ddcc 100644 --- a/arch/z16/src/common/z16_sigdeliver.c +++ b/arch/z16/src/common/z16_sigdeliver.c @@ -37,6 +37,7 @@ #include #include "sched/sched.h" +#include "signal/signal.h" #include "z16_internal.h" /**************************************************************************** @@ -61,9 +62,9 @@ void z16_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -79,7 +80,7 @@ void z16_sigdeliver(void) /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -101,7 +102,7 @@ void z16_sigdeliver(void) regs32[REG_PC / 2] = rtcb->xcp.saved_pc; regs[REG_FLAGS] = rtcb->xcp.saved_i; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/z80/src/ez80/ez80_schedulesigaction.c b/arch/z80/src/ez80/ez80_schedulesigaction.c index 2b5cf925aa7..097d3274fe7 100644 --- a/arch/z80/src/ez80/ez80_schedulesigaction.c +++ b/arch/z80/src/ez80/ez80_schedulesigaction.c @@ -35,6 +35,7 @@ #include "chip/switch.h" #include "sched/sched.h" +#include "signal/signal.h" #include "z80_internal.h" /**************************************************************************** @@ -119,8 +120,8 @@ void up_schedule_sigaction(FAR struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the interrupted task diff --git a/arch/z80/src/ez80/ez80_sigdeliver.c b/arch/z80/src/ez80/ez80_sigdeliver.c index ce22d2249f1..0fb49dbfb00 100644 --- a/arch/z80/src/ez80/ez80_sigdeliver.c +++ b/arch/z80/src/ez80/ez80_sigdeliver.c @@ -39,6 +39,7 @@ #include "chip/switch.h" #include "sched/sched.h" +#include "signal/signal.h" #include "z80_internal.h" /**************************************************************************** @@ -62,9 +63,9 @@ void z80_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -80,7 +81,7 @@ void z80_sigdeliver(void) /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -100,9 +101,12 @@ void z80_sigdeliver(void) * could be modified by a hostile program. */ - regs[XCPT_PC] = rtcb->xcp.saved_pc; - regs[XCPT_I] = rtcb->xcp.saved_i; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + regs[XCPT_PC] = rtcb->xcp.saved_pc; + regs[XCPT_I] = rtcb->xcp.saved_i; + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Modify the saved return state with the actual saved values in the * TCB. This depends on the fact that nested signal handling is diff --git a/arch/z80/src/z180/z180_schedulesigaction.c b/arch/z80/src/z180/z180_schedulesigaction.c index fe072f14247..45fdba2cd3a 100644 --- a/arch/z80/src/z180/z180_schedulesigaction.c +++ b/arch/z80/src/z180/z180_schedulesigaction.c @@ -38,6 +38,7 @@ #include "switch.h" #include "sched/sched.h" +#include "signal/signal.h" #include "z80_internal.h" /**************************************************************************** @@ -122,8 +123,8 @@ void up_schedule_sigaction(FAR struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the interrupted task diff --git a/arch/z80/src/z180/z180_sigdeliver.c b/arch/z80/src/z180/z180_sigdeliver.c index 5f4a3599908..7876b235f4a 100644 --- a/arch/z80/src/z180/z180_sigdeliver.c +++ b/arch/z80/src/z180/z180_sigdeliver.c @@ -36,6 +36,7 @@ #include "chip/switch.h" #include "sched/sched.h" +#include "signal/signal.h" #include "z80_internal.h" /**************************************************************************** @@ -59,9 +60,9 @@ void z80_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -77,7 +78,7 @@ void z80_sigdeliver(void) /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -97,9 +98,12 @@ void z80_sigdeliver(void) * could be modified by a hostile program. */ - regs[XCPT_PC] = rtcb->xcp.saved_pc; - regs[XCPT_I] = rtcb->xcp.saved_i; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + regs[XCPT_PC] = rtcb->xcp.saved_pc; + regs[XCPT_I] = rtcb->xcp.saved_i; + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/z80/src/z8/z8_schedulesigaction.c b/arch/z80/src/z8/z8_schedulesigaction.c index 39720960185..7cb92545604 100644 --- a/arch/z80/src/z8/z8_schedulesigaction.c +++ b/arch/z80/src/z8/z8_schedulesigaction.c @@ -35,6 +35,7 @@ #include "chip/switch.h" #include "sched/sched.h" +#include "signal/signal.h" #include "z80_internal.h" /**************************************************************************** @@ -119,8 +120,8 @@ void up_schedule_sigaction(FAR struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the interrupted task diff --git a/arch/z80/src/z8/z8_sigdeliver.c b/arch/z80/src/z8/z8_sigdeliver.c index 257b512e331..d7fd8c9e428 100644 --- a/arch/z80/src/z8/z8_sigdeliver.c +++ b/arch/z80/src/z8/z8_sigdeliver.c @@ -36,6 +36,7 @@ #include "chip/switch.h" #include "sched/sched.h" +#include "signal/signal.h" #include "z80_internal.h" /**************************************************************************** @@ -78,9 +79,9 @@ void z80_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -96,7 +97,7 @@ void z80_sigdeliver(void) /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -118,7 +119,10 @@ void z80_sigdeliver(void) regs[XCPT_PC] = rtcb->xcp.saved_pc; regs[XCPT_IRQCTL] = rtcb->xcp.saved_irqctl; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/arch/z80/src/z80/z80_schedulesigaction.c b/arch/z80/src/z80/z80_schedulesigaction.c index a8d93fd1f9b..51bebe3ebfd 100644 --- a/arch/z80/src/z80/z80_schedulesigaction.c +++ b/arch/z80/src/z80/z80_schedulesigaction.c @@ -36,6 +36,7 @@ #include "chip/switch.h" #include "sched/sched.h" +#include "signal/signal.h" #include "z80_internal.h" /**************************************************************************** @@ -120,8 +121,8 @@ void up_schedule_sigaction(FAR struct tcb_s *tcb) { /* In this case just deliver the signal now. */ - (tcb->sigdeliver)(tcb); - tcb->sigdeliver = NULL; + nxsig_deliver(tcb); + tcb->flags &= ~TCB_FLAG_SIGDELIVER; } /* CASE 2: We are in an interrupt handler AND the interrupted task diff --git a/arch/z80/src/z80/z80_sigdeliver.c b/arch/z80/src/z80/z80_sigdeliver.c index 5afdd263f1f..ec99b001169 100644 --- a/arch/z80/src/z80/z80_sigdeliver.c +++ b/arch/z80/src/z80/z80_sigdeliver.c @@ -36,6 +36,7 @@ #include "chip/switch.h" #include "sched/sched.h" +#include "signal/signal.h" #include "z80_internal.h" /**************************************************************************** @@ -59,9 +60,9 @@ void z80_sigdeliver(void) board_autoled_on(LED_SIGNAL); - sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n", - rtcb, rtcb->sigdeliver, rtcb->sigpendactionq.head); - DEBUGASSERT(rtcb->sigdeliver != NULL); + sinfo("rtcb=%p sigpendactionq.head=%p\n", + rtcb, rtcb->sigpendactionq.head); + DEBUGASSERT((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0); /* Save the return state on the stack. */ @@ -77,7 +78,7 @@ void z80_sigdeliver(void) /* Deliver the signals */ - (rtcb->sigdeliver)(rtcb); + nxsig_deliver(rtcb); /* Output any debug messages BEFORE restoring errno (because they may * alter errno), then disable interrupts again and restore the original @@ -97,9 +98,12 @@ void z80_sigdeliver(void) * could be modified by a hostile program. */ - regs[XCPT_PC] = rtcb->xcp.saved_pc; - regs[XCPT_I] = rtcb->xcp.saved_i; - rtcb->sigdeliver = NULL; /* Allows next handler to be scheduled */ + regs[XCPT_PC] = rtcb->xcp.saved_pc; + regs[XCPT_I] = rtcb->xcp.saved_i; + + /* Allows next handler to be scheduled */ + + rtcb->flags &= ~TCB_FLAG_SIGDELIVER; /* Then restore the correct state for this thread of execution. */ diff --git a/drivers/syslog/syslog_write.c b/drivers/syslog/syslog_write.c index 285f7547ab4..991605b27d4 100644 --- a/drivers/syslog/syslog_write.c +++ b/drivers/syslog/syslog_write.c @@ -68,7 +68,7 @@ static bool syslog_safe_to_block(void) /* It's not safe to block if a signal is being delivered */ rtcb = nxsched_self(); - if (rtcb->sigdeliver != NULL) + if ((rtcb->flags & TCB_FLAG_SIGDELIVER) != 0) { return false; } diff --git a/include/nuttx/sched.h b/include/nuttx/sched.h index 7f57396f37b..916b4e2b820 100644 --- a/include/nuttx/sched.h +++ b/include/nuttx/sched.h @@ -118,22 +118,23 @@ # define TCB_FLAG_TTYPE_TASK (0 << TCB_FLAG_TTYPE_SHIFT) /* Normal user task */ # define TCB_FLAG_TTYPE_PTHREAD (1 << TCB_FLAG_TTYPE_SHIFT) /* User pthread */ # define TCB_FLAG_TTYPE_KERNEL (2 << TCB_FLAG_TTYPE_SHIFT) /* Kernel thread */ -#define TCB_FLAG_POLICY_SHIFT (3) /* Bit 3-4: Scheduling policy */ +#define TCB_FLAG_POLICY_SHIFT (2) /* Bit 2-3: Scheduling policy */ #define TCB_FLAG_POLICY_MASK (3 << TCB_FLAG_POLICY_SHIFT) # define TCB_FLAG_SCHED_FIFO (0 << TCB_FLAG_POLICY_SHIFT) /* FIFO scheding policy */ # define TCB_FLAG_SCHED_RR (1 << TCB_FLAG_POLICY_SHIFT) /* Round robin scheding policy */ # define TCB_FLAG_SCHED_SPORADIC (2 << TCB_FLAG_POLICY_SHIFT) /* Sporadic scheding policy */ -#define TCB_FLAG_CPU_LOCKED (1 << 5) /* Bit 5: Locked to this CPU */ -#define TCB_FLAG_SIGNAL_ACTION (1 << 6) /* Bit 6: In a signal handler */ -#define TCB_FLAG_SYSCALL (1 << 7) /* Bit 7: In a system call */ -#define TCB_FLAG_EXIT_PROCESSING (1 << 8) /* Bit 8: Exitting */ -#define TCB_FLAG_FREE_STACK (1 << 9) /* Bit 9: Free stack after exit */ -#define TCB_FLAG_HEAP_CHECK (1 << 10) /* Bit 10: Heap check */ -#define TCB_FLAG_HEAP_DUMP (1 << 11) /* Bit 11: Heap dump */ -#define TCB_FLAG_DETACHED (1 << 12) /* Bit 12: Pthread detached */ -#define TCB_FLAG_FORCED_CANCEL (1 << 13) /* Bit 13: Pthread cancel is forced */ -#define TCB_FLAG_JOIN_COMPLETED (1 << 14) /* Bit 14: Pthread join completed */ -#define TCB_FLAG_FREE_TCB (1 << 15) /* Bit 15: Free tcb after exit */ +#define TCB_FLAG_CPU_LOCKED (1 << 4) /* Bit 4: Locked to this CPU */ +#define TCB_FLAG_SIGNAL_ACTION (1 << 5) /* Bit 5: In a signal handler */ +#define TCB_FLAG_SYSCALL (1 << 6) /* Bit 6: In a system call */ +#define TCB_FLAG_EXIT_PROCESSING (1 << 7) /* Bit 7: Exitting */ +#define TCB_FLAG_FREE_STACK (1 << 8) /* Bit 8: Free stack after exit */ +#define TCB_FLAG_HEAP_CHECK (1 << 9) /* Bit 9: Heap check */ +#define TCB_FLAG_HEAP_DUMP (1 << 10) /* Bit 10: Heap dump */ +#define TCB_FLAG_DETACHED (1 << 11) /* Bit 11: Pthread detached */ +#define TCB_FLAG_FORCED_CANCEL (1 << 12) /* Bit 12: Pthread cancel is forced */ +#define TCB_FLAG_JOIN_COMPLETED (1 << 13) /* Bit 13: Pthread join completed */ +#define TCB_FLAG_FREE_TCB (1 << 14) /* Bit 14: Free tcb after exit */ +#define TCB_FLAG_SIGDELIVER (1 << 15) /* Bit 15: Deliver pending signals */ /* Values for struct task_group tg_flags */ @@ -303,7 +304,6 @@ typedef enum tstate_e tstate_t; /* The following is the form of a thread start-up function */ typedef CODE void (*start_t)(void); -typedef CODE void (*sig_deliver_t)(FAR struct tcb_s *tcb); /* This is the entry point into the main thread of the task or into a created * pthread within the task. @@ -721,11 +721,6 @@ struct tcb_s struct xcptcontext xcp; /* Interrupt register save area */ - /* The following function pointer is non-zero if there are pending signals - * to be processed. - */ - - sig_deliver_t sigdeliver; #if CONFIG_TASK_NAME_SIZE > 0 char name[CONFIG_TASK_NAME_SIZE + 1]; /* Task name (with NUL terminator) */ #endif diff --git a/sched/signal/sig_dispatch.c b/sched/signal/sig_dispatch.c index d4404d7ac33..8bea2d26181 100644 --- a/sched/signal/sig_dispatch.c +++ b/sched/signal/sig_dispatch.c @@ -86,7 +86,7 @@ static int sig_handler(FAR void *cookie) tcb->flags &= ~TCB_FLAG_CPU_LOCKED; } - if (tcb->sigdeliver) + if ((tcb->flags & TCB_FLAG_SIGDELIVER) != 0) { up_schedule_sigaction(tcb); } @@ -160,13 +160,13 @@ static int nxsig_queue_action(FAR struct tcb_s *stcb, siginfo_t *info) * up_schedule_sigaction() */ - if (!stcb->sigdeliver) + if ((stcb->flags & TCB_FLAG_SIGDELIVER) == 0) { #ifdef CONFIG_SMP int cpu = stcb->cpu; int me = this_cpu(); - stcb->sigdeliver = nxsig_deliver; + stcb->flags |= TCB_FLAG_SIGDELIVER; if (cpu != me && stcb->task_state == TSTATE_TASK_RUNNING) { struct sig_arg_s arg; @@ -190,7 +190,7 @@ static int nxsig_queue_action(FAR struct tcb_s *stcb, siginfo_t *info) else #endif { - stcb->sigdeliver = nxsig_deliver; + stcb->flags |= TCB_FLAG_SIGDELIVER; up_schedule_sigaction(stcb); } }