third_party/pigweed/repo/pw_kvs/flash_partition_test.cc

   1 // Copyright 2020 The Pigweed Authors
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
   4 // use this file except in compliance with the License. You may obtain a copy of
   5 // the License at
   6 //
   7 //     https://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 // License for the specific language governing permissions and limitations under
  13 // the License.
  14
  15 #include <span>
  16
  17 #include "gtest/gtest.h"
  18 #include "pw_kvs/flash_memory.h"
  19 #include "pw_kvs/flash_test_partition.h"
  20 #include "pw_kvs_private/config.h"
  21 #include "pw_log/log.h"
  22
  23 namespace pw::kvs::PartitionTest {
  24 namespace {
  25
  26 #ifndef PW_FLASH_TEST_ITERATIONS
  27 #define PW_FLASH_TEST_ITERATIONS 2
  28 #endif  // PW_FLASH_TEST_ITERATIONS
  29
  30 constexpr size_t kTestIterations = PW_FLASH_TEST_ITERATIONS;
  31
  32 size_t error_count = 0;
  33
  34 void WriteData(FlashPartition& partition, uint8_t fill_byte) {
  35   uint8_t test_data[kMaxFlashAlignment];
  36   memset(test_data, fill_byte, sizeof(test_data));
  37
  38   const size_t alignment = partition.alignment_bytes();
  39
  40   ASSERT_EQ(OkStatus(), partition.Erase(0, partition.sector_count()));
  41
  42   const size_t chunks_per_sector = partition.sector_size_bytes() / alignment;
  43
  44   // Fill partition sector by sector. Fill the sector with an integer number
  45   // of alignment-size chunks. If the sector is not evenly divisible by
  46   // alignment-size, the remainder is not written.
  47   for (size_t sector_index = 0; sector_index < partition.sector_count();
  48        sector_index++) {
  49     FlashPartition::Address address =
  50         sector_index * partition.sector_size_bytes();
  51
  52     for (size_t chunk_index = 0; chunk_index < chunks_per_sector;
  53          chunk_index++) {
  54       StatusWithSize status =
  55           partition.Write(address, as_bytes(std::span(test_data, alignment)));
  56       ASSERT_EQ(OkStatus(), status.status());
  57       ASSERT_EQ(alignment, status.size());
  58       address += alignment;
  59     }
  60   }
  61
  62   // Check the fill result. Use expect so the test doesn't bail on error.
  63   // Count the errors and print if any errors are found.
  64   for (size_t sector_index = 0; sector_index < partition.sector_count();
  65        sector_index++) {
  66     FlashPartition::Address address =
  67         sector_index * partition.sector_size_bytes();
  68
  69     for (size_t chunk_index = 0; chunk_index < chunks_per_sector;
  70          chunk_index++) {
  71       memset(test_data, 0, sizeof(test_data));
  72       StatusWithSize status = partition.Read(address, alignment, test_data);
  73
  74       EXPECT_EQ(OkStatus(), status.status());
  75       EXPECT_EQ(alignment, status.size());
  76       if (!status.ok() || (alignment != status.size())) {
  77         error_count++;
  78         PW_LOG_DEBUG("   Read Error [%s], %u of %u",
  79                      status.status().str(),
  80                      unsigned(status.size()),
  81                      unsigned(alignment));
  82         continue;
  83       }
  84
  85       for (size_t i = 0; i < alignment; i++) {
  86         if (test_data[i] != fill_byte) {
  87           error_count++;
  88           PW_LOG_DEBUG(
  89               "   Error %u, Read compare @ address %x, got 0x%02x, "
  90               "expected 0x%02x",
  91               unsigned(error_count),
  92               unsigned(address + i),
  93               unsigned(test_data[i]),
  94               unsigned(fill_byte));
  95         }
  96       }
  97
  98       address += alignment;
  99     }
 100   }
 101
 102   EXPECT_EQ(error_count, 0U);
 103   if (error_count != 0) {
 104     PW_LOG_ERROR("Partition test, fill '%c', %u errors found",
 105                  fill_byte,
 106                  unsigned(error_count));
 107   }
 108 }
 109
 110 TEST(FlashPartitionTest, FillTest) {
 111   FlashPartition& test_partition = FlashTestPartition();
 112
 113   ASSERT_GE(kMaxFlashAlignment, test_partition.alignment_bytes());
 114
 115   for (size_t i = 0; i < kTestIterations; i++) {
 116     PW_LOG_DEBUG("FillTest iteration %u, write '0'", unsigned(i));
 117     WriteData(test_partition, 0);
 118     PW_LOG_DEBUG("FillTest iteration %u, write '0xff'", unsigned(i));
 119     WriteData(test_partition, 0xff);
 120     PW_LOG_DEBUG("FillTest iteration %u, write '0x55'", unsigned(i));
 121     WriteData(test_partition, 0x55);
 122     PW_LOG_DEBUG("FillTest iteration %u, write '0xa3'", unsigned(i));
 123     WriteData(test_partition, 0xa3);
 124     PW_LOG_DEBUG("Completed iterations %u, Total errors %u",
 125                  unsigned(i),
 126                  unsigned(error_count));
 127   }
 128 }
 129
 130 TEST(FlashPartitionTest, EraseTest) {
 131   FlashPartition& test_partition = FlashTestPartition();
 132
 133   static const uint8_t fill_byte = 0x55;
 134   uint8_t test_data[kMaxFlashAlignment];
 135   memset(test_data, fill_byte, sizeof(test_data));
 136
 137   ASSERT_GE(kMaxFlashAlignment, test_partition.alignment_bytes());
 138
 139   const size_t block_size =
 140       std::min(sizeof(test_data), test_partition.sector_size_bytes());
 141   auto data_span = std::span(test_data, block_size);
 142
 143   ASSERT_EQ(OkStatus(), test_partition.Erase(0, test_partition.sector_count()));
 144
 145   // Write to the first page of each sector.
 146   for (size_t sector_index = 0; sector_index < test_partition.sector_count();
 147        sector_index++) {
 148     FlashPartition::Address address =
 149         sector_index * test_partition.sector_size_bytes();
 150
 151     StatusWithSize status = test_partition.Write(address, as_bytes(data_span));
 152     ASSERT_EQ(OkStatus(), status.status());
 153     ASSERT_EQ(block_size, status.size());
 154   }
 155
 156   // Preset the flag to make sure the check actually sets it.
 157   bool is_erased = true;
 158   ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
 159   ASSERT_EQ(false, is_erased);
 160
 161   ASSERT_EQ(OkStatus(), test_partition.Erase());
 162
 163   // Preset the flag to make sure the check actually sets it.
 164   is_erased = false;
 165   ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
 166   ASSERT_EQ(true, is_erased);
 167
 168   // Read the first page of each sector and make sure it has been erased.
 169   for (size_t sector_index = 0; sector_index < test_partition.sector_count();
 170        sector_index++) {
 171     FlashPartition::Address address =
 172         sector_index * test_partition.sector_size_bytes();
 173
 174     StatusWithSize status =
 175         test_partition.Read(address, data_span.size_bytes(), data_span.data());
 176     EXPECT_EQ(OkStatus(), status.status());
 177     EXPECT_EQ(data_span.size_bytes(), status.size());
 178
 179     EXPECT_EQ(true, test_partition.AppearsErased(as_bytes(data_span)));
 180   }
 181 }
 182
 183 TEST(FlashPartitionTest, AlignmentCheck) {
 184   FlashPartition& test_partition = FlashTestPartition();
 185   const size_t alignment = test_partition.alignment_bytes();
 186   const size_t sector_size_bytes = test_partition.sector_size_bytes();
 187
 188   EXPECT_LE(alignment, kMaxFlashAlignment);
 189   EXPECT_GT(alignment, 0u);
 190   EXPECT_EQ(kMaxFlashAlignment % alignment, 0U);
 191   EXPECT_LE(kMaxFlashAlignment, sector_size_bytes);
 192   EXPECT_LE(sector_size_bytes % kMaxFlashAlignment, 0U);
 193 }
 194
 195 #define TESTING_CHECK_FAILURES_IS_SUPPORTED 0
 196 #if TESTING_CHECK_FAILURES_IS_SUPPORTED
 197 // TODO: Ensure that this test triggers an assert.
 198 TEST(FlashPartitionTest, BadWriteAddressAlignment) {
 199   FlashPartition& test_partition = FlashTestPartition();
 200
 201   // Can't get bad alignment with alignment of 1.
 202   if (test_partition.alignment_bytes() == 1) {
 203     return;
 204   }
 205
 206   std::array<std::byte, kMaxFlashAlignment> source_data;
 207   test_partition.Write(1, source_data);
 208 }
 209
 210 // TODO: Ensure that this test triggers an assert.
 211 TEST(FlashPartitionTest, BadWriteSizeAlignment) {
 212   FlashPartition& test_partition = FlashTestPartition();
 213
 214   // Can't get bad alignment with alignment of 1.
 215   if (test_partition.alignment_bytes() == 1) {
 216     return;
 217   }
 218
 219   std::array<std::byte, 1> source_data;
 220   test_partition.Write(0, source_data);
 221 }
 222
 223 // TODO: Ensure that this test triggers an assert.
 224 TEST(FlashPartitionTest, BadEraseAddressAlignment) {
 225   FlashPartition& test_partition = FlashTestPartition();
 226
 227   // Can't get bad alignment with sector size of 1.
 228   if (test_partition.sector_size_bytes() == 1) {
 229     return;
 230   }
 231
 232   // Try Erase at address 1 for 1 sector.
 233   test_partition.Erase(1, 1);
 234 }
 235
 236 #endif  // TESTING_CHECK_FAILURES_IS_SUPPORTED
 237
 238 TEST(FlashPartitionTest, IsErased) {
 239   FlashPartition& test_partition = FlashTestPartition();
 240   const size_t alignment = test_partition.alignment_bytes();
 241
 242   // Make sure the partition is big enough to do this test.
 243   ASSERT_GE(test_partition.size_bytes(), 3 * kMaxFlashAlignment);
 244
 245   ASSERT_EQ(OkStatus(), test_partition.Erase());
 246
 247   bool is_erased = true;
 248   ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
 249   ASSERT_EQ(true, is_erased);
 250
 251   static const uint8_t fill_byte = 0x55;
 252   uint8_t test_data[kMaxFlashAlignment];
 253   memset(test_data, fill_byte, sizeof(test_data));
 254   auto data_span = std::span(test_data);
 255
 256   // Write the chunk with fill byte.
 257   StatusWithSize status = test_partition.Write(alignment, as_bytes(data_span));
 258   ASSERT_EQ(OkStatus(), status.status());
 259   ASSERT_EQ(data_span.size_bytes(), status.size());
 260
 261   EXPECT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
 262   EXPECT_EQ(false, is_erased);
 263
 264   // Check the chunk that was written.
 265   EXPECT_EQ(OkStatus(),
 266             test_partition.IsRegionErased(
 267                 alignment, data_span.size_bytes(), &is_erased));
 268   EXPECT_EQ(false, is_erased);
 269
 270   // Check a region that starts erased but later has been written.
 271   EXPECT_EQ(OkStatus(),
 272             test_partition.IsRegionErased(0, 2 * alignment, &is_erased));
 273   EXPECT_EQ(false, is_erased);
 274
 275   // Check erased for a region smaller than kMaxFlashAlignment. This has been a
 276   // bug in the past.
 277   EXPECT_EQ(OkStatus(),
 278             test_partition.IsRegionErased(0, alignment, &is_erased));
 279   EXPECT_EQ(true, is_erased);
 280 }
 281
 282 }  // namespace
 283 }  // namespace pw::kvs::PartitionTest