diff --git a/arch/8051/src/up_assert.c b/arch/8051/src/up_assert.c
index 5e59d6af0de..f1f9bb87f79 100644
--- a/arch/8051/src/up_assert.c
+++ b/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/arch/8051/src/up_blocktask.c b/arch/8051/src/up_blocktask.c
index 14dc371dde1..554111ae014 100644
--- a/arch/8051/src/up_blocktask.c
+++ b/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/arch/8051/src/up_exit.c b/arch/8051/src/up_exit.c
index 27b9fe13869..c96467bf9d1 100644
--- a/arch/8051/src/up_exit.c
+++ b/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/arch/8051/src/up_initialize.c b/arch/8051/src/up_initialize.c
index b4835f4d199..c71b6c8df96 100644
--- a/arch/8051/src/up_initialize.c
+++ b/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/arch/8051/src/up_initialstate.c b/arch/8051/src/up_initialstate.c
index 85f172888bf..1defe9f5523 100644
--- a/arch/8051/src/up_initialstate.c
+++ b/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/arch/8051/src/up_internal.h b/arch/8051/src/up_internal.h
index c213cc3d406..46f4ffb20c6 100644
--- a/arch/8051/src/up_internal.h
+++ b/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/arch/8051/src/up_releasepending.c b/arch/8051/src/up_releasepending.c
index 55f46edae77..0d87608cf63 100644
--- a/arch/8051/src/up_releasepending.c
+++ b/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/arch/8051/src/up_reprioritizertr.c b/arch/8051/src/up_reprioritizertr.c
index 0d1941f6669..14c14e663a8 100644
--- a/arch/8051/src/up_reprioritizertr.c
+++ b/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/arch/8051/src/up_unblocktask.c b/arch/8051/src/up_unblocktask.c
index 1c82236a5fa..f3f9215497e 100644
--- a/arch/8051/src/up_unblocktask.c
+++ b/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/arch/arm/src/arm/up_allocpage.c b/arch/arm/src/arm/up_allocpage.c
index 0284e48bc32..8ec99b09c09 100644
--- a/arch/arm/src/arm/up_allocpage.c
+++ b/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/arch/arm/src/arm/up_assert.c b/arch/arm/src/arm/up_assert.c
index 5f713c34d8d..d97aba5ea36 100644
--- a/arch/arm/src/arm/up_assert.c
+++ b/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/arch/arm/src/arm/up_blocktask.c b/arch/arm/src/arm/up_blocktask.c
index f72a0246538..090cc64071e 100644
--- a/arch/arm/src/arm/up_blocktask.c
+++ b/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/arch/arm/src/arm/up_checkmapping.c b/arch/arm/src/arm/up_checkmapping.c
index ca8c3a03230..f86b6de7558 100644
--- a/arch/arm/src/arm/up_checkmapping.c
+++ b/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/arch/arm/src/arm/up_dataabort.c b/arch/arm/src/arm/up_dataabort.c
index 60ef8385ea7..99b3bf2ab79 100644
--- a/arch/arm/src/arm/up_dataabort.c
+++ b/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/arch/arm/src/arm/up_initialstate.c b/arch/arm/src/arm/up_initialstate.c
index fb672a2aca3..7d8ef65b18e 100644
--- a/arch/arm/src/arm/up_initialstate.c
+++ b/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/arch/arm/src/arm/up_prefetchabort.c b/arch/arm/src/arm/up_prefetchabort.c
index 9d028b0d4e2..541586de97b 100644
--- a/arch/arm/src/arm/up_prefetchabort.c
+++ b/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/arch/arm/src/arm/up_releasepending.c b/arch/arm/src/arm/up_releasepending.c
index 8adeeb26d90..169262e9580 100644
--- a/arch/arm/src/arm/up_releasepending.c
+++ b/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/arch/arm/src/arm/up_reprioritizertr.c b/arch/arm/src/arm/up_reprioritizertr.c
index 02bc39d6250..76979408327 100644
--- a/arch/arm/src/arm/up_reprioritizertr.c
+++ b/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/arch/arm/src/arm/up_schedulesigaction.c b/arch/arm/src/arm/up_schedulesigaction.c
index a76438f946f..f7d33254b0a 100644
--- a/arch/arm/src/arm/up_schedulesigaction.c
+++ b/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/arch/arm/src/arm/up_sigdeliver.c b/arch/arm/src/arm/up_sigdeliver.c
index 8684494483f..9459bf7e97f 100644
--- a/arch/arm/src/arm/up_sigdeliver.c
+++ b/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/arch/arm/src/arm/up_unblocktask.c b/arch/arm/src/arm/up_unblocktask.c
index 633dc4e8212..a2dc0f69431 100644
--- a/arch/arm/src/arm/up_unblocktask.c
+++ b/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/arch/arm/src/armv7-m/up_assert.c b/arch/arm/src/armv7-m/up_assert.c
index b40b1090c14..394c6858f40 100644
--- a/arch/arm/src/armv7-m/up_assert.c
+++ b/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/arch/arm/src/armv7-m/up_blocktask.c b/arch/arm/src/armv7-m/up_blocktask.c
index 896476ed2ed..15558ed4d7f 100644
--- a/arch/arm/src/armv7-m/up_blocktask.c
+++ b/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/arch/arm/src/armv7-m/up_initialstate.c b/arch/arm/src/armv7-m/up_initialstate.c
index 635a700fdf3..ee523a0167e 100644
--- a/arch/arm/src/armv7-m/up_initialstate.c
+++ b/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/arch/arm/src/armv7-m/up_releasepending.c b/arch/arm/src/armv7-m/up_releasepending.c
index 2f0d4dc39b7..21c79bfc7a3 100644
--- a/arch/arm/src/armv7-m/up_releasepending.c
+++ b/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/arch/arm/src/armv7-m/up_reprioritizertr.c b/arch/arm/src/armv7-m/up_reprioritizertr.c
index 9a971f0646f..94708a3be94 100644
--- a/arch/arm/src/armv7-m/up_reprioritizertr.c
+++ b/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/arch/arm/src/armv7-m/up_schedulesigaction.c b/arch/arm/src/armv7-m/up_schedulesigaction.c
index 9221a69a2ec..32f7082b3c5 100644
--- a/arch/arm/src/armv7-m/up_schedulesigaction.c
+++ b/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/arch/arm/src/armv7-m/up_sigdeliver.c b/arch/arm/src/armv7-m/up_sigdeliver.c
index 654214b39cc..2e75d254a17 100644
--- a/arch/arm/src/armv7-m/up_sigdeliver.c
+++ b/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/arch/arm/src/armv7-m/up_svcall.c b/arch/arm/src/armv7-m/up_svcall.c
index d32f0afc2ab..9fa5a0b8218 100644
--- a/arch/arm/src/armv7-m/up_svcall.c
+++ b/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/arch/arm/src/armv7-m/up_unblocktask.c b/arch/arm/src/armv7-m/up_unblocktask.c
index da10f037632..b2ff98879b4 100644
--- a/arch/arm/src/armv7-m/up_unblocktask.c
+++ b/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/arch/arm/src/common/up_checkstack.c b/arch/arm/src/common/up_checkstack.c
index ac8d9e7b91d..273d30d2379 100644
--- a/arch/arm/src/common/up_checkstack.c
+++ b/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/arch/arm/src/common/up_createstack.c b/arch/arm/src/common/up_createstack.c
index 3d6dfef4549..e3f963227f1 100644
--- a/arch/arm/src/common/up_createstack.c
+++ b/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/arch/arm/src/common/up_exit.c b/arch/arm/src/common/up_exit.c
index 16f5c444266..76bf4e0dd38 100644
--- a/arch/arm/src/common/up_exit.c
+++ b/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/arch/arm/src/common/up_internal.h b/arch/arm/src/common/up_internal.h
index 8a24f003e70..981fe7ae82a 100644
--- a/arch/arm/src/common/up_internal.h
+++ b/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/arch/arm/src/common/up_releasestack.c b/arch/arm/src/common/up_releasestack.c
index 82f5db88ff8..cb0bf030ade 100644
--- a/arch/arm/src/common/up_releasestack.c
+++ b/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/arch/arm/src/common/up_usestack.c b/arch/arm/src/common/up_usestack.c
index a3f4f48163e..d94f99a5756 100644
--- a/arch/arm/src/common/up_usestack.c
+++ b/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/arch/arm/src/common/up_vfork.c b/arch/arm/src/common/up_vfork.c
index 3b653e31704..f576f6bfd9c 100644
--- a/arch/arm/src/common/up_vfork.c
+++ b/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/arch/avr/src/avr/up_blocktask.c b/arch/avr/src/avr/up_blocktask.c
index 4bc587903de..7d48da78a35 100644
--- a/arch/avr/src/avr/up_blocktask.c
+++ b/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/arch/avr/src/avr/up_checkstack.c b/arch/avr/src/avr/up_checkstack.c
index b8325ccbc8e..e58ee0ca31d 100644
--- a/arch/avr/src/avr/up_checkstack.c
+++ b/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/arch/avr/src/avr/up_createstack.c b/arch/avr/src/avr/up_createstack.c
index 67219ec9c14..904a4acabde 100644
--- a/arch/avr/src/avr/up_createstack.c
+++ b/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/arch/avr/src/avr/up_dumpstate.c b/arch/avr/src/avr/up_dumpstate.c
index 3ce595bf07c..62e80255fcf 100644
--- a/arch/avr/src/avr/up_dumpstate.c
+++ b/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/arch/avr/src/avr/up_initialstate.c b/arch/avr/src/avr/up_initialstate.c
index 12fead20ae3..8672e6da752 100644
--- a/arch/avr/src/avr/up_initialstate.c
+++ b/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/arch/avr/src/avr/up_releasepending.c b/arch/avr/src/avr/up_releasepending.c
index 5684dcf5502..0a63189fe6d 100644
--- a/arch/avr/src/avr/up_releasepending.c
+++ b/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/arch/avr/src/avr/up_reprioritizertr.c b/arch/avr/src/avr/up_reprioritizertr.c
index af329c13f38..5b23a37a11a 100644
--- a/arch/avr/src/avr/up_reprioritizertr.c
+++ b/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/arch/avr/src/avr/up_schedulesigaction.c b/arch/avr/src/avr/up_schedulesigaction.c
index a70158a0deb..304f2dc2286 100644
--- a/arch/avr/src/avr/up_schedulesigaction.c
+++ b/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/arch/avr/src/avr/up_sigdeliver.c b/arch/avr/src/avr/up_sigdeliver.c
index 4398dba6b2b..40075379903 100644
--- a/arch/avr/src/avr/up_sigdeliver.c
+++ b/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/arch/avr/src/avr/up_unblocktask.c b/arch/avr/src/avr/up_unblocktask.c
index 0eff2edcd88..f1707b7bdee 100644
--- a/arch/avr/src/avr/up_unblocktask.c
+++ b/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/arch/avr/src/avr/up_usestack.c b/arch/avr/src/avr/up_usestack.c
index cedc9afe316..cd93f5d23c3 100644
--- a/arch/avr/src/avr/up_usestack.c
+++ b/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/arch/avr/src/avr32/up_blocktask.c b/arch/avr/src/avr32/up_blocktask.c
index 5d05350e684..a5ff53ae9ed 100644
--- a/arch/avr/src/avr32/up_blocktask.c
+++ b/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/arch/avr/src/avr32/up_createstack.c b/arch/avr/src/avr32/up_createstack.c
index 2d34a9adfef..93bbad6af38 100644
--- a/arch/avr/src/avr32/up_createstack.c
+++ b/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/arch/avr/src/avr32/up_dumpstate.c b/arch/avr/src/avr32/up_dumpstate.c
index d6113d40b93..32db56f0d43 100644
--- a/arch/avr/src/avr32/up_dumpstate.c
+++ b/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/arch/avr/src/avr32/up_initialstate.c b/arch/avr/src/avr32/up_initialstate.c
index fe3a79d90ba..adfc955960f 100644
--- a/arch/avr/src/avr32/up_initialstate.c
+++ b/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/arch/avr/src/avr32/up_releasepending.c b/arch/avr/src/avr32/up_releasepending.c
index 3cf29e623b0..00956e44205 100644
--- a/arch/avr/src/avr32/up_releasepending.c
+++ b/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/arch/avr/src/avr32/up_reprioritizertr.c b/arch/avr/src/avr32/up_reprioritizertr.c
index 0aad214e81e..bc9ba21f049 100644
--- a/arch/avr/src/avr32/up_reprioritizertr.c
+++ b/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/arch/avr/src/avr32/up_schedulesigaction.c b/arch/avr/src/avr32/up_schedulesigaction.c
index edf145a17c1..a710672dc65 100644
--- a/arch/avr/src/avr32/up_schedulesigaction.c
+++ b/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/arch/avr/src/avr32/up_sigdeliver.c b/arch/avr/src/avr32/up_sigdeliver.c
index 8c1c0b705d9..d9b46689058 100644
--- a/arch/avr/src/avr32/up_sigdeliver.c
+++ b/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/arch/avr/src/avr32/up_unblocktask.c b/arch/avr/src/avr32/up_unblocktask.c
index da6b31f8335..5ce48e3665b 100644
--- a/arch/avr/src/avr32/up_unblocktask.c
+++ b/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/arch/avr/src/avr32/up_usestack.c b/arch/avr/src/avr32/up_usestack.c
index e73de3fb06b..5afadb922d8 100644
--- a/arch/avr/src/avr32/up_usestack.c
+++ b/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/arch/avr/src/common/up_assert.c b/arch/avr/src/common/up_assert.c
index be7f635e81a..2e70a9c2893 100644
--- a/arch/avr/src/common/up_assert.c
+++ b/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/arch/avr/src/common/up_exit.c b/arch/avr/src/common/up_exit.c
index 68e33fde7d9..3b316123b17 100644
--- a/arch/avr/src/common/up_exit.c
+++ b/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/arch/avr/src/common/up_releasestack.c b/arch/avr/src/common/up_releasestack.c
index 2cf3c30e862..98b1faea104 100644
--- a/arch/avr/src/common/up_releasestack.c
+++ b/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/arch/hc/src/common/up_blocktask.c b/arch/hc/src/common/up_blocktask.c
index 4e5bf1826ba..da7131c4c14 100644
--- a/arch/hc/src/common/up_blocktask.c
+++ b/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/arch/hc/src/common/up_createstack.c b/arch/hc/src/common/up_createstack.c
index ef0a9df9c35..8c29190ae6c 100644
--- a/arch/hc/src/common/up_createstack.c
+++ b/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/arch/hc/src/common/up_exit.c b/arch/hc/src/common/up_exit.c
index 1c46875f84b..9fad697f190 100644
--- a/arch/hc/src/common/up_exit.c
+++ b/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/arch/hc/src/common/up_releasepending.c b/arch/hc/src/common/up_releasepending.c
index 0c09cb0c6cd..b8da18d60c1 100644
--- a/arch/hc/src/common/up_releasepending.c
+++ b/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/arch/hc/src/common/up_releasestack.c b/arch/hc/src/common/up_releasestack.c
index d3d917fc364..3d8b6117688 100644
--- a/arch/hc/src/common/up_releasestack.c
+++ b/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/arch/hc/src/common/up_reprioritizertr.c b/arch/hc/src/common/up_reprioritizertr.c
index 31c76a9f53a..92e18ff47e1 100644
--- a/arch/hc/src/common/up_reprioritizertr.c
+++ b/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/arch/hc/src/common/up_unblocktask.c b/arch/hc/src/common/up_unblocktask.c
index 9518da774bc..7d5f67a1b14 100644
--- a/arch/hc/src/common/up_unblocktask.c
+++ b/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/arch/hc/src/common/up_usestack.c b/arch/hc/src/common/up_usestack.c
index b0349b21b30..53a571ed4ba 100644
--- a/arch/hc/src/common/up_usestack.c
+++ b/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/arch/hc/src/m9s12/m9s12_assert.c b/arch/hc/src/m9s12/m9s12_assert.c
index 37ad5e30d23..62ad33d2d12 100644
--- a/arch/hc/src/m9s12/m9s12_assert.c
+++ b/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/arch/hc/src/m9s12/m9s12_initialstate.c b/arch/hc/src/m9s12/m9s12_initialstate.c
index 80bb5fe0356..3259cbb9ac2 100644
--- a/arch/hc/src/m9s12/m9s12_initialstate.c
+++ b/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/arch/mips/src/common/up_createstack.c b/arch/mips/src/common/up_createstack.c
index d5c285e25e6..722c1a35ec0 100644
--- a/arch/mips/src/common/up_createstack.c
+++ b/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/arch/mips/src/common/up_exit.c b/arch/mips/src/common/up_exit.c
index e112364b4b6..a5746f8aa82 100644
--- a/arch/mips/src/common/up_exit.c
+++ b/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/arch/mips/src/common/up_releasestack.c b/arch/mips/src/common/up_releasestack.c
index a54ea70cdbd..7cbeb86e7e2 100644
--- a/arch/mips/src/common/up_releasestack.c
+++ b/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/arch/mips/src/common/up_usestack.c b/arch/mips/src/common/up_usestack.c
index e41608f67d9..6fa521579e0 100644
--- a/arch/mips/src/common/up_usestack.c
+++ b/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/arch/mips/src/mips32/up_assert.c b/arch/mips/src/mips32/up_assert.c
index f27bc0ebe79..9f503ac8520 100644
--- a/arch/mips/src/mips32/up_assert.c
+++ b/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/arch/mips/src/mips32/up_blocktask.c b/arch/mips/src/mips32/up_blocktask.c
index 47fd4024b18..8d209da9f5e 100644
--- a/arch/mips/src/mips32/up_blocktask.c
+++ b/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/arch/mips/src/mips32/up_dumpstate.c b/arch/mips/src/mips32/up_dumpstate.c
index 1cd4267677c..064aa0681fe 100644
--- a/arch/mips/src/mips32/up_dumpstate.c
+++ b/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/arch/mips/src/mips32/up_initialstate.c b/arch/mips/src/mips32/up_initialstate.c
index 0c24d1ee03f..a4d204b307a 100644
--- a/arch/mips/src/mips32/up_initialstate.c
+++ b/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/arch/mips/src/mips32/up_releasepending.c b/arch/mips/src/mips32/up_releasepending.c
index 13918ca2166..7999bffebc0 100644
--- a/arch/mips/src/mips32/up_releasepending.c
+++ b/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/arch/mips/src/mips32/up_reprioritizertr.c b/arch/mips/src/mips32/up_reprioritizertr.c
index 2e5f41d6879..f4034cc1eee 100644
--- a/arch/mips/src/mips32/up_reprioritizertr.c
+++ b/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/arch/mips/src/mips32/up_schedulesigaction.c b/arch/mips/src/mips32/up_schedulesigaction.c
index f81fd890a73..1ab8c2b5627 100644
--- a/arch/mips/src/mips32/up_schedulesigaction.c
+++ b/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/arch/mips/src/mips32/up_sigdeliver.c b/arch/mips/src/mips32/up_sigdeliver.c
index 8009b369c87..0abc270d388 100644
--- a/arch/mips/src/mips32/up_sigdeliver.c
+++ b/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/arch/mips/src/mips32/up_swint0.c b/arch/mips/src/mips32/up_swint0.c
index 87ccddf7194..fc03de58bbb 100644
--- a/arch/mips/src/mips32/up_swint0.c
+++ b/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/arch/mips/src/mips32/up_unblocktask.c b/arch/mips/src/mips32/up_unblocktask.c
index 5dafe90f0ed..70a5a72410d 100644
--- a/arch/mips/src/mips32/up_unblocktask.c
+++ b/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/arch/mips/src/mips32/up_vfork.c b/arch/mips/src/mips32/up_vfork.c
index 6b7e27f318b..58e20f42d02 100644
--- a/arch/mips/src/mips32/up_vfork.c
+++ b/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/arch/rgmp/include/arch.h b/arch/rgmp/include/arch.h
index 32eb16ee360..af99356ea16 100644
--- a/arch/rgmp/include/arch.h
+++ b/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/arch/rgmp/src/arm/arch_nuttx.c b/arch/rgmp/src/arm/arch_nuttx.c
index cb946bfd1a4..e916c5520ff 100644
--- a/arch/rgmp/src/arm/arch_nuttx.c
+++ b/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/arch/rgmp/src/nuttx.c b/arch/rgmp/src/nuttx.c
index 7deb959a288..6cb300f82ef 100644
--- a/arch/rgmp/src/nuttx.c
+++ b/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/arch/rgmp/src/rgmp.c b/arch/rgmp/src/rgmp.c
index 479696fb5e2..db5dd955e87 100644
--- a/arch/rgmp/src/rgmp.c
+++ b/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/arch/rgmp/src/x86/arch_nuttx.c b/arch/rgmp/src/x86/arch_nuttx.c
index 04b8fa8c82a..c691784d950 100644
--- a/arch/rgmp/src/x86/arch_nuttx.c
+++ b/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/arch/sh/src/common/up_assert.c b/arch/sh/src/common/up_assert.c
index 62889fa5ab0..72880fd2ab0 100644
--- a/arch/sh/src/common/up_assert.c
+++ b/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/arch/sh/src/common/up_blocktask.c b/arch/sh/src/common/up_blocktask.c
index 0a53b6633ea..db7f0297c66 100644
--- a/arch/sh/src/common/up_blocktask.c
+++ b/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/arch/sh/src/common/up_createstack.c b/arch/sh/src/common/up_createstack.c
index f80e4f7c006..f868750de1f 100644
--- a/arch/sh/src/common/up_createstack.c
+++ b/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/arch/sh/src/common/up_exit.c b/arch/sh/src/common/up_exit.c
index 705f4985253..31c8e040493 100644
--- a/arch/sh/src/common/up_exit.c
+++ b/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/arch/sh/src/common/up_releasepending.c b/arch/sh/src/common/up_releasepending.c
index 955febea148..b3960972dd0 100644
--- a/arch/sh/src/common/up_releasepending.c
+++ b/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/arch/sh/src/common/up_releasestack.c b/arch/sh/src/common/up_releasestack.c
index bb6739433be..3b4e4c91436 100644
--- a/arch/sh/src/common/up_releasestack.c
+++ b/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/arch/sh/src/common/up_reprioritizertr.c b/arch/sh/src/common/up_reprioritizertr.c
index 99d350b29e2..dcf0fcd7b0b 100644
--- a/arch/sh/src/common/up_reprioritizertr.c
+++ b/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/arch/sh/src/common/up_unblocktask.c b/arch/sh/src/common/up_unblocktask.c
index 5841f50adbd..b7c88f82394 100644
--- a/arch/sh/src/common/up_unblocktask.c
+++ b/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/arch/sh/src/common/up_usestack.c b/arch/sh/src/common/up_usestack.c
index 41367ce0b28..ee26cb70c9b 100644
--- a/arch/sh/src/common/up_usestack.c
+++ b/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/arch/sh/src/m16c/m16c_dumpstate.c b/arch/sh/src/m16c/m16c_dumpstate.c
index 38571a7e110..3570a9ebe87 100644
--- a/arch/sh/src/m16c/m16c_dumpstate.c
+++ b/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/arch/sh/src/m16c/m16c_initialstate.c b/arch/sh/src/m16c/m16c_initialstate.c
index f667cf55726..ee22d5497d5 100644
--- a/arch/sh/src/m16c/m16c_initialstate.c
+++ b/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/arch/sh/src/m16c/m16c_schedulesigaction.c b/arch/sh/src/m16c/m16c_schedulesigaction.c
index 0dc33568d22..d7af7e47798 100644
--- a/arch/sh/src/m16c/m16c_schedulesigaction.c
+++ b/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/arch/sh/src/m16c/m16c_sigdeliver.c b/arch/sh/src/m16c/m16c_sigdeliver.c
index 958ff56af62..7bba3b90222 100644
--- a/arch/sh/src/m16c/m16c_sigdeliver.c
+++ b/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/arch/sh/src/sh1/sh1_dumpstate.c b/arch/sh/src/sh1/sh1_dumpstate.c
index f54ea46cef4..3d101c92dd9 100644
--- a/arch/sh/src/sh1/sh1_dumpstate.c
+++ b/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/arch/sh/src/sh1/sh1_initialstate.c b/arch/sh/src/sh1/sh1_initialstate.c
index c4fb11a7457..fe703f5a93f 100644
--- a/arch/sh/src/sh1/sh1_initialstate.c
+++ b/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/arch/sh/src/sh1/sh1_schedulesigaction.c b/arch/sh/src/sh1/sh1_schedulesigaction.c
index f0bc0af8483..1c05d669c32 100644
--- a/arch/sh/src/sh1/sh1_schedulesigaction.c
+++ b/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/arch/sh/src/sh1/sh1_sigdeliver.c b/arch/sh/src/sh1/sh1_sigdeliver.c
index 2f596b6b0f1..eb278163d2d 100644
--- a/arch/sh/src/sh1/sh1_sigdeliver.c
+++ b/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/arch/sim/src/up_blocktask.c b/arch/sim/src/up_blocktask.c
index c69c979aeb4..46598b442cd 100644
--- a/arch/sim/src/up_blocktask.c
+++ b/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/arch/sim/src/up_createstack.c b/arch/sim/src/up_createstack.c
index be8fe278b41..268a9ba46d0 100644
--- a/arch/sim/src/up_createstack.c
+++ b/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/arch/sim/src/up_exit.c b/arch/sim/src/up_exit.c
index 3f82246c97e..348c4a9e656 100644
--- a/arch/sim/src/up_exit.c
+++ b/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/arch/sim/src/up_initialstate.c b/arch/sim/src/up_initialstate.c
index 6f241fc47da..dfa11499546 100644
--- a/arch/sim/src/up_initialstate.c
+++ b/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/arch/sim/src/up_releasepending.c b/arch/sim/src/up_releasepending.c
index 52d76bcace8..036c652995f 100644
--- a/arch/sim/src/up_releasepending.c
+++ b/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/arch/sim/src/up_releasestack.c b/arch/sim/src/up_releasestack.c
index ef09fcb2a9a..c1e12ca00e9 100644
--- a/arch/sim/src/up_releasestack.c
+++ b/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/arch/sim/src/up_reprioritizertr.c b/arch/sim/src/up_reprioritizertr.c
index 15c1b26d55c..0b18defe6d8 100644
--- a/arch/sim/src/up_reprioritizertr.c
+++ b/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/arch/sim/src/up_schedulesigaction.c b/arch/sim/src/up_schedulesigaction.c
index 871040a9490..485f720cade 100644
--- a/arch/sim/src/up_schedulesigaction.c
+++ b/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/arch/sim/src/up_unblocktask.c b/arch/sim/src/up_unblocktask.c
index 04b6455f31c..f8b229f8d7c 100644
--- a/arch/sim/src/up_unblocktask.c
+++ b/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/arch/sim/src/up_usestack.c b/arch/sim/src/up_usestack.c
index aa832ff9025..afa41936410 100644
--- a/arch/sim/src/up_usestack.c
+++ b/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/arch/x86/src/common/up_assert.c b/arch/x86/src/common/up_assert.c
index 653e8e562f3..173ca6623c0 100644
--- a/arch/x86/src/common/up_assert.c
+++ b/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/arch/x86/src/common/up_blocktask.c b/arch/x86/src/common/up_blocktask.c
index 530147a9787..b1653f1e42a 100644
--- a/arch/x86/src/common/up_blocktask.c
+++ b/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/arch/x86/src/common/up_exit.c b/arch/x86/src/common/up_exit.c
index dee6f7d498b..2aa21f35226 100644
--- a/arch/x86/src/common/up_exit.c
+++ b/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/arch/x86/src/common/up_releasepending.c b/arch/x86/src/common/up_releasepending.c
index 979e0b50f62..3f9f9fc0b1d 100644
--- a/arch/x86/src/common/up_releasepending.c
+++ b/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/arch/x86/src/common/up_reprioritizertr.c b/arch/x86/src/common/up_reprioritizertr.c
index 53a0e431517..47c55f6b299 100644
--- a/arch/x86/src/common/up_reprioritizertr.c
+++ b/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/arch/x86/src/common/up_unblocktask.c b/arch/x86/src/common/up_unblocktask.c
index 3397b75e563..eac913886fc 100644
--- a/arch/x86/src/common/up_unblocktask.c
+++ b/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/arch/x86/src/i486/up_createstack.c b/arch/x86/src/i486/up_createstack.c
index 1a2f67f335b..fc739afdc44 100644
--- a/arch/x86/src/i486/up_createstack.c
+++ b/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/arch/x86/src/i486/up_initialstate.c b/arch/x86/src/i486/up_initialstate.c
index 078099bd124..8efd0e92a55 100644
--- a/arch/x86/src/i486/up_initialstate.c
+++ b/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/arch/x86/src/i486/up_releasestack.c b/arch/x86/src/i486/up_releasestack.c
index a10a001e1ab..47b3ea994dd 100644
--- a/arch/x86/src/i486/up_releasestack.c
+++ b/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/arch/x86/src/i486/up_schedulesigaction.c b/arch/x86/src/i486/up_schedulesigaction.c
index bacc126223b..1eb773ce899 100644
--- a/arch/x86/src/i486/up_schedulesigaction.c
+++ b/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/arch/x86/src/i486/up_sigdeliver.c b/arch/x86/src/i486/up_sigdeliver.c
index 468f5bc6662..0f2082a204f 100644
--- a/arch/x86/src/i486/up_sigdeliver.c
+++ b/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/arch/x86/src/i486/up_usestack.c b/arch/x86/src/i486/up_usestack.c
index 4a44c84151d..38290dd777f 100644
--- a/arch/x86/src/i486/up_usestack.c
+++ b/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/arch/z16/src/common/up_assert.c b/arch/z16/src/common/up_assert.c
index 661d8883385..06c77a73e7c 100644
--- a/arch/z16/src/common/up_assert.c
+++ b/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/arch/z16/src/common/up_blocktask.c b/arch/z16/src/common/up_blocktask.c
index 88b422cf888..93efee96f84 100644
--- a/arch/z16/src/common/up_blocktask.c
+++ b/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/arch/z16/src/common/up_createstack.c b/arch/z16/src/common/up_createstack.c
index ed9b1655cb5..a65c699178a 100644
--- a/arch/z16/src/common/up_createstack.c
+++ b/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/arch/z16/src/common/up_exit.c b/arch/z16/src/common/up_exit.c
index 20b808360b0..59764484fde 100644
--- a/arch/z16/src/common/up_exit.c
+++ b/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/arch/z16/src/common/up_initialstate.c b/arch/z16/src/common/up_initialstate.c
index 8938679aca5..50ff3f13371 100644
--- a/arch/z16/src/common/up_initialstate.c
+++ b/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/arch/z16/src/common/up_releasepending.c b/arch/z16/src/common/up_releasepending.c
index ff9a9782ee9..a25459730bb 100644
--- a/arch/z16/src/common/up_releasepending.c
+++ b/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/arch/z16/src/common/up_releasestack.c b/arch/z16/src/common/up_releasestack.c
index f064cae7ffd..82ba1b122b5 100644
--- a/arch/z16/src/common/up_releasestack.c
+++ b/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/arch/z16/src/common/up_reprioritizertr.c b/arch/z16/src/common/up_reprioritizertr.c
index 6e76d6ce156..2eb5c2cdb50 100644
--- a/arch/z16/src/common/up_reprioritizertr.c
+++ b/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/arch/z16/src/common/up_schedulesigaction.c b/arch/z16/src/common/up_schedulesigaction.c
index 1c5b9a78c59..b241d0a5b1b 100644
--- a/arch/z16/src/common/up_schedulesigaction.c
+++ b/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/arch/z16/src/common/up_sigdeliver.c b/arch/z16/src/common/up_sigdeliver.c
index d8636bd6f5f..8f511879893 100644
--- a/arch/z16/src/common/up_sigdeliver.c
+++ b/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/arch/z16/src/common/up_stackdump.c b/arch/z16/src/common/up_stackdump.c
index 077b0c8f75e..ef9eebb2383 100644
--- a/arch/z16/src/common/up_stackdump.c
+++ b/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/arch/z16/src/common/up_unblocktask.c b/arch/z16/src/common/up_unblocktask.c
index d72d554241d..f63981ab54e 100644
--- a/arch/z16/src/common/up_unblocktask.c
+++ b/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/arch/z16/src/common/up_usestack.c b/arch/z16/src/common/up_usestack.c
index 69e4763c53e..9ebe01de4a3 100644
--- a/arch/z16/src/common/up_usestack.c
+++ b/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/arch/z80/src/common/up_assert.c b/arch/z80/src/common/up_assert.c
index 11a2a4f2a89..27929c97a80 100644
--- a/arch/z80/src/common/up_assert.c
+++ b/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/arch/z80/src/common/up_blocktask.c b/arch/z80/src/common/up_blocktask.c
index bbc2be5e658..6a9f050aaee 100644
--- a/arch/z80/src/common/up_blocktask.c
+++ b/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/arch/z80/src/common/up_createstack.c b/arch/z80/src/common/up_createstack.c
index 28246aec331..6636643b101 100644
--- a/arch/z80/src/common/up_createstack.c
+++ b/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/arch/z80/src/common/up_exit.c b/arch/z80/src/common/up_exit.c
index 603a0bfbe1b..c738202a9f8 100644
--- a/arch/z80/src/common/up_exit.c
+++ b/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/arch/z80/src/common/up_releasepending.c b/arch/z80/src/common/up_releasepending.c
index bb51874653d..7e9eb9f18cb 100644
--- a/arch/z80/src/common/up_releasepending.c
+++ b/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/arch/z80/src/common/up_releasestack.c b/arch/z80/src/common/up_releasestack.c
index d41cc991825..b5c9ef2f9da 100644
--- a/arch/z80/src/common/up_releasestack.c
+++ b/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/arch/z80/src/common/up_reprioritizertr.c b/arch/z80/src/common/up_reprioritizertr.c
index b8102c99fa0..476f324e37b 100644
--- a/arch/z80/src/common/up_reprioritizertr.c
+++ b/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/arch/z80/src/common/up_stackdump.c b/arch/z80/src/common/up_stackdump.c
index f9c515337b4..6cb85dd3894 100644
--- a/arch/z80/src/common/up_stackdump.c
+++ b/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/arch/z80/src/common/up_unblocktask.c b/arch/z80/src/common/up_unblocktask.c
index d99d6d87dfc..9f9714bb9ef 100644
--- a/arch/z80/src/common/up_unblocktask.c
+++ b/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/arch/z80/src/common/up_usestack.c b/arch/z80/src/common/up_usestack.c
index 7d348a9c657..0aaa5f906e3 100644
--- a/arch/z80/src/common/up_usestack.c
+++ b/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/arch/z80/src/ez80/ez80_initialstate.c b/arch/z80/src/ez80/ez80_initialstate.c
index 9ff56e7c179..945ba5b3908 100644
--- a/arch/z80/src/ez80/ez80_initialstate.c
+++ b/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/arch/z80/src/ez80/ez80_schedulesigaction.c b/arch/z80/src/ez80/ez80_schedulesigaction.c
index 04643304d8d..c519fb18bfa 100644
--- a/arch/z80/src/ez80/ez80_schedulesigaction.c
+++ b/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/arch/z80/src/ez80/ez80_sigdeliver.c b/arch/z80/src/ez80/ez80_sigdeliver.c
index 2d946aa3225..aeb2d631627 100644
--- a/arch/z80/src/ez80/ez80_sigdeliver.c
+++ b/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/arch/z80/src/ez80/switch.h b/arch/z80/src/ez80/switch.h
index 0970b25ce78..f12983a1212 100644
--- a/arch/z80/src/ez80/switch.h
+++ b/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/arch/z80/src/z180/switch.h b/arch/z80/src/z180/switch.h
index 7bf851a7cef..5405ac8a292 100644
--- a/arch/z80/src/z180/switch.h
+++ b/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/arch/z80/src/z180/z180_initialstate.c b/arch/z80/src/z180/z180_initialstate.c
index 8d0211261fe..491ea6dfb50 100644
--- a/arch/z80/src/z180/z180_initialstate.c
+++ b/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/arch/z80/src/z180/z180_mmu.c b/arch/z80/src/z180/z180_mmu.c
index 5f9b26be2bf..09fa65f2108 100644
--- a/arch/z80/src/z180/z180_mmu.c
+++ b/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/arch/z80/src/z180/z180_schedulesigaction.c b/arch/z80/src/z180/z180_schedulesigaction.c
index 3d9bbe55b70..39344e51fb0 100644
--- a/arch/z80/src/z180/z180_schedulesigaction.c
+++ b/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/arch/z80/src/z180/z180_sigdeliver.c b/arch/z80/src/z180/z180_sigdeliver.c
index 281cfcf6a77..eb3fa8e2c96 100644
--- a/arch/z80/src/z180/z180_sigdeliver.c
+++ b/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/arch/z80/src/z8/switch.h b/arch/z80/src/z8/switch.h
index 17f15b6daf2..3e4a4d28e84 100644
--- a/arch/z80/src/z8/switch.h
+++ b/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/arch/z80/src/z8/z8_initialstate.c b/arch/z80/src/z8/z8_initialstate.c
index 706347da9e5..496d05b3412 100644
--- a/arch/z80/src/z8/z8_initialstate.c
+++ b/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/arch/z80/src/z8/z8_schedulesigaction.c b/arch/z80/src/z8/z8_schedulesigaction.c
index 7a5f6661593..daae090089c 100644
--- a/arch/z80/src/z8/z8_schedulesigaction.c
+++ b/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/arch/z80/src/z8/z8_sigdeliver.c b/arch/z80/src/z8/z8_sigdeliver.c
index d1153a4978f..50b81a202da 100644
--- a/arch/z80/src/z8/z8_sigdeliver.c
+++ b/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/arch/z80/src/z80/switch.h b/arch/z80/src/z80/switch.h
index 4a49c70eff5..472daad7868 100644
--- a/arch/z80/src/z80/switch.h
+++ b/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/arch/z80/src/z80/z80_initialstate.c b/arch/z80/src/z80/z80_initialstate.c
index 01cc4f00a59..2fcac2ed9c4 100644
--- a/arch/z80/src/z80/z80_initialstate.c
+++ b/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/arch/z80/src/z80/z80_schedulesigaction.c b/arch/z80/src/z80/z80_schedulesigaction.c
index 3b227d5e3c2..8935897262f 100644
--- a/arch/z80/src/z80/z80_schedulesigaction.c
+++ b/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/arch/z80/src/z80/z80_sigdeliver.c b/arch/z80/src/z80/z80_sigdeliver.c
index a8fc1e3470c..3eacd64676a 100644
--- a/arch/z80/src/z80/z80_sigdeliver.c
+++ b/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;