Add filesystem recovery tests

Add tests for filesystem resilience and wear leveling. These tests
take shared filesystem code and simulate different scenarios while
this code is running. Information on the new tests can be found below.

mbed-littlefs-tests-filesystem_recovery-resilience:
Tests that after every block device operation the filesystem is in a
well defined state.

mbed-littlefs-tests-filesystem_recovery-wear_leveling:
Tests that the littlefs correctly handles when flash is exhausted by
using a simulated block device until there are no free good blocks.

Note - This patch also adds several new block devices for testing.
These will eventually be moved into mbed-os.

Author: c1728p9

TESTS/filesystem_recovery/resilience/main.cpp

@@ -0,0 +1,80 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2017-2017 ARM Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "mbed.h"
+#include "unity.h"
+#include "utest.h"
+#include "test_env.h"
+
+#include "atomic_usage.h"
+#include "ObservingBlockDevice.h"
+#include "LittleFileSystem.h"
+
+
+using namespace utest::v1;
+
+#define TEST_CYCLES     10
+#define TEST_BD_SIZE    (16 * 1024)
+
+/**
+ * Check that the filesystem is valid after every change
+ *
+ * This test is to ensure that littlefs contains a valid filesystem at
+ * all times. This property is required for handling unexpected power
+ * loss.
+ */
+void test_resilience()
+{
+    HeapBlockDevice bd(TEST_BD_SIZE);
+
+    // Setup the test
+    setup_atomic_operations(&bd, true);
+
+    // Run check on every write operation
+    ObservingBlockDevice observer(&bd);
+    observer.attach(check_atomic_operations);
+
+    // Perform operations
+    printf("Performing %i operations on flash\n", TEST_CYCLES);
+    for (int i = 1; i <= TEST_CYCLES; i++) {
+        int64_t ret = perform_atomic_operations(&observer);
+        TEST_ASSERT_EQUAL(i, ret);
+    }
+    printf("No errors detected\n");
+}
+
+Case cases[] = {
+    Case("test resilience", test_resilience),
+};
+
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
+{
+    GREENTEA_SETUP(20, "default_auto");
+    return greentea_test_setup_handler(number_of_cases);
+}
+
+Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
+
+int main()
+{
+    Harness::run(specification);
+}

TESTS/filesystem_recovery/wear_leveling/main.cpp

@@ -0,0 +1,93 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2017-2017 ARM Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "mbed.h"
+#include "unity.h"
+#include "utest.h"
+#include "test_env.h"
+
+#include "atomic_usage.h"
+#include "ExhaustibleBlockDevice.h"
+#include "LittleFileSystem.h"
+
+using namespace utest::v1;
+
+#define ERASE_CYCLES    20
+#define TEST_BD_SIZE    (8 * 1024)
+
+static uint32_t test_wear_leveling_size(uint32_t bd_size)
+{
+    HeapBlockDevice hbd(bd_size, 1, 1, 512);
+    ExhaustibleBlockDevice ebd(&hbd, ERASE_CYCLES);
+
+    printf("Testing size %lu\n", bd_size);
+    setup_atomic_operations(&ebd, true);
+
+    int64_t cycles = 0;
+    while (true) {
+        int64_t ret = perform_atomic_operations(&ebd);
+        check_atomic_operations(&ebd);
+        if (-1 == ret) {
+            break;
+        }
+        cycles++;
+        TEST_ASSERT_EQUAL(cycles, ret);
+
+    }
+
+    printf("  Simulated flash lasted %lli cylces\n", cycles);
+    return cycles;
+}
+
+/**
+ * Check that storage life is proportional to storage size
+ *
+ * This test is to ensure that littlefs is properly handling wear
+ * leveling. It does this by creating a simulated flash block device
+ * which can be worn out and then using it until it is exhausted.
+ * It then doubles the size of the block device and runs the same
+ * test. If the block device with twice the size lasts at least
+ * twice as long then the test passes.
+ */
+void test_wear_leveling()
+{
+    uint32_t cycles_1 = test_wear_leveling_size(TEST_BD_SIZE * 1);
+    uint32_t cycles_2 = test_wear_leveling_size(TEST_BD_SIZE * 2);
+    TEST_ASSERT(cycles_2 > cycles_1 * 2);
+}
+
+Case cases[] = {
+    Case("test wear leveling", test_wear_leveling),
+};
+
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
+{
+    GREENTEA_SETUP(60, "default_auto");
+    return greentea_test_setup_handler(number_of_cases);
+}
+
+Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
+
+int main()
+{
+    Harness::run(specification);
+}

TESTS_COMMON/ExhaustibleBlockDevice.cpp

@@ -0,0 +1,107 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2017 ARM Limited
+ *
+ * Licensed 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.
+ */
+
+#include "ExhaustibleBlockDevice.h"
+
+
+ExhaustibleBlockDevice::ExhaustibleBlockDevice(BlockDevice *bd, uint32_t erase_cycles)
+    : _bd(bd), _erase_array(NULL), _erase_cycles(erase_cycles)
+{
+}
+
+ExhaustibleBlockDevice::~ExhaustibleBlockDevice()
+{
+    delete[] _erase_array;
+}
+
+int ExhaustibleBlockDevice::init()
+{
+    int err = _bd->init();
+    if (err) {
+        return err;
+    }
+
+    if (!_erase_array) {
+        // can only be allocated after initialization
+        _erase_array = new uint32_t[_bd->size() / _bd->get_erase_size()];
+        for (size_t i = 0; i < _bd->size() / _bd->get_erase_size(); i++) {
+            _erase_array[i] = _erase_cycles;
+        }
+    }
+
+    return 0;
+}
+
+int ExhaustibleBlockDevice::deinit()
+{
+    // _erase_array is lazily cleaned up in destructor to allow
+    // data to live across de/reinitialization
+    return _bd->deinit();
+}
+
+int ExhaustibleBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
+{
+    return _bd->read(buffer, addr, size);
+}
+
+int ExhaustibleBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size)
+{
+    MBED_ASSERT(is_valid_program(addr, size));
+
+    if (_erase_array[addr / get_erase_size()] == 0) {
+        // TODO possibly something more destructive here
+        return 0;
+    }
+
+    return _bd->program(buffer, addr, size);
+}
+
+int ExhaustibleBlockDevice::erase(bd_addr_t addr, bd_size_t size)
+{
+    MBED_ASSERT(is_valid_erase(addr, size));
+
+    // use an erase cycle
+    if (_erase_array[addr / get_erase_size()] > 0) {
+        _erase_array[addr / get_erase_size()] -= 1;
+    }
+
+    if (_erase_array[addr / get_erase_size()] == 0) {
+        // TODO possibly something more destructive here
+        return 0;
+    }
+
+    return _bd->erase(addr, size);
+}
+
+bd_size_t ExhaustibleBlockDevice::get_read_size() const
+{
+    return _bd->get_read_size();
+}
+
+bd_size_t ExhaustibleBlockDevice::get_program_size() const
+{
+    return _bd->get_program_size();
+}
+
+bd_size_t ExhaustibleBlockDevice::get_erase_size() const
+{
+    return _bd->get_erase_size();
+}
+
+bd_size_t ExhaustibleBlockDevice::size() const
+{
+    return _bd->size();
+}