Memfault Firmware SDK 1.5.2 (Build 5100)

Author: Memfault Inc

CHANGELOG.md

@@ -1,5 +1,43 @@
 # Memfault Firmware SDK Changelog
 
+## [1.5.2] - 2023-12-12
+
+### :chart_with_upwards_trend: Improvements
+
+- General:
+
+  - Add a self-test component which checks the device's integration state. This
+    self test is available via the demo cli command `self_test`, or can be
+    called directly via `memfault_self_test_run()` (see
+    [`self_test.h`](components/include/memfault/core/self_test.h) for details).
+    Currently, it validates device info and the build ID.
+
+  - Add a helper macro called `MEMFAULT_REBOOT_MARK_RESET_IMMINENT` in order to
+    make marking an imminent reboot easier. It takes the reboot reason as an
+    argument.
+
+- ESP-IDF:
+
+  - Add an opt-in assert on malloc failure, controlled with
+    `CONFIG_MEMFAULT_ASSERT_ON_ALLOC_FAILURE`. This is useful for tracking heap
+    memory issues. Depending on the design, a system may in general not have any
+    expected malloc failures, and may not be set up to handle them. This feature
+    will generate issues tagged as `Out Of Memory` in the Memfault platform.
+
+- Zephyr:
+
+  - Adjust the implementation of `memfault_zephyr_port_http_upload_sdk_data()`
+    to check the socket before each incremental call to the `send()` socket
+    operation and wait for the socket to become available. If the socket takes
+    too long (a healthy 5 second timeout is given), the function will return
+    with an error. Note this function was previously blocking, but may now abort
+    mid-transfer. This check was primarily added to prevent a busy loop that
+    hogs the CPU, preventing lower priority threads from running. This situation
+    could occur with larger HTTP transfers during which the socket may be busy
+    processing tx data when another send request occurs.
+
+  - Fix a build error in the Zephyr RTC port.
+
 ## [1.5.1] - 2023-12-07
 
 ### :chart_with_upwards_trend: Improvements

VERSION

@@ -1,3 +1,3 @@
-BUILD ID: 4929
-GIT COMMIT: 138e44883
-VERSION: 1.5.1
+BUILD ID: 5100
+GIT COMMIT: 6c3661b0e
+VERSION: 1.5.2

components/core/src/memfault_self_test.c

@@ -0,0 +1,157 @@
+//! @file
+//!
+//! Copyright (c) Memfault, Inc.
+//! See License.txt for details
+//!
+//! @brief
+//! Memfault SDK self test functions to verify SDK integration
+#include <ctype.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "memfault/core/build_info.h"
+#include "memfault/core/debug_log.h"
+#include "memfault/core/math.h"
+#include "memfault/core/platform/device_info.h"
+#include "memfault/core/self_test.h"
+#include "memfault_reboot_tracking_private.h"
+#include "memfault_self_test_private.h"
+
+typedef enum {
+  kDeviceInfoField_DeviceSerial = 0,
+  kDeviceInfoField_SoftwareType,
+  kDeviceInfoField_SoftwareVersion,
+  kDeviceInfoField_HardwareVersion,
+  kDeviceInfoField_BuildId,
+  kDeviceInfoField_Max,
+} eDeviceInfoField;
+
+static const char *s_device_info_field_names[] = {
+  [kDeviceInfoField_DeviceSerial] = "Device Serial",
+  [kDeviceInfoField_SoftwareType] = "Software Type",
+  [kDeviceInfoField_SoftwareVersion] = "Software Version",
+  [kDeviceInfoField_HardwareVersion] = "Hardware Version",
+  [kDeviceInfoField_BuildId] = "Build ID",
+};
+
+typedef bool (*FieldCharValidator)(unsigned char c);
+
+static const FieldCharValidator s_device_info_str_validators[] = {
+  [kDeviceInfoField_DeviceSerial] = memfault_self_test_valid_device_serial,
+  [kDeviceInfoField_SoftwareType] = memfault_self_test_valid_hw_version_sw_type,
+  [kDeviceInfoField_SoftwareVersion] = memfault_self_test_valid_sw_version,
+  [kDeviceInfoField_HardwareVersion] = memfault_self_test_valid_hw_version_sw_type,
+  NULL,
+};
+
+MEMFAULT_STATIC_ASSERT(MEMFAULT_ARRAY_SIZE(s_device_info_field_names) == kDeviceInfoField_Max,
+                       "Mismatch in field name table, must be equal");
+MEMFAULT_STATIC_ASSERT(MEMFAULT_ARRAY_SIZE(s_device_info_str_validators) == kDeviceInfoField_Max,
+                       "Mismatch in string validator table, must be equal");
+
+static bool prv_validate_string(const char *str, size_t len, FieldCharValidator is_valid) {
+  for (size_t idx = 0; idx < len; ++idx) {
+    unsigned char c = (unsigned char)str[idx];
+    if (!is_valid(c)) {
+      MEMFAULT_LOG_ERROR("Invalid char %c, found in %s", c, str);
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool is_field_valid(const char *str, eDeviceInfoField field) {
+  if (str == NULL) {
+    return false;
+  }
+  // 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);
+  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;
+  }
+
+  if (field < kDeviceInfoField_Max) {
+    FieldCharValidator validator = s_device_info_str_validators[field];
+    return (validator != NULL) ? prv_validate_string(str, len, validator) : false;
+  } else {
+    MEMFAULT_LOG_ERROR("Invalid device info string type %u for %s", field, str);
+    return false;
+  }
+}
+
+static uint32_t prv_validate_device_info_field(const char *str, eDeviceInfoField field) {
+  uint32_t result = 0;
+  if (!is_field_valid(str, field)) {
+    result = (uint32_t)(1 << field);
+  }
+
+  return result;
+}
+
+static uint32_t prv_validate_device_info(void) {
+  sMemfaultDeviceInfo device_info = { 0 };
+  memfault_platform_get_device_info(&device_info);
+  uint32_t results = 0;
+
+  // Validate each field in device_info
+  results |=
+    prv_validate_device_info_field(device_info.device_serial, kDeviceInfoField_DeviceSerial);
+
+  results |=
+    prv_validate_device_info_field(device_info.hardware_version, kDeviceInfoField_HardwareVersion);
+
+  results |=
+    prv_validate_device_info_field(device_info.software_version, kDeviceInfoField_SoftwareVersion);
+
+  results |=
+    prv_validate_device_info_field(device_info.software_type, kDeviceInfoField_SoftwareType);
+
+  return results;
+}
+
+static uint32_t prv_validate_build_id(void) {
+  char build_id_str[(MEMFAULT_BUILD_ID_LEN * 2) + 1] = {0};
+  uint32_t result = 0;
+
+  if (!memfault_build_id_get_string(build_id_str, MEMFAULT_ARRAY_SIZE(build_id_str))) {
+    result = (uint32_t)(1 << kDeviceInfoField_BuildId);
+  }
+
+  return result;
+}
+
+static void prv_device_info_test_describe(uint32_t results) {
+  MEMFAULT_LOG_INFO("Device Info Test Results");
+  MEMFAULT_LOG_INFO("------------------------");
+
+  if (results == 0) {
+    MEMFAULT_LOG_INFO("All fields valid");
+    return;
+  }
+
+  MEMFAULT_LOG_ERROR("One or more fields is invalid. Check for correct length and contents");
+  for (uint8_t i = 0; i < kDeviceInfoField_Max; i++) {
+    // Check if bit cleared, cleared bits indicate an invalid field
+    if ((results & (1 << i))) {
+      MEMFAULT_LOG_ERROR("%s invalid", s_device_info_field_names[i]);
+    }
+  }
+}
+
+uint32_t memfault_self_test_device_info_test(void) {
+  uint32_t results = 0;
+  // Validate the build ID
+  results |= prv_validate_build_id();
+  // Valid device info fields
+  results |= prv_validate_device_info();
+
+  prv_device_info_test_describe(results);
+  return results;
+}
+
+int memfault_self_test_run(void) {
+  // Run each test one at a time and return result of all runs OR'd together
+  return (memfault_self_test_device_info_test() != 0);
+}

components/core/src/memfault_self_test_private.h

@@ -0,0 +1,28 @@
+//! @file
+//!
+//! Copyright (c) Memfault, Inc.
+//! See License.txt for details
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Checks if char fits regex: [-a-zA-z0-0_]
+bool memfault_self_test_valid_device_serial(unsigned char c);
+
+//! Checks if char fits regex: [-a-zA-Z0-9_\.\+:]
+bool memfault_self_test_valid_hw_version_sw_type(unsigned char c);
+
+//! Simple wrapper for isprint, software version does not have any regex to match
+bool memfault_self_test_valid_sw_version(unsigned char c);
+
+//! Runs device info and build ID test
+uint32_t memfault_self_test_device_info_test(void);
+
+#ifdef __cplusplus
+}
+#endif

components/core/src/memfault_self_test_utils.c

@@ -0,0 +1,20 @@
+//! @file
+//!
+//! Copyright (c) Memfault, Inc.
+//! See License.txt for details
+#include <ctype.h>
+#include <stdbool.h>
+
+#include "memfault_self_test_private.h"
+
+bool memfault_self_test_valid_device_serial(unsigned char c) {
+  return (isalnum(c) > 0) || (c == '_') || (c == '-');
+}
+
+bool memfault_self_test_valid_hw_version_sw_type(unsigned char c) {
+  return (memfault_self_test_valid_device_serial(c)) || (c == '.') || (c == '+') || (c == ':');
+}
+
+bool memfault_self_test_valid_sw_version(unsigned char c) {
+  return (isprint(c) > 0);
+}

components/demo/src/memfault_demo_shell_commands.c

@@ -12,6 +12,7 @@
 #include "memfault/core/data_export.h"
 #include "memfault/core/debug_log.h"
 #include "memfault/core/math.h"
+#include "memfault/core/self_test.h"
 #include "memfault/demo/cli.h"
 #include "memfault/demo/shell_commands.h"
 #include "memfault/metrics/metrics.h"
@@ -63,6 +64,10 @@ int memfault_demo_cli_cmd_heartbeat(MEMFAULT_UNUSED int argc, MEMFAULT_UNUSED ch
   return 0;
 }
 
+int memfault_demo_cli_cmd_self_test(MEMFAULT_UNUSED int argc, MEMFAULT_UNUSED char *argv[]) {
+  return memfault_self_test_run();
+}
+
 static const sMemfaultShellCommand s_memfault_shell_commands[] = {
   {"clear_core", memfault_demo_cli_cmd_clear_core, "Clear an existing coredump"},
   {"drain_chunks", memfault_demo_drain_chunk_data,
@@ -100,6 +105,8 @@ static const sMemfaultShellCommand s_memfault_shell_commands[] = {
   {"test_reboot", memfault_demo_cli_cmd_system_reboot,
    "Force system reset and track it with a trace event"},
   {"test_trace", memfault_demo_cli_cmd_trace_event_capture, "Capture an example trace event"},
+  { "self_test", memfault_demo_cli_cmd_self_test,
+    "Run a self test to check integration with the SDK" },
 
   {"help", memfault_shell_help_handler, "Lists all commands"},
 };

components/include/memfault/components.h

@@ -40,6 +40,7 @@
 #include "memfault/core/reboot_reason_types.h"
 #include "memfault/core/reboot_tracking.h"
 #include "memfault/core/sdk_assert.h"
+#include "memfault/core/self_test.h"
 #include "memfault/core/task_watchdog.h"
 #include "memfault/core/trace_event.h"
 #include "memfault/demo/cli.h"

components/include/memfault/core/platform/device_info.h

@@ -16,6 +16,11 @@
 extern "C" {
 #endif
 
+//! Maximum string size of a field in MemfaultDeviceInfo. Does not include NULL terminator
+#if !defined(MEMFAULT_DEVICE_INFO_MAX_STRING_SIZE)
+  #define MEMFAULT_DEVICE_INFO_MAX_STRING_SIZE 128
+#endif  // !defined(MEMFAULT_DEVICE_INFO_MAX_STRING_SIZE)
+
 typedef struct MemfaultDeviceInfo {
   //! The device's serial number or unique identifier.
   //! Regular expression defining valid device serials: ^[-a-zA-Z0-9_]+$

components/include/memfault/core/reboot_tracking.h

@@ -23,6 +23,7 @@
 #include <inttypes.h>
 #include <stddef.h>
 
+#include "memfault/core/compiler.h"
 #include "memfault/core/event_storage.h"
 #include "memfault/core/reboot_reason_types.h"
 
@@ -109,6 +110,21 @@ typedef struct MfltRebootTrackingRegInfo {
 void memfault_reboot_tracking_mark_reset_imminent(eMemfaultRebootReason reboot_reason,
                                                   const sMfltRebootTrackingRegInfo *reg);
 
+//! Helper macro to capture the current pc & lr and call
+//! memfault_reboot_tracking_mark_reset_imminent
+#define MEMFAULT_REBOOT_MARK_RESET_IMMINENT(reason_)                       \
+  do {                                                                     \
+    void *mflt_pc;                                                         \
+    MEMFAULT_GET_PC(mflt_pc);                                              \
+    void *mflt_lr;                                                         \
+    MEMFAULT_GET_LR(mflt_lr);                                              \
+    sMfltRebootTrackingRegInfo mflt_reg_info = {                           \
+      .pc = (uint32_t)mflt_pc,                                             \
+      .lr = (uint32_t)mflt_lr,                                             \
+    };                                                                     \
+    memfault_reboot_tracking_mark_reset_imminent(reason_, &mflt_reg_info); \
+  } while (0)
+
 //! 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
 //!

components/include/memfault/core/self_test.h

@@ -0,0 +1,24 @@
+//! @file
+//!
+//! Copyright (c) Memfault, Inc.
+//! See License.txt for details
+//!
+//! @brief
+//! Public interface for self_test component
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//! Main entry point to performing a self test
+//!
+//! This function will carry out all component tests and return after completing all tests
+//! See output for test results and feedback on any errors detected
+//!
+//! @returns 0 on success or 1 if a subtest failed
+int memfault_self_test_run(void);
+
+#ifdef __cplusplus
+}
+#endif