bd: Added utility block device classes

- ChainingBlockDevice
- SlicingBlockDevice

Author: geky

features/TESTS/filesystem/util_block_device/main.cpp

@@ -0,0 +1,171 @@
+#include "mbed.h"
+#include "greentea-client/test_env.h"
+#include "unity.h"
+#include "utest.h"
+
+#include "HeapBlockDevice.h"
+#include "SlicingBlockDevice.h"
+#include "ChainingBlockDevice.h"
+#include <stdlib.h>
+
+using namespace utest::v1;
+
+#define BLOCK_SIZE 512
+uint8_t write_block[BLOCK_SIZE];
+uint8_t read_block[BLOCK_SIZE];
+
+
+void test_slicing() {
+    HeapBlockDevice bd(16*BLOCK_SIZE, BLOCK_SIZE);
+
+    // Test with first slice of block device
+    SlicingBlockDevice slice1(&bd, 0, 8*BLOCK_SIZE);
+
+    int err = slice1.init();
+    TEST_ASSERT_EQUAL(0, err);
+
+    TEST_ASSERT_EQUAL(BLOCK_SIZE, slice1.write_size());
+    TEST_ASSERT_EQUAL(8*BLOCK_SIZE, slice1.size());
+
+    // Fill with random sequence
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        write_block[i] = 0xff & rand();
+    }
+
+    // Write, sync, and read the block
+    err = slice1.write(write_block, 0, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    err = slice1.read(read_block, 0, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    // Check that the data was unmodified
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        TEST_ASSERT_EQUAL(0xff & rand(), read_block[i]);
+    }
+
+    // Check with original block device
+    err = bd.read(read_block, 0, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    // Check that the data was unmodified
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        TEST_ASSERT_EQUAL(0xff & rand(), read_block[i]);
+    }
+
+    err = slice1.deinit();
+    TEST_ASSERT_EQUAL(0, err);
+
+
+    // Test with second slice of block device
+    SlicingBlockDevice slice2(&bd, -8*BLOCK_SIZE);
+
+    err = slice2.init();
+    TEST_ASSERT_EQUAL(0, err);
+
+    TEST_ASSERT_EQUAL(BLOCK_SIZE, slice2.write_size());
+    TEST_ASSERT_EQUAL(8*BLOCK_SIZE, slice2.size());
+
+    // Fill with random sequence
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        write_block[i] = 0xff & rand();
+    }
+
+    // Write, sync, and read the block
+    err = slice2.write(write_block, 0, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    err = slice2.read(read_block, 0, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    // Check that the data was unmodified
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        TEST_ASSERT_EQUAL(0xff & rand(), read_block[i]);
+    }
+
+    // Check with original block device
+    err = bd.read(read_block, 8*BLOCK_SIZE, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    // Check that the data was unmodified
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        TEST_ASSERT_EQUAL(0xff & rand(), read_block[i]);
+    }
+
+    err = slice2.deinit();
+    TEST_ASSERT_EQUAL(0, err);
+}
+
+void test_chaining() {
+    HeapBlockDevice bd1(8*BLOCK_SIZE, BLOCK_SIZE);
+    HeapBlockDevice bd2(8*BLOCK_SIZE, BLOCK_SIZE);
+
+    // Test with chain of block device
+    BlockDevice *bds[] = {&bd1, &bd2};
+    ChainingBlockDevice chain(bds);
+
+    int err = chain.init();
+    TEST_ASSERT_EQUAL(0, err);
+
+    TEST_ASSERT_EQUAL(BLOCK_SIZE, chain.write_size());
+    TEST_ASSERT_EQUAL(16*BLOCK_SIZE, chain.size());
+
+    // Fill with random sequence
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        write_block[i] = 0xff & rand();
+    }
+
+    // Write, sync, and read the block
+    err = chain.write(write_block, 0, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    err = chain.read(read_block, 0, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    // Check that the data was unmodified
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        TEST_ASSERT_EQUAL(0xff & rand(), read_block[i]);
+    }
+
+    // Write, sync, and read the block
+    err = chain.write(write_block, 8*BLOCK_SIZE, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    err = chain.read(read_block, 8*BLOCK_SIZE, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    // Check that the data was unmodified
+    srand(1);
+    for (int i = 0; i < BLOCK_SIZE; i++) {
+        TEST_ASSERT_EQUAL(0xff & rand(), read_block[i]);
+    }
+
+    err = chain.deinit();
+    TEST_ASSERT_EQUAL(0, err);
+}
+
+
+// Test setup
+utest::v1::status_t test_setup(const size_t number_of_cases) {
+    GREENTEA_SETUP(10, "default_auto");
+    return verbose_test_setup_handler(number_of_cases);
+}
+
+Case cases[] = {
+    Case("Testing slicing of a block device", test_slicing),
+    Case("Testing chaining of block devices", test_chaining),
+};
+
+Specification specification(test_setup, cases);
+
+int main() {
+    return !Harness::run(specification);
+}

features/filesystem/bd/ChainingBlockDevice.cpp

@@ -0,0 +1,210 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2016 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 "ChainingBlockDevice.h"
+
+
+ChainingBlockDevice::ChainingBlockDevice(BlockDevice **bds, size_t bd_count)
+    : _bds(bds), _bd_count(bd_count)
+    , _read_size(0), _program_size(0), _erase_size(0), _size(0)
+{
+}
+
+static bool is_aligned(uint64_t x, uint64_t alignment)
+{
+    return (x / alignment) * alignment == x;
+}
+
+bd_error_t ChainingBlockDevice::init()
+{
+    _read_size = 0;
+    _program_size = 0;
+    _erase_size = 0;
+    _size = 0;
+
+    // Initialize children block devices, find all sizes and 
+    // assert that block sizes are similar. We can't do this in
+    // the constructor since some block devices may need to be
+    // initialized before they know their block size/count
+    for (size_t i = 0; i < _bd_count; i++) {
+        bd_error_t err = _bds[i]->init();
+        if (err) {
+            return err;
+        }
+
+        bd_size_t read = _bds[i]->read_size();
+        if (i == 0 || (read >= _read_size && is_aligned(read, _read_size))) {
+            _read_size = read;
+        } else if (_read_size > read && is_aligned(_read_size, read)) {
+            _read_size = _read_size;
+        } else {
+            return BD_ERROR_PARAMETER;
+        }
+
+        bd_size_t program = _bds[i]->program_size();
+        if (i == 0 || (program >= _program_size && is_aligned(program, _program_size))) {
+            _program_size = program;
+        } else if (_program_size > program && is_aligned(_program_size, program)) {
+            _program_size = _program_size;
+        } else {
+            return BD_ERROR_PARAMETER;
+        }
+
+        bd_size_t erase = _bds[i]->erase_size();
+        if (i == 0 || (erase >= _erase_size && is_aligned(erase, _erase_size))) {
+            _erase_size = erase;
+        } else if (_erase_size > erase && is_aligned(_erase_size, erase)) {
+            _erase_size = _erase_size;
+        } else {
+            return BD_ERROR_PARAMETER;
+        }
+
+        _size += _bds[i]->size();
+    }
+
+    return 0;
+}
+
+bd_error_t ChainingBlockDevice::deinit()
+{
+    for (size_t i = 0; i < _bd_count; i++) {
+        bd_error_t err = _bds[i]->deinit();
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+bd_error_t ChainingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
+{
+    if (!is_valid_read(addr, size)) {
+        return BD_ERROR_PARAMETER;
+    }
+
+    uint8_t *buffer = static_cast<uint8_t*>(b);
+
+    // Find block devices containing blocks, may span multiple block devices
+    for (size_t i = 0; i < _bd_count && size > 0; i++) {
+        bd_size_t bdsize = _bds[i]->size();
+
+        if (addr < bdsize) {
+            bd_size_t read = size;
+            if (addr + read > bdsize) {
+                read = bdsize - addr;
+            }
+
+            bd_error_t err = _bds[i]->read(buffer, addr, read);
+            if (err) {
+                return err;
+            }
+
+            buffer += read;
+            addr += read;
+            size -= read;
+        }
+
+        addr -= size;
+    }
+
+    return 0;
+}
+
+bd_error_t ChainingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
+{
+    if (!is_valid_program(addr, size)) {
+        return BD_ERROR_PARAMETER;
+    }
+
+    const uint8_t *buffer = static_cast<const uint8_t*>(b);
+
+    // Find block devices containing blocks, may span multiple block devices
+    for (size_t i = 0; i < _bd_count && size > 0; i++) {
+        bd_size_t bdsize = _bds[i]->size();
+
+        if (addr < bdsize) {
+            bd_size_t program = size;
+            if (addr + program > bdsize) {
+                program = bdsize - addr;
+            }
+
+            bd_error_t err = _bds[i]->program(buffer, addr, program);
+            if (err) {
+                return err;
+            }
+
+            buffer += program;
+            addr += program;
+            size -= program;
+        }
+
+        addr -= size;
+    }
+
+    return 0;
+}
+
+bd_error_t ChainingBlockDevice::erase(bd_addr_t addr, bd_size_t size)
+{
+    if (!is_valid_erase(addr, size)) {
+        return BD_ERROR_PARAMETER;
+    }
+
+    // Find block devices containing blocks, may span multiple block devices
+    for (size_t i = 0; i < _bd_count && size > 0; i++) {
+        bd_size_t bdsize = _bds[i]->size();
+
+        if (addr < bdsize) {
+            bd_size_t erase = size;
+            if (addr + erase > bdsize) {
+                erase = bdsize - addr;
+            }
+
+            bd_error_t err = _bds[i]->erase(addr, erase);
+            if (err) {
+                return err;
+            }
+
+            addr += erase;
+            size -= erase;
+        }
+
+        addr -= size;
+    }
+
+    return 0;
+}
+
+bd_size_t ChainingBlockDevice::read_size()
+{
+    return _read_size;
+}
+
+bd_size_t ChainingBlockDevice::program_size()
+{
+    return _program_size;
+}
+
+bd_size_t ChainingBlockDevice::erase_size()
+{
+    return _erase_size;
+}
+
+bd_size_t ChainingBlockDevice::size()
+{
+    return _size;
+}