Memfault Firmware SDK 0.36.0 (Build 838)

Author: Memfault Inc

CHANGES.md

@@ -1,3 +1,21 @@
+### Changes between Memfault SDK 0.34.2 and SDK 0.35.0 - Dec 6, 2022
+
+#### :chart_with_upwards_trend: Improvements
+
+- ESP-IDF:
+
+  - Add support for
+    [just-released ESP-IDF v5](https://github.com/espressif/esp-idf/releases/tag/v5.0)
+    🎉!
+  - Add an auto-OTA (and auto-WiFi-join) feature to the
+    [ESP32 example app](examples/esp32)- enabled by default but can be disabled
+    with Kconfig
+
+- The [Heap Stats tracing component](https://mflt.io/mcu-heap-stats) has been
+  revamped to make more efficient usage of the bookeeping structure. Usage
+  should be the same as before, but now should provide more data without
+  significantly expanding the memory utilization.
+
 ### Changes between Memfault SDK 0.35.0 and SDK 0.34.2 - Nov 22, 2022
 
 #### :rocket: New Features

VERSION

@@ -1,2 +1,2 @@
-BUILD ID: 615
-GIT COMMIT: 465ee2834
+BUILD ID: 838
+GIT COMMIT: 588aa169f

components/core/src/memfault_heap_stats.c

@@ -7,9 +7,6 @@
 //! malloc/free implementation to track last allocations with callsite
 //! information.
 
-#include "memfault/core/heap_stats.h"
-#include "memfault/core/heap_stats_impl.h"
-
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -18,14 +15,20 @@
 #include "memfault/config.h"
 #include "memfault/core/compiler.h"
 #include "memfault/core/debug_log.h"
+#include "memfault/core/heap_stats.h"
+#include "memfault/core/heap_stats_impl.h"
 #include "memfault/core/math.h"
 #include "memfault/core/platform/debug_log.h"
 #include "memfault/core/platform/overrides.h"
 
-#define MEMFAULT_HEAP_STATS_VERSION 1
+#define MEMFAULT_HEAP_STATS_VERSION 2
+
+MEMFAULT_STATIC_ASSERT(MEMFAULT_HEAP_STATS_MAX_COUNT < MEMFAULT_HEAP_STATS_LIST_END,
+                       "Number of entries in heap stats exceeds limits");
 
 sMfltHeapStats g_memfault_heap_stats = {
   .version = MEMFAULT_HEAP_STATS_VERSION,
+  .stats_pool_head = MEMFAULT_HEAP_STATS_LIST_END,
 };
 sMfltHeapStatEntry g_memfault_heap_stats_pool[MEMFAULT_HEAP_STATS_MAX_COUNT];
 
@@ -43,7 +46,10 @@ static void prv_heap_stats_unlock(void) {
 
 void memfault_heap_stats_reset(void) {
   prv_heap_stats_lock();
-  g_memfault_heap_stats = (sMfltHeapStats){0};
+  g_memfault_heap_stats = (sMfltHeapStats){
+    .version = MEMFAULT_HEAP_STATS_VERSION,
+    .stats_pool_head = MEMFAULT_HEAP_STATS_LIST_END,
+  };
   memset(g_memfault_heap_stats_pool, 0, sizeof(g_memfault_heap_stats_pool));
   prv_heap_stats_unlock();
 }
@@ -54,13 +60,43 @@ bool memfault_heap_stats_empty(void) {
   return g_memfault_heap_stats_pool[0].info.size == 0;
 }
 
-//! Return the next slot to write
-static sMfltHeapStatEntry *prv_get_next_entry(void) {
-  sMfltHeapStatEntry *slot =
-    &g_memfault_heap_stats_pool[g_memfault_heap_stats.stats_pool_head];
-  g_memfault_heap_stats.stats_pool_head = (g_memfault_heap_stats.stats_pool_head + 1) %
-                                          MEMFAULT_ARRAY_SIZE(g_memfault_heap_stats_pool);
-  return slot;
+//! Get the previous entry index of the entry index to be found
+//!
+//! Iterates through the entry array checking if entry is in use and if the
+//! next entry index matches the search index. If the previous entry cannot be found,
+//! MEMFAULT_HEAP_STATS_LIST_END is returned
+static uint16_t prv_get_previous_entry(uint16_t search_entry_index) {
+  uint16_t index = MEMFAULT_HEAP_STATS_LIST_END;
+
+  for (uint16_t i = 0; i < MEMFAULT_ARRAY_SIZE(g_memfault_heap_stats_pool); i++) {
+    sMfltHeapStatEntry *entry = &g_memfault_heap_stats_pool[i];
+    if (entry->info.in_use && entry->info.next_entry_index == search_entry_index) {
+      index = i;
+      break;
+    }
+  }
+
+  return index;
+}
+
+//! Return the next entry index to write new data to
+//!
+//! First searches for unused entries
+//! If none are found then traverses list to oldest (last) entry
+static uint16_t prv_get_new_entry_index(void) {
+  sMfltHeapStatEntry *entry;
+
+  for (uint16_t i = 0; i < MEMFAULT_ARRAY_SIZE(g_memfault_heap_stats_pool); i++) {
+    entry = &g_memfault_heap_stats_pool[i];
+
+    if (!entry->info.in_use) {
+      return i;  // favor unused entries
+    }
+  }
+
+  // No unused entry found, return the oldest (entry with next index of
+  // MEMFAULT_HEAP_STATS_LIST_END)
+  return prv_get_previous_entry(MEMFAULT_HEAP_STATS_LIST_END);
 }
 
 void memfault_heap_stats_malloc(const void *lr, const void *ptr, size_t size) {
@@ -71,8 +107,9 @@ void memfault_heap_stats_malloc(const void *lr, const void *ptr, size_t size) {
     if (g_memfault_heap_stats.in_use_block_count > g_memfault_heap_stats.max_in_use_block_count) {
       g_memfault_heap_stats.max_in_use_block_count = g_memfault_heap_stats.in_use_block_count;
     }
-    sMfltHeapStatEntry *slot = prv_get_next_entry();
-    *slot = (sMfltHeapStatEntry){
+    uint16_t new_entry_index = prv_get_new_entry_index();
+    sMfltHeapStatEntry *new_entry = &g_memfault_heap_stats_pool[new_entry_index];
+    *new_entry = (sMfltHeapStatEntry){
       .lr = lr,
       .ptr = ptr,
       .info =
@@ -81,6 +118,19 @@ void memfault_heap_stats_malloc(const void *lr, const void *ptr, size_t size) {
           .in_use = 1u,
         },
     };
+
+    // Append new entry to head of the list
+    new_entry->info.next_entry_index = g_memfault_heap_stats.stats_pool_head;
+    g_memfault_heap_stats.stats_pool_head = new_entry_index;
+
+    // Find next oldest entry (points to new entry)
+    // Update next entry index to MEMFAULT_HEAP_STATS_LIST_END
+    uint16_t next_oldest_entry_index = prv_get_previous_entry(new_entry_index);
+
+    if (next_oldest_entry_index != MEMFAULT_HEAP_STATS_LIST_END) {
+      g_memfault_heap_stats_pool[next_oldest_entry_index].info.next_entry_index =
+        MEMFAULT_HEAP_STATS_LIST_END;
+    }
   }
 
   prv_heap_stats_unlock();
@@ -92,9 +142,26 @@ void memfault_heap_stats_free(const void *ptr) {
     g_memfault_heap_stats.in_use_block_count--;
 
     // if the pointer exists in the tracked stats, mark it as freed
-    for (size_t i = 0; i < MEMFAULT_ARRAY_SIZE(g_memfault_heap_stats_pool); i++) {
-      if ((g_memfault_heap_stats_pool[i].ptr == ptr) && g_memfault_heap_stats_pool[i].info.in_use) {
-        g_memfault_heap_stats_pool[i].info.in_use = 0;
+    for (uint16_t i = 0; i < MEMFAULT_ARRAY_SIZE(g_memfault_heap_stats_pool); i++) {
+      sMfltHeapStatEntry *entry = &g_memfault_heap_stats_pool[i];
+      if ((entry->ptr == ptr) && entry->info.in_use) {
+        entry->info.in_use = 0;
+
+        // Find the entry previous to the removed entry
+        uint16_t previous_entry_index = prv_get_previous_entry(i);
+
+        // If list head removed, set next entry as new list head
+        if (g_memfault_heap_stats.stats_pool_head == i) {
+          g_memfault_heap_stats.stats_pool_head = entry->info.next_entry_index;
+        }
+
+        // If there's a valid previous entry, set it's next index to removed entry's
+        if (previous_entry_index != MEMFAULT_HEAP_STATS_LIST_END) {
+          g_memfault_heap_stats_pool[previous_entry_index].info.next_entry_index =
+            entry->info.next_entry_index;
+        }
+
+        entry->info.next_entry_index = MEMFAULT_HEAP_STATS_LIST_END;
         break;
       }
     }

components/include/memfault/core/heap_stats_impl.h

@@ -22,6 +22,10 @@ extern "C" {
 //! Number of regions used by heap stats
 #define MEMFAULT_HEAP_STATS_NUM_RAM_REGIONS 2
 
+//! Value used to indicate entry is the end of the list
+#define MEMFAULT_HEAP_STATS_LIST_END UINT16_MAX
+
+typedef struct MfltHeapStatEntry sMfltHeapStatEntry;
 
 //! The heap stats data structure, which is exported when capturing a core.
 typedef struct MfltHeapStatEntry {
@@ -37,10 +41,11 @@ typedef struct MfltHeapStatEntry {
     uint32_t size : 31;
     // 1 bit indicating whether this entry is still in use or has been freed
     uint32_t in_use : 1;
+    // Index to next oldest entry in heap stats entry array,
+    uint16_t next_entry_index;
   } info;
 } sMfltHeapStatEntry;
 
-
 typedef struct MfltHeapStats {
   uint8_t version;
 
@@ -51,7 +56,7 @@ typedef struct MfltHeapStats {
   uint32_t max_in_use_block_count;
 
   // Allocation entry list pointer
-  size_t stats_pool_head;
+  uint16_t stats_pool_head;
 } sMfltHeapStats;
 
 extern sMfltHeapStats g_memfault_heap_stats;

components/include/memfault/version.h

@@ -19,7 +19,7 @@ typedef struct {
   uint8_t patch;
 } sMfltSdkVersion;
 
-#define MEMFAULT_SDK_VERSION   { .major = 0, .minor = 35, .patch = 0 }
+#define MEMFAULT_SDK_VERSION   { .major = 0, .minor = 36, .patch = 0 }
 
 #ifdef __cplusplus
 }

examples/esp32/README.md

@@ -160,7 +160,7 @@ As a sanity check, let's request the device info from the debug console, enter
 esp32> get_device_info
 I (55239) mflt: S/N: 30AEA44AFF28
 I (55239) mflt: SW type: esp32-main
-I (55239) mflt: SW version: 1.0.0
+I (55239) mflt: SW version: 1.0.0-dev
 I (55239) mflt: HW version: esp32-proto
 ```
 
@@ -269,9 +269,9 @@ The following steps can be used to exercise OTA functionality:
    I (33288) mflt: Result: 0
    ```
 
-3. Change the `MEMFAULT_ESP32_MAIN_FIRMWARE_VERSION` to `"1.0.1"` in
-   [`apps/memfault_demo_app/main/memfault_platform_device_info.c`](apps/memfault_demo_app/main/memfault_platform_device_info.c),
-   and rebuild (`idf.py build`), but don't load it to the device. We'll use this
+3. Use `idf.py menuconfig` to change the value of
+   `MEMFAULT_ESP32_MAIN_FIRMWARE_VERSION` config variable to `"1.0.1"`, and
+   rebuild (`idf.py build`), but don't load it to the device. We'll use this
    build as our OTA payload!
 
 4. In the Memfault web app, go to "Software->OTA Releases" and create an OTA

examples/esp32/apps/memfault_demo_app/main/CMakeLists.txt

@@ -1,10 +1,21 @@
-set(COMPONENT_SRCS
+list(APPEND
+   COMPONENT_SRCS
    cmd_app.c
    cmd_system.c
-   cmd_wifi.c
    console_example_main.c
    memfault_platform_device_info.c
 )
+if("${IDF_VERSION_MAJOR}" VERSION_GREATER_EQUAL 4)
+   list(APPEND
+      COMPONENT_SRCS
+      cmd_wifi.c
+   )
+else()
+   list(APPEND
+      COMPONENT_SRCS
+      cmd_wifi_legacy.c
+   )
+endif()
 
 set(COMPONENT_ADD_INCLUDEDIRS .)
 

examples/esp32/apps/memfault_demo_app/main/Kconfig.projbuild

@@ -1,4 +1,4 @@
-menu "Example Configuration"
+menu "Memfault App Configuration"
 
 config STORE_HISTORY
     bool "Store command history in flash"
@@ -8,4 +8,24 @@ config STORE_HISTORY
         command history. If this option is enabled, initalizes a FAT filesystem
         and uses it to store command history.
 
-endmenu
+config MEMFAULT_ESP32_MAIN_FIRMWARE_VERSION
+    string "Main firmware version"
+    default "1.0.0-dev"
+    help
+        The version of the main firmware. Used when the device reports in as
+        well as for OTA checks.
+
+config MEMFAULT_APP_OTA
+    bool "Enable automatic periodic check+update for OTA"
+    default y
+    help
+        Enables the Memfault OTA subsystem. This will periodically check for
+        updates and apply them if available.
+
+config MEMFAULT_APP_WIFI_AUTOJOIN
+    bool "Enable automatic WiFi connection"
+    default y
+    help
+        Automatically join if credentials are configured.
+
+endmenu

examples/esp32/apps/memfault_demo_app/main/cmd_app.c

@@ -5,19 +5,19 @@
 //! Miscellaneous commands specific to this example app
 //!
 
+#include <ctype.h>
 #include <stdio.h>
 #include <string.h>
-#include <ctype.h>
-#include "esp_log.h"
-#include "esp_console.h"
+
 #include "cmd_decl.h"
+#include "esp_console.h"
+#include "esp_log.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 #include "sdkconfig.h"
 
 //! cause the task watchdog to fire by deadlocking the example task
-static int test_task_watchdog(int argc, char** argv)
-{
+static int test_task_watchdog(int argc, char** argv) {
   (void)argc, (void)argv;
   ESP_LOGI(__func__, "Setting the example_task to stuck, will cause the task watchdog to fire");
 
@@ -26,18 +26,16 @@ static int test_task_watchdog(int argc, char** argv)
   return 0;
 }
 
-static void register_test_task_watchdog(void)
-{
+static void register_test_task_watchdog(void) {
   const esp_console_cmd_t cmd = {
-      .command = "test_task_watchdog",
-      .help = "Demonstrate the task watchdog tripping on a deadlock",
-      .hint = NULL,
-      .func = &test_task_watchdog,
+    .command = "test_task_watchdog",
+    .help = "Demonstrate the task watchdog tripping on a deadlock",
+    .hint = NULL,
+    .func = &test_task_watchdog,
   };
-  ESP_ERROR_CHECK( esp_console_cmd_register(&cmd) );
+  ESP_ERROR_CHECK(esp_console_cmd_register(&cmd));
 }
 
-void register_app(void)
-{
+void register_app(void) {
   register_test_task_watchdog();
 }

examples/esp32/apps/memfault_demo_app/main/cmd_decl.h

@@ -11,15 +11,18 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 
-// Register system functions
+// Register system console commands
 void register_system(void);
 
-// Register WiFi functions
+// Register WiFi console commands
 void register_wifi(void);
 
-// Register app-specific functions
+// Attempt to join a wifi network
+bool wifi_join(const char* ssid, const char* pass);
+void wifi_load_creds(char** ssid, char** password);
+
+// Register app-specific console commands
+void register_app(void);
 
 // This semaphore is used to control the Task Watchdog example task
 extern SemaphoreHandle_t g_example_task_lock;
-
-void register_app(void);