IOTSTOR-953: Fix address calculations from SlicingBlockDevice

* Change MBED_ASSERTS() to return valid error code, so that
  checks are not bypassed on release builds.
* Fix starting address calculations so that "addr" parameter is always
  relative to SlicingDevice and "_start" is only added when calls to
  underlying storage block is made.
* Bypass BlockDevice:is_valid_*() to underlying block device.
  Slicingblockdevice was just verifying addresses independently, without
  verifying those from underlying block storage.

features/storage/blockdevice/SlicingBlockDevice.cpp

@@ -17,6 +17,7 @@
 #include "SlicingBlockDevice.h"
 #include "platform/mbed_assert.h"
 #include "stddef.h"
+#include <stdio.h>
 
 namespace mbed {
 
@@ -58,7 +59,9 @@ int SlicingBlockDevice::init()
     }
 
     // Check that block addresses are valid
-    MBED_ASSERT(is_valid_erase(_start, _stop - _start));
+    if (!is_valid_erase(0, _stop - _start)) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
 
     return 0;
 }
@@ -75,44 +78,41 @@ int SlicingBlockDevice::sync()
 
 int SlicingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 {
-    MBED_ASSERT(is_valid_read(addr + _start, size));
+    if (!is_valid_read(addr, size)) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
     return _bd->read(b, addr + _start, size);
 }
 
 int SlicingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
 {
-    MBED_ASSERT(is_valid_program(addr + _start, size));
+    if (!is_valid_program(addr, size)) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
     return _bd->program(b, addr + _start, size);
 }
 
 int SlicingBlockDevice::erase(bd_addr_t addr, bd_size_t size)
 {
-    MBED_ASSERT(is_valid_erase(addr + _start, size));
+    if (!is_valid_erase(addr, size)) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
     return _bd->erase(addr + _start, size);
 }
 
 bool SlicingBlockDevice::is_valid_read(bd_addr_t addr, bd_size_t size) const
 {
-    return (
+    return _bd->is_valid_read(_start + addr, size) && _start + addr + size <= _stop;
-               addr % get_read_size() == 0 &&
-               size % get_read_size() == 0 &&
-               addr + size <= (this->size() + _start));
 }
 
 bool SlicingBlockDevice::is_valid_program(bd_addr_t addr, bd_size_t size) const
 {
-    return (
+    return _bd->is_valid_program(_start + addr, size) && _start + addr + size <= _stop;
-               addr % get_program_size() == 0 &&
-               size % get_program_size() == 0 &&
-               addr + size <= (this->size() + _start));
 }
 
 bool SlicingBlockDevice::is_valid_erase(bd_addr_t addr, bd_size_t size) const
 {
-    return (
+    return _bd->is_valid_erase(_start + addr, size) && _start + addr + size <= _stop;
-               addr % get_erase_size(addr) == 0 &&
-               (addr + size) % get_erase_size(addr + size - 1) == 0 &&
-               addr + size <= (this->size() + _start));
 }
 
 bd_size_t SlicingBlockDevice::get_read_size() const
@@ -127,7 +127,7 @@ bd_size_t SlicingBlockDevice::get_program_size() const
 
 bd_size_t SlicingBlockDevice::get_erase_size() const
 {
-    return _bd->get_erase_size();
+    return _bd->get_erase_size(_start);
 }
 
 bd_size_t SlicingBlockDevice::get_erase_size(bd_addr_t addr) const