STORAGE: Merging feature-storage branch commits to master

drivers/DirHandle.h

@@ -16,6 +16,8 @@
 #ifndef MBED_DIRHANDLE_H
 #define MBED_DIRHANDLE_H
 
+#include <stdint.h>
+
 #if defined(__ARMCC_VERSION) || defined(__ICCARM__)
 #   define NAME_MAX 255
 typedef int mode_t;
@@ -28,6 +30,18 @@ typedef int mode_t;
 
 struct dirent {
     char d_name[NAME_MAX+1];
+    uint8_t d_type;
+};
+
+enum {
+    DT_UNKNOWN, // The file type could not be determined.
+    DT_FIFO,    // This is a named pipe (FIFO).
+    DT_CHR,     // This is a character device.
+    DT_DIR,     // This is a directory.
+    DT_BLK,     // This is a block device.
+    DT_REG,     // This is a regular file.
+    DT_LNK,     // This is a symbolic link.
+    DT_SOCK,    // This is a UNIX domain socket.
 };
 
 namespace mbed {

drivers/FileSystemLike.h

@@ -100,7 +100,15 @@ class FileSystemLike : public FileBase {
      */
     virtual int mkdir(const char *name, mode_t mode) { (void) name, (void) mode; return -1; }
 
-    // TODO other filesystem functions (mkdir, rm, rn, ls etc)
+    /** Store information about file in stat structure
+     *
+     *  @param name The name of the file to find information about
+     *  @param st The stat buffer to write to
+     *  @returns
+     *    0 on success or un-needed,
+     *   -1 on error
+     */
+    virtual int stat(const char *name, struct stat *st) = 0;
 };
 
 } // namespace mbed

features/FEATURE_LWIP/lwip-interface/lwip/src/api/lwip_err.c

@@ -40,7 +40,7 @@
 #include "lwip/def.h"
 #include "lwip/sys.h"
 
-#include "lwip/errno.h"
+#include "lwip/lwip_errno.h"
 
 #if !NO_SYS
 /** Table to quickly map an lwIP error (err_t) to a socket error

features/FEATURE_LWIP/lwip-interface/lwip/src/include/lwip/sockets.h

@@ -46,7 +46,7 @@
 #include "lwip/ip_addr.h"
 #include "lwip/err.h"
 #include "lwip/inet.h"
-#include "lwip/errno.h"
+#include "lwip/lwip_errno.h"
 
 #ifdef __cplusplus
 extern "C" {

features/FEATURE_LWIP/lwip-interface/lwip/src/include/posix/errno.h

@@ -30,4 +30,4 @@
  *
  */
 
-#include "lwip/errno.h"
+#include "lwip/lwip_errno.h"

features/TESTS/filesystem/heap_block_device/main.cpp

@@ -0,0 +1,97 @@
+/* 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 "mbed.h"
+#include "greentea-client/test_env.h"
+#include "unity.h"
+#include "utest.h"
+
+#include "HeapBlockDevice.h"
+#include <stdlib.h>
+
+using namespace utest::v1;
+
+/* It is not possible to build a KL25Z image with IAR including the file system if
+ * stack tracking statistics are enabled. If this is the case, build dummy
+ * tests.
+ */
+#if ! defined(__ICCARM__) && ! defined(TARGET_KL25Z) && ! defined(MBED_STACK_STATS_ENABLED)
+
+#define BLOCK_SIZE 512
+#define HEAP_BLOCK_DEVICE_TEST_01         test_read_write
+uint8_t write_block[BLOCK_SIZE];
+uint8_t read_block[BLOCK_SIZE];
+
+// Simple test which reads and writes a block
+void test_read_write() {
+    HeapBlockDevice bd(16*BLOCK_SIZE, BLOCK_SIZE);
+
+    int err = bd.init();
+    TEST_ASSERT_EQUAL(0, err);
+
+    // 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 = bd.program(write_block, 0, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    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 = bd.deinit();
+    TEST_ASSERT_EQUAL(0, err);
+}
+
+#else   /* ! defined(__ICCARM__) && ! defined(TARGET_KL25Z) && ! defined(MBED_STACK_STATS_ENABLED) */
+
+#define HEAP_BLOCK_DEVICE_TEST_01      heap_block_device_test_dummy
+
+/** @brief  heap_block_device_test_dummy    Dummy test case for testing when KL25Z being built with stack statistics enabled.
+ *
+ * @return success always
+ */
+static control_t heap_block_device_test_dummy()
+{
+    printf("Null test\n");
+    return CaseNext;
+}
+
+#endif  /* ! defined(__ICCARM__) && ! defined(TARGET_KL25Z) && ! defined(MBED_STACK_STATS_ENABLED) */
+
+// 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 read write of a block", HEAP_BLOCK_DEVICE_TEST_01),
+};
+
+Specification specification(test_setup, cases);
+
+int main() {
+    return !Harness::run(specification);
+}

features/TESTS/filesystem/util_block_device/main.cpp

@@ -0,0 +1,213 @@
+/* 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 "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;
+
+/* It is not possible to build a KL25Z image with IAR including the file system if
+ * stack tracking statistics are enabled. If this is the case, build dummy
+ * tests.
+ */
+#if ! defined(TOOLCHAIN_IAR) && ! defined(TARGET_KL25Z) && ! defined(MBED_STACK_STATS_ENABLED)
+
+#define BLOCK_COUNT 16
+#define BLOCK_SIZE 512
+#define UTIL_BLOCK_DEVICE_TEST_01         test_slicing
+#define UTIL_BLOCK_DEVICE_TEST_02         test_chaining
+uint8_t write_block[BLOCK_SIZE];
+uint8_t read_block[BLOCK_SIZE];
+
+
+// Simple test which read/writes blocks on a sliced block device
+void test_slicing() {
+    HeapBlockDevice bd(BLOCK_COUNT*BLOCK_SIZE, BLOCK_SIZE);
+
+    // Test with first slice of block device
+    SlicingBlockDevice slice1(&bd, 0, (BLOCK_COUNT/2)*BLOCK_SIZE);
+
+    int err = slice1.init();
+    TEST_ASSERT_EQUAL(0, err);
+
+    TEST_ASSERT_EQUAL(BLOCK_SIZE, slice1.get_program_size());
+    TEST_ASSERT_EQUAL((BLOCK_COUNT/2)*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.program(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, -(BLOCK_COUNT/2)*BLOCK_SIZE);
+
+    err = slice2.init();
+    TEST_ASSERT_EQUAL(0, err);
+
+    TEST_ASSERT_EQUAL(BLOCK_SIZE, slice2.get_program_size());
+    TEST_ASSERT_EQUAL((BLOCK_COUNT/2)*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.program(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, (BLOCK_COUNT/2)*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);
+}
+
+// Simple test which read/writes blocks on a chain of block devices
+void test_chaining() {
+    HeapBlockDevice bd1((BLOCK_COUNT/2)*BLOCK_SIZE, BLOCK_SIZE);
+    HeapBlockDevice bd2((BLOCK_COUNT/2)*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.get_program_size());
+    TEST_ASSERT_EQUAL(BLOCK_COUNT*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.program(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.program(write_block, (BLOCK_COUNT/2)*BLOCK_SIZE, BLOCK_SIZE);
+    TEST_ASSERT_EQUAL(0, err);
+
+    err = chain.read(read_block, (BLOCK_COUNT/2)*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);
+}
+
+#else   /* ! defined(TOOLCHAIN_IAR) && ! defined(TARGET_KL25Z) && ! defined(MBED_STACK_STATS_ENABLED) */
+
+#define UTIL_BLOCK_DEVICE_TEST_01      util_block_device_test_dummy
+#define UTIL_BLOCK_DEVICE_TEST_02      util_block_device_test_dummy
+
+/** @brief  util_block_device_test_dummy    Dummy test case for testing when KL25Z being built with stack statistics enabled.
+ *
+ * @return success always
+ */
+static control_t util_block_device_test_dummy()
+{
+    printf("Null test\n");
+    return CaseNext;
+}
+
+#endif  /* ! defined(TOOLCHAIN_IAR) && ! defined(TARGET_KL25Z) && ! defined(MBED_STACK_STATS_ENABLED) */
+
+// 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", UTIL_BLOCK_DEVICE_TEST_01),
+    Case("Testing chaining of block devices", UTIL_BLOCK_DEVICE_TEST_02),
+};
+
+Specification specification(test_setup, cases);
+
+int main() {
+    return !Harness::run(specification);
+}