Memfault Firmware SDK 1.6.2 (Build 5836)

Author: Memfault Inc

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Memfault Firmware SDK Changelog
 
+## [1.6.2] - 2024-01-29
+
+### :chart_with_upwards_trend: Improvements
+
+- General:
+
+  - Apply `clang-format` to the entire codebase, to ensure consistent code
+    formatting. The formatting rules are defined in
+    [`.clang-format`](.clang-format). No other changes are included in this
+    release. A
+    [`.git-blame-ignore-revs`](https://git-scm.com/docs/git-config#Documentation/git-config.txt-blameignoreRevsFile)
+    entry will be added in the next release, to enable ignoring this commit when
+    running `git blame`. Use this ignore file in your local repo with
+    `git config blame.ignoreRevsFile=.git-blame-ignore-revs`.
+
 ## [1.6.1] - 2024-01-29
 
 ### :chart_with_upwards_trend: Improvements

VERSION

@@ -1,3 +1,3 @@
-BUILD ID: 5829
-GIT COMMIT: 3f3b1b0ae
-VERSION: 1.6.1
+BUILD ID: 5836
+GIT COMMIT: ed83a4f3c
+VERSION: 1.6.2

components/core/src/arch_arm_cortex_m.c

@@ -23,12 +23,11 @@ void memfault_arch_disable_configurable_faults(void) {
   // Clear MEMFAULTENA, BUSFAULTENA, USGFAULTENA, SECUREFAULTENA
   //
   // This will force all faults to be routed through the HardFault Handler
-  volatile uint32_t *SHCSR = (uint32_t*)0xE000ED24;
+  volatile uint32_t *SHCSR = (uint32_t *)0xE000ED24;
   *SHCSR &= ~((uint32_t)0x000F0000);
 }
 
-MEMFAULT_WEAK
-void memfault_platform_halt_if_debugging(void) {
+MEMFAULT_WEAK void memfault_platform_halt_if_debugging(void) {
   volatile uint32_t *dhcsr = (volatile uint32_t *)0xE000EDF0;
   const uint32_t c_debugen_mask = 0x1;
 

components/core/src/memfault_batched_events.c

@@ -4,15 +4,14 @@
 //! See License.txt for details
 //!
 
-#include "memfault/core/batched_events.h"
-
 #include <string.h>
 
+#include "memfault/core/batched_events.h"
 #include "memfault/core/sdk_assert.h"
 #include "memfault/util/cbor.h"
 
-void memfault_batched_events_build_header(
-    size_t num_events, sMemfaultBatchedEventsHeader *header_out) {
+void memfault_batched_events_build_header(size_t num_events,
+                                          sMemfaultBatchedEventsHeader *header_out) {
   MEMFAULT_SDK_ASSERT(header_out != NULL);
 
   if (num_events <= 1) {

components/core/src/memfault_build_id.c

@@ -6,13 +6,12 @@
 //! @brief
 //! See header for more details
 
-#include "memfault/core/build_info.h"
-#include "memfault_build_id_private.h"
-
 #include <stdint.h>
 #include <string.h>
 
 #include "memfault/config.h"
+#include "memfault/core/build_info.h"
+#include "memfault_build_id_private.h"
 
 #if MEMFAULT_USE_GNU_BUILD_ID
 
@@ -29,7 +28,9 @@ MEMFAULT_BUILD_ID_QUALIFIER sMemfaultBuildIdStorage g_memfault_build_id = {
 #else
 
 // NOTE: We start the array with a 0x1, so the compiler will never place the variable in bss
-MEMFAULT_BUILD_ID_QUALIFIER uint8_t g_memfault_sdk_derived_build_id[MEMFAULT_BUILD_ID_LEN] = { 0x1, };
+MEMFAULT_BUILD_ID_QUALIFIER uint8_t g_memfault_sdk_derived_build_id[MEMFAULT_BUILD_ID_LEN] = {
+  0x1,
+};
 
 MEMFAULT_BUILD_ID_QUALIFIER sMemfaultBuildIdStorage g_memfault_build_id = {
   .type = kMemfaultBuildIdType_None,

components/core/src/memfault_build_id_private.h

@@ -34,7 +34,7 @@ typedef enum {
 } eMemfaultBuildIdType;
 
 typedef struct {
-  uint8_t type; // eMemfaultBuildIdType
+  uint8_t type;  // eMemfaultBuildIdType
   uint8_t len;
   // the length, in bytes, of the build id used when reporting data
   uint8_t short_len;
@@ -48,11 +48,11 @@ MEMFAULT_STATIC_ASSERT(((offsetof(sMemfaultBuildIdStorage, type) == 0) &&
                        "be sure to update fw_build_id.py!");
 
 #if defined(MEMFAULT_UNITTEST)
-//! NB: For unit tests we want to be able to instrument the data in the test
-//! so we drop the `const` qualifier
-#define MEMFAULT_BUILD_ID_QUALIFIER
+  //! NB: For unit tests we want to be able to instrument the data in the test
+  //! so we drop the `const` qualifier
+  #define MEMFAULT_BUILD_ID_QUALIFIER
 #else
-#define MEMFAULT_BUILD_ID_QUALIFIER const
+  #define MEMFAULT_BUILD_ID_QUALIFIER const
 #endif
 
 extern MEMFAULT_BUILD_ID_QUALIFIER sMemfaultBuildIdStorage g_memfault_build_id;
@@ -64,8 +64,9 @@ typedef MEMFAULT_PACKED_STRUCT {
   uint32_t namesz;
   uint32_t descsz;
   uint32_t type;
-  char  namedata[];
-} sMemfaultElfNoteSection;
+  char namedata[];
+}
+sMemfaultElfNoteSection;
 
 #ifdef __cplusplus
 }

components/core/src/memfault_compact_log_serializer.c

@@ -11,11 +11,11 @@
 
 #if MEMFAULT_COMPACT_LOG_ENABLE
 
-#include "memfault/core/compiler.h"
-#include "memfault/core/debug_log.h"
-#include "memfault/core/compact_log_helpers.h"
-#include "memfault/core/compact_log_serializer.h"
-#include "memfault/util/cbor.h"
+  #include "memfault/core/compact_log_helpers.h"
+  #include "memfault/core/compact_log_serializer.h"
+  #include "memfault/core/compiler.h"
+  #include "memfault/core/debug_log.h"
+  #include "memfault/util/cbor.h"
 
 //! Compact logs are placed in a linker section named "log_fmt". This is a symbol exposed by the
 //! linker which points to the start of the section
@@ -24,16 +24,15 @@ extern uint32_t __start_log_fmt;
 //! Note: We don't read this in the firmware but it is used during the decode
 //! process to sanity check the section is being laid out as we would expect.
 MEMFAULT_PUT_IN_SECTION(".log_fmt_hdr")
-MEMFAULT_NO_ALLOC
-const sMemfaultLogFmtElfSectionHeader g_memfault_log_fmt_elf_section_hdr = {
+MEMFAULT_NO_ALLOC const sMemfaultLogFmtElfSectionHeader g_memfault_log_fmt_elf_section_hdr = {
   .magic = 0x66474f4c, /* LOGf */
   .version = 1,
 };
 
 bool memfault_vlog_compact_serialize(sMemfaultCborEncoder *encoder, uint32_t log_id,
                                      uint32_t compressed_fmt, va_list args) {
   const uint32_t bits_per_arg = 2;
-  const uint32_t bits_per_arg_mask =  (1 << bits_per_arg) - 1;
+  const uint32_t bits_per_arg_mask = (1 << bits_per_arg) - 1;
 
   const size_t num_args = (31UL - MEMFAULT_CLZ(compressed_fmt)) / bits_per_arg;
 
@@ -54,11 +53,10 @@ bool memfault_vlog_compact_serialize(sMemfaultCborEncoder *encoder, uint32_t log
     // the promotion type of a given va_arg is encoded within two bits of the
     // compressed_fmt field.
     const uint32_t type =
-        (compressed_fmt >> ((num_args - i - 1) * bits_per_arg)) & bits_per_arg_mask;
+      (compressed_fmt >> ((num_args - i - 1) * bits_per_arg)) & bits_per_arg_mask;
 
     bool success = false;
     switch (type) {
-
       case MEMFAULT_LOG_ARG_PROMOTED_TO_INT32: {
         int32_t val = va_arg(args, int32_t);
         success = memfault_cbor_encode_signed_integer(encoder, val);
@@ -70,7 +68,7 @@ bool memfault_vlog_compact_serialize(sMemfaultCborEncoder *encoder, uint32_t log
         // by packing the cbor encoded int in an array.
         uint64_t val = va_arg(args, uint64_t);
         success = memfault_cbor_encode_array_begin(encoder, 1) &&
-            memfault_cbor_encode_long_signed_integer(encoder, (int64_t)val);
+                  memfault_cbor_encode_long_signed_integer(encoder, (int64_t)val);
         break;
       }
 
@@ -91,7 +89,8 @@ bool memfault_vlog_compact_serialize(sMemfaultCborEncoder *encoder, uint32_t log
         //
         // But parsing as a double is more portable and get's optimized away by compilers
         // like GCC anyway: https://godbolt.org/z/mVAS7D
-        MEMFAULT_STATIC_ASSERT(sizeof(uint64_t) == sizeof(double), "double does not fit in uint64_t");
+        MEMFAULT_STATIC_ASSERT(sizeof(uint64_t) == sizeof(double),
+                               "double does not fit in uint64_t");
 
         // Note: We use memcpy to properly type-pun / avoid strict-aliasing violation:
         //  https://mflt.io/strict-aliasing-type-punning
@@ -103,14 +102,13 @@ bool memfault_vlog_compact_serialize(sMemfaultCborEncoder *encoder, uint32_t log
       }
 
       case MEMFAULT_LOG_ARG_PROMOTED_TO_STR: {
-        const char *str = va_arg(args, const char*);
+        const char *str = va_arg(args, const char *);
         success = memfault_cbor_encode_string(encoder, str != NULL ? str : "(null)");
         break;
       }
 
       default:
         break;
-
     }
 
     if (!success) {
@@ -122,7 +120,7 @@ bool memfault_vlog_compact_serialize(sMemfaultCborEncoder *encoder, uint32_t log
 }
 
 bool memfault_log_compact_serialize(sMemfaultCborEncoder *encoder, uint32_t log_id,
-                            uint32_t compressed_fmt,  ...) {
+                                    uint32_t compressed_fmt, ...) {
   va_list args;
   va_start(args, compressed_fmt);
   const bool success = memfault_vlog_compact_serialize(encoder, log_id, compressed_fmt, args);

components/core/src/memfault_core_utils.c

@@ -5,26 +5,25 @@
 //!
 //! @brief
 
-#include "memfault/core/build_info.h"
-#include "memfault/core/device_info.h"
-#include "memfault/core/platform/device_info.h"
-#include "memfault_build_id_private.h"
-
-#include <string.h>
 #include <stdio.h>
+#include <string.h>
 
+#include "memfault/core/build_info.h"
 #include "memfault/core/compiler.h"
 #include "memfault/core/debug_log.h"
+#include "memfault/core/device_info.h"
 #include "memfault/core/math.h"
+#include "memfault/core/platform/device_info.h"
+#include "memfault_build_id_private.h"
 
 static const void *prv_get_build_id_start_pointer(void) {
   switch (g_memfault_build_id.type) {
     case kMemfaultBuildIdType_MemfaultBuildIdSha1:
       return g_memfault_build_id.storage;
     case kMemfaultBuildIdType_GnuBuildIdSha1: {
       const sMemfaultElfNoteSection *elf =
-          (const sMemfaultElfNoteSection *)g_memfault_build_id.storage;
-      return &elf->namedata[elf->namesz]; // Skip over { 'G', 'N', 'U', '\0' }
+        (const sMemfaultElfNoteSection *)g_memfault_build_id.storage;
+      return &elf->namedata[elf->namesz];  // Skip over { 'G', 'N', 'U', '\0' }
     }
     case kMemfaultBuildIdType_None:
     default:
@@ -69,8 +68,8 @@ bool memfault_build_id_get_string(char *out_buf, size_t buf_len) {
   return true;
 }
 
-const char *memfault_create_unique_version_string(const char * const version) {
-  static char s_version[MEMFAULT_UNIQUE_VERSION_MAX_LEN] = {0};
+const char *memfault_create_unique_version_string(const char *const version) {
+  static char s_version[MEMFAULT_UNIQUE_VERSION_MAX_LEN] = { 0 };
 
   // Immutable once created.
   if (s_version[0]) {
@@ -89,7 +88,7 @@ const char *memfault_create_unique_version_string(const char * const version) {
       s_version[version_len - 1] = '+';
 
       const size_t build_id_num_chars =
-          MEMFAULT_MIN(build_id_chars, sizeof(s_version) - version_len - 1);
+        MEMFAULT_MIN(build_id_chars, sizeof(s_version) - version_len - 1);
 
       if (!memfault_build_id_get_string(&s_version[version_len], build_id_num_chars)) {
         // Tack on something obvious to aid with debug but don't fail.
@@ -117,8 +116,7 @@ void memfault_build_info_dump(void) {
     return;
   }
 
-  const bool is_gnu =
-      (g_memfault_build_id.type == kMemfaultBuildIdType_GnuBuildIdSha1);
+  const bool is_gnu = (g_memfault_build_id.type == kMemfaultBuildIdType_GnuBuildIdSha1);
 
   char build_id_sha[41] = { 0 };
   for (size_t i = 0; i < sizeof(info.build_id); i++) {
@@ -132,7 +130,7 @@ void memfault_build_info_dump(void) {
 }
 
 void memfault_device_info_dump(void) {
-  struct MemfaultDeviceInfo info = {0};
+  struct MemfaultDeviceInfo info = { 0 };
   memfault_platform_get_device_info(&info);
   MEMFAULT_LOG_INFO("S/N: %s", info.device_serial ? info.device_serial : "<NULL>");
   MEMFAULT_LOG_INFO("SW type: %s", info.software_type ? info.software_type : "<NULL>");