Add some logic related to initialization to various block devices

- Add an initialization flag on which BD actions depend (fail if uninitialized).
- Fix behavior of init reference count if first initialization fails

Author: David Saada

features/filesystem/bd/BufferedBlockDevice.cpp

@@ -26,7 +26,7 @@ static inline uint32_t align_down(bd_size_t val, bd_size_t size)
 }
 
 BufferedBlockDevice::BufferedBlockDevice(BlockDevice *bd)
-    : _bd(bd), _bd_program_size(0), _curr_aligned_addr(0), _flushed(true), _cache(0), _init_ref_count(0)
+    : _bd(bd), _bd_program_size(0), _curr_aligned_addr(0), _flushed(true), _cache(0), _init_ref_count(0), _is_initialized(false)
 {
 }
 
@@ -57,11 +57,16 @@ int BufferedBlockDevice::init()
     _curr_aligned_addr = _bd->size();
     _flushed = true;
 
-    return 0;
+    _is_initialized = true;
+    return BD_ERROR_OK;
 }
 
 int BufferedBlockDevice::deinit()
 {
+    if (!_is_initialized) {
+        return BD_ERROR_OK;
+    }
+
     uint32_t val = core_util_atomic_decr_u32(&_init_ref_count, 1);
 
     if (val) {
@@ -70,11 +75,16 @@ int BufferedBlockDevice::deinit()
 
     delete[] _cache;
     _cache = 0;
+    _is_initialized = false;
     return _bd->deinit();
 }
 
 int BufferedBlockDevice::flush()
 {
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     if (!_flushed) {
         int ret = _bd->program(_cache, _curr_aligned_addr, _bd_program_size);
         if (ret) {
@@ -87,6 +97,10 @@ int BufferedBlockDevice::flush()
 
 int BufferedBlockDevice::sync()
 {
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     int ret = flush();
     if (ret) {
         return ret;
@@ -97,6 +111,10 @@ int BufferedBlockDevice::sync()
 int BufferedBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 {
     MBED_ASSERT(_cache);
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     bool moved_unit = false;
 
     bd_addr_t aligned_addr = align_down(addr, _bd_program_size);
@@ -132,7 +150,10 @@ int BufferedBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 
 int BufferedBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
 {
-    MBED_ASSERT(_cache);
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     int ret;
     bool moved_unit = false;
 
@@ -196,12 +217,19 @@ int BufferedBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
 int BufferedBlockDevice::erase(bd_addr_t addr, bd_size_t size)
 {
     MBED_ASSERT(is_valid_erase(addr, size));
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     return _bd->erase(addr, size);
 }
 
 int BufferedBlockDevice::trim(bd_addr_t addr, bd_size_t size)
 {
     MBED_ASSERT(is_valid_erase(addr, size));
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
 
     if ((_curr_aligned_addr >= addr) && (_curr_aligned_addr <= addr + size)) {
         _flushed = true;
@@ -222,20 +250,36 @@ bd_size_t BufferedBlockDevice::get_program_size() const
 
 bd_size_t BufferedBlockDevice::get_erase_size() const
 {
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     return _bd->get_erase_size();
 }
 
 bd_size_t BufferedBlockDevice::get_erase_size(bd_addr_t addr) const
 {
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     return _bd->get_erase_size(addr);
 }
 
 int BufferedBlockDevice::get_erase_value() const
 {
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     return _bd->get_erase_value();
 }
 
 bd_size_t BufferedBlockDevice::size() const
 {
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     return _bd->size();
 }

features/filesystem/bd/BufferedBlockDevice.h

@@ -154,6 +154,7 @@ class BufferedBlockDevice : public BlockDevice {
     bool _flushed;
     uint8_t *_cache;
     uint32_t _init_ref_count;
+    bool _is_initialized;
 
     /** Flush data in cache
      *

features/filesystem/bd/ChainingBlockDevice.cpp

@@ -21,7 +21,7 @@
 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)
-    , _erase_value(-1), _init_ref_count(0)
+    , _erase_value(-1), _init_ref_count(0), _is_initialized(false)
 {
 }
 
@@ -32,6 +32,7 @@ static bool is_aligned(uint64_t x, uint64_t alignment)
 
 int ChainingBlockDevice::init()
 {
+    int err;
     uint32_t val = core_util_atomic_incr_u32(&_init_ref_count, 1);
 
     if (val != 1) {
@@ -49,9 +50,9 @@ int ChainingBlockDevice::init()
     // 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++) {
-        int err = _bds[i]->init();
+        err = _bds[i]->init();
         if (err) {
-            return err;
+            goto fail;
         }
 
         bd_size_t read = _bds[i]->get_read_size();
@@ -85,11 +86,21 @@ int ChainingBlockDevice::init()
         _size += _bds[i]->size();
     }
 
-    return 0;
+    _is_initialized = true;
+    return BD_ERROR_OK;
+
+fail:
+    _is_initialized = false;
+    _init_ref_count = 0;
+    return err;
 }
 
 int ChainingBlockDevice::deinit()
 {
+    if (!_is_initialized) {
+        return BD_ERROR_OK;
+    }
+
     uint32_t val = core_util_atomic_decr_u32(&_init_ref_count, 1);
 
     if (val) {
@@ -103,11 +114,16 @@ int ChainingBlockDevice::deinit()
         }
     }
 
-    return 0;
+    _is_initialized = false;
+    return BD_ERROR_OK;
 }
 
 int ChainingBlockDevice::sync()
 {
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     for (size_t i = 0; i < _bd_count; i++) {
         int err = _bds[i]->sync();
         if (err) {
@@ -121,6 +137,10 @@ int ChainingBlockDevice::sync()
 int ChainingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 {
     MBED_ASSERT(is_valid_read(addr, size));
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     uint8_t *buffer = static_cast<uint8_t*>(b);
 
     // Find block devices containing blocks, may span multiple block devices
@@ -152,6 +172,10 @@ int ChainingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 int ChainingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
 {
     MBED_ASSERT(is_valid_program(addr, size));
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     const uint8_t *buffer = static_cast<const uint8_t*>(b);
 
     // Find block devices containing blocks, may span multiple block devices
@@ -183,6 +207,9 @@ int ChainingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
 int ChainingBlockDevice::erase(bd_addr_t addr, bd_size_t size)
 {
     MBED_ASSERT(is_valid_erase(addr, size));
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
 
     // Find block devices containing blocks, may span multiple block devices
     for (size_t i = 0; i < _bd_count && size > 0; i++) {
@@ -226,6 +253,10 @@ bd_size_t ChainingBlockDevice::get_erase_size() const
 
 bd_size_t ChainingBlockDevice::get_erase_size(bd_addr_t addr) const
 {
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+
     bd_addr_t bd_start_addr = 0;
     for (size_t i = 0; i < _bd_count; i++) {
         bd_size_t bdsize = _bds[i]->size();

features/filesystem/bd/ChainingBlockDevice.h

@@ -176,6 +176,7 @@ class ChainingBlockDevice : public BlockDevice
     bd_size_t _size;
     int _erase_value;
     uint32_t _init_ref_count;
+    bool _is_initialized;
 };