From cd70e6ce8bc1bc3d4a000fd310f7853fb86ed07b Mon Sep 17 00:00:00 2001
From: Giovanni Di Sirio <gdisirio@gmail.com>
Date: Sun, 14 Apr 2019 10:56:33 +0000
Subject: Re-merged MFS from trunk.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/branches/stable_19.1.x@12742 27425a3e-05d8-49a3-a47f-9c15f0e5edd8
---
 os/hal/lib/complex/mfs/hal_mfs.c             | 61 ++++++++++++++--------------
 os/hal/lib/complex/mfs/hal_mfs.h             | 15 ++++---
 test/mfs/configuration.xml                   | 47 ++++++++++++---------
 test/mfs/source/test/mfs_test_sequence_001.c | 36 +++++++++-------
 test/mfs/source/test/mfs_test_sequence_002.c |  3 +-
 5 files changed, 93 insertions(+), 69 deletions(-)

diff --git a/os/hal/lib/complex/mfs/hal_mfs.c b/os/hal/lib/complex/mfs/hal_mfs.c
index 2687fa8f8..f6e596e57 100644
--- a/os/hal/lib/complex/mfs/hal_mfs.c
+++ b/os/hal/lib/complex/mfs/hal_mfs.c
@@ -472,7 +472,8 @@ static mfs_error_t mfs_bank_scan_records(MFSDriver *mfsp,
     }
 
     /* It is not erased so checking for integrity.*/
-    if ((u.dhdr.fields.magic != MFS_HEADER_MAGIC) ||
+    if ((u.dhdr.fields.magic1 != MFS_HEADER_MAGIC_1) ||
+        (u.dhdr.fields.magic2 != MFS_HEADER_MAGIC_2) ||
         (u.dhdr.fields.id < 1U) ||
         (u.dhdr.fields.id > (uint32_t)MFS_CFG_MAX_RECORDS) ||
         (u.dhdr.fields.size > end_offset - hdr_offset)) {
@@ -1037,14 +1038,13 @@ mfs_error_t mfsWriteRecord(MFSDriver *mfsp, mfs_id_t id,
     }
 
     /* Writing the data header without the magic, it will be written last.*/
-    mfsp->buffer.dhdr.fields.magic = (uint32_t)mfsp->config->erased;
-    mfsp->buffer.dhdr.fields.id    = (uint16_t)id;
-    mfsp->buffer.dhdr.fields.size  = (uint32_t)n;
-    mfsp->buffer.dhdr.fields.crc   = crc16(0xFFFFU, buffer, n);
+    mfsp->buffer.dhdr.fields.id     = (uint16_t)id;
+    mfsp->buffer.dhdr.fields.size   = (uint32_t)n;
+    mfsp->buffer.dhdr.fields.crc    = crc16(0xFFFFU, buffer, n);
     RET_ON_ERROR(mfs_flash_write(mfsp,
-                                 mfsp->next_offset,
-                                 sizeof (mfs_data_header_t),
-                                 mfsp->buffer.data8));
+                                 mfsp->next_offset + (sizeof (uint32_t) * 2U),
+                                 sizeof (mfs_data_header_t) - (sizeof (uint32_t) * 2U),
+                                 mfsp->buffer.data8 + (sizeof (uint32_t) * 2U)));
 
     /* Writing the data part.*/
     RET_ON_ERROR(mfs_flash_write(mfsp,
@@ -1053,10 +1053,11 @@ mfs_error_t mfsWriteRecord(MFSDriver *mfsp, mfs_id_t id,
                                  buffer));
 
     /* Finally writing the magic number, it seals the operation.*/
-    mfsp->buffer.dhdr.fields.magic = (uint32_t)MFS_HEADER_MAGIC;
+    mfsp->buffer.dhdr.fields.magic1 = (uint32_t)MFS_HEADER_MAGIC_1;
+    mfsp->buffer.dhdr.fields.magic2 = (uint32_t)MFS_HEADER_MAGIC_2;
     RET_ON_ERROR(mfs_flash_write(mfsp,
                                  mfsp->next_offset,
-                                 sizeof (uint32_t),
+                                 sizeof (uint32_t) * 2U,
                                  mfsp->buffer.data8));
 
     /* The size of the old record instance, if present, must be subtracted
@@ -1093,14 +1094,13 @@ mfs_error_t mfsWriteRecord(MFSDriver *mfsp, mfs_id_t id,
     }
 
     /* Writing the data header without the magic, it will be written last.*/
-    mfsp->buffer.dhdr.fields.magic = (uint32_t)mfsp->config->erased;
-    mfsp->buffer.dhdr.fields.id    = (uint16_t)id;
-    mfsp->buffer.dhdr.fields.size  = (uint32_t)n;
-    mfsp->buffer.dhdr.fields.crc   = crc16(0xFFFFU, buffer, n);
+    mfsp->buffer.dhdr.fields.id     = (uint16_t)id;
+    mfsp->buffer.dhdr.fields.size   = (uint32_t)n;
+    mfsp->buffer.dhdr.fields.crc    = crc16(0xFFFFU, buffer, n);
     RET_ON_ERROR(mfs_flash_write(mfsp,
-                                 mfsp->tr_next_offset,
-                                 sizeof (mfs_data_header_t),
-                                 mfsp->buffer.data8));
+                                 mfsp->tr_next_offset + (sizeof (uint32_t) * 2U),
+                                 sizeof (mfs_data_header_t) - (sizeof (uint32_t) * 2U),
+                                 mfsp->buffer.data8 + (sizeof (uint32_t) * 2U)));
 
     /* Writing the data part.*/
     RET_ON_ERROR(mfs_flash_write(mfsp,
@@ -1189,10 +1189,11 @@ mfs_error_t mfsEraseRecord(MFSDriver *mfsp, mfs_id_t id) {
 
     /* Writing the data header with size set to zero, it means that the
        record is logically erased.*/
-    mfsp->buffer.dhdr.fields.magic = (uint32_t)MFS_HEADER_MAGIC;
-    mfsp->buffer.dhdr.fields.id    = (uint16_t)id;
-    mfsp->buffer.dhdr.fields.size  = (uint32_t)0;
-    mfsp->buffer.dhdr.fields.crc   = (uint16_t)0xFFFF;
+    mfsp->buffer.dhdr.fields.magic1 = (uint32_t)MFS_HEADER_MAGIC_1;
+    mfsp->buffer.dhdr.fields.magic2 = (uint32_t)MFS_HEADER_MAGIC_2;
+    mfsp->buffer.dhdr.fields.id     = (uint16_t)id;
+    mfsp->buffer.dhdr.fields.size   = (uint32_t)0;
+    mfsp->buffer.dhdr.fields.crc    = (uint16_t)0xFFFF;
     RET_ON_ERROR(mfs_flash_write(mfsp,
                                  mfsp->next_offset,
                                  sizeof (mfs_data_header_t),
@@ -1232,14 +1233,13 @@ mfs_error_t mfsEraseRecord(MFSDriver *mfsp, mfs_id_t id) {
 
     /* Writing the data header with size set to zero, it means that the
        record is logically erased. Note, the magic number is not set.*/
-    mfsp->buffer.dhdr.fields.magic = mfsp->config->erased;
-    mfsp->buffer.dhdr.fields.id    = (uint16_t)id;
-    mfsp->buffer.dhdr.fields.size  = (uint32_t)0;
-    mfsp->buffer.dhdr.fields.crc   = (uint16_t)0xFFFF;
+    mfsp->buffer.dhdr.fields.id     = (uint16_t)id;
+    mfsp->buffer.dhdr.fields.size   = (uint32_t)0;
+    mfsp->buffer.dhdr.fields.crc    = (uint16_t)0xFFFF;
     RET_ON_ERROR(mfs_flash_write(mfsp,
-                                 mfsp->next_offset,
-                                 sizeof (mfs_data_header_t),
-                                 mfsp->buffer.data8));
+                                 mfsp->tr_next_offset + (sizeof (uint32_t) * 2U),
+                                 sizeof (mfs_data_header_t) - (sizeof (uint32_t) * 2U),
+                                 mfsp->buffer.data8 + (sizeof (uint32_t) * 2U)));
 
     /* Adding a transaction operation record.*/
     top = &mfsp->tr_ops[mfsp->tr_nops];
@@ -1385,7 +1385,8 @@ mfs_error_t mfsCommitTransaction(MFSDriver *mfsp) {
   }
 
   /* Scanning all buffered operations in reverse order.*/
-  mfsp->buffer.dhdr.fields.magic = (uint32_t)MFS_HEADER_MAGIC;
+  mfsp->buffer.dhdr.fields.magic1 = (uint32_t)MFS_HEADER_MAGIC_1;
+  mfsp->buffer.dhdr.fields.magic2 = (uint32_t)MFS_HEADER_MAGIC_2;
   top = &mfsp->tr_ops[mfsp->tr_nops];
   while (top > &mfsp->tr_ops[0]) {
     /* On the previous element.*/
@@ -1394,7 +1395,7 @@ mfs_error_t mfsCommitTransaction(MFSDriver *mfsp) {
     /* Finalizing the operation by writing the magic number.*/
     RET_ON_ERROR(mfs_flash_write(mfsp,
                                  top->offset,
-                                 sizeof (uint32_t),
+                                 sizeof (uint32_t) * 2U,
                                  mfsp->buffer.data8));
   }
 
diff --git a/os/hal/lib/complex/mfs/hal_mfs.h b/os/hal/lib/complex/mfs/hal_mfs.h
index 14dfc75ee..43ffcbd47 100644
--- a/os/hal/lib/complex/mfs/hal_mfs.h
+++ b/os/hal/lib/complex/mfs/hal_mfs.h
@@ -36,7 +36,8 @@
 
 #define MFS_BANK_MAGIC_1                    0xEC705ADEU
 #define MFS_BANK_MAGIC_2                    0xF0339CC5U
-#define MFS_HEADER_MAGIC                    0x5FAE45F0U
+#define MFS_HEADER_MAGIC_1                  0x5FAE45F0U
+#define MFS_HEADER_MAGIC_2                  0xF045AE5FU
 
 /*===========================================================================*/
 /* Driver pre-compile time settings.                                         */
@@ -240,9 +241,13 @@ typedef union {
 typedef union {
   struct {
     /**
-     * @brief   Data header magic.
+     * @brief   Data header magic 1.
      */
-    uint32_t                magic;
+    uint32_t                magic1;
+    /**
+     * @brief   Data header magic 2.
+     */
+    uint32_t                magic2;
     /**
      * @brief   Record identifier.
      */
@@ -257,8 +262,8 @@ typedef union {
      */
     uint32_t                size;
   } fields;
-  uint8_t                   hdr8[12];
-  uint32_t                  hdr32[3];
+  uint8_t                   hdr8[16];
+  uint32_t                  hdr32[4];
 } mfs_data_header_t;
 
 typedef struct {
diff --git a/test/mfs/configuration.xml b/test/mfs/configuration.xml
index 070066b52..089f95f10 100644
--- a/test/mfs/configuration.xml
+++ b/test/mfs/configuration.xml
@@ -533,8 +533,9 @@ mfsErase(&mfs1);]]></value>
                     </tags>
                     <code>
                       <value><![CDATA[mfs_id_t id;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                  (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
+                  (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
 for (id = 1; id <= id_max; id++) {
   mfs_error_t err;
@@ -562,8 +563,9 @@ for (id = 1; id <= id_max; id++) {
                     </tags>
                     <code>
                       <value><![CDATA[mfs_error_t err;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                  (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
+                  (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
 err = mfsWriteRecord(&mfs1, id_max, sizeof mfs_pattern512 , mfs_pattern512);
 test_assert(err == MFS_ERR_OUT_OF_MEM, "creation didn't fail");]]></value>
@@ -644,8 +646,9 @@ mfsErase(&mfs1);]]></value>
                     </tags>
                     <code>
                       <value><![CDATA[mfs_id_t id;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                  (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
+                  (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
 for (id = 1; id <= id_max; id++) {
   mfs_error_t err;
@@ -716,8 +719,9 @@ test_assert(bank_verify_erased(MFS_BANK_0) == FLASH_NO_ERROR, "bank 0 not erased
                     </tags>
                     <code>
                       <value><![CDATA[mfs_id_t id;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                  (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
+                  (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
 for (id = 1; id <= MFS_CFG_MAX_RECORDS; id++) {
   mfs_error_t err;
@@ -791,7 +795,8 @@ test_assert(bank_verify_erased(MFS_BANK_1) == FLASH_NO_ERROR, "bank 1 not erased
                     </tags>
                     <code>
                       <value><![CDATA[mfs_id_t id;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
                   (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
 for (id = 1; id <= MFS_CFG_MAX_RECORDS; id++) {
@@ -848,19 +853,20 @@ mfsErase(&mfs1);]]></value>
                     </tags>
                     <code>
                       <value><![CDATA[mfs_id_t id;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                  (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 2));
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
+                  (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 4));
 
 for (id = 1; id <= id_max; id++) {
   mfs_error_t err;
   size_t size;
 
-  err = mfsWriteRecord(&mfs1, id, (sizeof mfs_pattern512 / 2), mfs_pattern512);
+  err = mfsWriteRecord(&mfs1, id, (sizeof mfs_pattern512 / 4), mfs_pattern512);
   test_assert(err == MFS_NO_ERROR, "error creating the record");
   size = sizeof mfs_buffer;
   err = mfsReadRecord(&mfs1, id, &size, mfs_buffer);
   test_assert(err == MFS_NO_ERROR, "record not found");
-  test_assert(size == (sizeof mfs_pattern512 / 2), "unexpected record length");
+  test_assert(size == (sizeof mfs_pattern512 / 4), "unexpected record length");
   test_assert(memcmp(mfs_pattern512, mfs_buffer, size) == 0,
               "wrong record content");
 }]]></value>
@@ -877,10 +883,11 @@ for (id = 1; id <= id_max; id++) {
                       <value><![CDATA[mfs_error_t err;
 size_t size;
 mfs_id_t id;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                  (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 2));
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
+                  (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 4));
 mfs_id_t n = ((mfscfg1.bank_size - sizeof (mfs_bank_header_t)) -
-              (id_max * (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 2)))) /
+              (id_max * (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 4)))) /
              sizeof (mfs_data_header_t);
 
 for (id = 1; id <= n; id++) {
@@ -902,8 +909,9 @@ for (id = 1; id <= n; id++) {
                     <code>
                       <value><![CDATA[mfs_error_t err;
 size_t size;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                  (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 2));
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
+                  (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 4));
 
 test_assert(mfs1.current_counter == 1, "not first instance");
 err = mfsEraseRecord(&mfs1, id_max);
@@ -1380,7 +1388,8 @@ mfsStart(&mfs1, &mfscfg1);]]></value>
                     </tags>
                     <code>
                       <value><![CDATA[mfs_id_t id;
-mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                        sizeof (mfs_data_header_t))) /
                   (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
 for (id = 1; id <= id_max; id++) {
diff --git a/test/mfs/source/test/mfs_test_sequence_001.c b/test/mfs/source/test/mfs_test_sequence_001.c
index 7c6d929ee..7b9017769 100644
--- a/test/mfs/source/test/mfs_test_sequence_001.c
+++ b/test/mfs/source/test/mfs_test_sequence_001.c
@@ -411,7 +411,8 @@ static void mfs_test_001_005_execute(void) {
   test_set_step(1);
   {
     mfs_id_t id;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
                       (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
     for (id = 1; id <= id_max; id++) {
@@ -437,7 +438,8 @@ static void mfs_test_001_005_execute(void) {
   test_set_step(2);
   {
     mfs_error_t err;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
                       (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
     err = mfsWriteRecord(&mfs1, id_max, sizeof mfs_pattern512 , mfs_pattern512);
@@ -532,7 +534,8 @@ static void mfs_test_001_006_execute(void) {
   test_set_step(1);
   {
     mfs_id_t id;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
                       (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
     for (id = 1; id <= id_max; id++) {
@@ -595,7 +598,8 @@ static void mfs_test_001_006_execute(void) {
   test_set_step(4);
   {
     mfs_id_t id;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
                       (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
     for (id = 1; id <= MFS_CFG_MAX_RECORDS; id++) {
@@ -661,7 +665,8 @@ static void mfs_test_001_006_execute(void) {
   test_set_step(7);
   {
     mfs_id_t id;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
                       (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
     for (id = 1; id <= MFS_CFG_MAX_RECORDS; id++) {
@@ -726,19 +731,20 @@ static void mfs_test_001_007_execute(void) {
   test_set_step(1);
   {
     mfs_id_t id;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                      (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 2));
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
+                      (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 4));
 
     for (id = 1; id <= id_max; id++) {
       mfs_error_t err;
       size_t size;
 
-      err = mfsWriteRecord(&mfs1, id, (sizeof mfs_pattern512 / 2), mfs_pattern512);
+      err = mfsWriteRecord(&mfs1, id, (sizeof mfs_pattern512 / 4), mfs_pattern512);
       test_assert(err == MFS_NO_ERROR, "error creating the record");
       size = sizeof mfs_buffer;
       err = mfsReadRecord(&mfs1, id, &size, mfs_buffer);
       test_assert(err == MFS_NO_ERROR, "record not found");
-      test_assert(size == (sizeof mfs_pattern512 / 2), "unexpected record length");
+      test_assert(size == (sizeof mfs_pattern512 / 4), "unexpected record length");
       test_assert(memcmp(mfs_pattern512, mfs_buffer, size) == 0,
                   "wrong record content");
     }
@@ -751,10 +757,11 @@ static void mfs_test_001_007_execute(void) {
     mfs_error_t err;
     size_t size;
     mfs_id_t id;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                      (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 2));
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
+                      (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 4));
     mfs_id_t n = ((mfscfg1.bank_size - sizeof (mfs_bank_header_t)) -
-                  (id_max * (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 2)))) /
+                  (id_max * (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 4)))) /
                  sizeof (mfs_data_header_t);
 
     for (id = 1; id <= n; id++) {
@@ -774,8 +781,9 @@ static void mfs_test_001_007_execute(void) {
   {
     mfs_error_t err;
     size_t size;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
-                      (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 2));
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
+                      (sizeof (mfs_data_header_t) + (sizeof mfs_pattern512 / 4));
 
     test_assert(mfs1.current_counter == 1, "not first instance");
     err = mfsEraseRecord(&mfs1, id_max);
diff --git a/test/mfs/source/test/mfs_test_sequence_002.c b/test/mfs/source/test/mfs_test_sequence_002.c
index c75858ea2..93206cbe4 100644
--- a/test/mfs/source/test/mfs_test_sequence_002.c
+++ b/test/mfs/source/test/mfs_test_sequence_002.c
@@ -480,7 +480,8 @@ static void mfs_test_002_003_execute(void) {
   test_set_step(1);
   {
     mfs_id_t id;
-    mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+    mfs_id_t id_max = (mfscfg1.bank_size - (sizeof (mfs_bank_header_t) +
+                                            sizeof (mfs_data_header_t))) /
                       (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
 
     for (id = 1; id <= id_max; id++) {
-- 
cgit v1.2.3