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
 }