Memfault Firmware SDK 1.9.0 (Build 7848)

Author: Memfault Inc

CHANGELOG.md

@@ -6,6 +6,73 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.0] - 2024-05-10
+
+### :chart_with_upwards_trend: Improvements
+
+- General:
+
+  - Correctly compile out the
+    [non-volatile event storage feature](https://docs.memfault.com/docs/mcu/metrics-api/#non-volatile-event-storage)
+    when `MEMFAULT_EVENT_STORAGE_NV_SUPPORT_ENABLED` is set to `0`. This feature
+    was previously not fully disabled, leaving some unused code in the final
+    executable. This is a minor code size improvement (approximately 300 bytes)
+    when the system is disabled (default).
+
+- Zephyr:
+
+  - Improve support for
+    [event timestamps](https://docs.memfault.com/docs/mcu/event-timestamps)
+    using Zephyr RTC devices, by adding support for RTC nodes identified using
+    `DT_ALIAS()` in addition to `DT_NODELABEL()`. Thanks to @corytodd for
+    providing the fix in
+    [#68](https://github.com/memfault/memfault-firmware-sdk/issues/68)!
+
+  - Add a Memfault HTTP OTA client backend for Zephyr MCUBoot platforms. This is
+    enabled with the `CONFIG_MEMFAULT_ZEPHYR_FOTA_BACKEND_MCUBOOT` Kconfig flag.
+    The OTA process is triggered by calling the `memfault_zephyr_fota_start()`
+    function, which is also exposed in the shell via the
+    `mflt get_latest_release` command.
+
+  - Add basic support for Xtensa targets in the Memfault Zephyr port. This
+    specifically targets the ESP32-S3 SOC.
+
+  - Add a success message when the Zephyr HTTP client posts data to Memfault.
+
+- ESP-IDF:
+
+  - Wrap calls to `esp_event_loop_create_default()` to prevent crashes if called
+    multiple times. This feature is enabled by default and is disabled with
+    `CONFIG_MEMFAULT_WRAP_EVENT_LOOP_CREATE_DEFAULT=n`
+
+  - Add an example
+    [Session Metric](https://docs.memfault.com/docs/mcu/metrics-api/#session-metrics)
+    to the [ESP32 example app](examples/esp32), which tracks statistics during
+    the ESP32 OTA session (bytes sent + received, etc).
+
+- nRF Connect SDK:
+
+  - Enable periodic upload, `CONFIG_MEMFAULT_HTTP_PERIODIC_UPLOAD=y`, by default
+    for nRF91x builds
+
+  - Default to `CONFIG_MEMFAULT_HTTP_PERIODIC_UPLOAD_USE_DEDICATED_WORKQUEUE`
+    when periodic upload is enabled
+
+  - Improve the stability of the
+    [nRF9160 sample app](examples/nrf-connect-sdk/nrf9160), by increasing the
+    `CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE` to `2048`.
+
+### :boom: Breaking Changes
+
+- Zephyr:
+
+  - Add a built-in implementation of `g_mflt_http_client_config` for Zephyr
+    devices using the Memfault HTTP client, which holds the
+    [Memfault Project Key](https://mflt.io/project-key) set via the Kconfig
+    symbol `CONFIG_MEMFAULT_PROJECT_KEY`. Users updating from a previous version
+    will have to set this Kconfig symbol when building, and any existing
+    implementation of `g_mflt_http_client_config` should be removed.
+
 ## [1.8.1] - 2024-04-24
 
 ### :chart_with_upwards_trend: Improvements

README.md

@@ -80,7 +80,7 @@ If you are using `git`, the Memfault SDK is typically added to a project as a
 submodule:
 
 ```
-$ git submodule add git@github.com:memfault/memfault-firmware-sdk.git $YOUR_PROJECT/third_party/memfault/memfault-firmware-sdk
+$ git submodule add https://github.com/memfault/memfault-firmware-sdk.git $YOUR_PROJECT/third_party/memfault/memfault-firmware-sdk
 ```
 
 This makes it easy to track the history of the Memfault SDK. You should not need

VERSION

@@ -1,3 +1,3 @@
-BUILD ID: 7582
-GIT COMMIT: ece044b45b
-VERSION: 1.8.1
+BUILD ID: 7848
+GIT COMMIT: e5e934d26b
+VERSION: 1.9.0

components/core/src/memfault_event_storage.c

@@ -42,6 +42,7 @@ MEMFAULT_WEAK void memfault_lock(void) { }
 
 MEMFAULT_WEAK void memfault_unlock(void) { }
 
+#if MEMFAULT_EVENT_STORAGE_NV_SUPPORT_ENABLED
 MEMFAULT_WEAK void memfault_event_storage_request_persist_callback(
   MEMFAULT_UNUSED const sMemfaultEventStoragePersistCbStatus *status) { }
 
@@ -53,6 +54,7 @@ MEMFAULT_WEAK const sMemfaultNonVolatileEventStorageImpl
   g_memfault_platform_nv_event_storage_impl = {
     .enabled = prv_nonvolatile_event_storage_enabled,
   };
+#endif
 
 typedef struct {
   bool write_in_progress;
@@ -76,6 +78,7 @@ static sMfltCircularBuffer s_event_storage;
 static sMemfaultEventStorageWriteState s_event_storage_write_state;
 static sMemfaultEventStorageReadState s_event_storage_read_state;
 
+#if MEMFAULT_EVENT_STORAGE_NV_SUPPORT_ENABLED
 static void prv_invoke_request_persist_callback(void) {
   sMemfaultEventStoragePersistCbStatus status;
   memfault_lock();
@@ -91,6 +94,7 @@ static void prv_invoke_request_persist_callback(void) {
 
   memfault_event_storage_request_persist_callback(&status);
 }
+#endif
 
 static size_t prv_get_total_event_size(sMemfaultEventStorageReadState *state) {
   if (state->num_events == 0) {
@@ -298,9 +302,11 @@ static void prv_event_storage_storage_finish_write(bool rollback) {
 
   // reset the write state
   s_event_storage_write_state = (sMemfaultEventStorageWriteState){ 0 };
+#if MEMFAULT_EVENT_STORAGE_NV_SUPPORT_ENABLED
   if (!rollback) {
     prv_invoke_request_persist_callback();
   }
+#endif
 }
 
 static size_t prv_get_size_cb(void) {
@@ -323,6 +329,7 @@ const sMemfaultEventStorageImpl *memfault_events_storage_boot(void *buf, size_t
   return &s_event_storage_impl;
 }
 
+#if MEMFAULT_EVENT_STORAGE_NV_SUPPORT_ENABLED
 static bool prv_save_event_to_persistent_storage(void) {
   size_t total_size;
   if (!prv_has_data_ram(&total_size)) {
@@ -375,7 +382,6 @@ int memfault_event_storage_persist(void) {
   return events_saved;
 }
 
-#if MEMFAULT_EVENT_STORAGE_NV_SUPPORT_ENABLED
 static void prv_nv_event_storage_mark_read_cb(void) {
   g_memfault_platform_nv_event_storage_impl.consume();
 

components/demo/src/panics/memfault_demo_panics.c

@@ -189,18 +189,6 @@ int memfault_demo_cli_cmd_usagefault(MEMFAULT_UNUSED int argc, MEMFAULT_UNUSED c
   return -1;
 }
 
-int memfault_demo_cli_loadaddr(int argc, char *argv[]) {
-  if (argc < 2) {
-    MEMFAULT_LOG_ERROR("Usage: loadaddr <addr>");
-    return -1;
-  }
-  uint32_t addr = (uint32_t)strtoul(argv[1], NULL, 0);
-  uint32_t val = *(uint32_t *)addr;
-
-  MEMFAULT_LOG_INFO("Read 0x%08" PRIx32 " from 0x%08" PRIx32, val, (uint32_t)(uintptr_t)addr);
-  return 0;
-}
-
 #endif  // MEMFAULT_COMPILER_ARM_CORTEX_M
 
 #if MEMFAULT_COMPILER_ARM_V7_A_R
@@ -223,3 +211,15 @@ int memfault_demo_cli_cmd_prefetchabort(MEMFAULT_UNUSED int argc, MEMFAULT_UNUSE
 }
 
 #endif  // MEMFAULT_COMPILER_ARM_V7_A_R
+
+int memfault_demo_cli_loadaddr(int argc, char *argv[]) {
+  if (argc < 2) {
+    MEMFAULT_LOG_ERROR("Usage: loadaddr <addr>");
+    return -1;
+  }
+  uint32_t addr = (uint32_t)strtoul(argv[1], NULL, 0);
+  uint32_t val = *(uint32_t *)addr;
+
+  MEMFAULT_LOG_INFO("Read 0x%08" PRIx32 " from 0x%08" PRIx32, val, (uint32_t)(uintptr_t)addr);
+  return 0;
+}

components/include/memfault/core/compiler_gcc.h

@@ -61,6 +61,18 @@ extern "C" {
       &&_l;                   \
     });
   #define MEMFAULT_BREAKPOINT(val) __asm__("break 0,0")
+#elif defined(__riscv)
+  #define MEMFAULT_GET_LR(_a) _a = __builtin_return_address(0)
+  // Take advantage of "Locally Declared Labels" to get a PC
+  //   https://gcc.gnu.org/onlinedocs/gcc/Local-Labels.html#Local-Labels
+  #define MEMFAULT_GET_PC(_a) \
+    _a = ({                   \
+      __label__ _l;           \
+    _l:                       \
+      &&_l;                   \
+    });
+  // Trigger a breakpoint exception (similar to bkpt instruction in ARM)
+  #define MEMFAULT_BREAKPOINT(val) __asm volatile("ebreak")
 #elif defined(MEMFAULT_UNITTEST) || \
   defined(__APPLE__)  // Memfault iOS SDK also #includes this header
   #define MEMFAULT_GET_LR(_a) _a = 0

components/include/memfault/core/event_storage.h

@@ -22,6 +22,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "memfault/config.h"
+
 // The unity test framework (http://www.throwtheswitch.org/unity) fails to generate mocks when
 // opaque pointers are used in a header.  To work around, the problem, we pull in the full internal
 // definition for "sMemfaultEventStorageImpl" when the unity framework is being used.
@@ -66,6 +68,7 @@ typedef struct MemfaultEventStorageInfo {
   size_t bytes_free;
 } sMemfaultEventStorageInfo;
 
+#if MEMFAULT_EVENT_STORAGE_NV_SUPPORT_ENABLED
 typedef struct MemfaultEventStoragePersistCbStatus {
   //! Summarizes the utilization of the RAM buffer passed in memfault_events_storage_boot()
   sMemfaultEventStorageInfo volatile_storage;
@@ -97,6 +100,8 @@ void memfault_event_storage_request_persist_callback(
 //! @return number of events saved or <0 for unexpected errors
 int memfault_event_storage_persist(void);
 
+#endif
+
 //! Simple API call to retrieve the number of bytes used in the allocated event storage buffer.
 //! Returns zero if the storage has not been allocated.
 size_t memfault_event_storage_bytes_used(void);

components/include/memfault/demo/cli.h

@@ -39,12 +39,12 @@ int memfault_demo_cli_cmd_memmanage(int argc, char *argv[]);
 //! Command which will generate a UsageFault on Cortex-M hardware
 int memfault_demo_cli_cmd_usagefault(int argc, char *argv[]);
 
+#endif  // MEMFAULT_COMPILER_ARM_CORTEX_M
+
 //! Read a 32-bit memory address and print the value. Can be used to test
 //! specific faults due to protected regions
 int memfault_demo_cli_loadaddr(int argc, char *argv[]);
 
-#endif  // MEMFAULT_COMPILER_ARM_CORTEX_M
-
 #if MEMFAULT_COMPILER_ARM_V7_A_R
 //! Trigger a data abort on an ARMv7-A/R chip
 int memfault_demo_cli_cmd_dataabort(int argc, char *argv[]);

components/include/memfault/version.h

@@ -19,8 +19,8 @@ typedef struct {
   uint8_t patch;
 } sMfltSdkVersion;
 
-#define MEMFAULT_SDK_VERSION   { .major = 1, .minor = 8, .patch = 1 }
-#define MEMFAULT_SDK_VERSION_STR "1.8.1"
+#define MEMFAULT_SDK_VERSION   { .major = 1, .minor = 9, .patch = 0 }
+#define MEMFAULT_SDK_VERSION_STR "1.9.0"
 
 #ifdef __cplusplus
 }

components/panics/src/memfault_fault_handling_riscv.c

@@ -17,6 +17,7 @@
   #include "memfault/panics/arch/riscv/riscv.h"
   #include "memfault/panics/coredump.h"
   #include "memfault/panics/coredump_impl.h"
+  #include "memfault/panics/fault_handling.h"
 
 const sMfltCoredumpRegion *memfault_coredump_get_arch_regions(size_t *num_regions) {
   *num_regions = 0;
@@ -42,6 +43,60 @@ void memfault_arch_fault_handling_assert(void *pc, void *lr, eMemfaultRebootReas
   prv_fault_handling_assert(pc, lr, reason);
 }
 
+// For non-esp-idf riscv implementations, provide a full assert handler and
+// other utilities.
+  #if defined(__ZEPHYR__) && defined(CONFIG_SOC_FAMILY_ESP32)
+    #include <hal/cpu_hal.h>
+    #include <zephyr/kernel.h>
+
+void memfault_platform_halt_if_debugging(void) {
+  if (cpu_ll_is_debugger_attached()) {
+    MEMFAULT_BREAKPOINT();
+  }
+}
+
+bool memfault_arch_is_inside_isr(void) {
+  // Use the Zephyr-specific implementation.
+  //
+  // It's not clear if there's a RISC-V standard way to check if the CPU is in
+  // an exception mode. The mcause register comes close but it won't tell us if
+  // a trap was taken due to a non-interrupt cause:
+  // https://five-embeddev.com/riscv-isa-manual/latest/machine.html#sec:mcause
+  return k_is_in_isr();
+}
+
+static void prv_fault_handling_assert_native(void *pc, void *lr, eMemfaultRebootReason reason) {
+  prv_fault_handling_assert(pc, lr, reason);
+
+    #if MEMFAULT_ASSERT_HALT_IF_DEBUGGING_ENABLED
+  memfault_platform_halt_if_debugging();
+    #endif
+
+  // dereference a null pointer to trigger fault
+  *(uint32_t *)0 = 0x77;
+
+  // We just trap'd into the fault handler logic so it should never be possible to get here but if
+  // we do the best thing that can be done is rebooting the system to recover it.
+  memfault_platform_reboot();
+}
+
+MEMFAULT_NO_OPT void memfault_fault_handling_assert_extra(void *pc, void *lr,
+                                                          sMemfaultAssertInfo *extra_info) {
+  prv_fault_handling_assert_native(pc, lr, extra_info->assert_reason);
+
+  MEMFAULT_UNREACHABLE;
+}
+
+MEMFAULT_NO_OPT void memfault_fault_handling_assert(void *pc, void *lr) {
+  prv_fault_handling_assert_native(pc, lr, kMfltRebootReason_Assert);
+
+  MEMFAULT_UNREACHABLE;
+}
+
+  #elif !defined(ESP_PLATFORM)
+    #error "Unsupported RISC-V platform, please contact [email protected]"
+  #endif  // !defined(ESP_PLATFORM) && defined(__ZEPHYR__)
+
 void memfault_fault_handler(const sMfltRegState *regs, eMemfaultRebootReason reason) {
   if (s_crash_reason == kMfltRebootReason_Unknown) {
     // TODO confirm this works correctly- we should have the correct
@@ -56,7 +111,8 @@ void memfault_fault_handler(const sMfltRegState *regs, eMemfaultRebootReason rea
   };
 
   sCoredumpCrashInfo info = {
-    .stack_address = (void *)regs->sp,
+    // Zephyr fault shim saves the stack pointer in s[0]
+    .stack_address = (void *)regs->s[0],
     .trace_reason = save_info.trace_reason,
     .exception_reg_state = regs,
   };
@@ -66,6 +122,11 @@ void memfault_fault_handler(const sMfltRegState *regs, eMemfaultRebootReason rea
   if (coredump_saved) {
     memfault_reboot_tracking_mark_coredump_saved();
   }
+
+  #if !MEMFAULT_FAULT_HANDLER_RETURN
+  memfault_platform_reboot();
+  MEMFAULT_UNREACHABLE;
+  #endif
 }
 
 size_t memfault_coredump_storage_compute_size_required(void) {