sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Revert "irq: add [enter|leave]_critical_section_nonirq"

Browse Source 
This reverts commit 1c5a0bf6cc.

Signed-off-by: hujun5 <hujun5@xiaomi.com>
This commit is contained in:
hujun5 2024-09-16 11:35:18 +08:00 committed by Xiang Xiao
parent 03b0b05c69
commit a2c704a84a
7 changed files with 153 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/nuttx/irq.h
View File

@ -258,10 +258,8 @@ int irqchain_detach(int irq, xcpt_t isr, FAR void *arg);
****************************************************************************/
#ifdef CONFIG_IRQCOUNT
irqstate_t enter_critical_section_nonirq(void) noinstrument_function;
irqstate_t enter_critical_section(void) noinstrument_function;
#else
# define enter_critical_section_nonirq() up_irq_save()
# define enter_critical_section() up_irq_save()
#endif
@ -290,10 +288,8 @@ irqstate_t enter_critical_section(void) noinstrument_function;
****************************************************************************/
#ifdef CONFIG_IRQCOUNT
void leave_critical_section_nonirq(irqstate_t flags) noinstrument_function;
void leave_critical_section(irqstate_t flags) noinstrument_function;
#else
# define leave_critical_section_nonirq(f) up_irq_restore(f)
# define leave_critical_section(f) up_irq_restore(f)
#endif

117
sched/irq/irq_csection.c
View File

@ -182,13 +182,24 @@ static inline_function bool irq_waitlock(int cpu)
#ifdef CONFIG_SMP
irqstate_t enter_critical_section(void)
{
FAR struct tcb_s *rtcb;
irqstate_t ret;
int cpu;
/* Verify that the system has sufficiently initialized so that the task
* lists are valid.
/* Disable interrupts.
*
* NOTE 1: Ideally this should disable interrupts on all CPUs, but most
* architectures only support disabling interrupts on the local CPU.
* NOTE 2: Interrupts may already be disabled, but we call up_irq_save()
* unconditionally because we need to return valid interrupt status in any
* event.
* NOTE 3: We disable local interrupts BEFORE taking the spinlock in order
* to prevent possible waits on the spinlock from interrupt handling on
* the local CPU.
*/
DEBUGASSERT(OSINIT_TASK_READY());
try_again:
ret = up_irq_save();
/* If called from an interrupt handler, then just take the spinlock.
* If we are already in a critical section, this will lock the CPU
@ -303,43 +314,9 @@ try_again_in_irq:
DEBUGASSERT(spin_is_locked(&g_cpu_irqlock) &&
(g_cpu_irqset & (1 << cpu)) != 0);
}
return 0;
}
else
{
return enter_critical_section_nonirq();
}
}
inline_function irqstate_t enter_critical_section_nonirq(void)
{
FAR struct tcb_s *rtcb;
irqstate_t ret;
int cpu;
/* Disable interrupts.
*
* NOTE 1: Ideally this should disable interrupts on all CPUs, but most
* architectures only support disabling interrupts on the local CPU.
* NOTE 2: Interrupts may already be disabled, but we call up_irq_save()
* unconditionally because we need to return valid interrupt status in any
* event.
* NOTE 3: We disable local interrupts BEFORE taking the spinlock in order
* to prevent possible waits on the spinlock from interrupt handling on
* the local CPU.
*/
try_again:
ret = up_irq_save();
/* Verify that the system has sufficiently initialized so that the task
* lists are valid.
*/
DEBUGASSERT(OSINIT_TASK_READY());
DEBUGASSERT(!up_interrupt_context());
/* Normal tasking environment.
*
* Get the TCB of the currently executing task on this CPU (avoid
@ -412,6 +389,7 @@ try_again:
sched_note_csection(rtcb, true);
#endif
}
}
/* Return interrupt status */
@ -422,41 +400,17 @@ try_again:
irqstate_t enter_critical_section(void)
{
/* Verify that the system has sufficiently initialized so that the task
* lists are valid.
*/
DEBUGASSERT(OSINIT_TASK_READY());
/* Check if we were called from an interrupt handler */
if (!up_interrupt_context())
{
return enter_critical_section_nonirq();
}
/* Return interrupt status */
return 0;
}
inline_function irqstate_t enter_critical_section_nonirq(void)
{
FAR struct tcb_s *rtcb;
irqstate_t ret;
/* Disable interrupts */
ret = up_irq_save();
/* Verify that the system has sufficiently initialized so that the task
* lists are valid.
*/
/* Check if we were called from an interrupt handler */
DEBUGASSERT(OSINIT_TASK_READY());
DEBUGASSERT(!up_interrupt_context());
rtcb = this_task();
if (!up_interrupt_context())
{
FAR struct tcb_s *rtcb = this_task();
DEBUGASSERT(rtcb != NULL);
/* Have we just entered the critical section? Or is this a nested
@ -466,6 +420,8 @@ inline_function irqstate_t enter_critical_section_nonirq(void)
DEBUGASSERT(rtcb->irqcount >= 0 && rtcb->irqcount < INT16_MAX);
if (++rtcb->irqcount == 1)
{
/* Note that we have entered the critical section */
#ifdef CONFIG_SCHED_CRITMONITOR
nxsched_critmon_csection(rtcb, true);
#endif
@ -473,6 +429,7 @@ inline_function irqstate_t enter_critical_section_nonirq(void)
sched_note_csection(rtcb, true);
#endif
}
}
/* Return interrupt status */
@ -492,7 +449,6 @@ inline_function irqstate_t enter_critical_section_nonirq(void)
#ifdef CONFIG_SMP
void leave_critical_section(irqstate_t flags)
{
FAR struct tcb_s *rtcb;
int cpu;
/* If called from an interrupt handler, then just release the
@ -525,7 +481,7 @@ void leave_critical_section(irqstate_t flags)
DEBUGASSERT(spin_is_locked(&g_cpu_irqlock) &&
g_cpu_nestcount[cpu] == 1);
rtcb = current_task(cpu);
FAR struct tcb_s *rtcb = current_task(cpu);
DEBUGASSERT(rtcb != NULL);
DEBUGASSERT((g_cpu_irqset & (1 << cpu)) != 0);
@ -539,17 +495,7 @@ void leave_critical_section(irqstate_t flags)
}
else
{
leave_critical_section_nonirq(flags);
}
}
inline_function void leave_critical_section_nonirq(irqstate_t flags)
{
FAR struct tcb_s *rtcb;
int cpu;
DEBUGASSERT(OSINIT_TASK_READY());
DEBUGASSERT(!up_interrupt_context());
/* Get the TCB of the currently executing task on this CPU (avoid
* using this_task() which can recurse.
@ -600,6 +546,11 @@ inline_function void leave_critical_section_nonirq(irqstate_t flags)
/* Have all CPUs released the lock? */
}
}
/* Restore the previous interrupt state which may still be interrupts
* disabled (but we don't have a mechanism to verify that now)
*/
up_irq_restore(flags);
}
@ -614,16 +565,7 @@ void leave_critical_section(irqstate_t flags)
if (!up_interrupt_context())
{
leave_critical_section_nonirq(flags);
}
}
inline_function void leave_critical_section_nonirq(irqstate_t flags)
{
FAR struct tcb_s *rtcb = this_task();
DEBUGASSERT(OSINIT_TASK_READY());
DEBUGASSERT(!up_interrupt_context());
DEBUGASSERT(rtcb != NULL);
/* Have we left entered the critical section? Or are we still
@ -642,6 +584,9 @@ inline_function void leave_critical_section_nonirq(irqstate_t flags)
sched_note_csection(rtcb, false);
#endif
}
}
/* Restore the previous interrupt state. */
up_irq_restore(flags);
}

4
sched/mqueue/mq_receive.c
View File

@ -98,7 +98,7 @@ ssize_t file_mq_receive(FAR struct file *mq, FAR char *msg, size_t msglen,
* because messages can be sent from interrupt level.
*/
flags = enter_critical_section_nonirq();
flags = enter_critical_section();
/* Get the message from the message queue */
@ -116,7 +116,7 @@ ssize_t file_mq_receive(FAR struct file *mq, FAR char *msg, size_t msglen,
ret = nxmq_do_receive(msgq, mqmsg, msg, prio);
}
leave_critical_section_nonirq(flags);
leave_critical_section(flags);
return ret;
}

4
sched/mqueue/mq_timedreceive.c
View File

@ -158,7 +158,7 @@ file_mq_timedreceive_internal(FAR struct file *mq, FAR char *msg,
* because messages can be sent from interrupt level.
*/
flags = enter_critical_section_nonirq();
flags = enter_critical_section();
/* Check if the message queue is empty. If it is NOT empty, then we
* will not need to start timer.
@ -233,7 +233,7 @@ file_mq_timedreceive_internal(FAR struct file *mq, FAR char *msg,
/* We can now restore interrupts */
errout_in_critical_section:
leave_critical_section_nonirq(flags);
leave_critical_section(flags);
return ret;
}

4
sched/semaphore/sem_clockwait.c
View File

@ -108,7 +108,7 @@ int nxsem_clockwait(FAR sem_t *sem, clockid_t clockid,
* enabled while we are blocked waiting for the semaphore.
*/
flags = enter_critical_section_nonirq();
flags = enter_critical_section();
/* Try to take the semaphore without waiting. */
@ -166,7 +166,7 @@ int nxsem_clockwait(FAR sem_t *sem, clockid_t clockid,
/* We can now restore interrupts and delete the watchdog */
out:
leave_critical_section_nonirq(flags);
leave_critical_section(flags);
return ret;
}

4
sched/semaphore/sem_tickwait.c
View File

@ -82,7 +82,7 @@ int nxsem_tickwait(FAR sem_t *sem, uint32_t delay)
* enabled while we are blocked waiting for the semaphore.
*/
flags = enter_critical_section_nonirq();
flags = enter_critical_section();
/* Try to take the semaphore without waiting. */
@ -120,7 +120,7 @@ int nxsem_tickwait(FAR sem_t *sem, uint32_t delay)
/* We can now restore interrupts */
out:
leave_critical_section_nonirq(flags);
leave_critical_section(flags);
return ret;
}

6
sched/semaphore/sem_wait.c
View File

@ -86,7 +86,7 @@ int nxsem_wait(FAR sem_t *sem)
* handler.
*/
flags = enter_critical_section_nonirq();
flags = enter_critical_section();
/* Make sure we were supplied with a valid semaphore. */
@ -99,7 +99,7 @@ int nxsem_wait(FAR sem_t *sem)
ret = nxsem_protect_wait(sem);
if (ret < 0)
{
leave_critical_section_nonirq(flags);
leave_critical_section(flags);
return ret;
}
@ -224,7 +224,7 @@ int nxsem_wait(FAR sem_t *sem)
#endif
}
leave_critical_section_nonirq(flags);
leave_critical_section(flags);
return ret;
}