Memfault Firmware SDK 1.7.0 (Build 6257)

Author: Memfault Inc

.codecov.yml

@@ -2,6 +2,10 @@ coverage:
   precision: 2
   round: down
   range: "70...100"
+  status:
+    project:
+      default:
+        target: 70%
 
 ignore:
   - "tests" # Don't include the tests themselves in the code coverage report

.git-blame-ignore-revs

@@ -0,0 +1,10 @@
+# https://docs.github.com/en/repositories/working-with-files/using-files/viewing-a-file#ignore-commits-in-the-blame-view
+#
+# This file contains a list of commits that are not likely what you
+# are looking for in a blame, such as mass reformatting or renaming.
+# You can set this file as a default ignore file for blame by running
+# the following command.
+#
+#     git config blame.ignoreRevsFile .git-blame-ignore-revs
+
+0ca1a2a16f7cbf0420d795ca3a4f508fe09f95bd # SDK v1.6.2 clang-format run

CHANGELOG.md

@@ -1,5 +1,70 @@
 # Memfault Firmware SDK Changelog
 
+## [1.7.0] - 2024-01-29
+
+### :rocket: New Features
+
+- General:
+
+  - :tada:Custom Reboot Reasons!:tada: The SDK now allows creating custom reboot
+    reasons in addition to those defined in
+    [`components/include/memfault/core/reboot_reason_types.h`](components/include/memfault/core/reboot_reason_types.h).
+    Users can create custom reboot reasons for both expected and unexpected
+    reboots. For more information see
+    [`components/include/memfault/core/reboot_tracking.h`](components/include/memfault/core/reboot_tracking.h).
+    Enable this feature with Kconfigs in Zephyr and ESP-IDF
+    (`CONFIG_MEMFAULT_REBOOT_REASON_CUSTOM_ENABLE=y`) or by adding
+    `#define MEMFAULT_REBOOT_REASON_CUSTOM_ENABLE 1` to your
+    `memfault_platform_config.h`.
+  - Added an option to include a Project Key in a chunk message header. This
+    allows a chunk to specify which project the included data should be sent to.
+    The default behavior is to use the project specified by the Project Key
+    header in the POST upload. To enable, add
+    `#define MEMFAULT_MESSAGE_HEADER_CONTAINS_PROJECT_KEY 1` and
+    `#define MEMFAULT_PROJECT_KEY "<project key string>"` to your
+    `memfault_platform_config.h`. Any chunks sent using this configuration will
+    be sent to the project routed with `MEMFAULT_PROJECT_KEY` rather than the
+    project routed with the POST header's Project Key.
+
+### :chart_with_upwards_trend: Improvements
+
+- General:
+
+  - Improved suggested linker snippets defining coredump memory regions
+  - Added a self test to validate platform time functions,
+    `memfault_platform_get_time_since_boot_ms()` and
+    `memfault_platform_time_get_current()`. This test will catch errors like
+    non-monotonically increasing counters and current time reported as near
+    epoch time
+  - Fixed backspace handling in the FreeRTOS QEMU example console
+  - Added `-fsanitize=leak` to the SDK unit tests (Linux only)
+  - Fixed a missing `strnlen()` definition when enabling the self test with some
+    libc implementations. This function is part of a POSIX standard that might
+    be missing from some libc implementations
+  - Added the previous release commit for 1.6.2 to `.git-blame-ignore-revs` to
+    allow for better `git blame` output since this commit contains _only_
+    formatting changes.
+
+- Zephyr:
+
+  - Added an example CDR implementation to the example QEMU app
+  - Added a Kconfig, (`CONFIG_MEMFAULT_RECORD_REBOOT_ON_SYSTEM_INIT`) to allow
+    deferring reboot reason collection to a later point in time. Setting this
+    option to `n` is intended to help when device info is only available after
+    boot completes.
+  - Added built-in metrics for Zephyr's IP subsystem,
+    (`CONFIG_MEMFAULT_METRICS_TCP_IP`)
+  - Added Kconfig to select either PEM or DER formats for TLS certificates,
+    (`CONFIG_MEMFAULT_TLS_CERTS_USE_DER`)
+
+- ESP-IDF:
+  - Added a Kconfig to enable/disable compact logging
+    (`CONFIG_MEMFAULT_COMPACT_LOG_ENABLE`)
+  - Improved build compatibility when building with PlatformIO
+  - Added support for networking over Ethernet interfaces
+  - Added a built-in `connectivity_connected_time` core metric for WiFi devices,
+    (`CONFIG_MEMFAULT_ESP_WIFI_CONNECTIVITY_TIME_METRICS`)
+
 ## [1.6.2] - 2024-01-29
 
 ### :chart_with_upwards_trend: Improvements

VERSION

@@ -1,3 +1,3 @@
-BUILD ID: 5836
-GIT COMMIT: ed83a4f3c
-VERSION: 1.6.2
+BUILD ID: 6257
+GIT COMMIT: 8cd2342158
+VERSION: 1.7.0

components/core/src/memfault_data_packetizer.c

@@ -133,8 +133,36 @@ typedef struct {
   sMfltChunkTransportCtx curr_msg_ctx;
 } sMfltTransportState;
 
+#if MEMFAULT_MESSAGE_HEADER_CONTAINS_PROJECT_KEY
+MEMFAULT_STATIC_ASSERT(
+  sizeof(MEMFAULT_PROJECT_KEY) > 1,
+  "MEMFAULT_PROJECT_KEY must be a string literal of at least 1 character + null terminator");
+#endif
+
 typedef MEMFAULT_PACKED_STRUCT {
-  uint8_t mflt_msg_type;  // eMfltMessageType
+// The first byte of the header is the message type. Bit layout:
+//   ┌───────────┬─┬─┐
+//   │0|1|2|3|4|5│6│7│
+//   └─────┬─────┴┬┴┬┘
+//         │      │ │
+//         │      │ └►RLE in use:
+//         │      │    0b0=no RLE
+//         │      │    0b1=RLE
+//         │      │
+//         │      └──►Project Key follows:
+//         │           0b0=no Project Key
+//         │           0b1=32 byte Project Key follows header byte
+//         │
+//         └─────────►eMfltMessageType
+//                     6 bits (63 values)
+#define MEMFAULT_MESSAGE_HEADER_RLE_ENABLE_MASK (1u << 7)
+#if MEMFAULT_MESSAGE_HEADER_CONTAINS_PROJECT_KEY
+  #define MEMFAULT_MESSAGE_HEADER_PROJECT_KEY_ENABLE_MASK (1u << 6)
+#endif
+  uint8_t mflt_msg_type;
+#if MEMFAULT_MESSAGE_HEADER_CONTAINS_PROJECT_KEY
+  uint8_t project_key[sizeof(MEMFAULT_PROJECT_KEY)];  // including null term
+#endif
 }
 sMfltPacketizerHdr;
 
@@ -162,12 +190,20 @@ static void prv_data_source_chunk_transport_msg_reader(uint32_t offset, void *bu
 
   const sMessageMetadata *msg_metadata = &s_mflt_packetizer_state.msg_metadata;
   if (offset < hdr_size) {
-    const uint8_t rle_enable_mask = 0x80;
     const uint8_t msg_type = (uint8_t)msg_metadata->source.type;
 
     sMfltPacketizerHdr hdr = {
-      .mflt_msg_type = msg_metadata->source.use_rle ? msg_type | rle_enable_mask : msg_type,
+      .mflt_msg_type = msg_type,
     };
+    if (msg_metadata->source.use_rle) {
+      const uint8_t rle_enable_mask = MEMFAULT_MESSAGE_HEADER_RLE_ENABLE_MASK;
+      hdr.mflt_msg_type |= rle_enable_mask;
+    }
+#if MEMFAULT_MESSAGE_HEADER_CONTAINS_PROJECT_KEY
+    const uint8_t prj_key_enable_mask = MEMFAULT_MESSAGE_HEADER_PROJECT_KEY_ENABLE_MASK;
+    hdr.mflt_msg_type |= prj_key_enable_mask;
+    memcpy(hdr.project_key, MEMFAULT_PROJECT_KEY, sizeof(hdr.project_key));
+#endif
     uint8_t *hdr_bytes = (uint8_t *)&hdr;
 
     const size_t bytes_to_copy = MEMFAULT_MIN(hdr_size - offset, buf_len);
@@ -245,12 +281,14 @@ static bool prv_load_next_message_to_send(bool enable_multi_packet_chunks,
     return false;
   }
 
+  const size_t hdr_size = sizeof(sMfltPacketizerHdr);
+
   *state = (sMfltTransportState){
     .active_message = true,
     .msg_metadata = msg_metadata,
     .curr_msg_ctx =
       (sMfltChunkTransportCtx){
-        .total_size = msg_metadata.total_size + sizeof(sMfltPacketizerHdr),
+        .total_size = msg_metadata.total_size + hdr_size,
         .read_msg = prv_data_source_chunk_transport_msg_reader,
         .enable_multi_call_chunk = enable_multi_packet_chunks,
       },

components/core/src/memfault_self_test.c

@@ -18,6 +18,7 @@
 #include "memfault/core/math.h"
 #include "memfault/core/platform/core.h"
 #include "memfault/core/platform/device_info.h"
+#include "memfault/core/platform/system_time.h"
 #include "memfault/core/reboot_tracking.h"
 #include "memfault/core/self_test.h"
 #include "memfault/core/trace_event.h"
@@ -76,7 +77,7 @@ static bool is_field_valid(const char *str, eDeviceInfoField field) {
   }
   // First validate min and max length
   // Max + 1 needed determine if we exceeded bounds before NULL found
-  size_t len = strnlen(str, MEMFAULT_DEVICE_INFO_MAX_STRING_SIZE + 1);
+  size_t len = memfault_strnlen(str, MEMFAULT_DEVICE_INFO_MAX_STRING_SIZE + 1);
   if ((len < 1) || (len > MEMFAULT_DEVICE_INFO_MAX_STRING_SIZE)) {
     MEMFAULT_LOG_ERROR("Invalid length %zu for %s", len, s_device_info_field_names[field]);
     return false;
@@ -311,6 +312,72 @@ uint32_t memfault_self_test_reboot_reason_test_verify(void) {
   return success ? 0 : 1;
 }
 
+// Use MEMFAULT_NO_OPT to prevent busy loop from being removed
+MEMFAULT_NO_OPT static uint32_t prv_get_time_since_boot_test(void) {
+  uint64_t start_time_ms = memfault_platform_get_time_since_boot_ms();
+
+  if (start_time_ms == 0) {
+    MEMFAULT_LOG_ERROR("Time since boot reported as 0");
+    return (1 << 0);
+  }
+
+  // Force a 100ms delay to ensure enough time has passed to yield a different timestamp
+  memfault_self_test_platform_delay(100);
+
+  uint64_t end_time_ms = memfault_platform_get_time_since_boot_ms();
+  if ((end_time_ms <= start_time_ms)) {
+    MEMFAULT_LOG_ERROR("Time since boot not monotonically increasing: start[%" PRIu64
+                       "] vs end[%" PRIu64 "]",
+                       start_time_ms, end_time_ms);
+    return (1 << 1);
+  }
+
+  MEMFAULT_LOG_INFO("Time since boot test succeeded");
+  return 0;
+}
+
+// Arbitrary point in recent history
+// The time test did not exist before 2024/01/29 UTC
+  #define MEMFAULT_SELF_TEST_TIMESTAMP_ANCHOR (1706486400)
+
+static uint32_t prv_platform_time_get_current_test(void) {
+  sMemfaultCurrentTime time = {
+    .type = kMemfaultCurrentTimeType_Unknown,
+    .info = {
+      .unix_timestamp_secs = 0,
+    },
+  };
+  bool result = memfault_platform_time_get_current(&time);
+  if (!result) {
+    MEMFAULT_LOG_ERROR("Current timestamp could not be recovered");
+    return (1 << 2);
+  }
+
+  if (time.type != kMemfaultCurrentTimeType_UnixEpochTimeSec) {
+    MEMFAULT_LOG_ERROR("Invalid time type returned: %u", time.type);
+    return (1 << 3);
+  }
+
+  if (time.info.unix_timestamp_secs < MEMFAULT_SELF_TEST_TIMESTAMP_ANCHOR) {
+    MEMFAULT_LOG_ERROR("Timestamp too far in the past: %" PRIu64, time.info.unix_timestamp_secs);
+    return (1 << 4);
+  }
+
+  MEMFAULT_LOG_INFO("Verify received timestamp for accuracy. Timestamp received %" PRIu64,
+                    time.info.unix_timestamp_secs);
+  return 0;
+}
+
+uint32_t memfault_self_test_time_test(void) {
+  MEMFAULT_SELF_TEST_PRINT_HEADER("Time Test");
+
+  uint32_t result = prv_get_time_since_boot_test();
+  result |= prv_platform_time_get_current_test();
+
+  MEMFAULT_LOG_INFO(MEMFAULT_SELF_TEST_END_OUTPUT);
+  return result;
+}
+
 #endif  // defined(MEMFAULT_UNITTEST_SELF_TEST)
 
 int memfault_self_test_run(uint32_t run_flags) {
@@ -333,5 +400,8 @@ int memfault_self_test_run(uint32_t run_flags) {
   if (run_flags & kMemfaultSelfTestFlag_RebootReasonVerify) {
     result = memfault_self_test_reboot_reason_test_verify();
   }
+  if (run_flags & kMemfaultSelfTestFlag_PlatformTime) {
+    result |= memfault_self_test_time_test();
+  }
   return (result == 0) ? 0 : 1;
 }

components/core/src/memfault_self_test_private.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
 #include "memfault/core/compiler.h"
@@ -56,6 +57,21 @@ MEMFAULT_NORETURN void memfault_self_test_reboot_reason_test(void);
 //! Verifies reboot reason test results
 uint32_t memfault_self_test_reboot_reason_test_verify(void);
 
+//! Runs tests against platform time functions
+uint32_t memfault_self_test_time_test(void);
+
+//! Internal implementation of strnlen
+//!
+//! Support for strnlen is inconsistent across a lot of libc implementations so we implement this
+//! here for compatibility reasons. See
+//! https://pubs.opengroup.org/onlinepubs/9699919799/functions/strlen.html
+//! @param str Pointer to a C string. Pointer must not be NULL
+//! @param n Maximum number of characters to examine when determining the length of the string
+//! @returns The strnlen() function shall return the number of bytes preceding the first null byte
+//! in the array to which s points, if s contains a null byte within the first maxlen bytes;
+//! otherwise, it shall return maxlen
+size_t memfault_strnlen(const char *str, size_t n);
+
 #ifdef __cplusplus
 }
 #endif

components/core/src/memfault_self_test_utils.c

@@ -52,3 +52,21 @@ uint32_t memfault_self_test_arg_to_flag(const char *arg) {
   MEMFAULT_LOG_WARN("No test type found for arg: %s. Default tests selected", arg);
   return kMemfaultSelfTestFlag_Default;
 }
+
+// Include an implementation of strnlen, based on picolibc/newlib
+// For reference: https://github.com/picolibc/picolibc/blob/main/newlib/libc/string/strnlen.c
+size_t memfault_strnlen(const char *str, size_t n) {
+  size_t count = 0;
+
+  // Must check n first to prevent out of bounds access
+  while (n-- && *str) {
+    count++;
+    str++;
+  }
+
+  return count;
+}
+
+MEMFAULT_WEAK void memfault_self_test_platform_delay(MEMFAULT_UNUSED uint32_t delay_ms) {
+  MEMFAULT_LOG_ERROR("%s not implemented for this platform", __func__);
+}