Memfault Firmware SDK 0.37.0 (Build 971)

Author: Memfault Inc

.cyignore

@@ -1,5 +1,8 @@
 cmake
+components/_feature_stubs
+components/_sortme
 examples
+internal
 makefile
 ports/atmel
 ports/dialog

CHANGES.md

@@ -1,3 +1,34 @@
+### Changes between Memfault SDK 0.37.0 and SDK 0.36.1 - Dec 16, 2022
+
+#### :chart_with_upwards_trend: Improvements
+
+- Built-in Metrics
+
+  - Add `MemfaultSdkMetric_UnexpectedRebootDidOccur` metric. This metric uses
+    the platform's reboot register and any reasons by the SDK function
+    `memfault_reboot_tracking_mark_reset_imminent` to classify a reboot. When
+    reboot tracking determines a reboot is unexpected, this metric is set to 1.
+    Otherwise this metric is 0.
+
+- [ModusToolbox:tm: Software](https://www.infineon.com/cms/en/design-support/tools/sdk/modustoolbox-software/)
+
+  - Add log capture during coredump to port
+
+- Demo CLI
+  - Add `mflt test loadaddr` command. This comamnd is used to test specific
+    faults due to protected regions
+
+#### :boom: Breaking Changes
+
+- Built-in Metrics
+  - The built-in metric, `MemfaultSdkMetric_UnexpectedRebootDidOccur`,
+    classifies all reboot reasons greater than or equal to
+    `kMfltRebootReason_UnknownError` **or** equal to `kMfltRebootReason_Unknown`
+    as "unexpected reboots". It is recommended to ensure your platform's
+    implementation of `memfault_reboot_reason_get` classifies the reboot
+    register values as accurately and precisely as possible to avoid incorrect
+    metric values.
+
 ### Changes between Memfault SDK 0.36.1 and SDK 0.36.0 - Dec 9, 2022
 
 #### :chart_with_upwards_trend: Improvements

VERSION

@@ -1,2 +1,2 @@
-BUILD ID: 874
-GIT COMMIT: 5402c68cc
+BUILD ID: 971
+GIT COMMIT: fdf6fee86

components/core/src/memfault_ram_reboot_info_tracking.c

@@ -58,6 +58,19 @@ MEMFAULT_STATIC_ASSERT(sizeof(sMfltRebootInfo) == MEMFAULT_REBOOT_TRACKING_REGIO
 
 static sMfltRebootInfo *s_mflt_reboot_info;
 
+//! Struct to retrieve reboot reason data from. Matches the fields of sMfltRebootReason
+//! as documented in reboot_tracking.h
+typedef struct {
+  eMemfaultRebootReason reboot_reg_reason;
+  eMemfaultRebootReason prior_stored_reason;
+  bool is_valid;
+} sMfltRebootReasonData;
+
+// Private struct to store reboot reason after reboot tracking is initialized
+static sMfltRebootReasonData s_reboot_reason_data = {
+  .is_valid = false,
+};
+
 static bool prv_check_or_init_struct(void) {
   if (s_mflt_reboot_info == NULL) {
     return false;
@@ -93,11 +106,50 @@ static bool prv_read_reset_info(sMfltResetReasonInfo *info) {
   return true;
 }
 
+//! Records reboot reasons from reboot register and prior saved reboot
+//!
+//! Stores both the new reboot reason derived from a platform's reboot register and
+//! any previously saved reboot reason. If there is no previously stored reboot reason,
+//! the reboot register reason is used.
+//!
+//! @param reboot_reg_reason New reboot reason from this boot
+//! @param prior_stored_reason Prior reboot reason stored in s_mflt_reboot_info
+static void prv_record_reboot_reason(eMemfaultRebootReason reboot_reg_reason,
+                                     eMemfaultRebootReason prior_stored_reason) {
+  s_reboot_reason_data.reboot_reg_reason = reboot_reg_reason;
+
+  if (prior_stored_reason != (eMemfaultRebootReason)MEMFAULT_REBOOT_REASON_NOT_SET) {
+    s_reboot_reason_data.prior_stored_reason = prior_stored_reason;
+  } else {
+    s_reboot_reason_data.prior_stored_reason = reboot_reg_reason;
+  }
+
+  s_reboot_reason_data.is_valid = true;
+}
+
+static bool prv_get_unexpected_reboot_occurred(void) {
+  // Check prior_stored_reason, reboot is unexpected if prior reason is set and in error range or
+  // unknown
+  if (s_reboot_reason_data.prior_stored_reason !=
+      (eMemfaultRebootReason)MEMFAULT_REBOOT_REASON_NOT_SET) {
+    if (s_reboot_reason_data.prior_stored_reason == kMfltRebootReason_Unknown ||
+        s_reboot_reason_data.prior_stored_reason >= kMfltRebootReason_UnknownError) {
+      return true;
+    }
+  }
+
+  // Check reboot_reg_reason second, reboot is unexpected if in error range or unknown
+  return (s_reboot_reason_data.reboot_reg_reason == kMfltRebootReason_Unknown ||
+          s_reboot_reason_data.reboot_reg_reason >= kMfltRebootReason_UnknownError);
+}
+
 static void prv_record_reboot_event(eMemfaultRebootReason reboot_reason,
                                     const sMfltRebootTrackingRegInfo *reg) {
-  if (reboot_reason >= kMfltRebootReason_UnknownError) {
-    s_mflt_reboot_info->crash_count++;
-  }
+  // Store both the new reason reported by hardware and the current recorded reason
+  // The combination of these will be used to determine if the bootup was expected
+  // by the metrics subsystem
+  // s_mflt_reboot_info can be cleared by any call to memfault_reboot_tracking_collect_reset_info
+  prv_record_reboot_reason(reboot_reason, s_mflt_reboot_info->last_reboot_reason);
 
   if (s_mflt_reboot_info->last_reboot_reason != MEMFAULT_REBOOT_REASON_NOT_SET) {
     // we are already tracking a reboot. We don't overwrite this because generally the first reboot
@@ -132,6 +184,10 @@ void memfault_reboot_tracking_boot(
   }
 
   prv_record_reboot_event(reset_reason, NULL);
+
+  if (prv_get_unexpected_reboot_occurred()) {
+    s_mflt_reboot_info->crash_count++;
+  }
 }
 
 void memfault_reboot_tracking_mark_reset_imminent(eMemfaultRebootReason reboot_reason,
@@ -190,3 +246,31 @@ void memfault_reboot_tracking_mark_coredump_saved(void) {
 
   s_mflt_reboot_info->coredump_saved = 1;
 }
+
+int memfault_reboot_tracking_get_reboot_reason(sMfltRebootReason *reboot_reason) {
+  if (reboot_reason == NULL || !s_reboot_reason_data.is_valid) {
+    return -1;
+  }
+
+  *reboot_reason = (sMfltRebootReason){
+    .reboot_reg_reason = s_reboot_reason_data.reboot_reg_reason,
+    .prior_stored_reason = s_reboot_reason_data.prior_stored_reason,
+  };
+
+  return 0;
+}
+
+int memfault_reboot_tracking_get_unexpected_reboot_occurred(bool *unexpected_reboot_occurred) {
+  if (unexpected_reboot_occurred == NULL || !s_reboot_reason_data.is_valid) {
+    return -1;
+  }
+
+  *unexpected_reboot_occurred = prv_get_unexpected_reboot_occurred();
+  return 0;
+}
+
+void memfault_reboot_tracking_clear_reboot_reason(void) {
+  s_reboot_reason_data = (sMfltRebootReasonData){
+    .is_valid = false,
+  };
+}

components/core/src/memfault_reboot_tracking_private.h

@@ -28,6 +28,9 @@ typedef struct MfltResetReasonInfo {
 //! Clears any crash information which was stored
 void memfault_reboot_tracking_clear_reset_info(void);
 
+//! Clears stored reboot reason stored at bootup
+void memfault_reboot_tracking_clear_reboot_reason(void);
+
 bool memfault_reboot_tracking_read_reset_info(sMfltResetReasonInfo *info);
 
 #ifdef __cplusplus

components/demo/src/panics/memfault_demo_panics.c

@@ -6,6 +6,7 @@
 //! @brief
 //! CLI commands which require integration of the "panic" component.
 
+#include <inttypes.h>
 #include <stdlib.h>
 
 #include "memfault/core/arch.h"
@@ -138,7 +139,8 @@ int memfault_demo_cli_cmd_memmanage(MEMFAULT_UNUSED int argc, MEMFAULT_UNUSED ch
   //  System space, that is, for addresses 0xE0000000 and higher. System space is always marked as
   //  XN, Execute Never."
   //
-  // So we can trip a MemManage exception by simply attempting to execute any addresss >= 0xE000.0000
+  // So we can trip a MemManage exception by simply attempting to execute any addresss >=
+  // 0xE000.0000
   void (*bad_func)(void) = (void (*)(void))0xEEEEDEAD;
   bad_func();
 
@@ -164,4 +166,16 @@ 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 */

components/include/memfault/core/reboot_reason_types.h

@@ -13,6 +13,9 @@ extern "C" {
 #endif
 
 typedef enum MfltResetReason {
+  // A reboot reason was not determined either by hardware or a previously marked reboot reason
+  // This reason is classified as an unexpected reboot when used by the built-in metric
+  // MemfaultSdkMetric_UnexpectedRebootDidOccur
   kMfltRebootReason_Unknown = 0x0000,
 
   //

components/include/memfault/core/reboot_tracking.h

@@ -50,6 +50,21 @@ typedef struct BootupInfo {
   eMemfaultRebootReason reset_reason;
 } sResetBootupInfo;
 
+//! Helper structure for storing/retrieving the device's reboot reason
+typedef struct MfltRebootType {
+  //! Stores the reboot reason determined from hardware during the current boot
+  eMemfaultRebootReason reboot_reg_reason;
+  //! Stores the reboot reason as read from s_mflt_reboot_info. This could be set in
+  //! the prior boot from either:
+  //! * the application using memfault_reboot_tracking_mark_reset_imminent (fault handler, firmware
+  //! update, etc)
+  //! * a reason determined from the reboot register at bootup
+  eMemfaultRebootReason prior_stored_reason;
+} sMfltRebootReason;
+
+//! Value used to determine state of reboot tracking data
+#define MEMFAULT_REBOOT_REASON_NOT_SET 0xffffffff
+
 #define MEMFAULT_REBOOT_TRACKING_REGION_SIZE 64
 
 //! Sets the memory region used for reboot tracking.
@@ -125,6 +140,25 @@ void memfault_reboot_tracking_reset_crash_count(void);
 //! never need to be called by an end user directly
 void memfault_reboot_tracking_mark_coredump_saved(void);
 
+//! Get the reported reboot reason from boot
+//!
+//! Each time the device boots, the reboot reason mapped from the platform reboot register is
+//! stored. This can be used either by other subsystems or users of the SDK.
+//!
+//! @param reboot_reason Pointer to store the reboot reason from boot
+//! @return 0 on success or 1 if the reboot reason is invalid
+//! or the input parameter is NULL
+
+int memfault_reboot_tracking_get_reboot_reason(sMfltRebootReason *reboot_reason);
+
+//! Returns a boolean representing whether an unexpected reboot occurred from boot
+//!
+//! This function uses a reboot reason from a reboot register and the prior reboot reason (if
+//! present) to determine if a reboot was unexpected.
+//!
+//! @param unexpected_reboot_occurred Pointer to store boolean marking an unexpected reboot
+//! @return 0 on success, or 1 if the result is invalid or the input parameter is NULL
+int memfault_reboot_tracking_get_unexpected_reboot_occurred(bool *unexpected_reboot_occurred);
 
 #ifdef __cplusplus
 }

components/include/memfault/demo/cli.h

@@ -39,6 +39,10 @@ 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[]);
 
+//! 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 */
 
 //! Command which will generate an assert

components/include/memfault/metrics/heartbeat_config.def

@@ -6,3 +6,4 @@
 MEMFAULT_METRICS_KEY_DEFINE(MemfaultSdkMetric_IntervalMs, kMemfaultMetricType_Timer)
 // The number of reboots that have taken place since the last heartbeat was collected
 MEMFAULT_METRICS_KEY_DEFINE(MemfaultSdkMetric_UnexpectedRebootCount, kMemfaultMetricType_Unsigned)
+MEMFAULT_METRICS_KEY_DEFINE_WITH_RANGE(MemfaultSdkMetric_UnexpectedRebootDidOccur, kMemfaultMetricType_Unsigned, 0, 1)