diff options
Diffstat (limited to 'nuttx/arch')
170 files changed, 421 insertions, 421 deletions
diff --git a/nuttx/arch/8051/src/up_assert.c b/nuttx/arch/8051/src/up_assert.c index 5e59d6af0..f1f9bb87f 100644 --- a/nuttx/arch/8051/src/up_assert.c +++ b/nuttx/arch/8051/src/up_assert.c @@ -70,7 +70,7 @@ static void _up_assert(int errorcode) { /* Are we in an interrupt handler or the idle task? */ - if (g_irqtos || ((FAR _TCB*)g_readytorun.head)->pid == 0) + if (g_irqtos || ((FAR struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -100,7 +100,7 @@ static void _up_assert(int errorcode) void up_assert(const uint8_t *filename, int lineno) { #if CONFIG_TASK_NAME_SIZE > 0 - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -124,7 +124,7 @@ void up_assert(const uint8_t *filename, int lineno) void up_assert_code(const uint8_t *filename, int lineno, int errorcode) { #if CONFIG_TASK_NAME_SIZE > 0 - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/8051/src/up_blocktask.c b/nuttx/arch/8051/src/up_blocktask.c index 14dc371dd..554111ae0 100644 --- a/nuttx/arch/8051/src/up_blocktask.c +++ b/nuttx/arch/8051/src/up_blocktask.c @@ -83,7 +83,7 @@ * ************************************************************************/ -void up_block_task(FAR _TCB *tcb, tstate_t task_state) +void up_block_task(FAR struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -94,7 +94,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; bool switch_needed; dbg("Blocking TCB=%p\n", tcb); @@ -139,7 +139,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", rtcb); /* Then setup so that the context will be performed on exit @@ -160,7 +160,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/8051/src/up_exit.c b/nuttx/arch/8051/src/up_exit.c index 27b9fe138..c96467bf9 100644 --- a/nuttx/arch/8051/src/up_exit.c +++ b/nuttx/arch/8051/src/up_exit.c @@ -77,7 +77,7 @@ void _exit(int status) { - FAR _TCB* tcb; + FAR struct tcb_s* tcb; dbg("TCB=%p exitting\n", tcb); @@ -95,7 +95,7 @@ void _exit(int status) * head of the list. */ - tcb = (FAR _TCB*)g_readytorun.head; + tcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", tcb); /* Then switch contexts */ diff --git a/nuttx/arch/8051/src/up_initialize.c b/nuttx/arch/8051/src/up_initialize.c index b4835f4d1..c71b6c8df 100644 --- a/nuttx/arch/8051/src/up_initialize.c +++ b/nuttx/arch/8051/src/up_initialize.c @@ -68,7 +68,7 @@ volatile uint8_t g_irqtos; * during the interrupt handling, these registers will be * copied into the TCB again (NOTE: We could save a copy * if the interrupt handling logic saved the registers - * directly into (_TCB*)g_readytorun.head->xcp.regs). + * directly into (struct tcb_s*)g_readytorun.head->xcp.regs). */ uint8_t g_irqregs[REGS_SIZE]; diff --git a/nuttx/arch/8051/src/up_initialstate.c b/nuttx/arch/8051/src/up_initialstate.c index 85f172888..1defe9f55 100644 --- a/nuttx/arch/8051/src/up_initialstate.c +++ b/nuttx/arch/8051/src/up_initialstate.c @@ -74,7 +74,7 @@ * ************************************************************************/ -void up_initial_state(FAR _TCB *tcb) +void up_initial_state(FAR struct tcb_s *tcb) { FAR uint8_t *frame = tcb->xcp.stack; FAR uint8_t *regs = tcb->xcp.regs; diff --git a/nuttx/arch/8051/src/up_internal.h b/nuttx/arch/8051/src/up_internal.h index c213cc3d4..46f4ffb20 100644 --- a/nuttx/arch/8051/src/up_internal.h +++ b/nuttx/arch/8051/src/up_internal.h @@ -79,7 +79,7 @@ extern volatile uint8_t g_irqtos; * during the interrupt handling, these registers will be * copied into the TCB again (NOTE: We could save a copy * if the interrupt handling logic saved the registers - * directly into (_TCB*)g_readytorun.head->xcp.regs). + * directly into (struct tcb_s*)g_readytorun.head->xcp.regs). */ extern uint8_t g_irqregs[REGS_SIZE]; diff --git a/nuttx/arch/8051/src/up_releasepending.c b/nuttx/arch/8051/src/up_releasepending.c index 55f46edae..0d87608cf 100644 --- a/nuttx/arch/8051/src/up_releasepending.c +++ b/nuttx/arch/8051/src/up_releasepending.c @@ -76,7 +76,7 @@ void up_release_pending(void) { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("From TCB=%p\n", rtcb); @@ -102,7 +102,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", rtcb); /* Then setup so that the context will be performed on exit @@ -124,7 +124,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/8051/src/up_reprioritizertr.c b/nuttx/arch/8051/src/up_reprioritizertr.c index 0d1941f66..14c14e663 100644 --- a/nuttx/arch/8051/src/up_reprioritizertr.c +++ b/nuttx/arch/8051/src/up_reprioritizertr.c @@ -85,7 +85,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(FAR struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -103,7 +103,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; bool switch_needed; dbg("TCB=%p PRI=%d\n", tcb, priority); @@ -157,7 +157,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", rtcb); /* Then setup so that the context will be performed on exit @@ -178,7 +178,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/8051/src/up_unblocktask.c b/nuttx/arch/8051/src/up_unblocktask.c index 1c82236a5..f3f921549 100644 --- a/nuttx/arch/8051/src/up_unblocktask.c +++ b/nuttx/arch/8051/src/up_unblocktask.c @@ -80,7 +80,7 @@ * ************************************************************************/ -void up_unblock_task(FAR _TCB *tcb) +void up_unblock_task(FAR struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -91,7 +91,7 @@ void up_unblock_task(FAR _TCB *tcb) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("Unblocking TCB=%p\n", tcb); @@ -131,7 +131,7 @@ void up_unblock_task(FAR _TCB *tcb) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", rtcb); /* Then setup so that the context will be performed on exit @@ -154,7 +154,7 @@ void up_unblock_task(FAR _TCB *tcb) * g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; dbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/arm/src/arm/up_allocpage.c b/nuttx/arch/arm/src/arm/up_allocpage.c index 0284e48bc..8ec99b09c 100644 --- a/nuttx/arch/arm/src/arm/up_allocpage.c +++ b/nuttx/arch/arm/src/arm/up_allocpage.c @@ -165,7 +165,7 @@ static bool g_pgwrap; * ****************************************************************************/ -int up_allocpage(FAR _TCB *tcb, FAR void **vpage) +int up_allocpage(FAR struct tcb_s *tcb, FAR void **vpage) { uintptr_t vaddr; uintptr_t paddr; diff --git a/nuttx/arch/arm/src/arm/up_assert.c b/nuttx/arch/arm/src/arm/up_assert.c index 5f713c34d..d97aba5ea 100644 --- a/nuttx/arch/arm/src/arm/up_assert.c +++ b/nuttx/arch/arm/src/arm/up_assert.c @@ -161,7 +161,7 @@ static inline void up_registerdump(void) #ifdef CONFIG_ARCH_STACKDUMP static void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint32_t sp = up_getsp(); uint32_t ustackbase; uint32_t ustacksize; @@ -257,7 +257,7 @@ static void _up_assert(int errorcode) { /* Are we in an interrupt handler or the idle task? */ - if (current_regs || ((_TCB*)g_readytorun.head)->pid == 0) + if (current_regs || ((struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -287,7 +287,7 @@ static void _up_assert(int errorcode) void up_assert(const uint8_t *filename, int lineno) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -309,7 +309,7 @@ void up_assert(const uint8_t *filename, int lineno) void up_assert_code(const uint8_t *filename, int lineno, int errorcode) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/arm/src/arm/up_blocktask.c b/nuttx/arch/arm/src/arm/up_blocktask.c index f72a02465..090cc6407 100644 --- a/nuttx/arch/arm/src/arm/up_blocktask.c +++ b/nuttx/arch/arm/src/arm/up_blocktask.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -95,7 +95,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -138,7 +138,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -156,7 +156,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/arm/src/arm/up_checkmapping.c b/nuttx/arch/arm/src/arm/up_checkmapping.c index ca8c3a032..f86b6de75 100644 --- a/nuttx/arch/arm/src/arm/up_checkmapping.c +++ b/nuttx/arch/arm/src/arm/up_checkmapping.c @@ -97,7 +97,7 @@ * ****************************************************************************/ -bool up_checkmapping(FAR _TCB *tcb) +bool up_checkmapping(FAR struct tcb_s *tcb) { uintptr_t vaddr; uint32_t *pte; diff --git a/nuttx/arch/arm/src/arm/up_dataabort.c b/nuttx/arch/arm/src/arm/up_dataabort.c index 60ef8385e..99b3bf2ab 100644 --- a/nuttx/arch/arm/src/arm/up_dataabort.c +++ b/nuttx/arch/arm/src/arm/up_dataabort.c @@ -102,9 +102,9 @@ #ifdef CONFIG_PAGING void up_dataabort(uint32_t *regs, uint32_t far, uint32_t fsr) { - FAR _TCB *tcb = (FAR _TCB *)g_readytorun.head; + FAR struct tcb_s *tcb = (FAR struct tcb_s *)g_readytorun.head; #ifdef CONFIG_PAGING - uint32_t *savestate; + uint32_t *savestate; /* Save the saved processor context in current_regs where it can be accessed * for register dumps and possibly context switching. diff --git a/nuttx/arch/arm/src/arm/up_initialstate.c b/nuttx/arch/arm/src/arm/up_initialstate.c index fb672a2ac..7d8ef65b1 100644 --- a/nuttx/arch/arm/src/arm/up_initialstate.c +++ b/nuttx/arch/arm/src/arm/up_initialstate.c @@ -78,7 +78,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; uint32_t cpsr; diff --git a/nuttx/arch/arm/src/arm/up_prefetchabort.c b/nuttx/arch/arm/src/arm/up_prefetchabort.c index 9d028b0d4..541586de9 100644 --- a/nuttx/arch/arm/src/arm/up_prefetchabort.c +++ b/nuttx/arch/arm/src/arm/up_prefetchabort.c @@ -121,7 +121,7 @@ void up_prefetchabort(uint32_t *regs) * prefetch and data aborts. */ - FAR _TCB *tcb = (FAR _TCB *)g_readytorun.head; + FAR struct tcb_s *tcb = (FAR struct tcb_s *)g_readytorun.head; tcb->xcp.far = regs[REG_R15]; /* Call pg_miss() to schedule the page fill. A consequences of this diff --git a/nuttx/arch/arm/src/arm/up_releasepending.c b/nuttx/arch/arm/src/arm/up_releasepending.c index 8adeeb26d..169262e95 100644 --- a/nuttx/arch/arm/src/arm/up_releasepending.c +++ b/nuttx/arch/arm/src/arm/up_releasepending.c @@ -75,7 +75,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -101,7 +101,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -121,7 +121,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/arm/src/arm/up_reprioritizertr.c b/nuttx/arch/arm/src/arm/up_reprioritizertr.c index 02bc39d62..769794083 100644 --- a/nuttx/arch/arm/src/arm/up_reprioritizertr.c +++ b/nuttx/arch/arm/src/arm/up_reprioritizertr.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -102,7 +102,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -156,7 +156,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -175,7 +175,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/arm/src/arm/up_schedulesigaction.c b/nuttx/arch/arm/src/arm/up_schedulesigaction.c index a76438f94..f7d33254b 100644 --- a/nuttx/arch/arm/src/arm/up_schedulesigaction.c +++ b/nuttx/arch/arm/src/arm/up_schedulesigaction.c @@ -101,7 +101,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ @@ -121,7 +121,7 @@ void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) sdbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and * a task is signalling itself for some reason. diff --git a/nuttx/arch/arm/src/arm/up_sigdeliver.c b/nuttx/arch/arm/src/arm/up_sigdeliver.c index 868449448..9459bf7e9 100644 --- a/nuttx/arch/arm/src/arm/up_sigdeliver.c +++ b/nuttx/arch/arm/src/arm/up_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint32_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/arm/src/arm/up_unblocktask.c b/nuttx/arch/arm/src/arm/up_unblocktask.c index 633dc4e82..a2dc0f694 100644 --- a/nuttx/arch/arm/src/arm/up_unblocktask.c +++ b/nuttx/arch/arm/src/arm/up_unblocktask.c @@ -79,7 +79,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -90,7 +90,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; /* Remove the task from the blocked task list */ @@ -128,7 +128,7 @@ void up_unblock_task(_TCB *tcb) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -148,7 +148,7 @@ void up_unblock_task(_TCB *tcb) * g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/arm/src/armv7-m/up_assert.c b/nuttx/arch/arm/src/armv7-m/up_assert.c index b40b1090c..394c6858f 100644 --- a/nuttx/arch/arm/src/armv7-m/up_assert.c +++ b/nuttx/arch/arm/src/armv7-m/up_assert.c @@ -167,8 +167,8 @@ static inline void up_registerdump(void) #ifdef CONFIG_ARCH_STACKDUMP static void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - uint32_t sp = up_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + uint32_t sp = up_getsp(); uint32_t ustackbase; uint32_t ustacksize; #if CONFIG_ARCH_INTERRUPTSTACK > 3 @@ -272,7 +272,7 @@ static void _up_assert(int errorcode) { /* Are we in an interrupt handler or the idle task? */ - if (current_regs || ((_TCB*)g_readytorun.head)->pid == 0) + if (current_regs || ((struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -302,7 +302,7 @@ static void _up_assert(int errorcode) void up_assert(const uint8_t *filename, int lineno) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -324,7 +324,7 @@ void up_assert(const uint8_t *filename, int lineno) void up_assert_code(const uint8_t *filename, int lineno, int errorcode) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/arm/src/armv7-m/up_blocktask.c b/nuttx/arch/arm/src/armv7-m/up_blocktask.c index 896476ed2..15558ed4d 100644 --- a/nuttx/arch/arm/src/armv7-m/up_blocktask.c +++ b/nuttx/arch/arm/src/armv7-m/up_blocktask.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -95,7 +95,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -138,7 +138,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -153,7 +153,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/arm/src/armv7-m/up_initialstate.c b/nuttx/arch/arm/src/armv7-m/up_initialstate.c index 635a700fd..ee523a016 100644 --- a/nuttx/arch/arm/src/armv7-m/up_initialstate.c +++ b/nuttx/arch/arm/src/armv7-m/up_initialstate.c @@ -81,7 +81,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/arm/src/armv7-m/up_releasepending.c b/nuttx/arch/arm/src/armv7-m/up_releasepending.c index 2f0d4dc39..21c79bfc7 100644 --- a/nuttx/arch/arm/src/armv7-m/up_releasepending.c +++ b/nuttx/arch/arm/src/armv7-m/up_releasepending.c @@ -75,7 +75,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -100,7 +100,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -116,7 +116,7 @@ void up_release_pending(void) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/arm/src/armv7-m/up_reprioritizertr.c b/nuttx/arch/arm/src/armv7-m/up_reprioritizertr.c index 9a971f064..94708a3be 100644 --- a/nuttx/arch/arm/src/armv7-m/up_reprioritizertr.c +++ b/nuttx/arch/arm/src/armv7-m/up_reprioritizertr.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -102,7 +102,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -157,7 +157,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -173,7 +173,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/arm/src/armv7-m/up_schedulesigaction.c b/nuttx/arch/arm/src/armv7-m/up_schedulesigaction.c index 9221a69a2..32f7082b3 100644 --- a/nuttx/arch/arm/src/armv7-m/up_schedulesigaction.c +++ b/nuttx/arch/arm/src/armv7-m/up_schedulesigaction.c @@ -101,7 +101,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ @@ -121,7 +121,7 @@ void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) sdbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and * a task is signalling itself for some reason. diff --git a/nuttx/arch/arm/src/armv7-m/up_sigdeliver.c b/nuttx/arch/arm/src/armv7-m/up_sigdeliver.c index 654214b39..2e75d254a 100644 --- a/nuttx/arch/arm/src/armv7-m/up_sigdeliver.c +++ b/nuttx/arch/arm/src/armv7-m/up_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint32_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/arm/src/armv7-m/up_svcall.c b/nuttx/arch/arm/src/armv7-m/up_svcall.c index d32f0afc2..9fa5a0b82 100644 --- a/nuttx/arch/arm/src/armv7-m/up_svcall.c +++ b/nuttx/arch/arm/src/armv7-m/up_svcall.c @@ -109,9 +109,9 @@ #ifdef CONFIG_NUTTX_KERNEL static inline void dispatch_syscall(uint32_t *regs) { - uint32_t cmd = regs[REG_R0]; - FAR _TCB *rtcb = sched_self(); - uintptr_t ret = (uintptr_t)ERROR; + uint32_t cmd = regs[REG_R0]; + FAR struct tcb_s *rtcb = sched_self(); + uintptr_t ret = (uintptr_t)ERROR; /* Verify the the SYS call number is within range */ diff --git a/nuttx/arch/arm/src/armv7-m/up_unblocktask.c b/nuttx/arch/arm/src/armv7-m/up_unblocktask.c index da10f0376..b2ff98879 100644 --- a/nuttx/arch/arm/src/armv7-m/up_unblocktask.c +++ b/nuttx/arch/arm/src/armv7-m/up_unblocktask.c @@ -79,7 +79,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -90,7 +90,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; /* Remove the task from the blocked task list */ @@ -128,7 +128,7 @@ void up_unblock_task(_TCB *tcb) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -143,7 +143,7 @@ void up_unblock_task(_TCB *tcb) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/arm/src/common/up_checkstack.c b/nuttx/arch/arm/src/common/up_checkstack.c index ac8d9e7b9..273d30d23 100644 --- a/nuttx/arch/arm/src/common/up_checkstack.c +++ b/nuttx/arch/arm/src/common/up_checkstack.c @@ -78,7 +78,7 @@ * ****************************************************************************/ -size_t up_check_tcbstack(FAR _TCB *tcb) +size_t up_check_tcbstack(FAR struct tcb_s *tcb) { FAR uint32_t *ptr; size_t mark; @@ -136,12 +136,12 @@ size_t up_check_tcbstack(FAR _TCB *tcb) size_t up_check_stack(void) { - return up_check_tcbstack((FAR _TCB*)g_readytorun.head); + return up_check_tcbstack((FAR struct tcb_s*)g_readytorun.head); } size_t up_check_stack_remain(void) { - return ((FAR _TCB*)g_readytorun.head)->adj_stack_size - up_check_tcbstack((FAR _TCB*)g_readytorun.head); + return ((FAR struct tcb_s*)g_readytorun.head)->adj_stack_size - up_check_tcbstack((FAR struct tcb_s*)g_readytorun.head); } #endif /* CONFIG_DEBUG && CONFIG_DEBUG_STACK */ diff --git a/nuttx/arch/arm/src/common/up_createstack.c b/nuttx/arch/arm/src/common/up_createstack.c index 3d6dfef45..e3f963227 100644 --- a/nuttx/arch/arm/src/common/up_createstack.c +++ b/nuttx/arch/arm/src/common/up_createstack.c @@ -128,7 +128,7 @@ static void *memset32(void *s, uint32_t c, size_t n) * must be allocated. ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) @@ -174,7 +174,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/arm/src/common/up_exit.c b/nuttx/arch/arm/src/common/up_exit.c index 16f5c4442..76bf4e0dd 100644 --- a/nuttx/arch/arm/src/common/up_exit.c +++ b/nuttx/arch/arm/src/common/up_exit.c @@ -73,7 +73,7 @@ ****************************************************************************/ #if defined(CONFIG_DUMP_ON_EXIT) && defined(CONFIG_DEBUG) -static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) +static void _up_dumponexit(FAR struct tcb_s *tcb, FAR void *arg) { #if CONFIG_NFILE_DESCRIPTORS > 0 FAR struct filelist *filelist; @@ -136,7 +136,7 @@ static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) void _exit(int status) { - _TCB* tcb; + struct tcb_s* tcb; /* Disable interrupts. They will be restored when the next * task is started. @@ -159,7 +159,7 @@ void _exit(int status) * head of the list. */ - tcb = (_TCB*)g_readytorun.head; + tcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/arm/src/common/up_internal.h b/nuttx/arch/arm/src/common/up_internal.h index 8a24f003e..981fe7ae8 100644 --- a/nuttx/arch/arm/src/common/up_internal.h +++ b/nuttx/arch/arm/src/common/up_internal.h @@ -410,8 +410,8 @@ extern void up_rnginitialize(void); #if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_STACK) extern size_t up_check_stack(void); -extern size_t up_check_tcbstack(FAR _TCB); -extern size_t up_check_tcbstack_remain(FAR _TCB); +extern size_t up_check_tcbstack(FAR struct tcb_s); +extern size_t up_check_tcbstack_remain(FAR struct tcb_s); #endif #endif /* __ASSEMBLY__ */ diff --git a/nuttx/arch/arm/src/common/up_releasestack.c b/nuttx/arch/arm/src/common/up_releasestack.c index 82f5db88f..cb0bf030a 100644 --- a/nuttx/arch/arm/src/common/up_releasestack.c +++ b/nuttx/arch/arm/src/common/up_releasestack.c @@ -67,7 +67,7 @@ * ****************************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/arm/src/common/up_usestack.c b/nuttx/arch/arm/src/common/up_usestack.c index a3f4f4816..d94f99a57 100644 --- a/nuttx/arch/arm/src/common/up_usestack.c +++ b/nuttx/arch/arm/src/common/up_usestack.c @@ -109,7 +109,7 @@ * ****************************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; size_t size_of_stack; @@ -146,7 +146,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/arm/src/common/up_vfork.c b/nuttx/arch/arm/src/common/up_vfork.c index 3b653e317..f576f6bfd 100644 --- a/nuttx/arch/arm/src/common/up_vfork.c +++ b/nuttx/arch/arm/src/common/up_vfork.c @@ -126,8 +126,8 @@ pid_t up_vfork(const struct vfork_s *context) { - _TCB *parent = (FAR _TCB *)g_readytorun.head; - _TCB *child; + struct tcb_s *parent = (FAR struct tcb_s *)g_readytorun.head; + struct tcb_s *child; size_t stacksize; uint32_t newsp; uint32_t newfp; diff --git a/nuttx/arch/avr/src/avr/up_blocktask.c b/nuttx/arch/avr/src/avr/up_blocktask.c index 4bc587903..7d48da78a 100644 --- a/nuttx/arch/avr/src/avr/up_blocktask.c +++ b/nuttx/arch/avr/src/avr/up_blocktask.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -95,7 +95,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -138,7 +138,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -153,7 +153,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/avr/src/avr/up_checkstack.c b/nuttx/arch/avr/src/avr/up_checkstack.c index b8325ccbc..e58ee0ca3 100644 --- a/nuttx/arch/avr/src/avr/up_checkstack.c +++ b/nuttx/arch/avr/src/avr/up_checkstack.c @@ -78,7 +78,7 @@ * ****************************************************************************/ -size_t up_check_tcbstack(FAR _TCB *tcb) +size_t up_check_tcbstack(FAR struct tcb_s *tcb) { FAR uint8_t *ptr; size_t mark; @@ -135,7 +135,7 @@ size_t up_check_tcbstack(FAR _TCB *tcb) size_t up_check_stack(void) { - return up_check_tcbstack((FAR _TCB*)g_readytorun.head); + return up_check_tcbstack((FAR struct tcb_s*)g_readytorun.head); } #endif /* CONFIG_DEBUG && CONFIG_DEBUG_STACK */ diff --git a/nuttx/arch/avr/src/avr/up_createstack.c b/nuttx/arch/avr/src/avr/up_createstack.c index 67219ec9c..904a4acab 100644 --- a/nuttx/arch/avr/src/avr/up_createstack.c +++ b/nuttx/arch/avr/src/avr/up_createstack.c @@ -87,7 +87,7 @@ * ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { /* Is there already a stack allocated of a different size? */ @@ -137,7 +137,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) top_of_stack = (size_t)tcb->stack_alloc_ptr + stack_size - 1; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (FAR void *)top_of_stack; tcb->adj_stack_size = stack_size; diff --git a/nuttx/arch/avr/src/avr/up_dumpstate.c b/nuttx/arch/avr/src/avr/up_dumpstate.c index 3ce595bf0..62e80255f 100644 --- a/nuttx/arch/avr/src/avr/up_dumpstate.c +++ b/nuttx/arch/avr/src/avr/up_dumpstate.c @@ -168,8 +168,8 @@ static inline void up_registerdump(void) void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - uint16_t sp = up_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + uint16_t sp = up_getsp(); uint16_t ustackbase; uint16_t ustacksize; #if CONFIG_ARCH_INTERRUPTSTACK > 0 diff --git a/nuttx/arch/avr/src/avr/up_initialstate.c b/nuttx/arch/avr/src/avr/up_initialstate.c index 12fead20a..8672e6da7 100644 --- a/nuttx/arch/avr/src/avr/up_initialstate.c +++ b/nuttx/arch/avr/src/avr/up_initialstate.c @@ -79,7 +79,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/avr/src/avr/up_releasepending.c b/nuttx/arch/avr/src/avr/up_releasepending.c index 5684dcf55..0a63189fe 100644 --- a/nuttx/arch/avr/src/avr/up_releasepending.c +++ b/nuttx/arch/avr/src/avr/up_releasepending.c @@ -75,7 +75,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -101,7 +101,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -117,7 +117,7 @@ void up_release_pending(void) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/avr/src/avr/up_reprioritizertr.c b/nuttx/arch/avr/src/avr/up_reprioritizertr.c index af329c13f..5b23a37a1 100644 --- a/nuttx/arch/avr/src/avr/up_reprioritizertr.c +++ b/nuttx/arch/avr/src/avr/up_reprioritizertr.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -102,7 +102,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -156,7 +156,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -172,7 +172,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/avr/src/avr/up_schedulesigaction.c b/nuttx/arch/avr/src/avr/up_schedulesigaction.c index a70158a0d..304f2dc22 100644 --- a/nuttx/arch/avr/src/avr/up_schedulesigaction.c +++ b/nuttx/arch/avr/src/avr/up_schedulesigaction.c @@ -101,7 +101,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ @@ -121,7 +121,7 @@ void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) sdbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and * a task is signalling itself for some reason. diff --git a/nuttx/arch/avr/src/avr/up_sigdeliver.c b/nuttx/arch/avr/src/avr/up_sigdeliver.c index 4398dba6b..400753799 100644 --- a/nuttx/arch/avr/src/avr/up_sigdeliver.c +++ b/nuttx/arch/avr/src/avr/up_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint8_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/avr/src/avr/up_unblocktask.c b/nuttx/arch/avr/src/avr/up_unblocktask.c index 0eff2edcd..f1707b7bd 100644 --- a/nuttx/arch/avr/src/avr/up_unblocktask.c +++ b/nuttx/arch/avr/src/avr/up_unblocktask.c @@ -79,7 +79,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -90,7 +90,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; /* Remove the task from the blocked task list */ @@ -128,7 +128,7 @@ void up_unblock_task(_TCB *tcb) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -143,7 +143,7 @@ void up_unblock_task(_TCB *tcb) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/avr/src/avr/up_usestack.c b/nuttx/arch/avr/src/avr/up_usestack.c index cedc9afe3..cd93f5d23 100644 --- a/nuttx/arch/avr/src/avr/up_usestack.c +++ b/nuttx/arch/avr/src/avr/up_usestack.c @@ -82,7 +82,7 @@ * ****************************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; @@ -115,7 +115,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) top_of_stack = (size_t)tcb->stack_alloc_ptr + stack_size - 1; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (FAR void *)top_of_stack; tcb->adj_stack_size = stack_size; diff --git a/nuttx/arch/avr/src/avr32/up_blocktask.c b/nuttx/arch/avr/src/avr32/up_blocktask.c index 5d05350e6..a5ff53ae9 100644 --- a/nuttx/arch/avr/src/avr32/up_blocktask.c +++ b/nuttx/arch/avr/src/avr32/up_blocktask.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -95,7 +95,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -138,7 +138,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -153,7 +153,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/avr/src/avr32/up_createstack.c b/nuttx/arch/avr/src/avr32/up_createstack.c index 2d34a9adf..93bbad6af 100644 --- a/nuttx/arch/avr/src/avr32/up_createstack.c +++ b/nuttx/arch/avr/src/avr32/up_createstack.c @@ -86,7 +86,7 @@ * ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) @@ -124,7 +124,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (size_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (FAR void *)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/avr/src/avr32/up_dumpstate.c b/nuttx/arch/avr/src/avr32/up_dumpstate.c index d6113d40b..32db56f0d 100644 --- a/nuttx/arch/avr/src/avr32/up_dumpstate.c +++ b/nuttx/arch/avr/src/avr32/up_dumpstate.c @@ -145,8 +145,8 @@ static inline void up_registerdump(void) void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - uint32_t sp = up_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + uint32_t sp = up_getsp(); uint32_t ustackbase; uint32_t ustacksize; #if CONFIG_ARCH_INTERRUPTSTACK > 3 diff --git a/nuttx/arch/avr/src/avr32/up_initialstate.c b/nuttx/arch/avr/src/avr32/up_initialstate.c index fe3a79d90..adfc95596 100644 --- a/nuttx/arch/avr/src/avr32/up_initialstate.c +++ b/nuttx/arch/avr/src/avr32/up_initialstate.c @@ -77,7 +77,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/avr/src/avr32/up_releasepending.c b/nuttx/arch/avr/src/avr32/up_releasepending.c index 3cf29e623..00956e442 100644 --- a/nuttx/arch/avr/src/avr32/up_releasepending.c +++ b/nuttx/arch/avr/src/avr32/up_releasepending.c @@ -75,7 +75,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -101,7 +101,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -117,7 +117,7 @@ void up_release_pending(void) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/avr/src/avr32/up_reprioritizertr.c b/nuttx/arch/avr/src/avr32/up_reprioritizertr.c index 0aad214e8..bc9ba21f0 100644 --- a/nuttx/arch/avr/src/avr32/up_reprioritizertr.c +++ b/nuttx/arch/avr/src/avr32/up_reprioritizertr.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -102,7 +102,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -156,7 +156,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -172,7 +172,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/avr/src/avr32/up_schedulesigaction.c b/nuttx/arch/avr/src/avr32/up_schedulesigaction.c index edf145a17..a710672dc 100644 --- a/nuttx/arch/avr/src/avr32/up_schedulesigaction.c +++ b/nuttx/arch/avr/src/avr32/up_schedulesigaction.c @@ -101,7 +101,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ @@ -121,7 +121,7 @@ void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) sdbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and * a task is signalling itself for some reason. diff --git a/nuttx/arch/avr/src/avr32/up_sigdeliver.c b/nuttx/arch/avr/src/avr32/up_sigdeliver.c index 8c1c0b705..d9b466890 100644 --- a/nuttx/arch/avr/src/avr32/up_sigdeliver.c +++ b/nuttx/arch/avr/src/avr32/up_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #if 0 uint32_t regs[XCPTCONTEXT_REGS+3]; /* Why +3? See below */ #else diff --git a/nuttx/arch/avr/src/avr32/up_unblocktask.c b/nuttx/arch/avr/src/avr32/up_unblocktask.c index da6b31f83..5ce48e366 100644 --- a/nuttx/arch/avr/src/avr32/up_unblocktask.c +++ b/nuttx/arch/avr/src/avr32/up_unblocktask.c @@ -79,7 +79,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -90,7 +90,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; /* Remove the task from the blocked task list */ @@ -128,7 +128,7 @@ void up_unblock_task(_TCB *tcb) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -143,7 +143,7 @@ void up_unblock_task(_TCB *tcb) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/avr/src/avr32/up_usestack.c b/nuttx/arch/avr/src/avr32/up_usestack.c index e73de3fb0..5afadb922 100644 --- a/nuttx/arch/avr/src/avr32/up_usestack.c +++ b/nuttx/arch/avr/src/avr32/up_usestack.c @@ -82,7 +82,7 @@ * ****************************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; size_t size_of_stack; @@ -113,7 +113,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (size_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (FAR void *)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/avr/src/common/up_assert.c b/nuttx/arch/avr/src/common/up_assert.c index be7f635e8..2e70a9c28 100644 --- a/nuttx/arch/avr/src/common/up_assert.c +++ b/nuttx/arch/avr/src/common/up_assert.c @@ -95,7 +95,7 @@ static void _up_assert(int errorcode) { /* Are we in an interrupt handler or the idle task? */ - if (current_regs || ((_TCB*)g_readytorun.head)->pid == 0) + if (current_regs || ((struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -125,7 +125,7 @@ static void _up_assert(int errorcode) void up_assert(const uint8_t *filename, int lineno) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -147,7 +147,7 @@ void up_assert(const uint8_t *filename, int lineno) void up_assert_code(const uint8_t *filename, int lineno, int errorcode) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/avr/src/common/up_exit.c b/nuttx/arch/avr/src/common/up_exit.c index 68e33fde7..3b316123b 100644 --- a/nuttx/arch/avr/src/common/up_exit.c +++ b/nuttx/arch/avr/src/common/up_exit.c @@ -73,7 +73,7 @@ ****************************************************************************/ #if defined(CONFIG_DUMP_ON_EXIT) && defined(CONFIG_DEBUG) -static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) +static void _up_dumponexit(FAR struct tcb_s *tcb, FAR void *arg) { #if CONFIG_NFILE_DESCRIPTORS > 0 FAR struct filelist *filelist; @@ -136,7 +136,7 @@ static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) void _exit(int status) { - _TCB* tcb; + struct tcb_s* tcb; /* Disable interrupts. They will be restored when the next * task is started. @@ -159,7 +159,7 @@ void _exit(int status) * head of the list. */ - tcb = (_TCB*)g_readytorun.head; + tcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/avr/src/common/up_releasestack.c b/nuttx/arch/avr/src/common/up_releasestack.c index 2cf3c30e8..98b1faea1 100644 --- a/nuttx/arch/avr/src/common/up_releasestack.c +++ b/nuttx/arch/avr/src/common/up_releasestack.c @@ -67,7 +67,7 @@ * ****************************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/hc/src/common/up_blocktask.c b/nuttx/arch/hc/src/common/up_blocktask.c index 4e5bf1826..da7131c4c 100644 --- a/nuttx/arch/hc/src/common/up_blocktask.c +++ b/nuttx/arch/hc/src/common/up_blocktask.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -95,7 +95,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -138,7 +138,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -156,7 +156,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/hc/src/common/up_createstack.c b/nuttx/arch/hc/src/common/up_createstack.c index ef0a9df9c..8c29190ae 100644 --- a/nuttx/arch/hc/src/common/up_createstack.c +++ b/nuttx/arch/hc/src/common/up_createstack.c @@ -83,7 +83,7 @@ * ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { @@ -118,7 +118,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) top_of_stack &= ~1; size_of_stack = top_of_stack - (size_t)tcb->stack_alloc_ptr; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/hc/src/common/up_exit.c b/nuttx/arch/hc/src/common/up_exit.c index 1c46875f8..9fad697f1 100644 --- a/nuttx/arch/hc/src/common/up_exit.c +++ b/nuttx/arch/hc/src/common/up_exit.c @@ -73,7 +73,7 @@ ****************************************************************************/ #if defined(CONFIG_DUMP_ON_EXIT) && defined(CONFIG_DEBUG) -static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) +static void _up_dumponexit(FAR struct tcb_s *tcb, FAR void *arg) { #if CONFIG_NFILE_DESCRIPTORS > 0 FAR struct filelist *filelist; @@ -136,7 +136,7 @@ static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) void _exit(int status) { - _TCB* tcb; + struct tcb_s* tcb; /* Disable interrupts. They will be restored when the next * task is started. @@ -159,7 +159,7 @@ void _exit(int status) * head of the list. */ - tcb = (_TCB*)g_readytorun.head; + tcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/hc/src/common/up_releasepending.c b/nuttx/arch/hc/src/common/up_releasepending.c index 0c09cb0c6..b8da18d60 100644 --- a/nuttx/arch/hc/src/common/up_releasepending.c +++ b/nuttx/arch/hc/src/common/up_releasepending.c @@ -74,7 +74,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -100,7 +100,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -120,7 +120,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/hc/src/common/up_releasestack.c b/nuttx/arch/hc/src/common/up_releasestack.c index d3d917fc3..3d8b61176 100644 --- a/nuttx/arch/hc/src/common/up_releasestack.c +++ b/nuttx/arch/hc/src/common/up_releasestack.c @@ -68,7 +68,7 @@ * ****************************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/hc/src/common/up_reprioritizertr.c b/nuttx/arch/hc/src/common/up_reprioritizertr.c index 31c76a9f5..92e18ff47 100644 --- a/nuttx/arch/hc/src/common/up_reprioritizertr.c +++ b/nuttx/arch/hc/src/common/up_reprioritizertr.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -102,7 +102,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -156,7 +156,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -175,7 +175,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/hc/src/common/up_unblocktask.c b/nuttx/arch/hc/src/common/up_unblocktask.c index 9518da774..7d5f67a1b 100644 --- a/nuttx/arch/hc/src/common/up_unblocktask.c +++ b/nuttx/arch/hc/src/common/up_unblocktask.c @@ -79,7 +79,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -90,7 +90,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; /* Remove the task from the blocked task list */ @@ -128,7 +128,7 @@ void up_unblock_task(_TCB *tcb) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -148,7 +148,7 @@ void up_unblock_task(_TCB *tcb) * g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/hc/src/common/up_usestack.c b/nuttx/arch/hc/src/common/up_usestack.c index b0349b21b..53a571ed4 100644 --- a/nuttx/arch/hc/src/common/up_usestack.c +++ b/nuttx/arch/hc/src/common/up_usestack.c @@ -80,7 +80,7 @@ * ****************************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; size_t size_of_stack; @@ -112,7 +112,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) top_of_stack &= ~1; size_of_stack = top_of_stack - (size_t)tcb->stack_alloc_ptr; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/hc/src/m9s12/m9s12_assert.c b/nuttx/arch/hc/src/m9s12/m9s12_assert.c index 37ad5e30d..62ad33d2d 100644 --- a/nuttx/arch/hc/src/m9s12/m9s12_assert.c +++ b/nuttx/arch/hc/src/m9s12/m9s12_assert.c @@ -156,8 +156,8 @@ static inline void up_registerdump(void) #ifdef CONFIG_ARCH_STACKDUMP static void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - uint16_t sp = up_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + uint16_t sp = up_getsp(); uint16_t ustackbase; uint16_t ustacksize; #if CONFIG_ARCH_INTERRUPTSTACK > 3 @@ -252,7 +252,7 @@ static void _up_assert(int errorcode) { /* Are we in an interrupt handler or the idle task? */ - if (current_regs || ((_TCB*)g_readytorun.head)->pid == 0) + if (current_regs || ((struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -282,7 +282,7 @@ static void _up_assert(int errorcode) void up_assert(const uint8_t *filename, int lineno) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -304,7 +304,7 @@ void up_assert(const uint8_t *filename, int lineno) void up_assert_code(const uint8_t *filename, int lineno, int errorcode) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/hc/src/m9s12/m9s12_initialstate.c b/nuttx/arch/hc/src/m9s12/m9s12_initialstate.c index 80bb5fe03..3259cbb9a 100644 --- a/nuttx/arch/hc/src/m9s12/m9s12_initialstate.c +++ b/nuttx/arch/hc/src/m9s12/m9s12_initialstate.c @@ -76,7 +76,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/mips/src/common/up_createstack.c b/nuttx/arch/mips/src/common/up_createstack.c index d5c285e25..722c1a35e 100644 --- a/nuttx/arch/mips/src/common/up_createstack.c +++ b/nuttx/arch/mips/src/common/up_createstack.c @@ -84,7 +84,7 @@ * must be allocated. ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) @@ -124,7 +124,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/mips/src/common/up_exit.c b/nuttx/arch/mips/src/common/up_exit.c index e112364b4..a5746f8aa 100644 --- a/nuttx/arch/mips/src/common/up_exit.c +++ b/nuttx/arch/mips/src/common/up_exit.c @@ -75,7 +75,7 @@ ****************************************************************************/ #if defined(CONFIG_DUMP_ON_EXIT) && defined(CONFIG_DEBUG) -static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) +static void _up_dumponexit(FAR struct tcb_s *tcb, FAR void *arg) { #if CONFIG_NFILE_DESCRIPTORS > 0 FAR struct filelist *filelist; @@ -138,7 +138,7 @@ static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) void _exit(int status) { - _TCB* tcb; + struct tcb_s* tcb; /* Disable interrupts. They will be restored when the next * task is started. @@ -161,7 +161,7 @@ void _exit(int status) * head of the list. */ - tcb = (_TCB*)g_readytorun.head; + tcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/mips/src/common/up_releasestack.c b/nuttx/arch/mips/src/common/up_releasestack.c index a54ea70cd..7cbeb86e7 100644 --- a/nuttx/arch/mips/src/common/up_releasestack.c +++ b/nuttx/arch/mips/src/common/up_releasestack.c @@ -67,7 +67,7 @@ * ****************************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/mips/src/common/up_usestack.c b/nuttx/arch/mips/src/common/up_usestack.c index e41608f67..6fa521579 100644 --- a/nuttx/arch/mips/src/common/up_usestack.c +++ b/nuttx/arch/mips/src/common/up_usestack.c @@ -82,7 +82,7 @@ * ****************************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; size_t size_of_stack; @@ -113,7 +113,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/mips/src/mips32/up_assert.c b/nuttx/arch/mips/src/mips32/up_assert.c index f27bc0ebe..9f503ac85 100644 --- a/nuttx/arch/mips/src/mips32/up_assert.c +++ b/nuttx/arch/mips/src/mips32/up_assert.c @@ -95,7 +95,7 @@ static void _up_assert(int errorcode) { /* Are we in an interrupt handler or the idle task? */ - if (current_regs || ((_TCB*)g_readytorun.head)->pid == 0) + if (current_regs || ((struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -125,7 +125,7 @@ static void _up_assert(int errorcode) void up_assert(const uint8_t *filename, int lineno) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -147,7 +147,7 @@ void up_assert(const uint8_t *filename, int lineno) void up_assert_code(const uint8_t *filename, int lineno, int errorcode) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/mips/src/mips32/up_blocktask.c b/nuttx/arch/mips/src/mips32/up_blocktask.c index 47fd4024b..8d209da9f 100644 --- a/nuttx/arch/mips/src/mips32/up_blocktask.c +++ b/nuttx/arch/mips/src/mips32/up_blocktask.c @@ -85,7 +85,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -96,7 +96,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -139,7 +139,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -154,7 +154,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/mips/src/mips32/up_dumpstate.c b/nuttx/arch/mips/src/mips32/up_dumpstate.c index 1cd426767..064aa0681 100644 --- a/nuttx/arch/mips/src/mips32/up_dumpstate.c +++ b/nuttx/arch/mips/src/mips32/up_dumpstate.c @@ -154,8 +154,8 @@ static inline void up_registerdump(void) void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - uint32_t sp = up_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + uint32_t sp = up_getsp(); uint32_t ustackbase; uint32_t ustacksize; #if CONFIG_ARCH_INTERRUPTSTACK > 3 diff --git a/nuttx/arch/mips/src/mips32/up_initialstate.c b/nuttx/arch/mips/src/mips32/up_initialstate.c index 0c24d1ee0..a4d204b30 100644 --- a/nuttx/arch/mips/src/mips32/up_initialstate.c +++ b/nuttx/arch/mips/src/mips32/up_initialstate.c @@ -80,7 +80,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; uint32_t regval; diff --git a/nuttx/arch/mips/src/mips32/up_releasepending.c b/nuttx/arch/mips/src/mips32/up_releasepending.c index 13918ca21..7999bffeb 100644 --- a/nuttx/arch/mips/src/mips32/up_releasepending.c +++ b/nuttx/arch/mips/src/mips32/up_releasepending.c @@ -77,7 +77,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -103,7 +103,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -119,7 +119,7 @@ void up_release_pending(void) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/mips/src/mips32/up_reprioritizertr.c b/nuttx/arch/mips/src/mips32/up_reprioritizertr.c index 2e5f41d68..f4034cc1e 100644 --- a/nuttx/arch/mips/src/mips32/up_reprioritizertr.c +++ b/nuttx/arch/mips/src/mips32/up_reprioritizertr.c @@ -86,7 +86,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -104,7 +104,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -158,7 +158,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -174,7 +174,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/mips/src/mips32/up_schedulesigaction.c b/nuttx/arch/mips/src/mips32/up_schedulesigaction.c index f81fd890a..1ab8c2b56 100644 --- a/nuttx/arch/mips/src/mips32/up_schedulesigaction.c +++ b/nuttx/arch/mips/src/mips32/up_schedulesigaction.c @@ -101,7 +101,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { uint32_t status; @@ -123,7 +123,7 @@ void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) sdbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and * a task is signalling itself for some reason. diff --git a/nuttx/arch/mips/src/mips32/up_sigdeliver.c b/nuttx/arch/mips/src/mips32/up_sigdeliver.c index 8009b369c..0abc270d3 100644 --- a/nuttx/arch/mips/src/mips32/up_sigdeliver.c +++ b/nuttx/arch/mips/src/mips32/up_sigdeliver.c @@ -82,7 +82,7 @@ void up_sigdeliver(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint32_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/mips/src/mips32/up_swint0.c b/nuttx/arch/mips/src/mips32/up_swint0.c index 87ccddf71..fc03de58b 100644 --- a/nuttx/arch/mips/src/mips32/up_swint0.c +++ b/nuttx/arch/mips/src/mips32/up_swint0.c @@ -139,9 +139,9 @@ static void up_registerdump(const uint32_t *regs) #ifdef CONFIG_NUTTX_KERNEL static inline void dispatch_syscall(uint32_t *regs) { - uint32_t cmd = regs[REG_A0]; - FAR _TCB *rtcb = sched_self(); - uintptr_t ret = (uintptr_t)ERROR; + uint32_t cmd = regs[REG_A0]; + FAR struct tcb_s *rtcb = sched_self(); + uintptr_t ret = (uintptr_t)ERROR; /* Verify the the SYS call number is within range */ diff --git a/nuttx/arch/mips/src/mips32/up_unblocktask.c b/nuttx/arch/mips/src/mips32/up_unblocktask.c index 5dafe90f0..70a5a7241 100644 --- a/nuttx/arch/mips/src/mips32/up_unblocktask.c +++ b/nuttx/arch/mips/src/mips32/up_unblocktask.c @@ -81,7 +81,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -92,7 +92,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; /* Remove the task from the blocked task list */ @@ -130,7 +130,7 @@ void up_unblock_task(_TCB *tcb) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -145,7 +145,7 @@ void up_unblock_task(_TCB *tcb) * ready to run list. */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/nuttx/arch/mips/src/mips32/up_vfork.c b/nuttx/arch/mips/src/mips32/up_vfork.c index 6b7e27f31..58e20f42d 100644 --- a/nuttx/arch/mips/src/mips32/up_vfork.c +++ b/nuttx/arch/mips/src/mips32/up_vfork.c @@ -113,8 +113,8 @@ pid_t up_vfork(const struct vfork_s *context) { - _TCB *parent = (FAR _TCB *)g_readytorun.head; - _TCB *child; + struct tcb_s *parent = (FAR struct tcb_s *)g_readytorun.head; + struct tcb_s *child; size_t stacksize; uint32_t newsp; #if CONFIG_MIPS32_FRAMEPOINTER diff --git a/nuttx/arch/rgmp/include/arch.h b/nuttx/arch/rgmp/include/arch.h index 32eb16ee3..af99356ea 100644 --- a/nuttx/arch/rgmp/include/arch.h +++ b/nuttx/arch/rgmp/include/arch.h @@ -48,10 +48,10 @@ struct up_wait { struct up_wait *next; - _TCB *task; + struct tcb_s *task; }; -extern _TCB *current_task; +extern struct tcb_s *current_task; void up_sigentry(void); diff --git a/nuttx/arch/rgmp/src/arm/arch_nuttx.c b/nuttx/arch/rgmp/src/arm/arch_nuttx.c index cb946bfd1..e916c5520 100644 --- a/nuttx/arch/rgmp/src/arm/arch_nuttx.c +++ b/nuttx/arch/rgmp/src/arm/arch_nuttx.c @@ -55,7 +55,7 @@ void nuttx_arch_exit(void) } -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct Trapframe *tf; diff --git a/nuttx/arch/rgmp/src/nuttx.c b/nuttx/arch/rgmp/src/nuttx.c index 7deb959a2..6cb300f82 100644 --- a/nuttx/arch/rgmp/src/nuttx.c +++ b/nuttx/arch/rgmp/src/nuttx.c @@ -54,7 +54,7 @@ #include <arch/arch.h> #include <os_internal.h> -_TCB *current_task = NULL; +struct tcb_s *current_task = NULL; /** @@ -62,7 +62,7 @@ _TCB *current_task = NULL; * to switch tasks. * Assumption: global interrupt is disabled. */ -static inline void up_switchcontext(_TCB *ctcb, _TCB *ntcb) +static inline void up_switchcontext(struct tcb_s *ctcb, struct tcb_s *ntcb) { // do nothing if two tasks are the same if (ctcb == ntcb) @@ -111,7 +111,7 @@ void up_allocate_heap(void **heap_start, size_t *heap_size) *heap_size = KERNBASE + kmem_size - (uint32_t)boot_freemem; } -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { int ret = ERROR; size_t *adj_stack_ptr; @@ -139,7 +139,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) return ret; } -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { /* Move up to next even word boundary if necessary */ @@ -158,7 +158,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) return OK; } -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { free(dtcb->stack_alloc_ptr); @@ -192,7 +192,7 @@ void up_release_stack(_TCB *dtcb) * hold the blocked task TCB. * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ if ((tcb->task_state < FIRST_READY_TO_RUN_STATE) || @@ -201,7 +201,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) return; } else { - _TCB *rtcb = current_task; + struct tcb_s *rtcb = current_task; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -217,7 +217,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) /* Now, perform the context switch if one is needed */ if (switch_needed) { - _TCB *nexttcb; + struct tcb_s *nexttcb; // this part should not be executed in interrupt context if (up_interrupt_context()) { panic("%s: %d\n", __func__, __LINE__); @@ -230,7 +230,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) warn("Disable preemption failed for task block itself\n"); sched_mergepending(); } - nexttcb = (_TCB*)g_readytorun.head; + nexttcb = (struct tcb_s*)g_readytorun.head; // context switch up_switchcontext(rtcb, nexttcb); } @@ -252,7 +252,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * ready to run taks, executed. * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ if ((tcb->task_state < FIRST_BLOCKED_STATE) || @@ -261,7 +261,7 @@ void up_unblock_task(_TCB *tcb) return; } else { - _TCB *rtcb = current_task; + struct tcb_s *rtcb = current_task; /* Remove the task from the blocked task list */ sched_removeblocked(tcb); @@ -277,7 +277,7 @@ void up_unblock_task(_TCB *tcb) // g_readytorun task list. if (sched_addreadytorun(tcb) && !up_interrupt_context()) { /* The currently active task has changed! */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; // context switch up_switchcontext(rtcb, nexttcb); } @@ -290,20 +290,20 @@ void up_unblock_task(_TCB *tcb) */ void up_release_pending(void) { - _TCB *rtcb = current_task; + struct tcb_s *rtcb = current_task; /* Merge the g_pendingtasks list into the g_readytorun task list */ if (sched_mergepending()) { /* The currently active task has changed! */ - _TCB *nexttcb = (_TCB*)g_readytorun.head; + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; // context switch up_switchcontext(rtcb, nexttcb); } } -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -320,7 +320,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) return; } else { - _TCB *rtcb = current_task; + struct tcb_s *rtcb = current_task; bool switch_needed; /* Remove the tcb task from the ready-to-run list. @@ -343,7 +343,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) /* Now, perform the context switch if one is needed */ if (switch_needed && !up_interrupt_context()) { - _TCB *nexttcb; + struct tcb_s *nexttcb; // If there are any pending tasks, then add them to the g_readytorun // task list now. It should be the up_realease_pending() called from // sched_unlock() to do this for disable preemption. But it block @@ -353,7 +353,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) sched_mergepending(); } - nexttcb = (_TCB*)g_readytorun.head; + nexttcb = (struct tcb_s*)g_readytorun.head; // context switch up_switchcontext(rtcb, nexttcb); } @@ -362,7 +362,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) void _exit(int status) { - _TCB* tcb; + struct tcb_s* tcb; /* Destroy the task at the head of the ready to run list. */ @@ -372,7 +372,7 @@ void _exit(int status) * head of the list. */ - tcb = (_TCB*)g_readytorun.head; + tcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -413,7 +413,7 @@ void up_assert_code(const uint8_t *filename, int line, int code) #ifndef CONFIG_DISABLE_SIGNALS -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ if (!tcb->xcp.sigdeliver) { diff --git a/nuttx/arch/rgmp/src/rgmp.c b/nuttx/arch/rgmp/src/rgmp.c index 479696fb5..db5dd955e 100644 --- a/nuttx/arch/rgmp/src/rgmp.c +++ b/nuttx/arch/rgmp/src/rgmp.c @@ -101,14 +101,14 @@ void rtos_exit_interrupt(void) local_irq_disable(); nest_irq--; if (!nest_irq) { - _TCB *rtcb = current_task; - _TCB *ntcb; + struct tcb_s *rtcb = current_task; + struct tcb_s *ntcb; if (rtcb->xcp.sigdeliver) { rtcb->xcp.ctx.tf = current_regs; push_xcptcontext(&rtcb->xcp); } - ntcb = (_TCB*)g_readytorun.head; + ntcb = (struct tcb_s*)g_readytorun.head; // switch needed if (rtcb != ntcb) { rtcb->xcp.ctx.tf = current_regs; diff --git a/nuttx/arch/rgmp/src/x86/arch_nuttx.c b/nuttx/arch/rgmp/src/x86/arch_nuttx.c index 04b8fa8c8..c691784d9 100644 --- a/nuttx/arch/rgmp/src/x86/arch_nuttx.c +++ b/nuttx/arch/rgmp/src/x86/arch_nuttx.c @@ -71,7 +71,7 @@ void nuttx_arch_exit(void) } -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct Trapframe *tf; diff --git a/nuttx/arch/sh/src/common/up_assert.c b/nuttx/arch/sh/src/common/up_assert.c index 62889fa5a..72880fd2a 100644 --- a/nuttx/arch/sh/src/common/up_assert.c +++ b/nuttx/arch/sh/src/common/up_assert.c @@ -81,7 +81,7 @@ static void _up_assert(int errorcode) { /* Are we in an interrupt handler or the idle task? */ - if (current_regs || ((_TCB*)g_readytorun.head)->pid == 0) + if (current_regs || ((struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -111,7 +111,7 @@ static void _up_assert(int errorcode) void up_assert(const uint8_t *filename, int lineno) { #if CONFIG_TASK_NAME_SIZE > 0 && defined(CONFIG_DEBUG) - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -133,7 +133,7 @@ void up_assert(const uint8_t *filename, int lineno) void up_assert_code(const uint8_t *filename, int lineno, int errorcode) { #if CONFIG_TASK_NAME_SIZE > 0 && defined(CONFIG_DEBUG) - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/sh/src/common/up_blocktask.c b/nuttx/arch/sh/src/common/up_blocktask.c index 0a53b6633..db7f0297c 100644 --- a/nuttx/arch/sh/src/common/up_blocktask.c +++ b/nuttx/arch/sh/src/common/up_blocktask.c @@ -83,7 +83,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -94,7 +94,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -137,7 +137,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -155,7 +155,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/sh/src/common/up_createstack.c b/nuttx/arch/sh/src/common/up_createstack.c index f80e4f7c0..f868750de 100644 --- a/nuttx/arch/sh/src/common/up_createstack.c +++ b/nuttx/arch/sh/src/common/up_createstack.c @@ -83,7 +83,7 @@ * must be allocated. ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) @@ -119,7 +119,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/sh/src/common/up_exit.c b/nuttx/arch/sh/src/common/up_exit.c index 705f49852..31c8e0404 100644 --- a/nuttx/arch/sh/src/common/up_exit.c +++ b/nuttx/arch/sh/src/common/up_exit.c @@ -74,7 +74,7 @@ ****************************************************************************/ #if defined(CONFIG_DUMP_ON_EXIT) && defined(CONFIG_DEBUG) -static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) +static void _up_dumponexit(FAR struct tcb_s *tcb, FAR void *arg) { #if CONFIG_NFILE_DESCRIPTORS > 0 FAR struct filelist *filelist; @@ -137,7 +137,7 @@ static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) void _exit(int status) { - _TCB* tcb; + struct tcb_s* tcb; /* Disable interrupts. They will be restored when the next * task is started. @@ -160,7 +160,7 @@ void _exit(int status) * head of the list. */ - tcb = (_TCB*)g_readytorun.head; + tcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/sh/src/common/up_releasepending.c b/nuttx/arch/sh/src/common/up_releasepending.c index 955febea1..b3960972d 100644 --- a/nuttx/arch/sh/src/common/up_releasepending.c +++ b/nuttx/arch/sh/src/common/up_releasepending.c @@ -75,7 +75,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -101,7 +101,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -121,7 +121,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/sh/src/common/up_releasestack.c b/nuttx/arch/sh/src/common/up_releasestack.c index bb6739433..3b4e4c914 100644 --- a/nuttx/arch/sh/src/common/up_releasestack.c +++ b/nuttx/arch/sh/src/common/up_releasestack.c @@ -67,7 +67,7 @@ * ****************************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/sh/src/common/up_reprioritizertr.c b/nuttx/arch/sh/src/common/up_reprioritizertr.c index 99d350b29..dcf0fcd7b 100644 --- a/nuttx/arch/sh/src/common/up_reprioritizertr.c +++ b/nuttx/arch/sh/src/common/up_reprioritizertr.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -102,7 +102,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -156,7 +156,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -175,7 +175,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/sh/src/common/up_unblocktask.c b/nuttx/arch/sh/src/common/up_unblocktask.c index 5841f50ad..b7c88f823 100644 --- a/nuttx/arch/sh/src/common/up_unblocktask.c +++ b/nuttx/arch/sh/src/common/up_unblocktask.c @@ -79,7 +79,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -90,7 +90,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; /* Remove the task from the blocked task list */ @@ -128,7 +128,7 @@ void up_unblock_task(_TCB *tcb) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -148,7 +148,7 @@ void up_unblock_task(_TCB *tcb) * g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/sh/src/common/up_usestack.c b/nuttx/arch/sh/src/common/up_usestack.c index 41367ce0b..ee26cb70c 100644 --- a/nuttx/arch/sh/src/common/up_usestack.c +++ b/nuttx/arch/sh/src/common/up_usestack.c @@ -82,7 +82,7 @@ * ****************************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; size_t size_of_stack; @@ -113,7 +113,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_size = top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/sh/src/m16c/m16c_dumpstate.c b/nuttx/arch/sh/src/m16c/m16c_dumpstate.c index 38571a7e1..3570a9ebe 100644 --- a/nuttx/arch/sh/src/m16c/m16c_dumpstate.c +++ b/nuttx/arch/sh/src/m16c/m16c_dumpstate.c @@ -158,8 +158,8 @@ static inline void m16c_registerdump(void) void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - uint16_t sp = m16c_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + uint16_t sp = m16c_getsp(); uint16_t ustackbase; uint16_t ustacksize; #if CONFIG_ARCH_INTERRUPTSTACK > 3 diff --git a/nuttx/arch/sh/src/m16c/m16c_initialstate.c b/nuttx/arch/sh/src/m16c/m16c_initialstate.c index f667cf557..ee22d5497 100644 --- a/nuttx/arch/sh/src/m16c/m16c_initialstate.c +++ b/nuttx/arch/sh/src/m16c/m16c_initialstate.c @@ -77,7 +77,7 @@ * ****************************************************************************/ -void up_initial_state(FAR _TCB *tcb) +void up_initial_state(FAR struct tcb_s *tcb) { FAR struct xcptcontext *xcp = &tcb->xcp; FAR uint8_t *regs = xcp->regs; diff --git a/nuttx/arch/sh/src/m16c/m16c_schedulesigaction.c b/nuttx/arch/sh/src/m16c/m16c_schedulesigaction.c index 0dc33568d..d7af7e477 100644 --- a/nuttx/arch/sh/src/m16c/m16c_schedulesigaction.c +++ b/nuttx/arch/sh/src/m16c/m16c_schedulesigaction.c @@ -100,7 +100,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ @@ -120,7 +120,7 @@ void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) sdbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and * a task is signalling itself for some reason. diff --git a/nuttx/arch/sh/src/m16c/m16c_sigdeliver.c b/nuttx/arch/sh/src/m16c/m16c_sigdeliver.c index 958ff56af..7bba3b902 100644 --- a/nuttx/arch/sh/src/m16c/m16c_sigdeliver.c +++ b/nuttx/arch/sh/src/m16c/m16c_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { #ifndef CONFIG_DISABLE_SIGNALS - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint8_t regs[XCPTCONTEXT_SIZE]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/sh/src/sh1/sh1_dumpstate.c b/nuttx/arch/sh/src/sh1/sh1_dumpstate.c index f54ea46ce..3d101c92d 100644 --- a/nuttx/arch/sh/src/sh1/sh1_dumpstate.c +++ b/nuttx/arch/sh/src/sh1/sh1_dumpstate.c @@ -147,7 +147,7 @@ static inline void sh1_registerdump(void) void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint32_t sp = sh1_getsp(); uint32_t ustackbase; uint32_t ustacksize; diff --git a/nuttx/arch/sh/src/sh1/sh1_initialstate.c b/nuttx/arch/sh/src/sh1/sh1_initialstate.c index c4fb11a74..fe703f5a9 100644 --- a/nuttx/arch/sh/src/sh1/sh1_initialstate.c +++ b/nuttx/arch/sh/src/sh1/sh1_initialstate.c @@ -92,7 +92,7 @@ static inline irqstate_t up_getsr(void) * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/sh/src/sh1/sh1_schedulesigaction.c b/nuttx/arch/sh/src/sh1/sh1_schedulesigaction.c index f0bc0af84..1c05d669c 100644 --- a/nuttx/arch/sh/src/sh1/sh1_schedulesigaction.c +++ b/nuttx/arch/sh/src/sh1/sh1_schedulesigaction.c @@ -100,7 +100,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ @@ -120,7 +120,7 @@ void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) sdbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and * a task is signalling itself for some reason. diff --git a/nuttx/arch/sh/src/sh1/sh1_sigdeliver.c b/nuttx/arch/sh/src/sh1/sh1_sigdeliver.c index 2f596b6b0..eb278163d 100644 --- a/nuttx/arch/sh/src/sh1/sh1_sigdeliver.c +++ b/nuttx/arch/sh/src/sh1/sh1_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { #ifndef CONFIG_DISABLE_SIGNALS - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint32_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/sim/src/up_blocktask.c b/nuttx/arch/sim/src/up_blocktask.c index c69c979ae..46598b442 100644 --- a/nuttx/arch/sim/src/up_blocktask.c +++ b/nuttx/arch/sim/src/up_blocktask.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ if ((tcb->task_state < FIRST_READY_TO_RUN_STATE) || @@ -94,7 +94,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; sdbg("Blocking TCB=%p\n", tcb); @@ -136,7 +136,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; sdbg("New Active Task TCB=%p\n", rtcb); /* The way that we handle signals in the simulation is kind of diff --git a/nuttx/arch/sim/src/up_createstack.c b/nuttx/arch/sim/src/up_createstack.c index be8fe278b..268a9ba46 100644 --- a/nuttx/arch/sim/src/up_createstack.c +++ b/nuttx/arch/sim/src/up_createstack.c @@ -85,7 +85,7 @@ * ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { int ret = ERROR; diff --git a/nuttx/arch/sim/src/up_exit.c b/nuttx/arch/sim/src/up_exit.c index 3f82246c9..348c4a9e6 100644 --- a/nuttx/arch/sim/src/up_exit.c +++ b/nuttx/arch/sim/src/up_exit.c @@ -76,7 +76,7 @@ void _exit(int status) { - _TCB* tcb; + struct tcb_s* tcb; sdbg("TCB=%p exitting\n", tcb); @@ -88,7 +88,7 @@ void _exit(int status) * head of the list. */ - tcb = (_TCB*)g_readytorun.head; + tcb = (struct tcb_s*)g_readytorun.head; sdbg("New Active Task TCB=%p\n", tcb); /* The way that we handle signals in the simulation is kind of diff --git a/nuttx/arch/sim/src/up_initialstate.c b/nuttx/arch/sim/src/up_initialstate.c index 6f241fc47..dfa114995 100644 --- a/nuttx/arch/sim/src/up_initialstate.c +++ b/nuttx/arch/sim/src/up_initialstate.c @@ -76,7 +76,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { memset(&tcb->xcp, 0, sizeof(struct xcptcontext)); tcb->xcp.regs[JB_SP] = (uint32_t)tcb->adj_stack_ptr; diff --git a/nuttx/arch/sim/src/up_releasepending.c b/nuttx/arch/sim/src/up_releasepending.c index 52d76bcac..036c65299 100644 --- a/nuttx/arch/sim/src/up_releasepending.c +++ b/nuttx/arch/sim/src/up_releasepending.c @@ -75,7 +75,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; sdbg("From TCB=%p\n", rtcb); @@ -96,7 +96,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; sdbg("New Active Task TCB=%p\n", rtcb); /* The way that we handle signals in the simulation is kind of diff --git a/nuttx/arch/sim/src/up_releasestack.c b/nuttx/arch/sim/src/up_releasestack.c index ef09fcb2a..c1e12ca00 100644 --- a/nuttx/arch/sim/src/up_releasestack.c +++ b/nuttx/arch/sim/src/up_releasestack.c @@ -69,7 +69,7 @@ * ****************************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/sim/src/up_reprioritizertr.c b/nuttx/arch/sim/src/up_reprioritizertr.c index 15c1b26d5..0b18defe6 100644 --- a/nuttx/arch/sim/src/up_reprioritizertr.c +++ b/nuttx/arch/sim/src/up_reprioritizertr.c @@ -85,7 +85,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -103,7 +103,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; sdbg("TCB=%p PRI=%d\n", tcb, priority); @@ -154,7 +154,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; sdbg("New Active Task TCB=%p\n", rtcb); /* The way that we handle signals in the simulation is kind of diff --git a/nuttx/arch/sim/src/up_schedulesigaction.c b/nuttx/arch/sim/src/up_schedulesigaction.c index 871040a94..485f720ca 100644 --- a/nuttx/arch/sim/src/up_schedulesigaction.c +++ b/nuttx/arch/sim/src/up_schedulesigaction.c @@ -96,11 +96,11 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* We don't have to anything complex for the simulated target */ - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { sigdeliver(tcb); } diff --git a/nuttx/arch/sim/src/up_unblocktask.c b/nuttx/arch/sim/src/up_unblocktask.c index 04b6455f3..f8b229f8d 100644 --- a/nuttx/arch/sim/src/up_unblocktask.c +++ b/nuttx/arch/sim/src/up_unblocktask.c @@ -79,7 +79,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ if ((tcb->task_state < FIRST_BLOCKED_STATE) || @@ -89,7 +89,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; sdbg("Unblocking TCB=%p\n", tcb); @@ -124,7 +124,7 @@ void up_unblock_task(_TCB *tcb) * g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; sdbg("New Active Task TCB=%p\n", rtcb); /* The way that we handle signals in the simulation is kind of diff --git a/nuttx/arch/sim/src/up_usestack.c b/nuttx/arch/sim/src/up_usestack.c index aa832ff90..afa419364 100644 --- a/nuttx/arch/sim/src/up_usestack.c +++ b/nuttx/arch/sim/src/up_usestack.c @@ -81,7 +81,7 @@ * ****************************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { /* Move up to next even word boundary if necessary */ diff --git a/nuttx/arch/x86/src/common/up_assert.c b/nuttx/arch/x86/src/common/up_assert.c index 653e8e562..173ca6623 100644 --- a/nuttx/arch/x86/src/common/up_assert.c +++ b/nuttx/arch/x86/src/common/up_assert.c @@ -115,8 +115,8 @@ static void up_stackdump(uint32_t sp, uint32_t stack_base) #ifdef CONFIG_ARCH_STACKDUMP static void up_dumpstate(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - uint32_t sp = up_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + uint32_t sp = up_getsp(); uint32_t ustackbase; uint32_t ustacksize; #if CONFIG_ARCH_INTERRUPTSTACK > 3 @@ -214,7 +214,7 @@ static void _up_assert(int errorcode) { /* Are we in an interrupt handler or the idle task? */ - if (current_regs || ((_TCB*)g_readytorun.head)->pid == 0) + if (current_regs || ((struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -244,7 +244,7 @@ static void _up_assert(int errorcode) void up_assert(const uint8_t *filename, int lineno) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -266,7 +266,7 @@ void up_assert(const uint8_t *filename, int lineno) void up_assert_code(const uint8_t *filename, int lineno, int errorcode) { #ifdef CONFIG_PRINT_TASKNAME - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/x86/src/common/up_blocktask.c b/nuttx/arch/x86/src/common/up_blocktask.c index 530147a97..b1653f1e4 100644 --- a/nuttx/arch/x86/src/common/up_blocktask.c +++ b/nuttx/arch/x86/src/common/up_blocktask.c @@ -83,7 +83,7 @@ * ****************************************************************************/ -void up_block_task(_TCB *tcb, tstate_t task_state) +void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -94,7 +94,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; /* Remove the tcb task from the ready-to-run list. If we @@ -137,7 +137,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -155,7 +155,7 @@ void up_block_task(_TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/x86/src/common/up_exit.c b/nuttx/arch/x86/src/common/up_exit.c index dee6f7d49..2aa21f352 100644 --- a/nuttx/arch/x86/src/common/up_exit.c +++ b/nuttx/arch/x86/src/common/up_exit.c @@ -73,7 +73,7 @@ ****************************************************************************/ #if defined(CONFIG_DUMP_ON_EXIT) && defined(CONFIG_DEBUG) -static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) +static void _up_dumponexit(FAR struct tcb_s *tcb, FAR void *arg) { #if CONFIG_NFILE_DESCRIPTORS > 0 FAR struct filelist *filelist; @@ -136,7 +136,7 @@ static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) void _exit(int status) { - _TCB* tcb; + struct tcb_s* tcb; /* Disable interrupts. They will be restored when the next * task is started. @@ -159,7 +159,7 @@ void _exit(int status) * head of the list. */ - tcb = (_TCB*)g_readytorun.head; + tcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/x86/src/common/up_releasepending.c b/nuttx/arch/x86/src/common/up_releasepending.c index 979e0b50f..3f9f9fc0b 100644 --- a/nuttx/arch/x86/src/common/up_releasepending.c +++ b/nuttx/arch/x86/src/common/up_releasepending.c @@ -75,7 +75,7 @@ void up_release_pending(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -101,7 +101,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -121,7 +121,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/x86/src/common/up_reprioritizertr.c b/nuttx/arch/x86/src/common/up_reprioritizertr.c index 53a0e4315..47c55f6b2 100644 --- a/nuttx/arch/x86/src/common/up_reprioritizertr.c +++ b/nuttx/arch/x86/src/common/up_reprioritizertr.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -102,7 +102,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -156,7 +156,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ @@ -175,7 +175,7 @@ void up_reprioritize_rtr(_TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/x86/src/common/up_unblocktask.c b/nuttx/arch/x86/src/common/up_unblocktask.c index 3397b75e5..eac913886 100644 --- a/nuttx/arch/x86/src/common/up_unblocktask.c +++ b/nuttx/arch/x86/src/common/up_unblocktask.c @@ -78,7 +78,7 @@ * ****************************************************************************/ -void up_unblock_task(_TCB *tcb) +void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -89,7 +89,7 @@ void up_unblock_task(_TCB *tcb) } else { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; /* Remove the task from the blocked task list */ @@ -127,7 +127,7 @@ void up_unblock_task(_TCB *tcb) * of the g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ @@ -147,7 +147,7 @@ void up_unblock_task(_TCB *tcb) * g_readytorun task list. */ - rtcb = (_TCB*)g_readytorun.head; + rtcb = (struct tcb_s*)g_readytorun.head; /* Then switch contexts */ diff --git a/nuttx/arch/x86/src/i486/up_createstack.c b/nuttx/arch/x86/src/i486/up_createstack.c index 1a2f67f33..fc739afdc 100644 --- a/nuttx/arch/x86/src/i486/up_createstack.c +++ b/nuttx/arch/x86/src/i486/up_createstack.c @@ -85,7 +85,7 @@ * ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { @@ -122,7 +122,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/x86/src/i486/up_initialstate.c b/nuttx/arch/x86/src/i486/up_initialstate.c index 078099bd1..8efd0e92a 100644 --- a/nuttx/arch/x86/src/i486/up_initialstate.c +++ b/nuttx/arch/x86/src/i486/up_initialstate.c @@ -77,7 +77,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/x86/src/i486/up_releasestack.c b/nuttx/arch/x86/src/i486/up_releasestack.c index a10a001e1..47b3ea994 100644 --- a/nuttx/arch/x86/src/i486/up_releasestack.c +++ b/nuttx/arch/x86/src/i486/up_releasestack.c @@ -67,7 +67,7 @@ * ****************************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/x86/src/i486/up_schedulesigaction.c b/nuttx/arch/x86/src/i486/up_schedulesigaction.c index bacc12622..1eb773ce8 100644 --- a/nuttx/arch/x86/src/i486/up_schedulesigaction.c +++ b/nuttx/arch/x86/src/i486/up_schedulesigaction.c @@ -96,7 +96,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ @@ -116,7 +116,7 @@ void up_schedule_sigaction(_TCB *tcb, sig_deliver_t sigdeliver) sdbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (_TCB*)g_readytorun.head) + if (tcb == (struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and a task is * signalling itself for some reason. diff --git a/nuttx/arch/x86/src/i486/up_sigdeliver.c b/nuttx/arch/x86/src/i486/up_sigdeliver.c index 468f5bc66..0f2082a20 100644 --- a/nuttx/arch/x86/src/i486/up_sigdeliver.c +++ b/nuttx/arch/x86/src/i486/up_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; uint32_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/x86/src/i486/up_usestack.c b/nuttx/arch/x86/src/i486/up_usestack.c index 4a44c8415..38290dd77 100644 --- a/nuttx/arch/x86/src/i486/up_usestack.c +++ b/nuttx/arch/x86/src/i486/up_usestack.c @@ -81,7 +81,7 @@ * ****************************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; size_t size_of_stack; @@ -110,7 +110,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/z16/src/common/up_assert.c b/nuttx/arch/z16/src/common/up_assert.c index 661d88833..06c77a73e 100644 --- a/nuttx/arch/z16/src/common/up_assert.c +++ b/nuttx/arch/z16/src/common/up_assert.c @@ -81,7 +81,7 @@ static void _up_assert(int errorcode) /* noreturn_function */ { /* Are we in an interrupt handler or the idle task? */ - if (up_interrupt_context() || ((FAR _TCB*)g_readytorun.head)->pid == 0) + if (up_interrupt_context() || ((FAR struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -115,7 +115,7 @@ void up_assert(void) #endif { #if CONFIG_TASK_NAME_SIZE > 0 - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -152,7 +152,7 @@ void up_assert_code(int errorcode) #endif { #if CONFIG_TASK_NAME_SIZE > 0 - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/z16/src/common/up_blocktask.c b/nuttx/arch/z16/src/common/up_blocktask.c index 88b422cf8..93efee96f 100644 --- a/nuttx/arch/z16/src/common/up_blocktask.c +++ b/nuttx/arch/z16/src/common/up_blocktask.c @@ -84,7 +84,7 @@ * ****************************************************************************/ -void up_block_task(FAR _TCB *tcb, tstate_t task_state) +void up_block_task(FAR struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -95,7 +95,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; bool switch_needed; /* dbg("Blocking TCB=%p\n", tcb); */ @@ -140,7 +140,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then setup so that the context will be performed on exit @@ -161,7 +161,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then switch contexts */ diff --git a/nuttx/arch/z16/src/common/up_createstack.c b/nuttx/arch/z16/src/common/up_createstack.c index ed9b1655c..a65c69917 100644 --- a/nuttx/arch/z16/src/common/up_createstack.c +++ b/nuttx/arch/z16/src/common/up_createstack.c @@ -84,7 +84,7 @@ * must be allocated. ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) @@ -120,7 +120,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/z16/src/common/up_exit.c b/nuttx/arch/z16/src/common/up_exit.c index 20b808360..59764484f 100644 --- a/nuttx/arch/z16/src/common/up_exit.c +++ b/nuttx/arch/z16/src/common/up_exit.c @@ -75,7 +75,7 @@ ****************************************************************************/ #if defined(CONFIG_DUMP_ON_EXIT) && defined(CONFIG_DEBUG) -static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) +static void _up_dumponexit(FAR struct tcb_s *tcb, FAR void *arg) { #if CONFIG_NFILE_DESCRIPTORS > 0 FAR struct filelist *filelist; @@ -138,7 +138,7 @@ static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) void _exit(int status) { - FAR _TCB* tcb; + FAR struct tcb_s* tcb; /* Disable interrupts. Interrupts will remain disabled until * the new task is resumed below. @@ -161,7 +161,7 @@ void _exit(int status) * head of the list. */ - tcb = (FAR _TCB*)g_readytorun.head; + tcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", tcb); /* Then switch contexts */ diff --git a/nuttx/arch/z16/src/common/up_initialstate.c b/nuttx/arch/z16/src/common/up_initialstate.c index 8938679ac..50ff3f133 100644 --- a/nuttx/arch/z16/src/common/up_initialstate.c +++ b/nuttx/arch/z16/src/common/up_initialstate.c @@ -76,7 +76,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { uint32_t *reg32 = (uint32_t*)tcb->xcp.regs; diff --git a/nuttx/arch/z16/src/common/up_releasepending.c b/nuttx/arch/z16/src/common/up_releasepending.c index ff9a9782e..a25459730 100644 --- a/nuttx/arch/z16/src/common/up_releasepending.c +++ b/nuttx/arch/z16/src/common/up_releasepending.c @@ -77,7 +77,7 @@ void up_release_pending(void) { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -103,7 +103,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then setup so that the context will be performed on exit @@ -125,7 +125,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/z16/src/common/up_releasestack.c b/nuttx/arch/z16/src/common/up_releasestack.c index f064cae7f..82ba1b122 100644 --- a/nuttx/arch/z16/src/common/up_releasestack.c +++ b/nuttx/arch/z16/src/common/up_releasestack.c @@ -67,7 +67,7 @@ * ************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/z16/src/common/up_reprioritizertr.c b/nuttx/arch/z16/src/common/up_reprioritizertr.c index 6e76d6ce1..2eb5c2cdb 100644 --- a/nuttx/arch/z16/src/common/up_reprioritizertr.c +++ b/nuttx/arch/z16/src/common/up_reprioritizertr.c @@ -86,7 +86,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(FAR struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -104,7 +104,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -158,7 +158,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then setup so that the context will be performed on exit @@ -179,7 +179,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/z16/src/common/up_schedulesigaction.c b/nuttx/arch/z16/src/common/up_schedulesigaction.c index 1c5b9a78c..b241d0a5b 100644 --- a/nuttx/arch/z16/src/common/up_schedulesigaction.c +++ b/nuttx/arch/z16/src/common/up_schedulesigaction.c @@ -100,7 +100,7 @@ * ****************************************************************************/ -void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ @@ -120,7 +120,7 @@ void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) dbg("rtcb=0x%p current_regs=0x%p\n", g_readytorun.head, current_regs); - if (tcb == (FAR _TCB*)g_readytorun.head) + if (tcb == (FAR struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and * a task is signalling itself for some reason. diff --git a/nuttx/arch/z16/src/common/up_sigdeliver.c b/nuttx/arch/z16/src/common/up_sigdeliver.c index d8636bd6f..8f5118798 100644 --- a/nuttx/arch/z16/src/common/up_sigdeliver.c +++ b/nuttx/arch/z16/src/common/up_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { #ifndef CONFIG_DISABLE_SIGNALS - FAR _TCB *rtcb = (_TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; chipreg_t regs[XCPTCONTEXT_REGS]; FAR uint32_t *regs32 = (FAR uint32_t*)regs; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/z16/src/common/up_stackdump.c b/nuttx/arch/z16/src/common/up_stackdump.c index 077b0c8f7..ef9eebb23 100644 --- a/nuttx/arch/z16/src/common/up_stackdump.c +++ b/nuttx/arch/z16/src/common/up_stackdump.c @@ -78,8 +78,8 @@ #ifdef CONFIG_ARCH_STACKDUMP static void up_stackdump(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - chipreg_t sp = up_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + chipreg_t sp = up_getsp(); chipreg_t stack_base = (chipreg_t)rtcb->adj_stack_ptr; chipreg_t stack_size = (chipreg_t)rtcb->adj_stack_size; diff --git a/nuttx/arch/z16/src/common/up_unblocktask.c b/nuttx/arch/z16/src/common/up_unblocktask.c index d72d55424..f63981ab5 100644 --- a/nuttx/arch/z16/src/common/up_unblocktask.c +++ b/nuttx/arch/z16/src/common/up_unblocktask.c @@ -81,7 +81,7 @@ * ****************************************************************************/ -void up_unblock_task(FAR _TCB *tcb) +void up_unblock_task(FAR struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -92,7 +92,7 @@ void up_unblock_task(FAR _TCB *tcb) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("Unblocking TCB=%p\n", tcb); */ @@ -132,7 +132,7 @@ void up_unblock_task(FAR _TCB *tcb) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then setup so that the context will be performed on exit @@ -155,7 +155,7 @@ void up_unblock_task(FAR _TCB *tcb) * g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then switch contexts */ diff --git a/nuttx/arch/z16/src/common/up_usestack.c b/nuttx/arch/z16/src/common/up_usestack.c index 69e4763c5..9ebe01de4 100644 --- a/nuttx/arch/z16/src/common/up_usestack.c +++ b/nuttx/arch/z16/src/common/up_usestack.c @@ -82,7 +82,7 @@ * ************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; size_t size_of_stack; @@ -113,7 +113,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_size = top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/z80/src/common/up_assert.c b/nuttx/arch/z80/src/common/up_assert.c index 11a2a4f2a..27929c97a 100644 --- a/nuttx/arch/z80/src/common/up_assert.c +++ b/nuttx/arch/z80/src/common/up_assert.c @@ -81,7 +81,7 @@ static void _up_assert(int errorcode) /* noreturn_function */ { /* Are we in an interrupt handler or the idle task? */ - if (up_interrupt_context() || ((FAR _TCB*)g_readytorun.head)->pid == 0) + if (up_interrupt_context() || ((FAR struct tcb_s*)g_readytorun.head)->pid == 0) { (void)irqsave(); for(;;) @@ -115,7 +115,7 @@ void up_assert(void) #endif { #if CONFIG_TASK_NAME_SIZE > 0 - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); @@ -152,7 +152,7 @@ void up_assert_code(int errorcode) #endif { #if CONFIG_TASK_NAME_SIZE > 0 - _TCB *rtcb = (_TCB*)g_readytorun.head; + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; #endif up_ledon(LED_ASSERTION); diff --git a/nuttx/arch/z80/src/common/up_blocktask.c b/nuttx/arch/z80/src/common/up_blocktask.c index bbc2be5e6..6a9f050aa 100644 --- a/nuttx/arch/z80/src/common/up_blocktask.c +++ b/nuttx/arch/z80/src/common/up_blocktask.c @@ -85,7 +85,7 @@ * ****************************************************************************/ -void up_block_task(FAR _TCB *tcb, tstate_t task_state) +void up_block_task(FAR struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ @@ -96,7 +96,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; bool switch_needed; /* dbg("Blocking TCB=%p\n", tcb); */ @@ -141,7 +141,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then setup so that the context will be performed on exit @@ -162,7 +162,7 @@ void up_block_task(FAR _TCB *tcb, tstate_t task_state) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then switch contexts */ diff --git a/nuttx/arch/z80/src/common/up_createstack.c b/nuttx/arch/z80/src/common/up_createstack.c index 28246aec3..6636643b1 100644 --- a/nuttx/arch/z80/src/common/up_createstack.c +++ b/nuttx/arch/z80/src/common/up_createstack.c @@ -82,7 +82,7 @@ * must be allocated. ****************************************************************************/ -int up_create_stack(_TCB *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size) { if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) @@ -118,7 +118,7 @@ int up_create_stack(_TCB *tcb, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_ptr = (uint32_t*)top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/z80/src/common/up_exit.c b/nuttx/arch/z80/src/common/up_exit.c index 603a0bfbe..c738202a9 100644 --- a/nuttx/arch/z80/src/common/up_exit.c +++ b/nuttx/arch/z80/src/common/up_exit.c @@ -76,7 +76,7 @@ ****************************************************************************/ #if defined(CONFIG_DUMP_ON_EXIT) && defined(CONFIG_DEBUG) -static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) +static void _up_dumponexit(FAR struct tcb_s *tcb, FAR void *arg) { #if CONFIG_NFILE_DESCRIPTORS > 0 FAR struct filelist *filelist; @@ -139,7 +139,7 @@ static void _up_dumponexit(FAR _TCB *tcb, FAR void *arg) void _exit(int status) { - FAR _TCB* tcb; + FAR struct tcb_s* tcb; /* Disable interrupts. Interrupts will remain disabled until * the new task is resumed below. @@ -162,7 +162,7 @@ void _exit(int status) * head of the list. */ - tcb = (FAR _TCB*)g_readytorun.head; + tcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", tcb); /* Then switch contexts */ diff --git a/nuttx/arch/z80/src/common/up_releasepending.c b/nuttx/arch/z80/src/common/up_releasepending.c index bb5187465..7e9eb9f18 100644 --- a/nuttx/arch/z80/src/common/up_releasepending.c +++ b/nuttx/arch/z80/src/common/up_releasepending.c @@ -78,7 +78,7 @@ void up_release_pending(void) { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("From TCB=%p\n", rtcb); @@ -104,7 +104,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then setup so that the context will be performed on exit @@ -126,7 +126,7 @@ void up_release_pending(void) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/z80/src/common/up_releasestack.c b/nuttx/arch/z80/src/common/up_releasestack.c index d41cc9918..b5c9ef2f9 100644 --- a/nuttx/arch/z80/src/common/up_releasestack.c +++ b/nuttx/arch/z80/src/common/up_releasestack.c @@ -67,7 +67,7 @@ * ************************************************************/ -void up_release_stack(_TCB *dtcb) +void up_release_stack(struct tcb_s *dtcb) { if (dtcb->stack_alloc_ptr) { diff --git a/nuttx/arch/z80/src/common/up_reprioritizertr.c b/nuttx/arch/z80/src/common/up_reprioritizertr.c index b8102c99f..476f324e3 100644 --- a/nuttx/arch/z80/src/common/up_reprioritizertr.c +++ b/nuttx/arch/z80/src/common/up_reprioritizertr.c @@ -87,7 +87,7 @@ * ****************************************************************************/ -void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) +void up_reprioritize_rtr(FAR struct tcb_s *tcb, uint8_t priority) { /* Verify that the caller is sane */ @@ -105,7 +105,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; bool switch_needed; slldbg("TCB=%p PRI=%d\n", tcb, priority); @@ -159,7 +159,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then setup so that the context will be performed on exit @@ -180,7 +180,7 @@ void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; slldbg("New Active Task TCB=%p\n", rtcb); /* Then switch contexts */ diff --git a/nuttx/arch/z80/src/common/up_stackdump.c b/nuttx/arch/z80/src/common/up_stackdump.c index f9c515337..6cb85dd38 100644 --- a/nuttx/arch/z80/src/common/up_stackdump.c +++ b/nuttx/arch/z80/src/common/up_stackdump.c @@ -79,8 +79,8 @@ #ifdef CONFIG_ARCH_STACKDUMP static void up_stackdump(void) { - _TCB *rtcb = (_TCB*)g_readytorun.head; - uint16_t sp = up_getsp(); + struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; + uint16_t sp = up_getsp(); uint16_t stack_base = (uint16_t)rtcb->adj_stack_ptr; uint16_t stack_size = (uint16_t)rtcb->adj_stack_size; diff --git a/nuttx/arch/z80/src/common/up_unblocktask.c b/nuttx/arch/z80/src/common/up_unblocktask.c index d99d6d87d..9f9714bb9 100644 --- a/nuttx/arch/z80/src/common/up_unblocktask.c +++ b/nuttx/arch/z80/src/common/up_unblocktask.c @@ -82,7 +82,7 @@ * ****************************************************************************/ -void up_unblock_task(FAR _TCB *tcb) +void up_unblock_task(FAR struct tcb_s *tcb) { /* Verify that the context switch can be performed */ @@ -93,7 +93,7 @@ void up_unblock_task(FAR _TCB *tcb) } else { - FAR _TCB *rtcb = (FAR _TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("Unblocking TCB=%p\n", tcb); */ @@ -133,7 +133,7 @@ void up_unblock_task(FAR _TCB *tcb) * of the g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then setup so that the context will be performed on exit @@ -156,7 +156,7 @@ void up_unblock_task(FAR _TCB *tcb) * g_readytorun task list. */ - rtcb = (FAR _TCB*)g_readytorun.head; + rtcb = (FAR struct tcb_s*)g_readytorun.head; /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then switch contexts */ diff --git a/nuttx/arch/z80/src/common/up_usestack.c b/nuttx/arch/z80/src/common/up_usestack.c index 7d348a9c6..0aaa5f906 100644 --- a/nuttx/arch/z80/src/common/up_usestack.c +++ b/nuttx/arch/z80/src/common/up_usestack.c @@ -81,7 +81,7 @@ * ************************************************************/ -int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) +int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { size_t top_of_stack; size_t size_of_stack; @@ -112,7 +112,7 @@ int up_use_stack(_TCB *tcb, void *stack, size_t stack_size) top_of_stack &= ~3; size_of_stack = top_of_stack - (uint32_t)tcb->stack_alloc_ptr + 4; - /* Save the adjusted stack values in the _TCB */ + /* Save the adjusted stack values in the struct tcb_s */ tcb->adj_stack_size = top_of_stack; tcb->adj_stack_size = size_of_stack; diff --git a/nuttx/arch/z80/src/ez80/ez80_initialstate.c b/nuttx/arch/z80/src/ez80/ez80_initialstate.c index 9ff56e7c1..945ba5b39 100644 --- a/nuttx/arch/z80/src/ez80/ez80_initialstate.c +++ b/nuttx/arch/z80/src/ez80/ez80_initialstate.c @@ -77,7 +77,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/z80/src/ez80/ez80_schedulesigaction.c b/nuttx/arch/z80/src/ez80/ez80_schedulesigaction.c index 04643304d..c519fb18b 100644 --- a/nuttx/arch/z80/src/ez80/ez80_schedulesigaction.c +++ b/nuttx/arch/z80/src/ez80/ez80_schedulesigaction.c @@ -68,7 +68,7 @@ * Name: ez80_sigsetup ****************************************************************************/ -static void ez80_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs) +static void ez80_sigsetup(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs) { /* Save the return address and interrupt state. These will be restored by * the signal trampoline after the signals have been delivered. @@ -121,7 +121,7 @@ static void ez80_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t * ****************************************************************************/ -void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver) { sdbg("tcb=0x%p sigdeliver=0x%04x\n", tcb, (uint16_t)sigdeliver); @@ -139,7 +139,7 @@ void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) * to the currently executing task. */ - if (tcb == (FAR _TCB*)g_readytorun.head) + if (tcb == (FAR struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and a task is * signalling itself for some reason. diff --git a/nuttx/arch/z80/src/ez80/ez80_sigdeliver.c b/nuttx/arch/z80/src/ez80/ez80_sigdeliver.c index 2d946aa32..aeb2d6316 100644 --- a/nuttx/arch/z80/src/ez80/ez80_sigdeliver.c +++ b/nuttx/arch/z80/src/ez80/ez80_sigdeliver.c @@ -81,7 +81,7 @@ void up_sigdeliver(void) { #ifndef CONFIG_DISABLE_SIGNALS - FAR _TCB *rtcb = (_TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; chipreg_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/z80/src/ez80/switch.h b/nuttx/arch/z80/src/ez80/switch.h index 0970b25ce..f12983a12 100644 --- a/nuttx/arch/z80/src/ez80/switch.h +++ b/nuttx/arch/z80/src/ez80/switch.h @@ -157,7 +157,7 @@ void ez80_restorecontext(FAR chipreg_t *regs); /* Defined in ez80_sigsetup.c */ -void ez80_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, chipreg_t *regs); +void ez80_sigsetup(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver, chipreg_t *regs); /* Defined in ez80_registerdump.c */ diff --git a/nuttx/arch/z80/src/z180/switch.h b/nuttx/arch/z80/src/z180/switch.h index 7bf851a7c..5405ac8a2 100644 --- a/nuttx/arch/z80/src/z180/switch.h +++ b/nuttx/arch/z80/src/z180/switch.h @@ -223,7 +223,7 @@ void z180_restoreusercontext(FAR chipreg_t *regs); /* Defined in z180_sigsetup.c */ -void z180_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs); +void z180_sigsetup(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs); /* Defined in z180_registerdump.c */ diff --git a/nuttx/arch/z80/src/z180/z180_initialstate.c b/nuttx/arch/z80/src/z180/z180_initialstate.c index 8d0211261..491ea6dfb 100644 --- a/nuttx/arch/z80/src/z180/z180_initialstate.c +++ b/nuttx/arch/z80/src/z180/z180_initialstate.c @@ -76,7 +76,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/z80/src/z180/z180_mmu.c b/nuttx/arch/z80/src/z180/z180_mmu.c index 5f9b26be2..09fa65f21 100644 --- a/nuttx/arch/z80/src/z180/z180_mmu.c +++ b/nuttx/arch/z80/src/z180/z180_mmu.c @@ -435,7 +435,7 @@ int up_addrenv_destroy(task_addrenv_t addrenv) * ****************************************************************************/ -int up_addrenv_assign(task_addrenv_t addrenv, FAR _TCB *tcb) +int up_addrenv_assign(task_addrenv_t addrenv, FAR struct tcb_s *tcb) { FAR struct z180_cbr_s *cbr = (FAR struct z180_cbr_s *)addrenv; int ret; @@ -470,7 +470,7 @@ int up_addrenv_assign(task_addrenv_t addrenv, FAR _TCB *tcb) * ****************************************************************************/ -int up_addrenv_share(FAR const _TCB *ptcb, FAR _TCB *ctcb) +int up_addrenv_share(FAR const struct tcb_s *ptcb, FAR struct tcb_s *ctcb) { irqstate_t flags; @@ -513,7 +513,7 @@ int up_addrenv_share(FAR const _TCB *ptcb, FAR _TCB *ctcb) * ****************************************************************************/ -int up_addrenv_release(FAR _TCB *tcb) +int up_addrenv_release(FAR struct tcb_s *tcb) { FAR struct z180_cbr_s *cbr; irqstate_t flags; diff --git a/nuttx/arch/z80/src/z180/z180_schedulesigaction.c b/nuttx/arch/z80/src/z180/z180_schedulesigaction.c index 3d9bbe55b..39344e51f 100644 --- a/nuttx/arch/z80/src/z180/z180_schedulesigaction.c +++ b/nuttx/arch/z80/src/z180/z180_schedulesigaction.c @@ -68,7 +68,7 @@ * Name: z180_sigsetup ****************************************************************************/ -static void z180_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs) +static void z180_sigsetup(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs) { /* Save the return address and interrupt state. These will be restored by * the signal trampoline after the signals have been delivered. @@ -121,7 +121,7 @@ static void z180_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t * ****************************************************************************/ -void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver) { dbg("tcb=0x%p sigdeliver=0x%04x\n", tcb, (uint16_t)sigdeliver); @@ -139,7 +139,7 @@ void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) * to the currently executing task. */ - if (tcb == (FAR _TCB*)g_readytorun.head) + if (tcb == (FAR struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and a task is * signalling itself for some reason. diff --git a/nuttx/arch/z80/src/z180/z180_sigdeliver.c b/nuttx/arch/z80/src/z180/z180_sigdeliver.c index 281cfcf6a..eb3fa8e2c 100644 --- a/nuttx/arch/z80/src/z180/z180_sigdeliver.c +++ b/nuttx/arch/z80/src/z180/z180_sigdeliver.c @@ -80,7 +80,7 @@ void up_sigdeliver(void) { #ifndef CONFIG_DISABLE_SIGNALS - FAR _TCB *rtcb = (_TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; chipreg_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/z80/src/z8/switch.h b/nuttx/arch/z80/src/z8/switch.h index 17f15b6da..3e4a4d28e 100644 --- a/nuttx/arch/z80/src/z8/switch.h +++ b/nuttx/arch/z80/src/z8/switch.h @@ -245,7 +245,7 @@ void z8_restorecontext(FAR chipreg_t *regs); /* Defined in z8_sigsetup.c */ -void z8_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs); +void z8_sigsetup(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs); /* Defined in z8_registerdump.c */ diff --git a/nuttx/arch/z80/src/z8/z8_initialstate.c b/nuttx/arch/z80/src/z8/z8_initialstate.c index 706347da9..496d05b34 100644 --- a/nuttx/arch/z80/src/z8/z8_initialstate.c +++ b/nuttx/arch/z80/src/z8/z8_initialstate.c @@ -78,7 +78,7 @@ * ****************************************************************************/ -void up_initial_state(FAR _TCB *tcb) +void up_initial_state(FAR struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/z80/src/z8/z8_schedulesigaction.c b/nuttx/arch/z80/src/z8/z8_schedulesigaction.c index 7a5f66615..daae09008 100644 --- a/nuttx/arch/z80/src/z8/z8_schedulesigaction.c +++ b/nuttx/arch/z80/src/z8/z8_schedulesigaction.c @@ -68,7 +68,7 @@ * Name: z8_sigsetup ****************************************************************************/ -static void z8_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs) +static void z8_sigsetup(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs) { /* Save the return address and interrupt state. These will be restored by * the signal trampoline after the signals have been delivered. @@ -121,7 +121,7 @@ static void z8_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t * * ****************************************************************************/ -void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver) { dbg("tcb=0x%p sigdeliver=0x%04x\n", tcb, (uint16_t)sigdeliver); @@ -139,7 +139,7 @@ void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) * to the currently executing task. */ - if (tcb == (FAR _TCB*)g_readytorun.head) + if (tcb == (FAR struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and a task is * signalling itself for some reason. diff --git a/nuttx/arch/z80/src/z8/z8_sigdeliver.c b/nuttx/arch/z80/src/z8/z8_sigdeliver.c index d1153a497..50b81a202 100644 --- a/nuttx/arch/z80/src/z8/z8_sigdeliver.c +++ b/nuttx/arch/z80/src/z8/z8_sigdeliver.c @@ -95,7 +95,7 @@ static void z8_copystate(FAR chipreg_t *dest, FAR const chipreg_t *src) void up_sigdeliver(void) { #ifndef CONFIG_DISABLE_SIGNALS - FAR _TCB *rtcb = (_TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; chipreg_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; diff --git a/nuttx/arch/z80/src/z80/switch.h b/nuttx/arch/z80/src/z80/switch.h index 4a49c70ef..472daad78 100644 --- a/nuttx/arch/z80/src/z80/switch.h +++ b/nuttx/arch/z80/src/z80/switch.h @@ -156,7 +156,7 @@ void z80_restoreusercontext(FAR chipreg_t *regs); /* Defined in z80_sigsetup.c */ -void z80_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs); +void z80_sigsetup(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs); /* Defined in z80_registerdump.c */ diff --git a/nuttx/arch/z80/src/z80/z80_initialstate.c b/nuttx/arch/z80/src/z80/z80_initialstate.c index 01cc4f00a..2fcac2ed9 100644 --- a/nuttx/arch/z80/src/z80/z80_initialstate.c +++ b/nuttx/arch/z80/src/z80/z80_initialstate.c @@ -76,7 +76,7 @@ * ****************************************************************************/ -void up_initial_state(_TCB *tcb) +void up_initial_state(struct tcb_s *tcb) { struct xcptcontext *xcp = &tcb->xcp; diff --git a/nuttx/arch/z80/src/z80/z80_schedulesigaction.c b/nuttx/arch/z80/src/z80/z80_schedulesigaction.c index 3b227d5e3..893589726 100644 --- a/nuttx/arch/z80/src/z80/z80_schedulesigaction.c +++ b/nuttx/arch/z80/src/z80/z80_schedulesigaction.c @@ -68,7 +68,7 @@ * Name: z80_sigsetup ****************************************************************************/ -static void z80_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs) +static void z80_sigsetup(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver, FAR chipreg_t *regs) { /* Save the return address and interrupt state. These will be restored by * the signal trampoline after the signals have been delivered. @@ -121,7 +121,7 @@ static void z80_sigsetup(FAR _TCB *tcb, sig_deliver_t sigdeliver, FAR chipreg_t * ****************************************************************************/ -void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) +void up_schedule_sigaction(FAR struct tcb_s *tcb, sig_deliver_t sigdeliver) { dbg("tcb=0x%p sigdeliver=0x%04x\n", tcb, (uint16_t)sigdeliver); @@ -139,7 +139,7 @@ void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver) * to the currently executing task. */ - if (tcb == (FAR _TCB*)g_readytorun.head) + if (tcb == (FAR struct tcb_s*)g_readytorun.head) { /* CASE 1: We are not in an interrupt handler and a task is * signalling itself for some reason. diff --git a/nuttx/arch/z80/src/z80/z80_sigdeliver.c b/nuttx/arch/z80/src/z80/z80_sigdeliver.c index a8fc1e347..3eacd6467 100644 --- a/nuttx/arch/z80/src/z80/z80_sigdeliver.c +++ b/nuttx/arch/z80/src/z80/z80_sigdeliver.c @@ -80,7 +80,7 @@ void up_sigdeliver(void) { #ifndef CONFIG_DISABLE_SIGNALS - FAR _TCB *rtcb = (_TCB*)g_readytorun.head; + FAR struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head; chipreg_t regs[XCPTCONTEXT_REGS]; sig_deliver_t sigdeliver; |