Fix nuket#7: Support mbed OS 5.5 and higher CMSIS-RTOS 2 API

Author: Max Vilimpoc

README.md

@@ -1,29 +1,38 @@
 # mbed-memory-status
 
-## Note
-
-As of mbed OS 5.5, this code no longer works. The switch to CMSIS-RTOS2 as the base OS has removed all of the low-level APIs that were relied upon.
-
-The last version of mbed OS that will work is [https://github.com/ARMmbed/mbed-os/releases/tag/mbed-os-5.4.7](mbed-os-5.4.7).
-
 ## Purpose
 
 Print thread stack, ISR stack, and global heap locations, sizes, and utilization at runtime when using mbed OS. Useful for tracking down total runtime memory usage and stack overflows.
 
 Does *not* use printf(). It *will* automatically initialize the default serial port to 115200 8N1 using the low-level mbed `serial_api.h` if no other instantiation has occurred.
 
+The code has now been fixed to detect whether it is running on the CMSIS-RTOS 1 or CMSIS-RTOS 2 API and will adjust its low-level API calls accordingly.
+
 ## Example
-```
+
+```c
+#include "mbed_memory_status.h"
+
 int main()
 {
     print_all_thread_info();
     print_heap_and_isr_stack_info();
 }
 ```
 
+## Building
+
+When building the code, make sure to pass the `MBED_STACK_STATS_ENABLED` compiler macro as follows, otherwise mbed will eliminate the stack canary code:
+
+```
+mbed compile -D MBED_STACK_STATS_ENABLED=1
+```
+
+This value can also be added permanently to the `mbed_app.json` macros.
+
 ## Output
 
-Using ARM RTX RTOS on mbed, this will print something like:
+Using ARM RTX RTOS on up to mbed 5.4.7, this will print something like:
 
 ```
     stack ( start: 20005100 end: 20005420 size: 00000320 used: 00000070 ) thread ( id: 2000542C entry: 00020D91 )
@@ -33,6 +42,16 @@ Using ARM RTX RTOS on mbed, this will print something like:
 isr_stack ( start: 20007800 end: 20008000 size: 00000800 used: 000002B0 )
 ```
 
+Using CMSIS-RTOS 2 from mbed 5.5 and higher, we gain access to thread names, so this will print something like:
+
+```
+    stack ( start: 20004628 end: 20005628 size: 00001000 used: 000000F8 ) thread ( id: 200045D8 entry: 0001CEBD name: main_thread )
+    stack ( start: 200040A0 end: 200042A0 size: 00000200 used: 00000100 ) thread ( id: 20003D58 entry: 0001D019 name: unknown )
+    stack ( start: 20003DA0 end: 200040A0 size: 00000300 used: 00000068 ) thread ( id: 20003D10 entry: 0001F1BD name: unknown )
+     heap ( start: 20005738 end: 2000FC00 size: 0000A4C8 used: 00000000 )  alloc ( ok: 00000000  fail: 00000000 )
+isr_stack ( start: 2000FC00 end: 20010000 size: 00000400 )
+```
+
 ## Use
 
 Add to your program:
@@ -56,8 +75,18 @@ Then define this in `mbed_memory_status.c`, or via the `mbed_app.json` macros, o
 #define DEBUG_ISR_STACK_USAGE  1
 ```
 
-## Why
+## Gotchas
+
+On mbed 5.5 and up, there may be a Heisenbug when calling print_thread_info() inside of osKernelLock()!
+
+This error sometimes appears on the serial console shortly after chip startup, but not always:
+`mbed assertation failed: os_timer->get_tick() == svcRtxKernelGetTickCount(), file: .\mbed-os\rtos\TARGET_CORTEX\mbed_rtx_idle.c`
+
+The RTOS seems to be asserting an idle constraint violation due to the slowness of sending data through the serial port, but it does not happen consistently.
+
+## Why This Exists
 
 This code exists because of a stupid amount of bug-hunting:
+
 > https://vilimpoc.org/blog/2017/02/01/stack-heap-and-thread-crash-hunting-in-mbed-os/
 > https://vilimpoc.org/blog/2017/02/04/isr-stack-usage-on-mbed/

mbed_memory_status.c

@@ -32,6 +32,10 @@
 #include "platform/mbed_critical.h"
 #include "platform/mbed_stats.h"
 
+#if !MBED_STACK_STATS_ENABLED
+#warning MBED_STACK_STATS_ENABLED != 1, so there will be no stack usage measurements.
+#endif
+
 #ifndef DEBUG_ISR_STACK_USAGE
 #define DEBUG_ISR_STACK_USAGE  0
 #endif
@@ -192,10 +196,24 @@ static void debug_print_pointer(const void * pointer)
 #if (defined (MBED_CONF_RTOS_PRESENT) && (MBED_CONF_RTOS_PRESENT != 0))
 #include "cmsis_os.h"
 
-// Temporarily #undef NULL or the compiler complains about previous def.
-#undef NULL
-#include "rt_TypeDef.h"
- 
+// cmsis_os.h provides some useful defines:
+//
+// For mbed OS 5.4 and lower,  osCMSIS == 0x10002U (see: rtos/rtx/TARGET_CORTEX_M)
+// For mbed OS 5.5 and higher, osCMSIS == 0x20001U (see: rtos/TARGET_CORTEX/rtx{4|5})
+//
+// Starting in mbed OS 5.5, a new RTOS layer was introduced with a different API.
+
+#if (osCMSIS < 0x20000U)
+    // Temporarily #undef NULL or the compiler complains about previous def.
+    #undef NULL
+    #include "rt_TypeDef.h"
+#else
+    #include "rtx_lib.h"
+    // #include <stdlib.h>  // Include if you need malloc() / free() below. (probably better for non-C99 compilers)
+#endif
+
+#if (osCMSIS < 0x20000U)
+
 // No public forward declaration for this.
 extern P_TCB rt_tid2ptcb (osThreadId thread_id);
 
@@ -248,6 +266,89 @@ void print_all_thread_info(void)
     _osThreadEnumFree(enumId);
 }
 
+#else
+
+static void print_thread_info(osThreadId threadId)
+{
+    // Refs: rtx_lib.h - #define os_thread_t osRtxThread_t
+    //       rtx_os.h  - typedef struct osRtxThread_s { } osRtxThread_t
+
+    if (!threadId) return;
+
+    os_thread_t * tcb = (os_thread_t *) threadId;
+
+    uint32_t stackSize = osThreadGetStackSize(threadId);
+    uint32_t stackUsed = osThreadGetStackSpace(threadId);
+    
+    DPL("    stack ( start: ");
+    debug_print_pointer(tcb->stack_mem);
+
+    DPL(" end: ");
+    debug_print_pointer((uint8_t *) tcb->stack_mem + stackSize);
+
+    DPL(" size: ");
+    debug_print_u32(stackSize);
+    
+    DPL(" used: ");
+    debug_print_u32(stackSize - stackUsed);
+    
+    DPL(" ) ");
+
+    DPL("thread ( id: ");
+    debug_print_pointer(threadId);
+    
+    DPL(" entry: ");
+    debug_print_u32(tcb->thread_addr);
+
+    DPL(" name: ");
+    DPL(osThreadGetName(threadId) ? osThreadGetName(threadId) : "unknown");
+
+    DPL(" )\r\n");
+}
+
+void print_all_thread_info(void)
+{
+    // Refs: mbed_stats.c - mbed_stats_stack_get_each()
+
+    uint32_t     threadCount = osThreadGetCount();
+    osThreadId_t threads[threadCount];
+
+    // osThreadId_t * threads = malloc(sizeof(osThreadId_t) * threadCount);
+    // MBED_ASSERT(NULL != threads);
+
+    memset(threads, 0, threadCount * sizeof(osThreadId_t));
+
+    // This will probably only work if the number of threads remains constant 
+    // (i.e. the number of thread control blocks remains constant)
+    //
+    // This is probably the case on a deterministic realtime embedded system
+    // with limited SRAM.
+
+    osKernelLock();
+
+    threadCount = osThreadEnumerate(threads, threadCount);
+
+    for (uint32_t i = 0; i < threadCount; i++)
+    {
+        // There seems to be a Heisenbug when calling print_thread_info() 
+        // inside of osKernelLock()!
+        
+        // This error may appear on the serial console:
+        // mbed assertation failed: os_timer->get_tick() == svcRtxKernelGetTickCount(), file: .\mbed-os\rtos\TARGET_CORTEX\mbed_rtx_idle.c
+        
+        // The RTOS seems to be asserting an idle constraint violation due 
+        // to the slowness of sending data through the serial port, but it
+        // does not happen consistently.
+        print_thread_info(threads[i]);
+    }
+
+    osKernelUnlock();
+
+    // free(threads);
+}
+
+#endif
+
 void print_current_thread_id(void)
 {
     DPL("Current thread: ");