Xtensa ESP32: Add stack checking logic.

arch/Kconfig

@@ -77,6 +77,7 @@ config ARCH_X86
 
 config ARCH_XTENSA
 	bool "Xtensa"
+	select ARCH_HAVE_STACKCHECK
 	select ARCH_HAVE_CUSTOMOPT
 	---help---
 		Cadence® Tensilica® Xtensa® actictures.

arch/xtensa/src/common/xtensa_checkstack.c

@@ -0,0 +1,214 @@
+/****************************************************************************
+ * arch/xtensa/src/common/xtensa_checkstack.c
+ *
+ *   Copyright (C) 2016 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <sched.h>
+#include <assert.h>
+#include <debug.h>
+
+#include <nuttx/arch.h>
+#include <nuttx/tls.h>
+#include <nuttx/board.h>
+
+#include "xtensa.h"
+#include "sched/sched.h"
+
+#ifdef CONFIG_STACK_COLORATION
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+static size_t do_stackcheck(uintptr_t alloc, size_t size);
+
+/****************************************************************************
+ * Name: do_stackcheck
+ *
+ * Description:
+ *   Determine (approximately) how much stack has been used be searching the
+ *   stack memory for a high water mark.  That is, the deepest level of the
+ *   stack that clobbered some recognizable marker in the stack memory.
+ *
+ * Input Parameters:
+ *   alloc - Allocation base address of the stack
+ *   size - The size of the stack in bytes
+ *
+ * Returned value:
+ *   The estimated amount of stack space used.
+ *
+ ****************************************************************************/
+
+static size_t do_stackcheck(uintptr_t alloc, size_t size)
+{
+  FAR uintptr_t start;
+  FAR uintptr_t end;
+  FAR uint32_t *ptr;
+  size_t mark;
+
+  if (size == 0)
+    {
+      return 0;
+    }
+
+  /* Get aligned addresses of the top and bottom of the stack */
+
+#ifdef CONFIG_TLS
+  /* Skip over the TLS data structure at the bottom of the stack */
+
+  DEBUGASSERT((alloc & TLS_STACK_MASK) == 0);
+  start = alloc + sizeof(struct tls_info_s);
+#else
+  start = alloc & ~3;
+#endif
+  end   = (alloc + size + 3) & ~3;
+
+  /* Get the adjusted size based on the top and bottom of the stack */
+
+  size  = end - start;
+
+  /* The Xtensa CPUs use a push-down stack:  the stack grows toward lower
+   * addresses in memory.  We need to start at the lowest address in the
+   * stack memory allocation and search to higher addresses.  The first word
+   * we encounter that does not have the magic value is the high water mark.
+   */
+
+  for (ptr = (FAR uint32_t *)start, mark = (size >> 2);
+       *ptr == STACK_COLOR && mark > 0;
+       ptr++, mark--);
+
+  /* If the stack is completely used, then this might mean that the stack
+   * overflowed from above (meaning that the stack is too small), or may
+   * have been overwritten from below meaning that some other stack or data
+   * structure overflowed.
+   *
+   * If you see returned values saying that the entire stack is being used
+   * then enable the following logic to see it there are unused areas in the
+   * middle of the stack.
+   */
+
+#if 0
+  if (mark + 16 > nwords)
+    {
+      int i;
+      int j;
+
+      ptr = (FAR uint32_t *)start;
+      for (i = 0; i < size; i += 4*64)
+        {
+          for (j = 0; j < 64; j++)
+            {
+              int ch;
+              if (*ptr++ == STACK_COLOR)
+                {
+                  ch = '.';
+                }
+              else
+                {
+                  ch = 'X';
+                }
+
+              up_putc(ch);
+            }
+
+          up_putc('\n');
+        }
+    }
+#endif
+
+  /* Return our guess about how much stack space was used */
+
+  return mark << 2;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: up_check_stack and friends
+ *
+ * Description:
+ *   Determine (approximately) how much stack has been used be searching the
+ *   stack memory for a high water mark.  That is, the deepest level of the
+ *   stack that clobbered some recognizable marker in the stack memory.
+ *
+ * Input Parameters:
+ *   None
+ *
+ * Returned value:
+ *   The estimated amount of stack space used.
+ *
+ ****************************************************************************/
+
+size_t up_check_tcbstack(FAR struct tcb_s *tcb)
+{
+  return do_stackcheck((uintptr_t)tcb->stack_alloc_ptr, tcb->adj_stack_size);
+}
+
+ssize_t up_check_tcbstack_remain(FAR struct tcb_s *tcb)
+{
+  return (ssize_t)tcb->adj_stack_size - (ssize_t)up_check_tcbstack(tcb);
+}
+
+size_t up_check_stack(void)
+{
+  return up_check_tcbstack(this_task());
+}
+
+ssize_t up_check_stack_remain(void)
+{
+  return up_check_tcbstack_remain(this_task());
+}
+
+#if CONFIG_ARCH_INTERRUPTSTACK > 3
+size_t up_check_intstack(void)
+{
+  return do_stackcheck((uintptr_t)&g_intstackalloc, (CONFIG_ARCH_INTERRUPTSTACK & ~3));
+}
+
+size_t up_check_intstack_remain(void)
+{
+  return (CONFIG_ARCH_INTERRUPTSTACK & ~3) - up_check_intstack();
+}
+#endif
+
+#endif /* CONFIG_STACK_COLORATION */

arch/xtensa/src/common/xtensa_dumpstate.c

@@ -78,6 +78,42 @@ static inline uint32_t xtensa_getsp(void)
   return sp;
 }
 
+/****************************************************************************
+ * Name: up_taskdump
+ ****************************************************************************/
+
+#ifdef CONFIG_STACK_COLORATION
+static void up_taskdump(FAR struct tcb_s *tcb, FAR void *arg)
+{
+  /* Dump interesting properties of this task */
+
+#if CONFIG_TASK_NAME_SIZE > 0
+  _alert("%s: PID=%d Stack Used=%lu of %lu\n",
+        tcb->name, tcb->pid, (unsigned long)up_check_tcbstack(tcb),
+        (unsigned long)tcb->adj_stack_size);
+#else
+  _alert("PID: %d Stack Used=%lu of %lu\n",
+        tcb->pid, (unsigned long)up_check_tcbstack(tcb),
+        (unsigned long)tcb->adj_stack_size);
+#endif
+}
+#endif
+
+/****************************************************************************
+ * Name: up_showtasks
+ ****************************************************************************/
+
+#ifdef CONFIG_STACK_COLORATION
+static inline void up_showtasks(void)
+{
+  /* Dump interesting properties of each task in the crash environment */
+
+  sched_foreach(up_taskdump, NULL);
+}
+#else
+#  define up_showtasks()
+#endif
+
 /****************************************************************************
  * Name: xtensa_stackdump
  ****************************************************************************/
@@ -187,6 +223,9 @@ void xtensa_dumpstate(void)
   _alert("IRQ stack:\n");
   _alert("  base: %08x\n", istackbase);
   _alert("  size: %08x\n", istacksize);
+#ifdef CONFIG_STACK_COLORATION
+  _alert("  used: %08x\n", up_check_intstack());
+#endif
 
   /* Does the current stack pointer lie within the interrupt
    * stack?
@@ -211,10 +250,16 @@ void xtensa_dumpstate(void)
   _alert("User stack:\n");
   _alert("  base: %08x\n", ustackbase);
   _alert("  size: %08x\n", ustacksize);
+#ifdef CONFIG_STACK_COLORATION
+  _alert("  used: %08x\n", up_check_tcbstack(rtcb));
+#endif
 #else
   _alert("sp:         %08x\n", sp);
   _alert("stack base: %08x\n", ustackbase);
   _alert("stack size: %08x\n", ustacksize);
+#ifdef CONFIG_STACK_COLORATION
+  _alert("stack used: %08x\n", up_check_tcbstack(rtcb));
+#endif
 #endif
 
   /* Dump the user stack if the stack pointer lies within the allocated user
@@ -235,6 +280,10 @@ void xtensa_dumpstate(void)
   /* Then dump the registers (if available) */
 
   xtensa_registerdump();
+
+  /* Dump the state of all tasks (if available) */
+
+  up_showtasks();
 }
 
 #endif /* CONFIG_ARCH_STACKDUMP */

arch/xtensa/src/esp32/Make.defs

@@ -68,6 +68,11 @@ ifeq ($(CONFIG_SMP),y)
   CMN_CSRCS += xtensa_cpupause.c
 endif
 
+ifeq ($(CONFIG_STACK_COLORATION),y)
+  CMN_CSRCS += xtensa_checkstack.c
+endif
+
+
 # Use of common/xtensa_etherstub.c is deprecated.  The preferred mechanism
 # is to use CONFIG_NETDEV_LATEINIT=y to suppress the call to
 # up_netinitialize() in xtensa_initialize.c.  Then this stub would not be

arch/xtensa/src/esp32/esp32_cpustart.c

@@ -148,6 +148,24 @@ void xtensa_appcpu_start(void)
   FAR struct tcb_s *tcb = this_task();
   register uint32_t sp;
 
+#ifdef CONFIG_STACK_COLORATION
+  {
+    register uint32_t *ptr;
+    register int i;
+
+      /* If stack debug is enabled, then fill the stack with a recognizable value
+       * that we can use later to test for high water marks.
+       */
+
+      for (i = 0, ptr = (uint32_t *)tcb->stack_alloc_ptr;
+           i < tcb->adj_stack_size;
+           i += sizeof(uint32_t))
+        {
+          *ptr++ = STACK_COLOR;
+        }
+  }
+#endif
+
   /* Move to the stack assigned to us by up_smp_start immediately.  Although
    * we were give a stack pointer at start-up, we don't know where that stack
    * pointer is positioned respect to our memory map.  The only safe option

arch/xtensa/src/esp32/esp32_start.c

@@ -93,6 +93,22 @@ void IRAM_ATTR __start(void)
 
   up_irq_disable();
 
+#ifdef CONFIG_STACK_COLORATION
+  {
+    register uint32_t *ptr;
+    register int i;
+
+      /* If stack debug is enabled, then fill the stack with a recognizable value
+       * that we can use later to test for high water marks.
+       */
+
+      for (i = 0, ptr = g_idlestack;  i < IDLETHREAD_STACKWORDS; i++)
+        {
+          *ptr++ = STACK_COLOR;
+        }
+  }
+#endif
+
   /* Move the stack to a known location.  Although we were give a stack
    * pointer at start-up, we don't know where that stack pointer is positioned
    * respect to our memory map.  The only safe option is to switch to a well-