Memfault Firmware SDK 1.22.0 (Build 13216)

Author: Memfault Inc

CHANGELOG.md

@@ -6,6 +6,59 @@ 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.22.0] - 2025-03-19
+
+### 📈 Added
+
+- General
+
+  - Enable building the SDK on `aarch64`. Note that this only adds support for
+    building the SDK on that target, full end-to-end support is not yet
+    available.
+
+- Zephyr:
+
+  - For SOC's with a data cache, flush the cache prior to performing a system
+    reboot, to ensure data integrity of the RAM-backed reboot tracking data.
+    This is added to the `memfault_platform_reboot()` default implementation,
+    which can be overridden by the user if needed.
+
+    SOC's without a cache will have no effect from this change.
+
+### 🛠️ Changed
+
+- General:
+
+  - `MEMFAULT_LOG_TIMESTAMPS_ENABLE` is now enabled by default. When enabled,
+    and `memfault_platform_time_get_current()` returns a valid timestamp, logs
+    will include a second-precision timestamp. This applies to both:
+
+    - logs captured as part of a coredump
+    - logs sent to Memfault after invoking `memfault_log_trigger_collection()`
+
+  - Remove some 64-bit integer divides used when computing the built-in
+    `uptime_s` metric, and in the FreeRTOS
+    `memfault_platform_get_time_since_boot_ms()` implementation.
+
+- ESP-IDF:
+
+  - Log lines that are only a single `'\n'` character are no longer recorded in
+    the Memfault Log Buffer.
+
+### 🚩 Deprecated
+
+### 🔥 Removed
+
+### 🐛 Fixed
+
+- Zephyr:
+
+  - The `hwinfo`-based Reset Reason implementation did not clear the reset
+    reason register after reading the data. Updated to properly call
+    `hwinfo_clear_reset_cause()` after reading the reset reason.
+
+### 🔒 Security
+
 ## [1.21.1] - 2025-03-07
 
 ### 🐛 Fixed

VERSION

@@ -1,3 +1,3 @@
-BUILD ID: 12975
-GIT COMMIT: b107685f75
-VERSION: 1.21.1
+BUILD ID: 13216
+GIT COMMIT: fd0102e4c8
+VERSION: 1.22.0

components/core/src/memfault_log_data_source.c

@@ -100,31 +100,48 @@ __attribute__((no_sanitize_undefined))
     #endif
   #endif
 static bool
-prv_copy_msg_callback(sMfltLogIterator *iter, MEMFAULT_UNUSED size_t offset, const char *buf,
-                      size_t buf_len) {
+prv_serialize_msg_callback(sMfltLogIterator *iter, MEMFAULT_UNUSED size_t offset, const char *buf,
+                           size_t buf_len) {
   sMfltLogEncodingCtx *const ctx = (sMfltLogEncodingCtx *)iter->user_ctx;
-  return memfault_cbor_join(&ctx->encoder, buf, buf_len);
-}
 
-static bool prv_encode_current_log(sMemfaultCborEncoder *encoder, sMfltLogIterator *iter) {
-  if (!memfault_cbor_encode_unsigned_integer(encoder,
+  #if MEMFAULT_LOG_TIMESTAMPS_ENABLE
+  // Encode the timestamp value, if it's present, otherwise insert a 0
+  uint32_t timestamp;
+  if (memfault_log_hdr_is_timestamped(iter->entry.hdr)) {
+    if (buf_len < sizeof(timestamp)) {
+      return false;
+    }
+    memcpy(&timestamp, buf, sizeof(timestamp));
+    buf += sizeof(timestamp);
+    buf_len -= sizeof(timestamp);
+  } else {
+    timestamp = 0;
+  }
+
+  if (!memfault_cbor_encode_unsigned_integer(&ctx->encoder, timestamp)) {
+    return false;
+  }
+  #endif
+
+  // Encode the log level
+  if (!memfault_cbor_encode_unsigned_integer(&ctx->encoder,
                                              memfault_log_get_level_from_hdr(iter->entry.hdr))) {
     return false;
   }
 
   eMemfaultLogRecordType type = memfault_log_get_type_from_hdr(iter->entry.hdr);
-  bool success;
 
   // Note: We encode "preformatted" logs (i.e logs that have run through printf) as cbor text
   // string and "compact" logs as a cbor byte array so we can differentiate between the two while
   // decoding
   if (type == kMemfaultLogRecordType_Preformatted) {
-    success = memfault_cbor_encode_string_begin(encoder, iter->entry.len);
+    // The message is not null-terminated, so we can't use
+    // memfault_cbor_encode_string() directly.
+    bool success = memfault_cbor_encode_string_begin(&ctx->encoder, buf_len);
+    return success && memfault_cbor_join(&ctx->encoder, buf, buf_len);
   } else {  // kMemfaultLogRecordType_Compact
-    success = memfault_cbor_encode_byte_string_begin(encoder, iter->entry.len);
+    return memfault_cbor_encode_byte_string(&ctx->encoder, buf, buf_len);
   }
-
-  return (success && memfault_log_iter_copy_msg(iter, prv_copy_msg_callback));
 }
 
 static bool prv_log_iterate_encode_callback(sMfltLogIterator *iter) {
@@ -133,7 +150,7 @@ static bool prv_log_iterate_encode_callback(sMfltLogIterator *iter) {
     return false;
   }
   if (!prv_log_is_sent(iter->entry.hdr)) {
-    ctx->has_encoding_error |= !prv_encode_current_log(&ctx->encoder, iter);
+    ctx->has_encoding_error |= !memfault_log_iter_copy_msg(iter, prv_serialize_msg_callback);
     // It's possible more logs have been added to the buffer
     // after the memfault_log_data_source_has_been_triggered() call. They cannot be included,
     // because the total message size has already been communicated to the packetizer.
@@ -146,16 +163,24 @@ static bool prv_log_iterate_encode_callback(sMfltLogIterator *iter) {
 
 static bool prv_encode(sMemfaultCborEncoder *encoder, void *iter) {
   sMfltLogEncodingCtx *ctx = (sMfltLogEncodingCtx *)((sMfltLogIterator *)iter)->user_ctx;
-  if (!memfault_serializer_helper_encode_metadata_with_time(encoder, kMemfaultEventType_Logs,
+  #if MEMFAULT_LOG_TIMESTAMPS_ENABLE
+  eMemfaultEventType event_type = kMemfaultEventType_LogsTimestamped;
+  // To save space, all logs are encoded into a single array (as opposed to using a map or
+  // array per log):
+  const size_t elements_per_log = 3;  // timestamp, lvl, msg
+  #else
+  eMemfaultEventType event_type = kMemfaultEventType_Logs;
+  const size_t elements_per_log = 2;  // lvl, msg
+  #endif
+
+  if (!memfault_serializer_helper_encode_metadata_with_time(encoder, event_type,
                                                             &ctx->trigger_time)) {
     return false;
   }
   if (!memfault_cbor_encode_unsigned_integer(encoder, kMemfaultEventKey_EventInfo)) {
     return false;
   }
-  // To save space, all logs are encoded into a single array (as opposed to using a map or
-  // array per log):
-  const size_t elements_per_log = 2;  // hdr, msg
+
   if (!memfault_cbor_encode_array_begin(encoder, elements_per_log * ctx->num_logs)) {
     return false;
   }

components/demo/src/memfault_demo_cli_log.c

@@ -33,6 +33,7 @@ int memfault_demo_cli_cmd_test_log(MEMFAULT_UNUSED int argc, MEMFAULT_UNUSED cha
 }
 
 int memfault_demo_cli_cmd_trigger_logs(MEMFAULT_UNUSED int argc, MEMFAULT_UNUSED char *argv[]) {
+  MEMFAULT_LOG_RAW("Triggering log collection");
   memfault_log_trigger_collection();
   return 0;
 }

components/demo/src/panics/memfault_demo_panics.c

@@ -223,7 +223,7 @@ int memfault_demo_cli_loadaddr(int argc, char *argv[]) {
     return -1;
   }
   uint32_t addr = (uint32_t)strtoul(argv[1], NULL, 0);
-  uint32_t val = *(uint32_t *)addr;
+  uint32_t val = *(uint32_t *)(uintptr_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

@@ -52,6 +52,10 @@ extern "C" {
   #define MEMFAULT_GET_LR(_a) _a = __builtin_return_address(0)
   #define MEMFAULT_GET_PC(_a) __asm volatile("mov %0, pc" : "=r"(_a))
   #define MEMFAULT_BREAKPOINT(val) __asm volatile("bkpt " #val)
+#elif defined(__aarch64__)
+  #define MEMFAULT_GET_LR(_a) _a = __builtin_return_address(0)
+  #define MEMFAULT_GET_PC(_a) __asm volatile("adr %0, ." : "=r"(_a))
+  #define MEMFAULT_BREAKPOINT(val) __asm volatile("brk %0" : : "I"(val))
 #elif defined(__XTENSA__)
   #define MEMFAULT_GET_LR(_a) _a = __builtin_return_address(0)
   #define MEMFAULT_GET_PC(_a) \

components/include/memfault/core/serializer_key_ids.h

@@ -36,6 +36,7 @@ typedef enum {
   // Deprecated: kMemfaultEventType_LogError = 3, use trace_with_log feature instead
   kMemfaultEventType_Logs = 4,
   kMemfaultEventType_Cdr = 5,
+  kMemfaultEventType_LogsTimestamped = 6,
 } eMemfaultEventType;
 
 //! EventInfo dictionary keys for events with type kMemfaultEventType_Heartbeat.

components/include/memfault/default_config.h

@@ -169,7 +169,7 @@ extern "C" {
 //! available. Currently timestamps are only decoded from logs embedded in
 //! coredumps.
 #ifndef MEMFAULT_LOG_TIMESTAMPS_ENABLE
-  #define MEMFAULT_LOG_TIMESTAMPS_ENABLE 0
+  #define MEMFAULT_LOG_TIMESTAMPS_ENABLE 1
 #endif
 
 //! Controls whether or not multiple events will be batched into a single

components/include/memfault/version.h

@@ -20,8 +20,8 @@ typedef struct {
 } sMfltSdkVersion;
 
 #define MEMFAULT_SDK_VERSION \
-  { .major = 1, .minor = 21, .patch = 1 }
-#define MEMFAULT_SDK_VERSION_STR "1.21.1"
+  { .major = 1, .minor = 22, .patch = 0 }
+#define MEMFAULT_SDK_VERSION_STR "1.22.0"
 
 #ifdef __cplusplus
 }

components/metrics/src/memfault_metrics.c

@@ -556,7 +556,26 @@ static void prv_collect_builtin_data(void) {
   prv_memfault_collect_log_metrics();
 #endif
 #if MEMFAULT_METRICS_UPTIME_ENABLE
-  MEMFAULT_METRIC_SET_UNSIGNED(uptime_s, memfault_platform_get_time_since_boot_ms() / 1000);
+  // uptime_s is a 32-bit value measuring seconds since boot. Convert the uptime
+  // in milliseconds to seconds using the following approach, to avoid 64-bit
+  // division:
+  //
+  // precomputed_scale_factor = (1 << 32) / 1000 = 0x418937
+  // uptime_seconds = (uptime_ms * 0x418937) >> 32
+  //
+  // The maximum millisecond value that can be converted to seconds without
+  // overflowing using this algorithm is:
+  //
+  // (0xFFFF_FFFF_FFFF_FFFF / ((1 << 32) / 1000)) = 4294967592000 milliseconds
+  //
+  // 4294967592000 / 1000 / 60 / 60 / 24 / 365 ≈ 136 years
+  //
+  // 4294967592000 / 1000 = 4294967592 seconds, 0x1_0000_0128 in hex, which
+  // exceeds the possible value for a 32-bit integer, so we don't lose any range
+  // with this algorithm.
+  const uint32_t uptime_seconds =
+    (uint32_t)((memfault_platform_get_time_since_boot_ms() * 0x418937ull) >> 32);
+  MEMFAULT_METRIC_SET_UNSIGNED(uptime_s, uptime_seconds);
 #endif
 }
 

components/panics/src/memfault_stdlib_assert.c

@@ -20,7 +20,14 @@
 void __aeabi_assert(const char *failedExpr, const char *file, int line) {
   (void)failedExpr, (void)file, (void)line;
   #elif (defined(__GNUC__))
+    // Disable -Wreserved-identifier for clang
+    #pragma GCC diagnostic push
+    #if defined(__clang__)
+      #pragma GCC diagnostic ignored "-Wreserved-identifier"
+    #endif
+extern void __assert_func(const char *file, int line, const char *func, const char *failedexpr);
 void __assert_func(const char *file, int line, const char *func, const char *failedexpr) {
+    #pragma GCC diagnostic pop
   (void)file, (void)line, (void)func, (void)failedexpr;
   #endif
   MEMFAULT_ASSERT(0);

examples/freertos/src/memfault/memfault_platform_config.h

@@ -23,4 +23,6 @@
 // Enable adding custom demo shell commands
 #define MEMFAULT_DEMO_SHELL_COMMAND_EXTENSIONS 1
 
-#define MEMFAULT_PLATFORM_HAS_LOG_CONFIG 1
+#if !defined(MEMFAULT_PLATFORM_HAS_LOG_CONFIG)
+  #define MEMFAULT_PLATFORM_HAS_LOG_CONFIG 1
+#endif

examples/freertos/src/memfault/memfault_platform_port.c

@@ -12,6 +12,10 @@
 #include "memfault/ports/freertos_coredump.h"
 #include "memfault/ports/reboot_reason.h"
 
+#if !defined(MEMFAULT_EXAMPLE_USE_REAL_TIME)
+  #define MEMFAULT_EXAMPLE_USE_REAL_TIME 1
+#endif
+
 // Buffer used to store formatted string for output
 #define MEMFAULT_DEBUG_LOG_BUFFER_SIZE_BYTES \
   (sizeof("2024-11-27T14:19:29Z|123456780 I ") + MEMFAULT_DATA_EXPORT_BASE64_CHUNK_MAX_LEN)
@@ -82,6 +86,7 @@ void memfault_platform_log_raw(const char *fmt, ...) {
 }
 
 bool memfault_platform_time_get_current(sMemfaultCurrentTime *time_output) {
+#if MEMFAULT_EXAMPLE_USE_REAL_TIME
   // Get time from time.h
 
   // Debug: print time fields
@@ -105,6 +110,10 @@ bool memfault_platform_time_get_current(sMemfaultCurrentTime *time_output) {
     },
   };
   return true;
+#else
+  (void)time_output;
+  return false;
+#endif
 }
 
 void memfault_platform_reboot_tracking_boot(void) {

examples/freertos/src/metrics.c

@@ -24,6 +24,10 @@
   #define DEBUG_PRINTF(fmt, ...)
 #endif
 
+#if !defined(MEMFAULT_EXAMPLE_DAILY_HEARTBEAT_ENABLE)
+  #define MEMFAULT_EXAMPLE_DAILY_HEARTBEAT_ENABLE 1
+#endif
+
 static StackType_t metrics_task_stack[EXAMPLE_TASK_STACKS];
 static StaticTask_t metrics_task_tcb;
 
@@ -97,27 +101,39 @@ static void prv_collect_libc_heap_usage_metrics(void) {
   MEMFAULT_METRIC_SET_UNSIGNED(memory_pct_max, heap_pct);
 }
 
+#if MEMFAULT_EXAMPLE_DAILY_HEARTBEAT_ENABLE
 static void prv_daily_heartbeat(void) {
-  // This function is called once a day to stop + start a "daily_heartbeat"
-  // session.
+  // Generate a daily_heartbeat session report once a day, based on
+  // MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS. This demonstrates a simple way to
+  // track metrics over a 24 hour interval.
+  MEMFAULT_STATIC_ASSERT((24 * 60 * 60) % MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS == 0,
+                         "Heartbeat interval must be an even divisor of a day");
+  // For testing, set MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS to a low value (1 second), and
+  // uncomment the below line
+  // #define DAILY_HEARTBEAT_INTERVAL_COUNT (24)
+  #define DAILY_HEARTBEAT_INTERVAL_COUNT ((24 * 60 * 60) / MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS)
+  static uint64_t s_last_daily_heartbeat_interval = 0;
 
-  // The first time this is called on boot will be a no-op, since the session
-  // has not been started yet
-  uint32_t uptime_s = memfault_platform_get_time_since_boot_ms() / 1000;
+  if (++s_last_daily_heartbeat_interval % DAILY_HEARTBEAT_INTERVAL_COUNT == 0) {
+    // The first time this is called on boot will be a no-op, since the session
+    // has not been started yet
+    uint32_t uptime_s = memfault_platform_get_time_since_boot_ms() / 1000;
 
-  if (uptime_s > MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS) {
-    MEMFAULT_LOG_INFO("📆 Triggering daily heartbeat");
-  }
+    if (uptime_s > MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS) {
+      MEMFAULT_LOG_INFO("📆 Triggering daily heartbeat");
+    }
 
-  // Record a sample metric into the daily session
-  MEMFAULT_METRIC_SESSION_SET_UNSIGNED(uptime_s, daily_heartbeat, uptime_s);
+    // Record a sample metric into the daily session
+    MEMFAULT_METRIC_SESSION_SET_UNSIGNED(uptime_s, daily_heartbeat, uptime_s);
 
-  // End the session
-  MEMFAULT_METRICS_SESSION_END(daily_heartbeat);
+    // End the session
+    MEMFAULT_METRICS_SESSION_END(daily_heartbeat);
 
-  // Start a new session for the next daily interval
-  MEMFAULT_METRICS_SESSION_START(daily_heartbeat);
+    // Start a new session for the next daily interval
+    MEMFAULT_METRICS_SESSION_START(daily_heartbeat);
+  }
 }
+#endif  // MEMFAULT_EXAMPLE_DAILY_HEARTBEAT_ENABLE
 
 void memfault_metrics_heartbeat_collect_data(void) {
   MEMFAULT_LOG_INFO("💓 Heartbeat callback triggered");
@@ -131,19 +147,9 @@ void memfault_metrics_heartbeat_collect_data(void) {
 #endif
   prv_collect_libc_heap_usage_metrics();
 
-  // Call prv_daily_heartbeat() once a day, based on MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS
-  // This is a simple way to track daily metrics
-  MEMFAULT_STATIC_ASSERT((24 * 60 * 60) % MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS == 0,
-                         "Heartbeat interval must be an even divisor of a day");
-  // For testing, set MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS to a low value (1 second), and
-  // uncomment the below line
-// #define DAILY_HEARTBEAT_INTERVAL_COUNT (24)
-#define DAILY_HEARTBEAT_INTERVAL_COUNT ((24 * 60 * 60) / MEMFAULT_METRICS_HEARTBEAT_INTERVAL_SECS)
-  static uint64_t s_last_daily_heartbeat_interval = 0;
-
-  if (++s_last_daily_heartbeat_interval % DAILY_HEARTBEAT_INTERVAL_COUNT == 0) {
-    prv_daily_heartbeat();
-  }
+#if MEMFAULT_EXAMPLE_DAILY_HEARTBEAT_ENABLE
+  prv_daily_heartbeat();
+#endif
 
   // For demonstration purposes, print the current values. This is not
   // recommended for production.