Memfault Firmware SDK 1.7.1 (Build 6524)

Author: Memfault Inc

CHANGELOG.md

@@ -1,6 +1,58 @@
 # Memfault Firmware SDK Changelog
 
-## [1.7.0] - 2024-01-29
+## [1.7.1] - 2024-02-28
+
+### :chart_with_upwards_trend: Improvements
+
+- General:
+
+  - Fix a reboot reason test on MacOS by adding a stub implementation of a
+    function to avoid an empty archive not allowed by the system clang install
+  - Add a new macro `MEMFAULT_REBOOT_MARK_RESET_IMMINENT_CUSTOM()` that is more
+    concise for custom reboot reasons by taking the reboot reason name directly.
+    Previously, `MEMFAULT_REBOOT_MARK_RESET_IMMINENT()` was the only option,
+    which requires passing a key with `MEMFAULT_REBOOT_REASON_KEY()`.
+  - Add a session start callback with
+    `memfault_metrics_session_register_start_cb()`. This change enables, for
+    example, tracking battery percent drop across sessions; battery state
+    tracking variables can now be initialized at the start of a session.
+  - Add a coredump storage test to the self test which will now test the
+    coredump storage implementations and check available storage capacity. This
+    is currently experimental and must be explicitly enabled with the Kconfig
+    `CONFIG_MEMFAULT_SHELL_SELF_TEST_COREDUMP_STORAGE=y` on Zephyr,
+    `CONFIG_MEMFAULT_CLI_SELF_TEST_COREDUMP_STORAGE=y` on ESP-IDF, or by adding
+    `#define MEMFAULT_DEMO_CLI_SELF_TEST_COREDUMP_STORAGE 1` to your
+    `memfault_platform_config.h` for other platforms.
+  - Convert the previous `heartbeat_dump` command to `metrics_dump` that can
+    either dump all current heartbeat metrics with `metrics_dump heartbeat` or
+    all session metrics with `metrics_dump sessions` that haven't yet been
+    exported. These commands help with testing metrics collection locally
+    without needing to push chunks to Memfault.
+  - Apply a handful of changes to fix items raised by a new static analyzer
+  - Fix a minor formatting issue that was causing a compilation error for CC ARM
+  - Update support links to refer to the preferred site
+    https://mflt.io/contact-support instead of the Memfault support email. This
+    link will redirect to a form where questions can be sent to the Memfault
+    support team.
+  - Update the `README.md`s in example apps to point to the
+    [Demo CLI](https://docs.memfault.com/docs/mcu/demo-cli) page on the Memfault
+    docs website where comprehensive information is available on commands and
+    their output
+
+- nRF-Connect SDK:
+
+  - Fix a problem caused by mismatched root certificates in modem storage. This
+    change will ensure that all certificates are updated if they do not match
+    expected contents. Prior to v1.7.1, the SDK would only update a certificate
+    by checking each tag for certificate existence, not certificate content. In
+    v1.3.0, the order of root certificates was changed and one was removed. On
+    devices running pre-1.3.0 firmware, updating to later versions can hit a
+    mismatch between the expected certificates and those in modem storage.
+  - Remove a root certificate deprecated in v1.3.0 if present in modem storage.
+    Devices using an SDK version before v1.3.0 may contain a now deprecated root
+    certificate.
+
+## [1.7.0] - 2024-02-15
 
 ### :rocket: New Features
 

README.md

@@ -161,7 +161,7 @@ the top for build & test coverage status of the `master` branch.
 - I'm getting error XYZ, what to do now?
 
   - Don't hesitate to contact us for help! You can reach us through
-    [[email protected]](mailto:[email protected]).
+    <https://mflt.io/contact-support>.
 
 # License
 

VERSION

@@ -1,3 +1,3 @@
-BUILD ID: 6257
-GIT COMMIT: 8cd2342158
-VERSION: 1.7.0
+BUILD ID: 6524
+GIT COMMIT: 14c45caf49
+VERSION: 1.7.1

components/core/src/memfault_event_storage.c

@@ -329,6 +329,8 @@ static bool prv_save_event_to_persistent_storage(void) {
     return false;
   }
 
+  MEMFAULT_SDK_ASSERT(g_memfault_platform_nv_event_storage_impl.write != NULL);
+
   const bool success =
     g_memfault_platform_nv_event_storage_impl.write(prv_event_storage_read_ram, total_size);
   if (success) {

components/core/src/memfault_heap_stats.c

@@ -68,10 +68,10 @@ bool memfault_heap_stats_empty(void) {
 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++) {
+  for (size_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;
+      index = (uint16_t)i;
       break;
     }
   }
@@ -87,16 +87,16 @@ static uint16_t prv_get_new_entry_index(void) {
   sMfltHeapStatEntry *entry;
   uint16_t unused_index = MEMFAULT_HEAP_STATS_LIST_END;
 
-  for (uint16_t i = 0; i < MEMFAULT_ARRAY_SIZE(g_memfault_heap_stats_pool); i++) {
+  for (size_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) {
       if (entry->info.size == 0) {
-        return i;  // favor never used entries
+        return (uint16_t)i;  // favor never used entries
       }
       // save the first inactive entry found
       if (unused_index == MEMFAULT_HEAP_STATS_LIST_END) {
-        unused_index = i;
+        unused_index = (uint16_t)i;
       }
     }
   }
@@ -152,13 +152,13 @@ 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 (uint16_t i = 0; i < MEMFAULT_ARRAY_SIZE(g_memfault_heap_stats_pool); i++) {
+    for (size_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);
+        uint16_t previous_entry_index = prv_get_previous_entry((uint16_t)i);
 
         // If list head removed, set next entry as new list head
         if (g_memfault_heap_stats.stats_pool_head == i) {

components/core/src/memfault_self_test.c

@@ -26,6 +26,14 @@
 #include "memfault/panics/coredump_impl.h"
 #include "memfault_self_test_private.h"
 
+// Wrap this definition to prevent unused macro warning
+#if !MEMFAULT_DEMO_CLI_SELF_TEST_COREDUMP_STORAGE
+  #ifndef MEMFAULT_SELF_TEST_COREDUMP_STORAGE_DISABLE_MSG
+    #define MEMFAULT_SELF_TEST_COREDUMP_STORAGE_DISABLE_MSG \
+      "Set MEMFAULT_DEMO_CLI_SELF_TEST_COREDUMP_STORAGE in memfault_platform_config.h"
+  #endif  // !MEMFAULT_SELF_TEST_COREDUMP_STORAGE_DISABLE_MSG
+#endif    // !MEMFAULT_DEMO_CLI_SELF_TEST_COREDUMP_STORAGE
+
 #if !defined(MEMFAULT_UNITTEST_SELF_TEST)
 
 typedef enum {
@@ -140,9 +148,9 @@ static void prv_device_info_test_describe(uint32_t results) {
   }
 
   MEMFAULT_LOG_ERROR("One or more fields is invalid. Check for correct length and contents");
-  for (uint8_t i = 0; i < kDeviceInfoField_Max; i++) {
+  for (size_t i = 0; i < kDeviceInfoField_Max; i++) {
     // Check if bit cleared, cleared bits indicate an invalid field
-    if ((results & (1 << i))) {
+    if ((results & (1u << i))) {
       MEMFAULT_LOG_ERROR("%s invalid", s_device_info_field_names[i]);
     }
   }
@@ -232,7 +240,7 @@ static void prv_print_region_group_info(const char *group_name, const sMfltCored
   MEMFAULT_LOG_INFO("-----------------------------");
   MEMFAULT_LOG_INFO("%10s|%10s|%6s|", "Address", "Length", "Type");
   MEMFAULT_LOG_INFO("-----------------------------");
-  for (size_t i = 0; i < num_regions; i++) {
+  for (size_t i = 0; (regions != NULL) && (i < num_regions); i++) {
     sMfltCoredumpRegion region = regions[i];
     MEMFAULT_LOG_INFO("0x%08" PRIxPTR "|%10" PRIu32 "|%6u|", (uintptr_t)region.region_start,
                       region.region_size, region.type);
@@ -378,6 +386,42 @@ uint32_t memfault_self_test_time_test(void) {
   return result;
 }
 
+uint32_t memfault_self_test_coredump_storage_capacity_test(void) {
+  MEMFAULT_SELF_TEST_PRINT_HEADER("Coredump Storage Capacity Test");
+  bool result = memfault_coredump_storage_check_size();
+  MEMFAULT_LOG_INFO(MEMFAULT_SELF_TEST_END_OUTPUT);
+  return result ? 0 : 1;
+}
+
+uint32_t memfault_self_test_coredump_storage_test(void) {
+  MEMFAULT_SELF_TEST_PRINT_HEADER("Coredump Storage Test");
+
+  if (memfault_coredump_has_valid_coredump(NULL)) {
+    MEMFAULT_LOG_ERROR("Aborting test, valid coredump present");
+    MEMFAULT_LOG_INFO(MEMFAULT_SELF_TEST_END_OUTPUT);
+    return (1 << 0);
+  }
+
+  // Wrap test with calls to disable/enable irqs to allow test to run uninterrupted
+  // Abort if we cannot disable irqs
+  bool irqs_disabled = memfault_self_test_platform_disable_irqs();
+  if (!irqs_disabled) {
+    MEMFAULT_LOG_ERROR("Aborting test, could not disable interrupts");
+    MEMFAULT_LOG_INFO(MEMFAULT_SELF_TEST_END_OUTPUT);
+    return (1 << 1);
+  }
+
+  memfault_coredump_storage_debug_test_begin();
+  if (!memfault_self_test_platform_enable_irqs()) {
+    MEMFAULT_LOG_WARN("Failed to enable interrupts after test completed");
+  }
+
+  bool result = memfault_coredump_storage_debug_test_finish();
+
+  MEMFAULT_LOG_INFO(MEMFAULT_SELF_TEST_END_OUTPUT);
+  return result ? 0 : (1 << 2);
+}
+
 #endif  // defined(MEMFAULT_UNITTEST_SELF_TEST)
 
 int memfault_self_test_run(uint32_t run_flags) {
@@ -403,5 +447,17 @@ int memfault_self_test_run(uint32_t run_flags) {
   if (run_flags & kMemfaultSelfTestFlag_PlatformTime) {
     result |= memfault_self_test_time_test();
   }
+  if (run_flags & kMemfaultSelfTestFlag_CoredumpStorage) {
+#if MEMFAULT_DEMO_CLI_SELF_TEST_COREDUMP_STORAGE
+    result |= memfault_self_test_coredump_storage_test();
+#else
+    MEMFAULT_LOG_ERROR("Coredump storage test not enabled");
+    MEMFAULT_LOG_ERROR(MEMFAULT_SELF_TEST_COREDUMP_STORAGE_DISABLE_MSG);
+    result = 1;
+#endif
+  }
+  if (run_flags & kMemfaultSelfTestFlag_CoredumpStorageCapacity) {
+    result |= memfault_self_test_coredump_storage_capacity_test();
+  }
   return (result == 0) ? 0 : 1;
 }

components/core/src/memfault_self_test_private.h

@@ -60,6 +60,15 @@ uint32_t memfault_self_test_reboot_reason_test_verify(void);
 //! Runs tests against platform time functions
 uint32_t memfault_self_test_time_test(void);
 
+//! Runs tests against platform coredump storage implementation
+//!
+//! This test will check for the existence of a valid coredump before proceeding and abort if one is
+//! found to prevent overwriting valid data
+uint32_t memfault_self_test_coredump_storage_test(void);
+
+//! Runs test to check capacity of coredump storage against worst case
+uint32_t memfault_self_test_coredump_storage_capacity_test(void);
+
 //! Internal implementation of strnlen
 //!
 //! Support for strnlen is inconsistent across a lot of libc implementations so we implement this

components/core/src/memfault_self_test_utils.c

@@ -37,6 +37,10 @@ static const struct {
     .name = "reboot_verify",
     .value = kMemfaultSelfTestFlag_RebootReasonVerify,
   },
+  {
+    .name = "coredump_storage",
+    .value = kMemfaultSelfTestFlag_CoredumpStorage,
+  },
 };
 
 #define SELF_TEST_MAX_NAME_LEN 30
@@ -70,3 +74,13 @@ size_t memfault_strnlen(const char *str, size_t n) {
 MEMFAULT_WEAK void memfault_self_test_platform_delay(MEMFAULT_UNUSED uint32_t delay_ms) {
   MEMFAULT_LOG_ERROR("%s not implemented for this platform", __func__);
 }
+
+MEMFAULT_WEAK bool memfault_self_test_platform_disable_irqs(void) {
+  MEMFAULT_LOG_ERROR("%s not implemented for this platform", __func__);
+  return false;
+}
+
+MEMFAULT_WEAK bool memfault_self_test_platform_enable_irqs(void) {
+  MEMFAULT_LOG_ERROR("%s not implemented for this platform", __func__);
+  return false;
+}

components/demo/src/memfault_demo_shell_commands.c

@@ -7,6 +7,7 @@
 //! Command definitions for the minimal shell/console implementation.
 
 #include <stddef.h>
+#include <string.h>
 
 #include "memfault/core/compiler.h"
 #include "memfault/core/data_export.h"
@@ -52,8 +53,25 @@ MEMFAULT_WEAK void memfault_metrics_heartbeat_debug_trigger(void) {
   MEMFAULT_LOG_RAW("Disabled. metrics component integration required");
 }
 
-int memfault_demo_cli_cmd_heartbeat_dump(MEMFAULT_UNUSED int argc, MEMFAULT_UNUSED char *argv[]) {
-  memfault_metrics_heartbeat_debug_print();
+MEMFAULT_WEAK void memfault_metrics_all_sessions_debug_print(void) {
+  MEMFAULT_LOG_RAW("Disabled. metrics component integration required");
+}
+
+static int memfault_demo_cli_cmd_metrics_dump(int argc, char *argv[]) {
+  if (argc < 2) {
+    MEMFAULT_LOG_RAW("Enter 'heartbeat' or 'sessions'");
+    return 0;
+  }
+
+  if (!strncmp(argv[1], "sessions", sizeof("sessions"))) {
+    memfault_metrics_all_sessions_debug_print();
+  } else if (!strncmp(argv[1], "heartbeat", sizeof("heartbeat"))) {
+    memfault_metrics_heartbeat_debug_print();
+  } else {
+    MEMFAULT_LOG_RAW("Unknown option. Enter 'heartbeat' or 'sessions'");
+    return 0;
+  }
+
   return 0;
 }
 
@@ -83,9 +101,8 @@ static const sMemfaultShellCommand s_memfault_shell_commands[] = {
   { "get_core", memfault_demo_cli_cmd_get_core, "Get coredump info" },
   { "get_device_info", memfault_demo_cli_cmd_get_device_info, "Get device info" },
   { "coredump_size", memfault_demo_cli_cmd_coredump_size, "Print the coredump storage capacity" },
-  { "heartbeat_dump", memfault_demo_cli_cmd_heartbeat_dump,
-    "Dump current Memfault metrics heartbeat state" },
-  { "heartbeat", memfault_demo_cli_cmd_heartbeat, "Trigger a heartbeat" },
+  { "metrics_dump", memfault_demo_cli_cmd_metrics_dump,
+    "Dump current heartbeat or session metrics" },
   //
   // Test commands for validating SDK functionality: https://mflt.io/mcu-test-commands
   //

components/include/memfault/core/reboot_tracking.h

@@ -125,6 +125,12 @@ void memfault_reboot_tracking_mark_reset_imminent(eMemfaultRebootReason reboot_r
     memfault_reboot_tracking_mark_reset_imminent(reason_, &mflt_reg_info); \
   } while (0)
 
+//! Helper macro that behaves the same as `MEMFAULT_REBOOT_MARK_RESET_IMMINENT` but allows
+//! for a custom reboot reason to be specified without needed to use the
+//! `MEMFAULT_REBOOT_REASON_KEY` macro
+#define MEMFAULT_REBOOT_MARK_RESET_IMMINENT_CUSTOM(reason_) \
+  MEMFAULT_REBOOT_MARK_RESET_IMMINENT(MEMFAULT_REBOOT_REASON_KEY(reason_))
+
 //! Collects recent reset info and pushes it to memfault_event_storage so that the data can
 //! can be sent out using the Memfault data packetizer
 //!