You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by vi...@apache.org on 2025/02/12 01:20:08 UTC
(mynewt-core) 01/05: sys/log: Add number of entries support in logs
This is an automated email from the ASF dual-hosted git repository.
vipulrahane pushed a commit to branch vipul/logging_num_entries_callbacks
in repository https://gitbox.apache.org/repos/asf/mynewt-core.git
commit 11477742234c9b4c2f9c507a6f360b38af0e86ff
Author: Vipul Rahane <vi...@juul.com>
AuthorDate: Mon Mar 18 11:00:56 2024 -0700
sys/log: Add number of entries support in logs
- Add number of entries support in logs
- Add TLV for number of entries support
- Also update log_shell and add syscfgs to support the same.
- Added support in fcb2 and cbmem for number of entries
- This makes it such that log entries are backwards and forwards
compatible.
- Number of entries can be read using the console or newtmgr
- This is an optional feature enabled only if
LOG_FLAGS_TLV_SUPPORT: 1 and LOG_TLV_NUM_ENTRIES: 1
apps/slinky: Dependency issue
- fcb2 and config_fcb2 and log_fcb2 should be selectable via the target
using syscfgs, it does not need to be specific to the app
sys/log/full/selftest: Add selftests for num_entries
sys/log/full/selftest: Add unit tests for log fcb2 image hash and num_entries
sys/log: Update selftests to account for header and trailers
- Earlier these would only account for the entries, now they
also account for headers and trailers
sys/log: Reverse TLV implementation for number of entries support
callbacks
---
apps/slinky/pkg.yml | 12 -
fs/fcb2/include/fcb/fcb2.h | 9 +
fs/fcb2/src/fcb.c | 9 +
fs/fcb2/src/fcb_priv.h | 9 -
hw/mcu/native/src/hal_flash.c | 2 +-
sys/log/common/include/log_common/log_common.h | 64 +++-
sys/log/full/include/log/log.h | 236 +++++++++++-
.../selftest/align1_img_hash_num_entries/pkg.yml | 30 ++
.../src/log_test_align1.c} | 26 +-
.../align1_img_hash_num_entries/syscfg.yml | 30 ++
sys/log/full/selftest/align1_num_entries/pkg.yml | 30 ++
.../src/log_test_align1.c} | 26 +-
.../full/selftest/align1_num_entries/syscfg.yml | 29 ++
sys/log/full/selftest/align4_num_entries/pkg.yml | 30 ++
.../src/log_test_align1.c} | 26 +-
.../src/log_test_align4.c} | 28 +-
.../full/selftest/align4_num_entries/syscfg.yml | 29 ++
sys/log/full/selftest/fcb2_align1_imghash/pkg.yml | 30 ++
.../src/log_test_align1.c} | 26 +-
.../full/selftest/fcb2_align1_imghash/syscfg.yml | 29 ++
.../fcb2_align1_imghash_num_entries/pkg.yml | 30 ++
.../src/log_test_align1.c} | 26 +-
.../fcb2_align1_imghash_num_entries/syscfg.yml | 30 ++
.../util/include/log_test_util/log_test_util.h | 4 +
sys/log/full/selftest/util/src/log_test_util.c | 91 ++++-
.../src/testcases/log_test_case_cbmem_append.c | 25 +-
.../testcases/log_test_case_cbmem_append_body.c | 24 +-
.../testcases/log_test_case_cbmem_append_mbuf.c | 28 +-
.../log_test_case_cbmem_append_mbuf_body.c | 24 +-
.../src/testcases/log_test_case_cbmem_printf.c | 23 +-
.../util/src/testcases/log_test_case_fcb_append.c | 27 +-
.../src/testcases/log_test_case_fcb_append_body.c | 26 +-
.../src/testcases/log_test_case_fcb_append_mbuf.c | 26 +-
.../testcases/log_test_case_fcb_append_mbuf_body.c | 24 +-
sys/log/full/src/log.c | 405 ++++++++++++++++++++-
sys/log/full/src/log_cbmem.c | 74 +++-
sys/log/full/src/log_fcb.c | 210 ++++++++---
sys/log/full/src/log_fcb2.c | 164 +++++++--
sys/log/full/src/log_shell.c | 51 ++-
sys/log/full/syscfg.yml | 6 +
40 files changed, 1684 insertions(+), 344 deletions(-)
diff --git a/apps/slinky/pkg.yml b/apps/slinky/pkg.yml
index 3c1013123..93db421c4 100644
--- a/apps/slinky/pkg.yml
+++ b/apps/slinky/pkg.yml
@@ -44,15 +44,3 @@ pkg.deps:
pkg.deps.I2C_0: test/i2c_scan
pkg.deps.I2C_1: test/i2c_scan
pkg.deps.I2C_2: test/i2c_scan
-
-pkg.deps.CONFIG_NFFS:
- - "@apache-mynewt-core/fs/nffs"
-
-pkg.deps.CONFIG_LITTLEFS:
- - "@apache-mynewt-core/fs/littlefs"
-
-pkg.deps.CONFIG_FCB:
- - "@apache-mynewt-core/fs/fcb"
-
-pkg.deps.REBOOT_LOG_FCB:
- - "@apache-mynewt-core/fs/fcb"
diff --git a/fs/fcb2/include/fcb/fcb2.h b/fs/fcb2/include/fcb/fcb2.h
index e089fccbc..2f0c72090 100644
--- a/fs/fcb2/include/fcb/fcb2.h
+++ b/fs/fcb2/include/fcb/fcb2.h
@@ -304,6 +304,15 @@ int fcb2_clear(struct fcb2 *fcb);
*/
int fcb2_area_info(struct fcb2 *fcb, int sector, int *elemsp, int *bytesp);
+/**
+ * Length of data in flash considering alignment
+ *
+ * @param range Active range
+ * @param len Length to be calculated using alignment
+ *
+ */
+int fcb2_len_in_flash(const struct flash_sector_range *range, uint16_t len);
+
#ifdef __cplusplus
}
diff --git a/fs/fcb2/src/fcb.c b/fs/fcb2/src/fcb.c
index e8a65ff12..0f1e31ee3 100644
--- a/fs/fcb2/src/fcb.c
+++ b/fs/fcb2/src/fcb.c
@@ -101,6 +101,15 @@ fcb2_init(struct fcb2 *fcb)
return rc;
}
+int
+fcb2_len_in_flash(const struct flash_sector_range *range, uint16_t len)
+{
+ if (range->fsr_align <= 1) {
+ return len;
+ }
+ return (len + (range->fsr_align - 1)) & ~(range->fsr_align - 1);
+}
+
int
fcb2_free_sector_cnt(struct fcb2 *fcb)
{
diff --git a/fs/fcb2/src/fcb_priv.h b/fs/fcb2/src/fcb_priv.h
index d02784fab..6f91ff09f 100644
--- a/fs/fcb2/src/fcb_priv.h
+++ b/fs/fcb2/src/fcb_priv.h
@@ -40,15 +40,6 @@ struct fcb2_sector_info {
uint16_t si_sector_in_range; /* Sector number relative to si_range */
};
-static inline int
-fcb2_len_in_flash(const struct flash_sector_range *range, uint16_t len)
-{
- if (range->fsr_align <= 1) {
- return len;
- }
- return (len + (range->fsr_align - 1)) & ~(range->fsr_align - 1);
-}
-
int fcb2_getnext_in_area(struct fcb2 *fcb, struct fcb2_entry *loc);
static inline int
diff --git a/hw/mcu/native/src/hal_flash.c b/hw/mcu/native/src/hal_flash.c
index b39b5158c..439f9d4fa 100644
--- a/hw/mcu/native/src/hal_flash.c
+++ b/hw/mcu/native/src/hal_flash.c
@@ -152,7 +152,7 @@ static int
flash_native_write_internal(uint32_t address, const void *src, uint32_t length,
int allow_overwrite)
{
- static uint8_t buf[256];
+ uint8_t buf[256] = {0};
uint32_t cur;
uint32_t end;
int chunk_sz;
diff --git a/sys/log/common/include/log_common/log_common.h b/sys/log/common/include/log_common/log_common.h
index 9974fa2ef..1ec4de551 100644
--- a/sys/log/common/include/log_common/log_common.h
+++ b/sys/log/common/include/log_common/log_common.h
@@ -28,6 +28,7 @@ extern "C" {
#endif
struct log;
+struct log_entry_hdr;
#define LOG_VERSION_V3 3
@@ -132,11 +133,70 @@ typedef void log_append_cb(struct log *log, uint32_t idx);
/** @typdef log_notify_rotate_cb
* @brief Callback that is executed each time we are about to rotate a log.
- *
- * @param log The log that is about to rotate
+ *
+ * @param log The log that is about to rotate
*/
typedef void log_notify_rotate_cb(const struct log *log);
+/** @typedef log_mbuf_trailer_append_cb
+ * @brief Callback that is executed each time the corresponding log entry is
+ * appended to
+ *
+ * @param log The log that was just appended to
+ * @param om Pointer to the mbuf that contains the log entry
+ * @param loc Argument pointing to the location of
+ * the entry
+ * @return 0 on success, non-zero on failure
+ */
+typedef int log_trailer_mbuf_append_cb(struct log *log, struct os_mbuf *om, void *loc);
+
+/** @typedef log_cbmem_trailer_append_cb
+ * @brief Callback that is executed each time the corresponding log entry is
+ * appended to
+ *
+ * @param log The log that was just appended to
+ * @param buf Pointer to the buffer that contains the log entry
+ * @param buflen Length of the trailer
+ * @return 0 on success, non-zero on failure
+ */
+typedef int log_cbmem_trailer_append_cb(struct log *log, uint8_t *buf,
+ uint16_t buflen);
+
+/** @typedef log_cbmem_trailer_mbuf_append_cb
+ * @brief Callback that is executed each time the corresponding log entry is
+ * appended to
+ *
+ * @param log The log that was just appended to
+ * @param om Pointer to the mbuf
+ *
+ * @return 0 on success, non-zero on failure
+ */
+typedef int log_cbmem_trailer_mbuf_append_cb(struct log *log, struct os_mbuf *om);
+
+/** @typedef log_trailer_append_cb
+ * @brief Callback that is executed each time the corresponding log entry is
+ * appended to
+ *
+ * @param log The log that was just appended to
+ * @param buf Buffer to append trailer to
+ * @param buflen Length of the trailer to be filled up
+ * @param loc Argument pointing to the location of
+ * the entry
+ * @return 0 on success, non-zero on failure
+ */
+typedef int log_trailer_append_cb(struct log *log, uint8_t *buf,
+ uint16_t buflen, void *loc);
+
+/** @typedef log_trailer_len_cb
+ * @brief Callback used to read length of trailer in a log entry
+ *
+ * @param log The log the trailer is to be read from
+ * @param hdr Log entry header of the log entry the log is
+ * read from
+ * @return Length of the appended trailer
+ */
+typedef uint16_t log_trailer_len_cb(struct log *log, const struct log_entry_hdr *hdr);
+
#ifdef __cplusplus
}
#endif
diff --git a/sys/log/full/include/log/log.h b/sys/log/full/include/log/log.h
index d04a191eb..644fc6bea 100644
--- a/sys/log/full/include/log/log.h
+++ b/sys/log/full/include/log/log.h
@@ -77,18 +77,18 @@ struct log_storage_info {
};
#endif
-typedef int (*log_walk_func_t)(struct log *, struct log_offset *log_offset,
+typedef int (*log_walk_func_t)(struct log *log, struct log_offset *log_offset,
const void *dptr, uint16_t len);
typedef int (*log_walk_body_func_t)(struct log *log,
struct log_offset *log_offset, const struct log_entry_hdr *hdr,
const void *dptr, uint16_t len);
-typedef int (*lh_read_func_t)(struct log *, const void *dptr, void *buf,
+typedef int (*lh_read_func_t)(struct log *log, const void *dptr, void *buf,
uint16_t offset, uint16_t len);
-typedef int (*lh_read_mbuf_func_t)(struct log *, const void *dptr, struct os_mbuf *om,
+typedef int (*lh_read_mbuf_func_t)(struct log *log, const void *dptr, struct os_mbuf *om,
uint16_t offset, uint16_t len);
-typedef int (*lh_append_func_t)(struct log *, void *buf, int len);
+typedef int (*lh_append_func_t)(struct log *log, void *buf, int len);
typedef int (*lh_append_body_func_t)(struct log *log,
const struct log_entry_hdr *hdr,
const void *body, int body_len);
@@ -96,16 +96,19 @@ typedef int (*lh_append_mbuf_func_t)(struct log *, struct os_mbuf *om);
typedef int (*lh_append_mbuf_body_func_t)(struct log *log,
const struct log_entry_hdr *hdr,
struct os_mbuf *om);
-typedef int (*lh_walk_func_t)(struct log *,
+typedef int (*lh_walk_func_t)(struct log *log,
log_walk_func_t walk_func, struct log_offset *log_offset);
-typedef int (*lh_flush_func_t)(struct log *);
+typedef int (*lh_flush_func_t)(struct log *log);
+typedef uint16_t (*lh_read_entry_len_func_t)(struct log *log, const void *dptr);
#if MYNEWT_VAL(LOG_STORAGE_INFO)
-typedef int (*lh_storage_info_func_t)(struct log *, struct log_storage_info *);
+typedef int (*lh_storage_info_func_t)(struct log *log, struct log_storage_info *);
#endif
#if MYNEWT_VAL(LOG_STORAGE_WATERMARK)
-typedef int (*lh_set_watermark_func_t)(struct log *, uint32_t);
+typedef int (*lh_set_watermark_func_t)(struct log *log, uint32_t);
#endif
-typedef int (*lh_registered_func_t)(struct log *);
+typedef int (*lh_registered_func_t)(struct log *log);
+/* This calculates length based on alignment of underlying medium */
+typedef int (*lh_len_in_medium_func_t)(struct log *log, uint16_t len);
struct log_handler {
int log_type;
@@ -118,6 +121,8 @@ struct log_handler {
lh_walk_func_t log_walk;
lh_walk_func_t log_walk_sector;
lh_flush_func_t log_flush;
+ lh_read_entry_len_func_t log_read_entry_len;
+ lh_len_in_medium_func_t log_len_in_medium;
#if MYNEWT_VAL(LOG_STORAGE_INFO)
lh_storage_info_func_t log_storage_info;
#endif
@@ -131,8 +136,12 @@ struct log_handler {
/* Image hash length to be looged */
#define LOG_IMG_HASHLEN 4
-/* Flags used to indicate type of data in reserved payload*/
-#define LOG_FLAGS_IMG_HASH (1 << 0)
+/* Flags used to indicate type of data in reserved payload */
+#define LOG_FLAGS_IMG_HASH (1 << 0)
+#define LOG_FLAGS_TRAILER_SUPPORT (1 << 1)
+
+#define LOGS_TLV_NUM_ENTRIES (1 << 0)
+#define LOG_TLV_NUM_TLVS (1 << 1)
#if MYNEWT_VAL(LOG_VERSION) == 3
struct log_entry_hdr {
@@ -140,16 +149,56 @@ struct log_entry_hdr {
uint32_t ue_index;
uint8_t ue_module;
uint8_t ue_level;
- uint8_t ue_etype:4;
- uint8_t ue_flags:4;
+ uint8_t ue_etype : 4;
+ uint8_t ue_flags : 4;
uint8_t ue_imghash[4];
-}__attribute__((__packed__));
+ /* Number of entries field which helps in calculating number of
+ * entries per log, these go on incrementing similar to an index
+ * but per log.
+ */
+ uint32_t ue_num_entries;
+} __attribute__((__packed__));
+
+struct log_tlv {
+ uint8_t len;
+ uint8_t tag;
+ /* Value is of variable size appended based on len,
+ * val is logged after the tag and len are logged
+ */
+} __attribute__((__packed__));
+
#else
#error "Unsupported log version"
#endif
#define LOG_BASE_ENTRY_HDR_SIZE (15)
+#define LOG_NUM_ENTRIES_SIZE (sizeof(((struct log *)0)->l_num_entries))
+#define LOG_NUM_TLVS_SIZE (1)
+
+#if MYNEWT_VAL(LOG_FCB2)
+#define LF_MAX_ALIGN LOG_FCB2_MAX_ALIGN
+#else
+#define LF_MAX_ALIGN LOG_FCB_MAX_ALIGN
+#endif
+
+#define LOG_FCB_MAX_TLV_SIZE(__tlv_name__) \
+ /* sizeof(struct log_tlv)) + alignment */ \
+ (LF_MAX_ALIGN + \
+ /* Max size per value of TLV including alignment */ \
+ (LOG_ ## __tlv_name__ ## _SIZE/LF_MAX_ALIGN) ? \
+ (LOG_ ## __tlv_name__ ## _SIZE + LF_MAX_ALIGN) : \
+ LF_MAX_ALIGN)
+
+#define LOG_FCB_MAX_TLVS_SIZE LOG_FCB_MAX_TLV_SIZE(NUM_ENTRIES) + \
+ LOG_FCB_MAX_TLV_SIZE(NUM_TLVS)
+
+#define LOG_FCB_EXT_HDR_SIZE LOG_BASE_ENTRY_HDR_SIZE + LOG_IMG_HASHLEN + \
+ LF_MAX_ALIGN
+
+#define LOG_FCB_FLAT_BUF_SIZE (LOG_FCB_EXT_HDR_SIZE > LOG_FCB_MAX_TLVS_SIZE) ? \
+ LOG_FCB_EXT_HDR_SIZE : LOG_FCB_MAX_TLVS_SIZE
+
#define LOG_MODULE_STR(module) log_module_get_name(module)
#if MYNEWT_VAL(LOG_LEVEL) <= LOG_LEVEL_DEBUG
@@ -214,6 +263,14 @@ struct log {
uint16_t l_max_entry_len; /* Log body length; if 0 disables check. */
#if !MYNEWT_VAL(LOG_GLOBAL_IDX)
uint32_t l_idx;
+#endif
+ uint32_t l_num_entries;
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ log_trailer_len_cb *l_trailer_len_cb;
+ log_trailer_append_cb *l_trailer_append_cb;
+ log_trailer_mbuf_append_cb *l_trailer_mbuf_append_cb;
+ log_cbmem_trailer_append_cb *l_cbmem_trailer_append_cb;
+ log_cbmem_trailer_mbuf_append_cb *l_cbmem_trailer_mbuf_append_cb;
#endif
#if MYNEWT_VAL(LOG_STATS)
STATS_SECT_DECL(logs) l_stats;
@@ -513,6 +570,18 @@ void log_printf(struct log *log, uint8_t module, uint8_t level,
int log_read(struct log *log, const void *dptr, void *buf, uint16_t off,
uint16_t len);
+/**
+ * Reads entry length from the specified log.
+ *
+ * @param log The log to read from.
+ * @param dptr Medium-specific data describing the area to
+ * read from; typically obtained by a call to
+ * `log_walk`.
+ * @return The number of bytes of entry length; 0 on failure.
+ */
+uint16_t
+log_read_entry_len(struct log *log, const void *dptr);
+
/**
* @brief Reads a single log entry header.
*
@@ -530,11 +599,10 @@ int log_read_hdr(struct log *log, const void *dptr, struct log_entry_hdr *hdr);
* @brief Reads the header length
*
* @param hdr Ptr to the header
- *
+ *
* @return Length of the header
*/
-uint16_t
-log_hdr_len(const struct log_entry_hdr *hdr);
+uint16_t log_hdr_len(const struct log_entry_hdr *hdr);
/**
* @brief Reads data from the body of a log entry into a flat buffer.
@@ -727,6 +795,33 @@ log_set_rotate_notify_cb(struct log *log, log_notify_rotate_cb *cb);
int log_set_watermark(struct log *log, uint32_t index);
#endif
+/**
+ * Fill number of entries
+ *
+ * @param log Ptr to log structure
+ * @param dptr Ptr to data to be read
+ * @param num_entries Ptr to number of entries
+ * @param offset Offset of the num of entries field in the log entry
+ *
+ * @return 0 on success, non-zero on failure
+ */
+int log_fill_num_entries(struct log *log, const void *dptr,
+ uint32_t *num_entries,
+ uint16_t offset);
+/**
+ * Fill number of tlvs
+ *
+ * @param log Ptr to log structure
+ * @param dptr Ptr to data to be read
+ * @param num_entries Ptr to number of entries
+ * @param offset Offset of the num of entries field in the log entry
+ *
+ * @return 0 on success, non-zero on failure
+ */
+int
+log_fill_num_tlvs(struct log *log, const void *dptr, uint8_t *num_tlvs,
+ uint16_t offset);
+
/**
* Fill log current image hash
*
@@ -737,6 +832,113 @@ int log_set_watermark(struct log *log, uint32_t index);
int
log_fill_current_img_hash(struct log_entry_hdr *hdr);
+/**
+ * Reads the log entry's header from the specified log and log index
+ *
+ * @param log The log to read from.
+ * @param idx Index of the log entry to read header from
+ * @param out_hdr On success, the last entry header gets written
+ * here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+log_read_hdr_by_idx(struct log *log, uint32_t idx, struct log_entry_hdr *out_hdr);
+
+/**
+ * Get number of entries in log
+ *
+ * @param log The log to get number of entries for
+ * @param idx The log index to read number of entries from
+ * @param num_entries Ptr to fill up number of entries in log
+ */
+int
+log_get_entries(struct log *log, uint32_t idx, uint32_t *entries);
+
+/**
+ * Get the length of data in medium - storage (fcb/fcb2), memory or stream
+ *
+ * @param log The log to get number of entries for
+ * @param len Length in medium with padding if any
+ */
+int
+log_len_in_medium(struct log *log, uint16_t len);
+
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+/**
+ * @brief Reads the trailer length
+ *
+ * @param hdr Ptr to the header
+ *
+ * @return Length of the trailer
+ */
+uint16_t log_trailer_len(struct log *log, const struct log_entry_hdr *hdr);
+
+/**
+ * @brief Reads a single log entry trailer.
+ *
+ * @param log The log to read from.
+ * @param dptr Medium-specific data describing the area to
+ * read from; typically obtained by a call to
+ * `log_walk`.
+ * @param tlv tlv type
+ * @param buf Value buffer
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int log_read_trailer(struct log *log, const void *dptr, uint16_t tlv, void *buf);
+
+/**
+ * Append trailer to the log entry
+ *
+ * @param log Pointer to the log
+ * @param buf Pointer to the buffer containing trailer
+ * @param buflen Length of the trailer
+ * @param loc Pointer to the log entry
+ */
+int
+log_trailer_append(struct log *log, uint8_t *buf, uint16_t buflen,
+ void *loc);
+
+/**
+ * Append trailer in an mbuf to the log entry
+ *
+ * @param log Pointer to the log
+ * @param om Pointer to the os_mbuf
+ * @param loc Pointer to the log entry
+ */
+int
+log_mbuf_trailer_append(struct log *log, struct os_mbuf *om, void *loc);
+
+/**
+ * Register trailer callbacks
+ *
+ * @param log Pointer to the log
+ * @param ltac Pointer to the log trailer append callback
+ * @param ltlc Pointer to the log trailer length callback
+ */
+static inline void
+log_register_trailer_cbs(struct log *log, log_trailer_append_cb *ltac,
+ log_trailer_len_cb *ltlc)
+{
+ log->l_trailer_append_cb = ltac;
+ log->l_trailer_len_cb = ltlc;
+}
+
+/**
+ * Register trailer callbacks
+ *
+ * @param log Pointer to the log
+ * @param ltmac Pointer to the log trailer mbuf append callback
+ */
+static inline void
+log_register_mbuf_trailer_cbs(struct log *log,
+ log_trailer_mbuf_append_cb *ltmac)
+{
+ log->l_trailer_mbuf_append_cb = ltmac;
+}
+#endif
+
/* Handler exports */
#if MYNEWT_VAL(LOG_CONSOLE)
extern const struct log_handler log_console_handler;
diff --git a/sys/log/full/selftest/align1_img_hash_num_entries/pkg.yml b/sys/log/full/selftest/align1_img_hash_num_entries/pkg.yml
new file mode 100644
index 000000000..56700bf5f
--- /dev/null
+++ b/sys/log/full/selftest/align1_img_hash_num_entries/pkg.yml
@@ -0,0 +1,30 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+pkg.name: sys/log/full/selftest/align1_img_hash_num_entries
+pkg.type: unittest
+pkg.description: "Log unit tests; flash-alignment=1."
+pkg.author: "Apache Mynewt <de...@mynewt.apache.org>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+
+pkg.deps:
+ - "@apache-mynewt-core/sys/console/stub"
+ - "@apache-mynewt-core/sys/log/full"
+ - "@apache-mynewt-core/sys/log/full/selftest/util"
+ - "@apache-mynewt-core/test/testutil"
+ - "@apache-mynewt-core/boot/stub"
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c b/sys/log/full/selftest/align1_img_hash_num_entries/src/log_test_align1.c
similarity index 71%
copy from sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
copy to sys/log/full/selftest/align1_img_hash_num_entries/src/log_test_align1.c
index f48b87657..6fb73ffba 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
+++ b/sys/log/full/selftest/align1_img_hash_num_entries/src/log_test_align1.c
@@ -17,25 +17,17 @@
* under the License.
*/
+#include "os/mynewt.h"
#include "log_test_util/log_test_util.h"
-TEST_CASE_SELF(log_test_case_cbmem_printf)
+int
+main(int argc, char **argv)
{
- struct cbmem cbmem;
- struct log log;
- char *str;
- int i;
+ log_test_suite_cbmem_flat();
+ log_test_suite_cbmem_mbuf();
+ log_test_suite_fcb_flat();
+ log_test_suite_fcb_mbuf();
+ log_test_suite_misc();
- ltu_setup_cbmem(&cbmem, &log);
-
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
-
- log_printf(&log, 0, 0, str, strlen(str));
- }
-
- ltu_verify_contents(&log);
+ return tu_any_failed;
}
diff --git a/sys/log/full/selftest/align1_img_hash_num_entries/syscfg.yml b/sys/log/full/selftest/align1_img_hash_num_entries/syscfg.yml
new file mode 100644
index 000000000..049ef49ea
--- /dev/null
+++ b/sys/log/full/selftest/align1_img_hash_num_entries/syscfg.yml
@@ -0,0 +1,30 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+syscfg.vals:
+ LOG_FCB: 1
+ MCU_FLASH_MIN_WRITE_SIZE: 1
+
+ # The mbuf append tests allocate lots of mbufs; ensure no exhaustion.
+ MSYS_1_BLOCK_COUNT: 1000
+ LOG_FLAGS_IMAGE_HASH: 1
+ LOG_FLAGS_TRAILER_SUPPORT: 1
+ LOGS_TLV_NUM_ENTRIES: 1
+ IMGMGR_DUMMY_HDR: 1
+ LOG_MGMT: 0
+ IMG_MGMT: 0
diff --git a/sys/log/full/selftest/align1_num_entries/pkg.yml b/sys/log/full/selftest/align1_num_entries/pkg.yml
new file mode 100644
index 000000000..8a0bf7d10
--- /dev/null
+++ b/sys/log/full/selftest/align1_num_entries/pkg.yml
@@ -0,0 +1,30 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+pkg.name: sys/log/full/selftest/align1_num_entries
+pkg.type: unittest
+pkg.description: "Log unit tests; flash-alignment=1."
+pkg.author: "Apache Mynewt <de...@mynewt.apache.org>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+
+pkg.deps:
+ - "@apache-mynewt-core/sys/console/stub"
+ - "@apache-mynewt-core/sys/log/full"
+ - "@apache-mynewt-core/sys/log/full/selftest/util"
+ - "@apache-mynewt-core/test/testutil"
+ - "@apache-mynewt-core/boot/stub"
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c b/sys/log/full/selftest/align1_num_entries/src/log_test_align1.c
similarity index 71%
copy from sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
copy to sys/log/full/selftest/align1_num_entries/src/log_test_align1.c
index f48b87657..6fb73ffba 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
+++ b/sys/log/full/selftest/align1_num_entries/src/log_test_align1.c
@@ -17,25 +17,17 @@
* under the License.
*/
+#include "os/mynewt.h"
#include "log_test_util/log_test_util.h"
-TEST_CASE_SELF(log_test_case_cbmem_printf)
+int
+main(int argc, char **argv)
{
- struct cbmem cbmem;
- struct log log;
- char *str;
- int i;
+ log_test_suite_cbmem_flat();
+ log_test_suite_cbmem_mbuf();
+ log_test_suite_fcb_flat();
+ log_test_suite_fcb_mbuf();
+ log_test_suite_misc();
- ltu_setup_cbmem(&cbmem, &log);
-
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
-
- log_printf(&log, 0, 0, str, strlen(str));
- }
-
- ltu_verify_contents(&log);
+ return tu_any_failed;
}
diff --git a/sys/log/full/selftest/align1_num_entries/syscfg.yml b/sys/log/full/selftest/align1_num_entries/syscfg.yml
new file mode 100644
index 000000000..7171a4122
--- /dev/null
+++ b/sys/log/full/selftest/align1_num_entries/syscfg.yml
@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+syscfg.vals:
+ LOG_FCB: 1
+ MCU_FLASH_MIN_WRITE_SIZE: 1
+
+ # The mbuf append tests allocate lots of mbufs; ensure no exhaustion.
+ MSYS_1_BLOCK_COUNT: 1000
+ LOG_FLAGS_TRAILER_SUPPORT: 1
+ LOGS_TLV_NUM_ENTRIES: 1
+ IMGMGR_DUMMY_HDR: 1
+ LOG_MGMT: 0
+ IMG_MGMT: 0
diff --git a/sys/log/full/selftest/align4_num_entries/pkg.yml b/sys/log/full/selftest/align4_num_entries/pkg.yml
new file mode 100644
index 000000000..339101d7b
--- /dev/null
+++ b/sys/log/full/selftest/align4_num_entries/pkg.yml
@@ -0,0 +1,30 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+pkg.name: sys/log/full/selftest/align4_num_entries
+pkg.type: unittest
+pkg.description: "Log unit tests; flash-alignment=4."
+pkg.author: "Apache Mynewt <de...@mynewt.apache.org>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+
+pkg.deps:
+ - "@apache-mynewt-core/sys/console/stub"
+ - "@apache-mynewt-core/sys/log/full"
+ - "@apache-mynewt-core/sys/log/full/selftest/util"
+ - "@apache-mynewt-core/test/testutil"
+ - "@apache-mynewt-core/boot/stub"
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c b/sys/log/full/selftest/align4_num_entries/src/log_test_align1.c
similarity index 71%
copy from sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
copy to sys/log/full/selftest/align4_num_entries/src/log_test_align1.c
index f48b87657..6fb73ffba 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
+++ b/sys/log/full/selftest/align4_num_entries/src/log_test_align1.c
@@ -17,25 +17,17 @@
* under the License.
*/
+#include "os/mynewt.h"
#include "log_test_util/log_test_util.h"
-TEST_CASE_SELF(log_test_case_cbmem_printf)
+int
+main(int argc, char **argv)
{
- struct cbmem cbmem;
- struct log log;
- char *str;
- int i;
+ log_test_suite_cbmem_flat();
+ log_test_suite_cbmem_mbuf();
+ log_test_suite_fcb_flat();
+ log_test_suite_fcb_mbuf();
+ log_test_suite_misc();
- ltu_setup_cbmem(&cbmem, &log);
-
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
-
- log_printf(&log, 0, 0, str, strlen(str));
- }
-
- ltu_verify_contents(&log);
+ return tu_any_failed;
}
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c b/sys/log/full/selftest/align4_num_entries/src/log_test_align4.c
similarity index 71%
copy from sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
copy to sys/log/full/selftest/align4_num_entries/src/log_test_align4.c
index f48b87657..b1c5a1d23 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
+++ b/sys/log/full/selftest/align4_num_entries/src/log_test_align4.c
@@ -17,25 +17,25 @@
* under the License.
*/
+#include "os/mynewt.h"
#include "log_test_util/log_test_util.h"
-TEST_CASE_SELF(log_test_case_cbmem_printf)
+int
+main(int argc, char **argv)
{
- struct cbmem cbmem;
- struct log log;
- char *str;
- int i;
+ log_test_suite_cbmem_flat();
- ltu_setup_cbmem(&cbmem, &log);
+ log_test_suite_cbmem_mbuf();
+ log_test_suite_fcb_flat();
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+#if 0
+ /* Current fcb mbuf implementation supports only
+ * 1 byte alignment
+ */
+ log_test_suite_fcb_mbuf();
+#endif
- log_printf(&log, 0, 0, str, strlen(str));
- }
+ log_test_suite_misc();
- ltu_verify_contents(&log);
+ return tu_any_failed;
}
diff --git a/sys/log/full/selftest/align4_num_entries/syscfg.yml b/sys/log/full/selftest/align4_num_entries/syscfg.yml
new file mode 100644
index 000000000..7171a4122
--- /dev/null
+++ b/sys/log/full/selftest/align4_num_entries/syscfg.yml
@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+syscfg.vals:
+ LOG_FCB: 1
+ MCU_FLASH_MIN_WRITE_SIZE: 1
+
+ # The mbuf append tests allocate lots of mbufs; ensure no exhaustion.
+ MSYS_1_BLOCK_COUNT: 1000
+ LOG_FLAGS_TRAILER_SUPPORT: 1
+ LOGS_TLV_NUM_ENTRIES: 1
+ IMGMGR_DUMMY_HDR: 1
+ LOG_MGMT: 0
+ IMG_MGMT: 0
diff --git a/sys/log/full/selftest/fcb2_align1_imghash/pkg.yml b/sys/log/full/selftest/fcb2_align1_imghash/pkg.yml
new file mode 100644
index 000000000..f931c7d49
--- /dev/null
+++ b/sys/log/full/selftest/fcb2_align1_imghash/pkg.yml
@@ -0,0 +1,30 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+pkg.name: sys/log/full/selftest/fcb2_align1_imghash
+pkg.type: unittest
+pkg.description: "Log unit tests; FCB2 flash-alignment=1."
+pkg.author: "Apache Mynewt <de...@mynewt.apache.org>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+
+pkg.deps:
+ - "@apache-mynewt-core/sys/console/stub"
+ - "@apache-mynewt-core/sys/log/full"
+ - "@apache-mynewt-core/sys/log/full/selftest/util"
+ - "@apache-mynewt-core/test/testutil"
+ - "@apache-mynewt-core/boot/stub"
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c b/sys/log/full/selftest/fcb2_align1_imghash/src/log_test_align1.c
similarity index 71%
copy from sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
copy to sys/log/full/selftest/fcb2_align1_imghash/src/log_test_align1.c
index f48b87657..6fb73ffba 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
+++ b/sys/log/full/selftest/fcb2_align1_imghash/src/log_test_align1.c
@@ -17,25 +17,17 @@
* under the License.
*/
+#include "os/mynewt.h"
#include "log_test_util/log_test_util.h"
-TEST_CASE_SELF(log_test_case_cbmem_printf)
+int
+main(int argc, char **argv)
{
- struct cbmem cbmem;
- struct log log;
- char *str;
- int i;
+ log_test_suite_cbmem_flat();
+ log_test_suite_cbmem_mbuf();
+ log_test_suite_fcb_flat();
+ log_test_suite_fcb_mbuf();
+ log_test_suite_misc();
- ltu_setup_cbmem(&cbmem, &log);
-
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
-
- log_printf(&log, 0, 0, str, strlen(str));
- }
-
- ltu_verify_contents(&log);
+ return tu_any_failed;
}
diff --git a/sys/log/full/selftest/fcb2_align1_imghash/syscfg.yml b/sys/log/full/selftest/fcb2_align1_imghash/syscfg.yml
new file mode 100644
index 000000000..fa4b33f97
--- /dev/null
+++ b/sys/log/full/selftest/fcb2_align1_imghash/syscfg.yml
@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+syscfg.vals:
+ LOG_FCB2: 1
+ MCU_FLASH_MIN_WRITE_SIZE: 1
+ LOG_FLAGS_IMAGE_HASH: 1
+
+ # The mbuf append tests allocate lots of mbufs; ensure no exhaustion.
+ MSYS_1_BLOCK_COUNT: 1000
+ LOG_FLAGS_IMAGE_HASH: 1
+ IMGMGR_DUMMY_HDR: 1
+ LOG_MGMT: 0
+ IMG_MGMT: 0
diff --git a/sys/log/full/selftest/fcb2_align1_imghash_num_entries/pkg.yml b/sys/log/full/selftest/fcb2_align1_imghash_num_entries/pkg.yml
new file mode 100644
index 000000000..e84f61ad7
--- /dev/null
+++ b/sys/log/full/selftest/fcb2_align1_imghash_num_entries/pkg.yml
@@ -0,0 +1,30 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+pkg.name: sys/log/full/selftest/fcb2_align1_imghash_num_entries
+pkg.type: unittest
+pkg.description: "Log unit tests; FCB2 flash-alignment=1."
+pkg.author: "Apache Mynewt <de...@mynewt.apache.org>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+
+pkg.deps:
+ - "@apache-mynewt-core/sys/console/stub"
+ - "@apache-mynewt-core/sys/log/full"
+ - "@apache-mynewt-core/sys/log/full/selftest/util"
+ - "@apache-mynewt-core/test/testutil"
+ - "@apache-mynewt-core/boot/stub"
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c b/sys/log/full/selftest/fcb2_align1_imghash_num_entries/src/log_test_align1.c
similarity index 71%
copy from sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
copy to sys/log/full/selftest/fcb2_align1_imghash_num_entries/src/log_test_align1.c
index f48b87657..6fb73ffba 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
+++ b/sys/log/full/selftest/fcb2_align1_imghash_num_entries/src/log_test_align1.c
@@ -17,25 +17,17 @@
* under the License.
*/
+#include "os/mynewt.h"
#include "log_test_util/log_test_util.h"
-TEST_CASE_SELF(log_test_case_cbmem_printf)
+int
+main(int argc, char **argv)
{
- struct cbmem cbmem;
- struct log log;
- char *str;
- int i;
+ log_test_suite_cbmem_flat();
+ log_test_suite_cbmem_mbuf();
+ log_test_suite_fcb_flat();
+ log_test_suite_fcb_mbuf();
+ log_test_suite_misc();
- ltu_setup_cbmem(&cbmem, &log);
-
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
-
- log_printf(&log, 0, 0, str, strlen(str));
- }
-
- ltu_verify_contents(&log);
+ return tu_any_failed;
}
diff --git a/sys/log/full/selftest/fcb2_align1_imghash_num_entries/syscfg.yml b/sys/log/full/selftest/fcb2_align1_imghash_num_entries/syscfg.yml
new file mode 100644
index 000000000..190b3e9d0
--- /dev/null
+++ b/sys/log/full/selftest/fcb2_align1_imghash_num_entries/syscfg.yml
@@ -0,0 +1,30 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+syscfg.vals:
+ LOG_FCB2: 1
+ MCU_FLASH_MIN_WRITE_SIZE: 1
+
+ # The mbuf append tests allocate lots of mbufs; ensure no exhaustion.
+ MSYS_1_BLOCK_COUNT: 1000
+ LOG_FLAGS_IMAGE_HASH: 1
+ LOG_FLAGS_TRAILER_SUPPORT: 1
+ LOGS_TLV_NUM_ENTRIES: 1
+ IMGMGR_DUMMY_HDR: 1
+ LOG_MGMT: 0
+ IMG_MGMT: 0
diff --git a/sys/log/full/selftest/util/include/log_test_util/log_test_util.h b/sys/log/full/selftest/util/include/log_test_util/log_test_util.h
index 90b77e498..4c23c3733 100644
--- a/sys/log/full/selftest/util/include/log_test_util/log_test_util.h
+++ b/sys/log/full/selftest/util/include/log_test_util/log_test_util.h
@@ -41,6 +41,7 @@ extern struct fcb2 log_fcb;
#endif
extern struct log my_log;
extern char *ltu_str_logs[];
+extern uint8_t dummy_log_arr[];
struct os_mbuf *ltu_flat_to_fragged_mbuf(const void *flat, int len,
int frag_sz);
@@ -49,6 +50,9 @@ void ltu_setup_2fcbs(struct fcb_log *fcb_log1, struct log *log1,
struct fcb_log *fcb_log2, struct log *log2);
void ltu_setup_cbmem(struct cbmem *cbmem, struct log *log);
void ltu_verify_contents(struct log *log);
+uint16_t *ltu_get_ltu_off_arr(void);
+uint16_t ltu_init_arr(void);
+int ltu_num_strs(void);
TEST_SUITE_DECL(log_test_suite_cbmem_flat);
TEST_CASE_DECL(log_test_case_cbmem_append);
diff --git a/sys/log/full/selftest/util/src/log_test_util.c b/sys/log/full/selftest/util/src/log_test_util.c
index 2447cbb61..b8a04cc7d 100644
--- a/sys/log/full/selftest/util/src/log_test_util.c
+++ b/sys/log/full/selftest/util/src/log_test_util.c
@@ -18,6 +18,7 @@
*/
#include "log_test_util/log_test_util.h"
+#include "log/log.h"
#if MYNEWT_VAL(LOG_FCB)
static struct flash_area fcb_areas[] = {
@@ -46,6 +47,37 @@ static struct flash_sector_range fcb_range = {
static int ltu_str_idx = 0;
static int ltu_str_max_idx = 0;
+struct dummy_log {
+ struct log_entry_hdr hdr;
+ struct log_tlv tlv;
+ uint32_t num_entries;
+};
+
+struct dummy_log dummy_log = {
+ .hdr = {
+ .ue_ts = 1,
+ .ue_module = 2,
+ .ue_etype = 3,
+ .ue_flags = 0
+#if MYNEWT_VAL(LOG_FLAGS_IMAGE_HASH)
+ | LOG_FLAGS_IMG_HASH
+#endif
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ | LOG_FLAGS_TRAILER_SUPPORT
+#endif
+ ,
+ .ue_etype = 0,
+ .ue_imghash = {1, 2, 3, 4},
+ .ue_level = 3,
+ .ue_num_entries = 5
+ },
+ .tlv = {
+ .tag = LOGS_TLV_NUM_ENTRIES,
+ .len = LOG_NUM_ENTRIES_SIZE
+ },
+ .num_entries = 0,
+};
+
char *ltu_str_logs[] = {
"testdata",
"1testdata2",
@@ -54,6 +86,10 @@ char *ltu_str_logs[] = {
NULL
};
+uint16_t ltu_off_arr[5];
+
+uint8_t dummy_log_arr[2048];
+
static uint8_t ltu_cbmem_buf[2048];
int
@@ -66,6 +102,41 @@ ltu_num_strs(void)
return i;
}
+uint16_t *
+ltu_get_ltu_off_arr(void)
+{
+ return ltu_off_arr;
+}
+
+uint16_t
+ltu_init_arr(void)
+{
+ int i;
+ uint16_t offset = 0;
+
+ for (i = 0; i < ltu_num_strs(); i++) {
+ TEST_ASSERT_FATAL(offset <= 2048);
+ ltu_off_arr[i] = offset;
+ memcpy(dummy_log_arr + offset, &dummy_log.hdr, LOG_BASE_ENTRY_HDR_SIZE);
+ offset += LOG_BASE_ENTRY_HDR_SIZE;
+#if MYNEWT_VAL(LOG_FLAGS_IMAGE_HASH)
+ memcpy(dummy_log_arr + offset,
+ dummy_log.hdr.ue_imghash, LOG_IMG_HASHLEN);
+ offset += LOG_IMG_HASHLEN;
+#endif
+ memcpy(dummy_log_arr + offset, ltu_str_logs[i], strlen(ltu_str_logs[i]));
+ offset += strlen(ltu_str_logs[i]);
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT) && MYNEWT_VAL(LOGS_TLV_NUM_ENTRIES)
+ memcpy(dummy_log_arr + offset, &dummy_log.tlv, sizeof(struct log_tlv));
+ offset += sizeof(struct log_tlv);
+ memcpy(dummy_log_arr + offset, &dummy_log.num_entries, LOG_NUM_ENTRIES_SIZE);
+ offset += LOG_NUM_ENTRIES_SIZE;
+#endif
+ }
+ ltu_off_arr[i] = offset;
+ return offset;
+}
+
struct os_mbuf *
ltu_flat_to_fragged_mbuf(const void *flat, int len, int frag_sz)
{
@@ -190,6 +261,8 @@ ltu_walk_verify(struct log *log, struct log_offset *log_offset,
char data[128];
int dlen;
uint16_t hdr_len;
+ uint16_t trailer_len;
+ uint16_t offset = 0;
TEST_ASSERT(ltu_str_idx < ltu_str_max_idx);
@@ -197,9 +270,17 @@ ltu_walk_verify(struct log *log, struct log_offset *log_offset,
rc = log_read(log, dptr, &ueh, 0, LOG_BASE_ENTRY_HDR_SIZE);
TEST_ASSERT(rc == LOG_BASE_ENTRY_HDR_SIZE);
+ offset = LOG_BASE_ENTRY_HDR_SIZE;
+
+ if (ueh.ue_flags & LOG_FLAGS_IMG_HASH) {
+ rc = log_read(log, dptr, data, offset, LOG_IMG_HASHLEN);
+ TEST_ASSERT(rc == LOG_IMG_HASHLEN);
+ offset += LOG_IMG_HASHLEN;
+ }
hdr_len = log_hdr_len(&ueh);
- dlen = len - hdr_len;
+ trailer_len = log_trailer_len(log, &ueh);
+ dlen = len - hdr_len - trailer_len;
TEST_ASSERT(dlen < sizeof(data));
rc = log_read(log, dptr, data, hdr_len, dlen);
@@ -218,6 +299,12 @@ ltu_walk_verify(struct log *log, struct log_offset *log_offset,
rc = log_read_body(log, dptr, data, 0, dlen);
TEST_ASSERT(rc == dlen);
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT) && MYNEWT_VAL(LOGS_TLV_NUM_ENTRIES)
+ uint32_t num_entries;;
+ rc = log_read_trailer(log, dptr, LOGS_TLV_NUM_ENTRIES, &num_entries);
+ TEST_ASSERT(rc == 0);
+#endif
+
TEST_ASSERT(strlen(ltu_str_logs[ltu_str_idx]) == dlen);
TEST_ASSERT(!memcmp(ltu_str_logs[ltu_str_idx], data, dlen));
@@ -263,6 +350,8 @@ ltu_walk_body_verify(struct log *log, struct log_offset *log_offset,
TEST_ASSERT(len < sizeof(data));
+ len -= log_trailer_len(log, euh);
+
rc = log_read_body(log, dptr, data, 0, len);
TEST_ASSERT(rc == len);
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append.c b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append.c
index 180f3774f..5f5d9d17a 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append.c
@@ -23,23 +23,26 @@ TEST_CASE_SELF(log_test_case_cbmem_append)
{
struct cbmem cbmem;
struct log log;
- uint8_t buf[256];
- char *str;
- int body_len;
+ uint16_t len = 0;
+ uint16_t *off_arr;
int i;
int rc;
+ int num_strs = ltu_num_strs();
+ struct log_entry_hdr *hdr;
ltu_setup_cbmem(&cbmem, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
- body_len = strlen(str);
- memcpy(buf + LOG_HDR_SIZE, str, body_len);
- rc = log_append_typed(&log, 0, 0, LOG_ETYPE_STRING, buf, body_len);
+ for (i = 0; i < num_strs; i++) {
+ hdr = (struct log_entry_hdr *)(dummy_log_arr + off_arr[i]);
+ len = off_arr[i+1] - off_arr[i] - log_hdr_len(hdr) - log_trailer_len(&log, hdr);
+ rc = log_append_typed(&log, 2, 3, LOG_ETYPE_STRING,
+ dummy_log_arr + off_arr[i],
+ len);
TEST_ASSERT_FATAL(rc == 0);
}
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_body.c b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_body.c
index 0a7fb1c11..8948bacad 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_body.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_body.c
@@ -23,18 +23,28 @@ TEST_CASE_SELF(log_test_case_cbmem_append_body)
{
struct cbmem cbmem;
struct log log;
- char *str;
+ uint16_t len = 0;
+ uint16_t *off_arr;
int i;
+ int rc;
+ struct log_entry_hdr *hdr;
+ int num_strs = ltu_num_strs();
ltu_setup_cbmem(&cbmem, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
- log_append_body(&log, 0, 0, LOG_ETYPE_STRING, str, strlen(str));
+ for (i = 0; i < num_strs; i++) {
+ hdr = (struct log_entry_hdr *)(dummy_log_arr + off_arr[i]);
+ len = off_arr[i + 1] - off_arr[i] -
+ log_hdr_len(hdr) - log_trailer_len(&log, hdr);
+ rc = log_append_body(&log, 2, 3, LOG_ETYPE_STRING,
+ dummy_log_arr + off_arr[i] + log_hdr_len(hdr),
+ len);
+ TEST_ASSERT_FATAL(rc == 0);
}
ltu_verify_contents(&log);
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_mbuf.c b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_mbuf.c
index 3bf305549..aaeab19d3 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_mbuf.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_mbuf.c
@@ -22,28 +22,28 @@
TEST_CASE_SELF(log_test_case_cbmem_append_mbuf)
{
struct cbmem cbmem;
- struct os_mbuf *om;
struct log log;
- char *str;
- int rc;
+ struct os_mbuf *om;
+ uint16_t len = 0;
+ uint16_t *off_arr;
int i;
+ int rc;
+ int num_strs = ltu_num_strs();
ltu_setup_cbmem(&cbmem, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
+ for (i = 0; i < num_strs; i++) {
+ len = off_arr[i+1] - off_arr[i];
/* Split chain into several mbufs. */
- om = ltu_flat_to_fragged_mbuf(str, strlen(str), 2);
-
- /* Prepend space for the entry header. */
- om = os_mbuf_prepend(om, LOG_HDR_SIZE);
- TEST_ASSERT(om != NULL);
+ om = ltu_flat_to_fragged_mbuf(dummy_log_arr + off_arr[i],
+ len, 2);
- rc = log_append_mbuf_typed(&log, 0, 0, LOG_ETYPE_STRING, om);
+ rc = log_append_mbuf_typed(&log, 2, 3, LOG_ETYPE_STRING, om);
TEST_ASSERT_FATAL(rc == 0);
}
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_mbuf_body.c b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_mbuf_body.c
index fddb1bbc8..86775f807 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_mbuf_body.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_append_mbuf_body.c
@@ -24,22 +24,30 @@ TEST_CASE_SELF(log_test_case_cbmem_append_mbuf_body)
struct cbmem cbmem;
struct os_mbuf *om;
struct log log;
- char *str;
int rc;
int i;
+ uint16_t len;
+ int num_strs = ltu_num_strs();
+ struct log_entry_hdr *hdr;
+ uint16_t *off_arr;
ltu_setup_cbmem(&cbmem, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
+
+ for (i = 0; i < num_strs; i++) {
+ hdr = (struct log_entry_hdr *)(dummy_log_arr + off_arr[i]);
+ len = off_arr[i + 1] - off_arr[i] -
+ log_hdr_len(hdr);
/* Split chain into several mbufs. */
- om = ltu_flat_to_fragged_mbuf(str, strlen(str), 2);
+ om = ltu_flat_to_fragged_mbuf(dummy_log_arr + off_arr[i] + log_hdr_len(hdr),
+ len, 2);
- rc = log_append_mbuf_body(&log, 0, 0, LOG_ETYPE_STRING, om);
+ rc = log_append_mbuf_body(&log, 2, 3, LOG_ETYPE_STRING, om);
TEST_ASSERT_FATAL(rc == 0);
}
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
index f48b87657..f29bdcdb1 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_cbmem_printf.c
@@ -23,18 +23,27 @@ TEST_CASE_SELF(log_test_case_cbmem_printf)
{
struct cbmem cbmem;
struct log log;
- char *str;
int i;
+ uint16_t len = 0;
+ int num_strs = ltu_num_strs();
+ uint16_t *off_arr;
+ struct log_entry_hdr *hdr;
+ char data[256];
ltu_setup_cbmem(&cbmem, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
- log_printf(&log, 0, 0, str, strlen(str));
+ for (i = 0; i < num_strs; i++) {
+ hdr = (struct log_entry_hdr *)(dummy_log_arr + off_arr[i]);
+ len = off_arr[i+1] - off_arr[i] - log_hdr_len(hdr) - log_trailer_len(&log, hdr);
+ memcpy(data, dummy_log_arr + off_arr[i] + log_hdr_len(hdr),
+ len);
+ data[len] = '\0';
+ log_printf(&log, 0, 0, data, len);
}
ltu_verify_contents(&log);
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append.c b/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append.c
index 808188ce1..3fe8f4e28 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append.c
@@ -23,22 +23,27 @@ TEST_CASE_SELF(log_test_case_fcb_append)
{
struct fcb_log fcb_log;
struct log log;
- uint8_t buf[256];
- char *str;
- int body_len;
+ uint16_t len = 0;
+ uint16_t *off_arr;
int i;
+ int rc;
+ int num_strs = ltu_num_strs();
+ struct log_entry_hdr *hdr;
ltu_setup_fcb(&fcb_log, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
- body_len = strlen(str);
- memcpy(buf + LOG_HDR_SIZE, str, body_len);
- log_append_typed(&log, 0, 0, LOG_ETYPE_STRING, buf, body_len);
+ for (i = 0;i < num_strs; i++) {
+ hdr = (struct log_entry_hdr *)(dummy_log_arr + off_arr[i]);
+ len = off_arr[i+1] - off_arr[i] - log_hdr_len(hdr) - log_trailer_len(&log, hdr);
+ rc = log_append_typed(&log, 2, 3, LOG_ETYPE_STRING,
+ dummy_log_arr + off_arr[i],
+ len);
+ TEST_ASSERT_FATAL(rc == 0);
}
ltu_verify_contents(&log);
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_body.c b/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_body.c
index 1d0a86637..996ff647e 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_body.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_body.c
@@ -23,18 +23,30 @@ TEST_CASE_SELF(log_test_case_fcb_append_body)
{
struct fcb_log fcb_log;
struct log log;
- char *str;
+ uint16_t len = 0;
+ uint16_t *off_arr;
int i;
+ int rc;
+ struct log_entry_hdr *hdr;
+ int num_strs = ltu_num_strs();
ltu_setup_fcb(&fcb_log, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
- log_append_body(&log, 0, 0, LOG_ETYPE_STRING, str, strlen(str));
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
+
+ for (i = 0; i < num_strs; i++) {
+ hdr = (struct log_entry_hdr *)(dummy_log_arr + off_arr[i]);
+ len = off_arr[i + 1] - off_arr[i] -
+ log_hdr_len(hdr) - log_trailer_len(&log, hdr);
+ rc = log_append_body(&log, 2, 3, LOG_ETYPE_STRING,
+ dummy_log_arr + off_arr[i] + log_hdr_len(hdr),
+ len);
+ TEST_ASSERT_FATAL(rc == 0);
}
ltu_verify_contents(&log);
+
}
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_mbuf.c b/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_mbuf.c
index e566c78bd..7a3c2b035 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_mbuf.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_mbuf.c
@@ -24,26 +24,28 @@ TEST_CASE_SELF(log_test_case_fcb_append_mbuf)
struct fcb_log fcb_log;
struct os_mbuf *om;
struct log log;
- char *str;
int rc;
int i;
+ int num_strs = ltu_num_strs();
+ struct log_entry_hdr *hdr;
+ uint16_t *off_arr;
+ uint16_t len;
ltu_setup_fcb(&fcb_log, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
+ for (i = 0; i < num_strs; i++) {
+ hdr = (struct log_entry_hdr *)(dummy_log_arr + off_arr[i]);
+ len = off_arr[i+1] - off_arr[i] - log_trailer_len(&log, hdr);
/* Split chain into several mbufs. */
- om = ltu_flat_to_fragged_mbuf(str, strlen(str), 2);
+ om = ltu_flat_to_fragged_mbuf(dummy_log_arr + off_arr[i],
+ len, 2);
- /* Prepend space for the entry header. */
- om = os_mbuf_prepend(om, LOG_HDR_SIZE);
- TEST_ASSERT(om != NULL);
-
- rc = log_append_mbuf_typed(&log, 0, 0, LOG_ETYPE_STRING, om);
+ rc = log_append_mbuf_typed(&log, 2, 3, LOG_ETYPE_STRING, om);
TEST_ASSERT_FATAL(rc == 0);
}
diff --git a/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_mbuf_body.c b/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_mbuf_body.c
index 25d536479..bc980835a 100644
--- a/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_mbuf_body.c
+++ b/sys/log/full/selftest/util/src/testcases/log_test_case_fcb_append_mbuf_body.c
@@ -24,22 +24,30 @@ TEST_CASE_SELF(log_test_case_fcb_append_mbuf_body)
struct fcb_log fcb_log;
struct os_mbuf *om;
struct log log;
- char *str;
int rc;
int i;
+ int num_strs = ltu_num_strs();
+ struct log_entry_hdr *hdr;
+ uint16_t *off_arr;
+ uint16_t len;
ltu_setup_fcb(&fcb_log, &log);
+ len = ltu_init_arr();
+ TEST_ASSERT_FATAL(len != 0);
- for (i = 0; ; i++) {
- str = ltu_str_logs[i];
- if (!str) {
- break;
- }
+ off_arr = ltu_get_ltu_off_arr();
+ TEST_ASSERT_FATAL(off_arr != NULL);
+
+ for (i = 0; i < num_strs; i++) {
+ hdr = (struct log_entry_hdr *)(dummy_log_arr + off_arr[i]);
+ len = off_arr[i + 1] - off_arr[i] -
+ log_hdr_len(hdr) - log_trailer_len(&log, hdr);
/* Split chain into several mbufs. */
- om = ltu_flat_to_fragged_mbuf(str, strlen(str), 2);
+ om = ltu_flat_to_fragged_mbuf(dummy_log_arr + off_arr[i] + log_hdr_len(hdr),
+ len, 2);
- rc = log_append_mbuf_body(&log, 0, 0, LOG_ETYPE_STRING, om);
+ rc = log_append_mbuf_body(&log, 2, 3, LOG_ETYPE_STRING, om);
TEST_ASSERT_FATAL(rc == 0);
}
diff --git a/sys/log/full/src/log.c b/sys/log/full/src/log.c
index 978924e6b..3fde2987f 100644
--- a/sys/log/full/src/log.c
+++ b/sys/log/full/src/log.c
@@ -299,11 +299,77 @@ struct log_read_hdr_arg {
};
static int
-log_read_hdr_walk(struct log *log, struct log_offset *log_offset, const void *dptr,
- uint16_t len)
+log_update_num_entries_hdr_walk(struct log *log, struct log_offset *log_offset,
+ const void *dptr, uint16_t len)
+{
+ uint32_t *num_entries;
+ uint16_t offset = 0;
+ int rc;
+ struct log_entry_hdr hdr;
+
+ (void)offset;
+ num_entries = log_offset->lo_arg;
+
+ rc = log_read(log, dptr, &hdr, 0, LOG_BASE_ENTRY_HDR_SIZE);
+ if (rc >= LOG_BASE_ENTRY_HDR_SIZE) {
+ *num_entries += 1;
+ return 0;
+ }
+
+ return -1;
+}
+
+static int
+log_process_tlvs(struct log *log, const void *dptr, uint8_t num_tlvs,
+ uint16_t tlv_tag, void *buf, uint16_t len)
+{
+ struct log_tlv *tlv;
+ uint8_t tmpbuf[sizeof(*tlv) + 8] = {0};
+ uint16_t offset;
+ int tlv_len;
+ int rc = SYS_ENOENT;
+
+ offset = len;
+ tlv_len = log_len_in_medium(log, sizeof(*tlv));
+ do {
+ offset -= tlv_len;
+ rc = log_read(log, dptr, tmpbuf, offset, tlv_len);
+ if (rc < tlv_len) {
+ return SYS_EINVAL;
+ }
+ tlv = (struct log_tlv *)tmpbuf;
+
+ offset -= log_len_in_medium(log, tlv->len);
+ if (tlv->tag != tlv_tag) {
+ continue;
+ }
+
+ switch (tlv_tag) {
+ case LOGS_TLV_NUM_ENTRIES:
+ rc = log_fill_num_entries(log, dptr, buf, offset);
+ break;
+ case LOG_TLV_NUM_TLVS:
+ rc = log_fill_num_tlvs(log, dptr, buf, offset);
+ break;
+ default:
+ return SYS_ENOTSUP;
+ }
+
+ if (!rc) {
+ return SYS_EOK;
+ }
+ } while (offset && num_tlvs);
+
+ return SYS_EOK;
+}
+
+static int
+log_read_hdr_walk(struct log *log, struct log_offset *log_offset,
+ const void *dptr, uint16_t len)
{
struct log_read_hdr_arg *arg;
int rc;
+ uint8_t num_tlvs = 0;
arg = log_offset->lo_arg;
@@ -319,10 +385,62 @@ log_read_hdr_walk(struct log *log, struct log_offset *log_offset, const void *dp
}
}
+ if (arg->hdr->ue_flags & LOG_FLAGS_TRAILER_SUPPORT) {
+ /* Read number of TLVs, if it does not exist
+ * num_tlvs = 0, so only one TLV will get read
+ * from the end of the entry
+ */
+ rc = log_process_tlvs(log, dptr, 0, LOG_TLV_NUM_TLVS,
+ &num_tlvs, len);
+ if (!rc || rc == SYS_ENOTSUP) {
+ arg->read_success = 1;
+ } else {
+ arg->read_success = 0;
+ }
+
+ if (!rc || rc == SYS_ENOTSUP) {
+ rc = log_process_tlvs(log, dptr, num_tlvs, LOGS_TLV_NUM_ENTRIES,
+ &arg->hdr->ue_num_entries, len);
+ if (!rc || rc == SYS_ENOTSUP) {
+ arg->read_success = 1;
+ } else {
+ arg->read_success = 0;
+ }
+ }
+ }
+
/* Abort the walk; only one header needed. */
return 1;
}
+/**
+ * Update number of entries of the specified log.
+ *
+ * @param log The log to read from.
+ * @param num_entries Pointer to the number of entries.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+static int
+log_update_num_entries(struct log *log, uint32_t *num_entries)
+{
+ struct log_offset log_offset;
+ int rc = 0;
+
+
+ log_offset.lo_arg = num_entries;
+ log_offset.lo_ts = 0;
+ log_offset.lo_index = 0;
+ log_offset.lo_data_len = 0;
+
+ rc = log_walk(log, log_update_num_entries_hdr_walk, &log_offset);
+ if (rc) {
+ return -1;
+ }
+
+ return 0;
+}
+
/**
* Reads the final log entry's header from the specified log.
*
@@ -354,6 +472,66 @@ log_read_last_hdr(struct log *log, struct log_entry_hdr *out_hdr)
return 0;
}
+/**
+ * Get number of entries in log
+ *
+ * @param log The log to get number of entries for
+ * @param idx The log index to read number of entries from
+ * @param num_entries Ptr to fill up number of entries in log
+ *
+ * @return 0 on success, non-zero on failure
+ */
+int
+log_get_entries(struct log *log, uint32_t idx, uint32_t *entries)
+{
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT) && MYNEWT_VAL(LOGS_TLV_NUM_ENTRIES)
+ int rc = 0;
+ struct log_entry_hdr hdr;
+
+ rc = log_read_hdr_by_idx(log, idx, &hdr);
+ if (!rc) {
+ *entries = log->l_num_entries - hdr.ue_num_entries;
+ return SYS_EOK;
+ } else {
+ return rc;
+ }
+#else
+ return SYS_ENOTSUP;
+#endif
+}
+
+/**
+ * Reads the log entry's header from the specified log and log index
+ *
+ * @param log The log to read from.
+ * @param idx Index of the log entry to read header from
+ * @param out_hdr On success, the last entry header gets written
+ * here.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int
+log_read_hdr_by_idx(struct log *log, uint32_t idx, struct log_entry_hdr *out_hdr)
+{
+ struct log_read_hdr_arg arg;
+ struct log_offset log_offset;
+
+ arg.hdr = out_hdr;
+ arg.read_success = 0;
+
+ log_offset.lo_arg = &arg;
+ log_offset.lo_ts = 0;
+ log_offset.lo_index = idx;
+ log_offset.lo_data_len = 0;
+
+ log_walk(log, log_read_hdr_walk, &log_offset);
+ if (!arg.read_success) {
+ return -1;
+ }
+
+ return 0;
+}
+
/*
* Associate an instantiation of a log with the logging infrastructure
*/
@@ -362,6 +540,7 @@ log_register(const char *name, struct log *log, const struct log_handler *lh,
void *arg, uint8_t level)
{
struct log_entry_hdr hdr;
+ uint32_t num_entries = 0;
int sr;
int rc;
@@ -400,13 +579,21 @@ log_register(const char *name, struct log *log, const struct log_handler *lh,
}
}
- /* If this is a persisted log, read the index from its most recent entry.
- * We need to ensure the index of all subseqently written entries is
- * monotonically increasing.
- */
if (log->l_log->log_type == LOG_TYPE_STORAGE) {
+ memset(&hdr, 0, sizeof(hdr));
rc = log_read_last_hdr(log, &hdr);
if (rc == 0) {
+ /* If the number of entries are not set in the last header,
+ * it was probably not supported when the entry was logged.
+ * Count number of entries in this specific case
+ */
+ if (!hdr.ue_num_entries) {
+ log_update_num_entries(log, &num_entries);
+ }
+ /* If this is a persisted log, read the index from its most
+ * recent entry. We need to ensure the index of all subsequently
+ * written entries is monotonically increasing.
+ */
OS_ENTER_CRITICAL(sr);
#if MYNEWT_VAL(LOG_GLOBAL_IDX)
if (hdr.ue_index > g_log_info.li_next_index) {
@@ -417,6 +604,15 @@ log_register(const char *name, struct log *log, const struct log_handler *lh,
log->l_idx = hdr.ue_index;
}
#endif
+ /* If this is a persisted log, read the num_entries from its most
+ * recent entry. We need to ensure the number of entries are
+ * monotonically increasing.
+ */
+ if (!hdr.ue_num_entries) {
+ log->l_num_entries = num_entries;
+ } else if (hdr.ue_num_entries >= log->l_num_entries) {
+ log->l_num_entries = hdr.ue_num_entries + 1;
+ }
OS_EXIT_CRITICAL(sr);
}
}
@@ -433,11 +629,55 @@ log_set_append_cb(struct log *log, log_append_cb *cb)
uint16_t
log_hdr_len(const struct log_entry_hdr *hdr)
{
+ uint16_t len;
+
+ len = LOG_BASE_ENTRY_HDR_SIZE;
if (hdr->ue_flags & LOG_FLAGS_IMG_HASH) {
- return LOG_BASE_ENTRY_HDR_SIZE + LOG_IMG_HASHLEN;
+ len += LOG_IMG_HASHLEN;
}
- return LOG_BASE_ENTRY_HDR_SIZE;
+ return len;
+}
+
+int
+log_len_in_medium(struct log *log, uint16_t len)
+{
+ if (log->l_log->log_len_in_medium) {
+ return log->l_log->log_len_in_medium(log, len);
+ }
+
+ return len;
+}
+
+uint16_t
+log_trailer_len(struct log *log, const struct log_entry_hdr *hdr)
+{
+ if (log->l_trailer_len_cb) {
+ return log->l_trailer_len_cb(log, hdr);
+ } else {
+ return 0;
+ }
+}
+
+int
+log_trailer_append(struct log *log, uint8_t *buf, uint16_t buflen,
+ void *loc)
+{
+ if (log->l_trailer_append_cb) {
+ return log->l_trailer_append_cb(log, buf, buflen, loc);
+ } else {
+ return SYS_ENOTSUP;
+ }
+}
+
+int
+log_mbuf_trailer_append(struct log *log, struct os_mbuf *om, void *loc)
+{
+ if (log->l_trailer_mbuf_append_cb) {
+ return log->l_trailer_mbuf_append_cb(log, om, loc);
+ } else {
+ return SYS_ENOTSUP;
+ }
}
void
@@ -565,6 +805,11 @@ log_append_prepare(struct log *log, uint8_t module, uint8_t level,
}
#endif
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT) && MYNEWT_VAL(LOGS_TLV_NUM_ENTRIES)
+ ue->ue_flags |= LOG_FLAGS_TRAILER_SUPPORT;
+ ue->ue_num_entries = log->l_num_entries;
+#endif
+
err:
return (rc);
}
@@ -594,7 +839,7 @@ int
log_append_typed(struct log *log, uint8_t module, uint8_t level, uint8_t etype,
void *data, uint16_t len)
{
- struct log_entry_hdr *hdr;
+ struct log_entry_hdr hdr;
int rc;
LOG_STATS_INC(log, writes);
@@ -604,20 +849,20 @@ log_append_typed(struct log *log, uint8_t module, uint8_t level, uint8_t etype,
goto err;
}
- hdr = (struct log_entry_hdr *)data;
- rc = log_append_prepare(log, module, level, etype, hdr);
+ hdr = *(struct log_entry_hdr *)data;
+ rc = log_append_prepare(log, module, level, etype, &hdr);
if (rc != 0) {
LOG_STATS_INC(log, drops);
goto err;
}
- rc = log->l_log->log_append(log, data, len + log_hdr_len(hdr));
+ rc = log->l_log->log_append(log, data, len + log_hdr_len(&hdr));
if (rc != 0) {
LOG_STATS_INC(log, errs);
goto err;
}
- log_call_append_cb(log, hdr->ue_index);
+ log_call_append_cb(log, hdr.ue_index);
return (0);
err:
@@ -665,7 +910,7 @@ log_append_mbuf_typed_no_free(struct log *log, uint8_t module, uint8_t level,
uint16_t hdr_len;
int rc;
- /* Remove a loyer of indirection for convenience. */
+ /* Remove a layer of indirection for convenience. */
om = *om_ptr;
LOG_STATS_INC(log, writes);
@@ -932,6 +1177,20 @@ err:
return rc;
}
+/**
+ * Reads entry length from the specified log.
+ *
+ * @return The number of bytes of entry length; 0 on failure.
+ */
+uint16_t
+log_read_entry_len(struct log *log, const void *dptr)
+{
+ if (log->l_log->log_read_entry_len) {
+ return log->l_log->log_read_entry_len(log, dptr);
+ }
+ return 0;
+}
+
/**
* Reads from the specified log.
*
@@ -951,7 +1210,7 @@ log_read(struct log *log, const void *dptr, void *buf, uint16_t off,
int
log_read_hdr(struct log *log, const void *dptr, struct log_entry_hdr *hdr)
{
- int bytes_read;
+ int bytes_read = 0;
bytes_read = log_read(log, dptr, hdr, 0, LOG_BASE_ENTRY_HDR_SIZE);
if (bytes_read != LOG_BASE_ENTRY_HDR_SIZE) {
@@ -969,6 +1228,78 @@ log_read_hdr(struct log *log, const void *dptr, struct log_entry_hdr *hdr)
return 0;
}
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+static int
+log_tlv_exists(uint16_t tlv)
+{
+ switch (tlv) {
+#if MYNEWT_VAL(LOGS_TLV_NUM_ENTRIES)
+ case LOGS_TLV_NUM_ENTRIES:
+ return 0;
+#endif
+
+#if MYNEWT_VAL(LOG_TLV_NUM_TLVS)
+ case LOG_TLV_NUM_TLVS:
+ return 0;
+#endif
+ default:
+ return SYS_ENOTSUP;
+ }
+}
+#endif
+
+int
+log_read_trailer(struct log *log, const void *dptr, uint16_t tlv, void *buf)
+{
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ int rc;
+ struct log_entry_hdr hdr;
+ uint16_t entry_len;
+ uint8_t num_tlvs = 0;
+
+ if (!buf) {
+ return SYS_EINVAL;
+ }
+
+ rc = log_tlv_exists(tlv);
+ if (rc) {
+ return rc;
+ }
+
+ rc = log_read_hdr(log, dptr, &hdr);
+ if (rc) {
+ return rc;
+ }
+
+ if (hdr.ue_flags & LOG_FLAGS_TRAILER_SUPPORT) {
+ entry_len = log_read_entry_len(log, dptr);
+ if (tlv == LOG_TLV_NUM_TLVS) {
+ rc = log_process_tlvs(log, dptr, 0, LOG_TLV_NUM_TLVS, &num_tlvs,
+ entry_len);
+ if (rc) {
+ return rc;
+ }
+
+ memcpy(buf, &num_tlvs, LOG_NUM_TLVS_SIZE);
+ }
+
+ if (tlv == LOGS_TLV_NUM_ENTRIES) {
+ rc = log_process_tlvs(log, dptr, num_tlvs, LOGS_TLV_NUM_ENTRIES,
+ &hdr.ue_num_entries, entry_len);
+ if (rc) {
+ return rc;
+ }
+
+ memcpy(buf, &hdr.ue_num_entries, LOG_NUM_ENTRIES_SIZE);
+ }
+ }
+
+ return 0;
+#else
+ return SYS_ENOTSUP;
+#endif
+}
+
int
log_read_body(struct log *log, const void *dptr, void *buf, uint16_t off,
uint16_t len)
@@ -1019,6 +1350,8 @@ log_flush(struct log *log)
{
int rc;
+ log->l_num_entries = 0;
+
rc = log->l_log->log_flush(log);
if (rc != 0) {
goto err;
@@ -1107,6 +1440,48 @@ log_set_max_entry_len(struct log *log, uint16_t max_entry_len)
log->l_max_entry_len = max_entry_len;
}
+int
+log_fill_num_entries(struct log *log, const void *dptr, uint32_t *num_entries,
+ uint16_t offset)
+{
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT) && MYNEWT_VAL(LOGS_TLV_NUM_ENTRIES)
+ int rc = 0;
+ uint32_t tmpdata;
+
+ rc = log_read(log, dptr, &tmpdata, offset, LOG_NUM_ENTRIES_SIZE);
+ if (rc < LOG_NUM_ENTRIES_SIZE) {
+ return rc;
+ }
+
+ *num_entries = tmpdata;
+
+ return SYS_EOK;
+#else
+ return SYS_ENOTSUP;
+#endif
+}
+
+int
+log_fill_num_tlvs(struct log *log, const void *dptr, uint8_t *num_tlvs,
+ uint16_t offset)
+{
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT) && MYNEWT_VAL(LOG_TLV_NUM_TLVS)
+ int rc = 0;
+ uint32_t tmpdata;
+
+ rc = log_read(log, dptr, &tmpdata, offset, LOG_NUM_TLVS_SIZE);
+ if (rc < LOG_NUM_TLVS_SIZE) {
+ return rc;
+ }
+
+ *num_tlvs = tmpdata;
+
+ return SYS_EOK;
+#else
+ return SYS_ENOTSUP;
+#endif
+}
+
int
log_fill_current_img_hash(struct log_entry_hdr *hdr)
{
diff --git a/sys/log/full/src/log_cbmem.c b/sys/log/full/src/log_cbmem.c
index 02cd3503f..d43d79912 100644
--- a/sys/log/full/src/log_cbmem.c
+++ b/sys/log/full/src/log_cbmem.c
@@ -25,8 +25,14 @@ static int
log_cbmem_append_body(struct log *log, const struct log_entry_hdr *hdr,
const void *body, int body_len)
{
+ int rc = 0;
struct cbmem *cbmem;
- struct cbmem_scat_gath sg = {
+ uint8_t trailer[LOG_NUM_ENTRIES_SIZE] = {0};
+ uint16_t trailer_len = 0;
+ struct cbmem_scat_gath *sg = (struct cbmem_scat_gath *)&trailer[0];
+
+ trailer_len = log_trailer_len(log, hdr);
+ *sg = (struct cbmem_scat_gath) {
.entries = (struct cbmem_scat_gath_entry[]) {
{
.flat_buf = hdr,
@@ -40,21 +46,40 @@ log_cbmem_append_body(struct log *log, const struct log_entry_hdr *hdr,
.flat_buf = body,
.flat_len = body_len,
},
+ {
+ .flat_buf = trailer,
+ .flat_len = 0
+ }
},
- .count = 3,
+ .count = 4,
};
if (hdr->ue_flags & LOG_FLAGS_IMG_HASH) {
- sg.entries[1].flat_len = LOG_IMG_HASHLEN;
+ sg->entries[1].flat_len = LOG_IMG_HASHLEN;
+ }
+
+ if (hdr->ue_flags & LOG_FLAGS_TRAILER_SUPPORT) {
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ if (log->l_cbmem_trailer_append_cb) {
+ rc = log->l_cbmem_trailer_append_cb(log, trailer, trailer_len);
+ if (!rc) {
+ sg->count += ((trailer_len - sizeof(sg->count))/sizeof(sg->entries[0]));
+ sg->entries[3].flat_len = trailer_len;
+ }
+ }
+#endif
}
+
cbmem = (struct cbmem *) log->l_arg;
- return cbmem_append_scat_gath(cbmem, &sg);
+ rc = cbmem_append_scat_gath(cbmem, sg);
+
+ return rc;
}
static int
log_cbmem_append(struct log *log, void *buf, int len)
-{
+{
uint16_t hdr_len;
hdr_len = log_hdr_len(buf);
@@ -67,6 +92,7 @@ static int
log_cbmem_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
struct os_mbuf *om)
{
+ int rc = 0;
struct cbmem *cbmem;
struct cbmem_scat_gath sg = {
.entries = (struct cbmem_scat_gath_entry[]) {
@@ -88,9 +114,20 @@ log_cbmem_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
if (hdr->ue_flags & LOG_FLAGS_IMG_HASH) {
sg.entries[1].flat_len = LOG_IMG_HASHLEN;
}
+
+ if (hdr->ue_flags & LOG_FLAGS_TRAILER_SUPPORT) {
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ if (log->l_cbmem_trailer_mbuf_append_cb) {
+ log->l_cbmem_trailer_mbuf_append_cb(log, om);
+ }
+#endif
+ }
+
cbmem = (struct cbmem *) log->l_arg;
- return cbmem_append_scat_gath(cbmem, &sg);
+ rc = cbmem_append_scat_gath(cbmem, &sg);
+
+ return rc;
}
static int
@@ -110,25 +147,25 @@ log_cbmem_append_mbuf(struct log *log, struct os_mbuf *om)
* We do a pull up twice, once so that the base header is
* contiguous, so that we read the flags correctly, second
* time is so that we account for the image hash as well.
- */
+ */
os_mbuf_pullup(om, LOG_BASE_ENTRY_HDR_SIZE);
-
- /*
+
+ /*
* We can just pass the om->om_data ptr as the log_entry_hdr
* because the log_entry_hdr is a packed struct and does not
* cause any alignment or padding issues
- */
+ */
hdr_len = log_hdr_len((struct log_entry_hdr *)om->om_data);
-
+
os_mbuf_pullup(om, hdr_len);
-
+
memcpy(&hdr, om->om_data, hdr_len);
os_mbuf_adj(om, hdr_len);
rc = log_cbmem_append_mbuf_body(log, &hdr, om);
-
+
os_mbuf_prepend(om, hdr_len);
memcpy(om->om_data, &hdr, hdr_len);
@@ -136,6 +173,16 @@ log_cbmem_append_mbuf(struct log *log, struct os_mbuf *om)
return rc;
}
+static uint16_t
+log_cbmem_read_entry_len(struct log *log, const void *dptr)
+{
+ struct cbmem_entry_hdr *hdr;
+
+ hdr = (struct cbmem_entry_hdr *) dptr;
+
+ return hdr->ceh_len;
+}
+
static int
log_cbmem_read(struct log *log, const void *dptr, void *buf, uint16_t offset,
uint16_t len)
@@ -264,6 +311,7 @@ log_cbmem_storage_info(struct log *log, struct log_storage_info *info)
const struct log_handler log_cbmem_handler = {
.log_type = LOG_TYPE_MEMORY,
.log_read = log_cbmem_read,
+ .log_read_entry_len = log_cbmem_read_entry_len,
.log_read_mbuf = log_cbmem_read_mbuf,
.log_append = log_cbmem_append,
.log_append_body = log_cbmem_append_body,
diff --git a/sys/log/full/src/log_fcb.c b/sys/log/full/src/log_fcb.c
index 12b8cb060..e25bcd70f 100644
--- a/sys/log/full/src/log_fcb.c
+++ b/sys/log/full/src/log_fcb.c
@@ -26,6 +26,7 @@
#include "flash_map/flash_map.h"
#include "fcb/fcb.h"
#include "log/log.h"
+#include <console/console.h>
/* Assume the flash alignment requirement is no stricter than 32. */
#define LOG_FCB_MAX_ALIGN 32
@@ -277,20 +278,33 @@ err:
return (rc);
}
-/**
- * Calculates the number of message body bytes that should be included after
- * the entry header in the first write. Inclusion of body bytes is necessary
- * to satisfy the flash hardware's write alignment restrictions.
- */
static int
-log_fcb_hdr_body_bytes(uint8_t align, uint8_t hdr_len)
+log_fcb_write_mbuf(struct fcb_entry *loc, struct os_mbuf *om)
{
- uint8_t mod;
+ int rc;
+
+ while (om) {
+ rc = flash_area_write(loc->fe_area, loc->fe_data_off, om->om_data,
+ om->om_len);
+ if (rc != 0) {
+ return SYS_EIO;
+ }
+ loc->fe_data_off += om->om_len;
+ om = SLIST_NEXT(om, om_next);
+ }
+
+ return 0;
+}
+
+int
+log_fcb_hdr_trailer_bytes(uint16_t align, uint16_t len)
+{
+ uint16_t mod;
/* Assume power-of-two alignment for faster modulo calculation. */
assert((align & (align - 1)) == 0);
- mod = hdr_len & (align - 1);
+ mod = len & (align - 1);
if (mod == 0) {
return 0;
}
@@ -302,27 +316,35 @@ static int
log_fcb_append_body(struct log *log, const struct log_entry_hdr *hdr,
const void *body, int body_len)
{
- uint8_t buf[LOG_BASE_ENTRY_HDR_SIZE + LOG_IMG_HASHLEN +
- LOG_FCB_MAX_ALIGN - 1];
+ uint8_t buf[LOG_FCB_FLAT_BUF_SIZE] = {0};
struct fcb *fcb;
struct fcb_entry loc;
struct fcb_log *fcb_log;
const uint8_t *u8p;
int hdr_alignment;
- int chunk_sz;
+ int trailer_alignment = 0;
+ int chunk_sz = 0;
int rc;
uint16_t hdr_len;
+ uint16_t trailer_len;
+ uint16_t padding = 0;
+ uint16_t offset = 0;
fcb_log = (struct fcb_log *)log->l_arg;
fcb = &fcb_log->fl_fcb;
+ (void)offset;
+ (void)padding;
+ (void)trailer_alignment;
+
if (fcb->f_align > LOG_FCB_MAX_ALIGN) {
return SYS_ENOTSUP;
}
hdr_len = log_hdr_len(hdr);
+ trailer_len = log_trailer_len(log, hdr);
- rc = log_fcb_start_append(log, hdr_len + body_len, &loc);
+ rc = log_fcb_start_append(log, hdr_len + body_len + trailer_len, &loc);
if (rc != 0) {
return rc;
}
@@ -332,7 +354,7 @@ log_fcb_append_body(struct log *log, const struct log_entry_hdr *hdr,
* the flash alignment). If the hash flag is set, we have to account for
* appending the hash right after the header.
*/
- hdr_alignment = log_fcb_hdr_body_bytes(fcb->f_align, hdr_len);
+ hdr_alignment = log_fcb_hdr_trailer_bytes(fcb->f_align, hdr_len);
if (hdr_alignment > body_len) {
chunk_sz = hdr_len + body_len;
} else {
@@ -350,6 +372,7 @@ log_fcb_append_body(struct log *log, const struct log_entry_hdr *hdr,
if (hdr->ue_flags & LOG_FLAGS_IMG_HASH) {
memcpy(buf + LOG_BASE_ENTRY_HDR_SIZE, hdr->ue_imghash, LOG_IMG_HASHLEN);
}
+
memcpy(buf + hdr_len, u8p, hdr_alignment);
rc = fcb_write(fcb, &loc, buf, chunk_sz);
@@ -357,15 +380,70 @@ log_fcb_append_body(struct log *log, const struct log_entry_hdr *hdr,
return rc;
}
+ loc.fe_data_off += chunk_sz;
+
/* Append the remainder of the message body. */
u8p += hdr_alignment;
body_len -= hdr_alignment;
- if (body_len > 0) {
- rc = fcb_write(fcb, &loc, u8p, body_len);
- if (rc != 0) {
- return rc;
+ if (hdr->ue_flags & LOG_FLAGS_TRAILER_SUPPORT) {
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ /* This writes padding + trailer_alignment */
+
+ /* Calculate trailer alignment */
+ trailer_alignment = log_fcb_hdr_trailer_bytes(fcb->f_align, chunk_sz + body_len);
+
+ if (body_len > 0) {
+ padding = trailer_alignment ? fcb->f_align - trailer_alignment : 0;
+ /* Writes body - padding bytes */
+ rc = flash_area_write(loc.fe_area, loc.fe_data_off, u8p,
+ body_len - padding);
+ if (rc != 0) {
+ return rc;
+ }
+
+ loc.fe_data_off += body_len - padding;
+
+ u8p = u8p + body_len - padding;
+ memset(buf, 0, sizeof(buf));
+ memcpy(buf, u8p, padding);
+ offset = padding;
+ offset += trailer_alignment;
+ /* Writes the following:
+ * -----------------------------------------------------------------
+ * | body: body_len - padding from end of body | trailer_alignment |
+ * -----------------------------------------------------------------
+ */
+ rc = flash_area_write(loc.fe_area, loc.fe_data_off, buf, offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ loc.fe_data_off += offset;
+
+ /* The first trailer gets appended after the padding + trailer_alignment
+ * Trailers start from updated loc.fe_data_off.
+ */
+ rc = log_trailer_append(log, buf, trailer_len, &loc);
+ if (rc && rc != SYS_ENOTSUP) {
+ return rc;
+ }
+ }
+#else
+ if (body_len > 0) {
+ rc = flash_area_write(loc.fe_area, loc.fe_data_off, u8p, body_len);
+ if (rc != 0) {
+ return rc;
+ }
+ }
+#endif
+ } else {
+ if (body_len > 0) {
+ rc = flash_area_write(loc.fe_area, loc.fe_data_off, u8p, body_len);
+ if (rc != 0) {
+ return rc;
+ }
}
}
@@ -388,25 +466,6 @@ log_fcb_append(struct log *log, void *buf, int len)
len - hdr_len);
}
-static int
-log_fcb_write_mbuf(struct fcb_entry *loc, struct os_mbuf *om)
-{
- int rc;
-
- while (om) {
- rc = flash_area_write(loc->fe_area, loc->fe_data_off, om->om_data,
- om->om_len);
- if (rc != 0) {
- return SYS_EIO;
- }
-
- loc->fe_data_off += om->om_len;
- om = SLIST_NEXT(om, om_next);
- }
-
- return 0;
-}
-
static int
log_fcb_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
struct os_mbuf *om)
@@ -427,7 +486,7 @@ log_fcb_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
return SYS_ENOTSUP;
}
- len = log_hdr_len(hdr) + os_mbuf_len(om);
+ len = log_hdr_len(hdr) + os_mbuf_len(om) + log_trailer_len(log, hdr);
rc = log_fcb_start_append(log, len, &loc);
if (rc != 0) {
return rc;
@@ -449,9 +508,23 @@ log_fcb_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
}
loc.fe_data_off += LOG_IMG_HASHLEN;
}
- rc = log_fcb_write_mbuf(&loc, om);
- if (rc != 0) {
- return rc;
+
+ if (hdr->ue_flags & LOG_FLAGS_TRAILER_SUPPORT) {
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ /* The first TLV gets appended after the padding + trailer_alignment
+ * Trailers start from updated loc.fe_data_off. Write everything
+ * together
+ */
+ rc = log_mbuf_trailer_append(log, om, &loc);
+ if (rc && rc != SYS_ENOTSUP) {
+ return rc;
+ }
+#endif
+ } else {
+ rc = log_fcb_write_mbuf(&loc, om);
+ if (rc != 0) {
+ return rc;
+ }
}
rc = fcb_append_finish(fcb, &loc);
@@ -504,6 +577,20 @@ log_fcb_append_mbuf(struct log *log, struct os_mbuf *om)
return rc;
}
+static uint16_t
+log_fcb_read_entry_len(struct log *log, const void *dptr)
+{
+ struct fcb_entry *loc;
+
+ loc = (struct fcb_entry *)dptr;
+
+ if (!log || !dptr) {
+ return 0;
+ }
+
+ return loc->fe_data_len;
+}
+
static int
log_fcb_read(struct log *log, const void *dptr, void *buf, uint16_t offset,
uint16_t len)
@@ -801,6 +888,18 @@ log_fcb_new_watermark_index(struct log *log, struct log_offset *log_offset,
}
}
+static int
+log_fcb_len_in_medium(struct log *log, uint16_t len)
+{
+ struct fcb_log *fl;
+ struct fcb *fcb;
+
+ fl = (struct fcb_log *)log->l_arg;
+ fcb = &fl->fl_fcb;
+
+ return fcb_len_in_flash(fcb, len);
+}
+
static int
log_fcb_set_watermark(struct log *log, uint32_t index)
{
@@ -848,8 +947,8 @@ log_fcb_copy_entry(struct log *log, struct fcb_entry *entry,
struct fcb *dst_fcb)
{
struct log_entry_hdr ueh;
- char data[MYNEWT_VAL(LOG_FCB_COPY_MAX_ENTRY_LEN) + LOG_BASE_ENTRY_HDR_SIZE +
- LOG_IMG_HASHLEN];
+ char data[MYNEWT_VAL(LOG_FCB_COPY_MAX_ENTRY_LEN) +
+ LOG_BASE_ENTRY_HDR_SIZE + LOG_IMG_HASHLEN];
uint16_t hdr_len;
int dlen;
int rc;
@@ -862,7 +961,6 @@ log_fcb_copy_entry(struct log *log, struct fcb_entry *entry,
}
hdr_len = log_hdr_len(&ueh);
-
dlen = min(entry->fe_data_len, MYNEWT_VAL(LOG_FCB_COPY_MAX_ENTRY_LEN) +
hdr_len);
@@ -988,23 +1086,25 @@ err:
}
const struct log_handler log_fcb_handler = {
- .log_type = LOG_TYPE_STORAGE,
- .log_read = log_fcb_read,
- .log_read_mbuf = log_fcb_read_mbuf,
- .log_append = log_fcb_append,
- .log_append_body = log_fcb_append_body,
- .log_append_mbuf = log_fcb_append_mbuf,
+ .log_type = LOG_TYPE_STORAGE,
+ .log_read = log_fcb_read,
+ .log_read_mbuf = log_fcb_read_mbuf,
+ .log_append = log_fcb_append,
+ .log_append_body = log_fcb_append_body,
+ .log_append_mbuf = log_fcb_append_mbuf,
.log_append_mbuf_body = log_fcb_append_mbuf_body,
- .log_walk = log_fcb_walk,
- .log_walk_sector = log_fcb_walk_area,
- .log_flush = log_fcb_flush,
+ .log_walk = log_fcb_walk,
+ .log_walk_sector = log_fcb_walk_area,
+ .log_flush = log_fcb_flush,
+ .log_read_entry_len = log_fcb_read_entry_len,
#if MYNEWT_VAL(LOG_STORAGE_INFO)
- .log_storage_info = log_fcb_storage_info,
+ .log_storage_info = log_fcb_storage_info,
#endif
#if MYNEWT_VAL(LOG_STORAGE_WATERMARK)
- .log_set_watermark = log_fcb_set_watermark,
+ .log_set_watermark = log_fcb_set_watermark,
+ .log_len_in_medium = log_fcb_len_in_medium,
#endif
- .log_registered = log_fcb_registered,
+ .log_registered = log_fcb_registered,
};
#endif
diff --git a/sys/log/full/src/log_fcb2.c b/sys/log/full/src/log_fcb2.c
index b307acfe9..3264752a2 100644
--- a/sys/log/full/src/log_fcb2.c
+++ b/sys/log/full/src/log_fcb2.c
@@ -202,14 +202,14 @@ err:
* to satisfy the flash hardware's write alignment restrictions.
*/
static int
-log_fcb2_hdr_body_bytes(uint8_t align, uint8_t hdr_len)
+log_fcb2_hdr_body_bytes(uint16_t align, uint16_t len)
{
- uint8_t mod;
+ uint16_t mod;
/* Assume power-of-two alignment for faster modulo calculation. */
assert((align & (align - 1)) == 0);
- mod = hdr_len & (align - 1);
+ mod = len & (align - 1);
if (mod == 0) {
return 0;
}
@@ -217,22 +217,44 @@ log_fcb2_hdr_body_bytes(uint8_t align, uint8_t hdr_len)
return align - mod;
}
+static int
+log_fcb2_write_mbuf(struct fcb2_entry *loc, struct os_mbuf *om, int off)
+{
+ int rc;
+
+ while (om) {
+ rc = fcb2_write(loc, off, om->om_data, om->om_len);
+ if (rc != 0) {
+ return SYS_EIO;
+ }
+
+ off += om->om_len;
+ om = SLIST_NEXT(om, om_next);
+ }
+
+ return SYS_EOK;
+}
+
static int
log_fcb2_append_body(struct log *log, const struct log_entry_hdr *hdr,
const void *body, int body_len)
{
- uint8_t buf[LOG_BASE_ENTRY_HDR_SIZE + LOG_IMG_HASHLEN +
- LOG_FCB2_MAX_ALIGN - 1];
+ uint8_t buf[LOG_FCB_FLAT_BUF_SIZE] = {0};
struct fcb2_entry loc;
const uint8_t *u8p;
int hdr_alignment;
- int chunk_sz;
+ int trailer_alignment = 0;
+ uint16_t chunk_sz = 0;
int rc;
uint16_t hdr_len;
+ uint16_t trailer_len;
hdr_len = log_hdr_len(hdr);
+ trailer_len = log_trailer_len(log, hdr);
- rc = log_fcb2_start_append(log, hdr_len + body_len, &loc);
+ (void)trailer_alignment;
+
+ rc = log_fcb2_start_append(log, hdr_len + body_len + trailer_len, &loc);
if (rc != 0) {
return rc;
}
@@ -271,11 +293,63 @@ log_fcb2_append_body(struct log *log, const struct log_entry_hdr *hdr,
u8p += hdr_alignment;
body_len -= hdr_alignment;
+ if (hdr->ue_flags & LOG_FLAGS_TRAILER_SUPPORT) {
+ memset(buf, 0, sizeof(buf));
+ /* Calculate trailer alignment */
+ trailer_alignment = log_fcb2_hdr_body_bytes(loc.fe_range->fsr_align, chunk_sz + body_len);
+
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ uint16_t offset = 0;
+ uint16_t padding = 0;
+
+ if (body_len > 0) {
+ padding = trailer_alignment ? loc.fe_range->fsr_align - trailer_alignment : 0;
+ rc = fcb2_write(&loc, chunk_sz, u8p, body_len - padding);
+ if (rc != 0) {
+ return rc;
+ }
- if (body_len > 0) {
- rc = fcb2_write(&loc, chunk_sz, u8p, body_len);
- if (rc != 0) {
- return rc;
+ chunk_sz += body_len - padding;
+
+ u8p = u8p + body_len - padding;
+ memcpy(buf, u8p, padding);
+ offset = padding;
+ offset += trailer_alignment;
+ /* Writes the following:
+ * -----------------------------------------------------------------
+ * | body: body_len - padding from end of body | trailer_alignment |
+ * -----------------------------------------------------------------
+ */
+ rc = fcb2_write(&loc, chunk_sz, buf, offset);
+ if (rc != 0) {
+ return rc;
+ }
+
+ chunk_sz += offset;
+ /* The first TLV gets appended after the padding + trailer_alignment
+ * Trailers start from updated chunk_sz offset.
+ */
+ rc = log_fcb2_tlvs_write(log, buf, sizeof(buf), &loc, &chunk_sz);
+ if (rc) {
+ return rc;
+ }
+ }
+#else
+ if (body_len > 0) {
+ rc = fcb2_write(&loc, chunk_sz, u8p, body_len);
+ if (rc != 0) {
+ return rc;
+ }
+ chunk_sz += body_len;
+ }
+#endif
+ } else {
+ if (body_len > 0) {
+ rc = fcb2_write(&loc, chunk_sz, u8p, body_len);
+ if (rc != 0) {
+ return rc;
+ }
+ chunk_sz += body_len;
}
}
@@ -298,24 +372,6 @@ log_fcb2_append(struct log *log, void *buf, int len)
len - hdr_len);
}
-static int
-log_fcb2_write_mbuf(struct fcb2_entry *loc, struct os_mbuf *om, int off)
-{
- int rc;
-
- while (om) {
- rc = fcb2_write(loc, off, om->om_data, om->om_len);
- if (rc != 0) {
- return SYS_EIO;
- }
-
- off += om->om_len;
- om = SLIST_NEXT(om, om_next);
- }
-
- return 0;
-}
-
static int
log_fcb2_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
struct os_mbuf *om)
@@ -336,7 +392,7 @@ log_fcb2_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
}
#endif
- len = log_hdr_len(hdr) + os_mbuf_len(om);
+ len = log_hdr_len(hdr) + os_mbuf_len(om) + log_trailer_len(log, hdr);
rc = log_fcb2_start_append(log, len, &loc);
if (rc != 0) {
return rc;
@@ -356,9 +412,23 @@ log_fcb2_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
}
len += LOG_IMG_HASHLEN;
}
- rc = log_fcb2_write_mbuf(&loc, om, len);
- if (rc != 0) {
- return rc;
+
+ if (hdr->ue_flags & LOG_FLAGS_TRAILER_SUPPORT) {
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ /* The first TLV gets appended after the padding + trailer_alignment
+ * Trailers start from updated loc.fe_data_off. Write everything
+ * together
+ */
+ rc = log_fcb2_mbuf_tlvs_write(log, om, &loc, len);
+ if (rc != 0) {
+ return rc;
+ }
+#endif
+ } else {
+ rc = log_fcb2_write_mbuf(&loc, om, len);
+ if (rc != 0) {
+ return rc;
+ }
}
rc = fcb2_append_finish(&loc);
@@ -369,6 +439,18 @@ log_fcb2_append_mbuf_body(struct log *log, const struct log_entry_hdr *hdr,
return 0;
}
+static int
+log_fcb2_len_in_medium(struct log *log, uint16_t len)
+{
+ struct fcb_log *fl;
+ struct fcb2 *fcb;
+
+ fl = (struct fcb_log *)log->l_arg;
+ fcb = &fl->fl_fcb;
+
+ return fcb2_len_in_flash(fcb->f_active.fe_range, len);
+}
+
static int
log_fcb2_append_mbuf(struct log *log, struct os_mbuf *om)
{
@@ -411,6 +493,20 @@ log_fcb2_append_mbuf(struct log *log, struct os_mbuf *om)
return rc;
}
+static uint16_t
+log_fcb2_read_entry_len(struct log *log, const void *dptr)
+{
+ struct fcb2_entry *loc;
+
+ loc = (struct fcb2_entry *)dptr;
+
+ if (!log || !dptr) {
+ return 0;
+ }
+
+ return loc->fe_data_len;
+}
+
static int
log_fcb2_read(struct log *log, const void *dptr, void *buf, uint16_t off, uint16_t len)
{
@@ -895,6 +991,8 @@ const struct log_handler log_fcb_handler = {
.log_append_mbuf_body = log_fcb2_append_mbuf_body,
.log_walk = log_fcb2_walk,
.log_flush = log_fcb2_flush,
+ .log_read_entry_len = log_fcb2_read_entry_len,
+ .log_len_in_medium = log_fcb2_len_in_medium,
#if MYNEWT_VAL(LOG_STORAGE_INFO)
.log_storage_info = log_fcb2_storage_info,
#endif
diff --git a/sys/log/full/src/log_shell.c b/sys/log/full/src/log_shell.c
index a10c08eb1..257233b2a 100644
--- a/sys/log/full/src/log_shell.c
+++ b/sys/log/full/src/log_shell.c
@@ -88,6 +88,15 @@ shell_log_dump_entry(struct log *log, struct log_offset *log_offset,
bool read_hash = ueh->ue_flags & LOG_FLAGS_IMG_HASH;
bool add_lf = true;
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT) && MYNEWT_VAL(LOGS_TLV_NUM_ENTRIES)
+ bool read_num_entries = ueh->ue_flags & LOG_FLAGS_TRAILER_SUPPORT;
+#else
+ bool read_num_entries = false;
+#endif
+ uint32_t entries = 0;
+
+ dlen = min(len, 128);
+
if (arg) {
arg->count++;
/* Continue walk if number of entries to skip not reached yet */
@@ -96,9 +105,17 @@ shell_log_dump_entry(struct log *log, struct log_offset *log_offset,
}
}
- dlen = min(len, 128);
-
if (read_data) {
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ dlen -= log_len_in_medium(log, sizeof(struct log_tlv));
+
+ rc = log_read_trailer(log, dptr, LOGS_TLV_NUM_ENTRIES, &entries);
+ if (!rc) {
+ dlen -= log_len_in_medium(log, LOG_NUM_ENTRIES_SIZE);
+ } else {
+ console_printf("failed to read trailer\n");
+ }
+#endif
rc = log_read_body(log, dptr, data, 0, dlen);
if (rc < 0) {
return rc;
@@ -118,6 +135,17 @@ shell_log_dump_entry(struct log *log, struct log_offset *log_offset,
console_printf(" [%llu] ", ueh->ue_ts);
}
+ if (read_num_entries) {
+#if MYNEWT_VAL(LOG_FLAGS_TRAILER_SUPPORT)
+ dlen -= log_len_in_medium(log, sizeof(struct log_tlv));
+ rc = log_read_trailer(log, dptr, LOGS_TLV_NUM_ENTRIES, &entries);
+ if (!rc) {
+ dlen -= log_len_in_medium(log, LOG_NUM_ENTRIES_SIZE);
+ }
+#endif
+ console_printf("[ne=%u]", (unsigned int)entries);
+ }
+ console_printf(" [%llu] ", ueh->ue_ts);
#if MYNEWT_VAL(LOG_SHELL_SHOW_INDEX)
console_printf(" [ix=%lu] ", ueh->ue_index);
#endif
@@ -173,6 +201,8 @@ shell_log_dump_cmd(int argc, char **argv)
bool reverse = false;
bool dump_logs = true;
struct walk_arg arg = {};
+ bool num_entries = false;
+ uint32_t entries;
int i;
int rc;
@@ -216,6 +246,16 @@ shell_log_dump_cmd(int argc, char **argv)
/* the -c option is to clear a log (or logs). */
if (!strcmp(argv[i], "-c")) {
clear_log = true;
+ } else if (argc == 3 && !strcmp(argv[i], "-ne")) {
+ num_entries = true;
+ log_name = argv[i+1];
+ break;
+ } else if (argc == 5 && !strcmp(argv[i], "-ne") &&
+ !strcmp(argv[i+2], "-i")) {
+ num_entries = true;
+ log_name = argv[i+1];
+ log_limit = parse_ll_bounds(argv[i+3], 1, 1000000, &rc);
+ break;
} else if (isdigit((unsigned char)argv[i][0])) {
log_limit = parse_ll_bounds(argv[i], 1, 1000000, &rc);
if (clear_log) {
@@ -257,6 +297,13 @@ shell_log_dump_cmd(int argc, char **argv)
if (rc != 0) {
goto err;
}
+ } else if (num_entries) {
+ rc = log_get_entries(log, log_limit, &entries);
+ if (!rc) {
+ console_printf("entries: %u\n", (unsigned int)entries);
+ } else {
+ console_printf("Invalid or empty log, rc=%d!\n", rc);
+ }
} else {
if (dump_logs) {
console_printf("Dumping log %s\n", log->l_name);
diff --git a/sys/log/full/syscfg.yml b/sys/log/full/syscfg.yml
index dc35b6c54..b245825c9 100644
--- a/sys/log/full/syscfg.yml
+++ b/sys/log/full/syscfg.yml
@@ -58,6 +58,12 @@ syscfg.defs:
1 - enable.
value: 0
+ LOG_FLAGS_TRAILER_SUPPORT:
+ description: >
+ Enable logging TLV with custom data types in every log entry
+ 0 - disable; 1 - enable.
+ value: 0
+
LOG_FCB:
description: 'Support logging to FCB.'
value: 0