Merge branch 'master' of https://github.com/ARMmbed/mbed-os into security-manager-dev

Author: pan-

TESTS/mbed_drivers/flashiap/main.cpp

@@ -22,6 +22,7 @@
 #include "utest/utest.h"
 #include "unity/unity.h"
 #include "greentea-client/test_env.h"
+#include <algorithm>
 
 #include "mbed.h"
 
@@ -48,10 +49,10 @@ void flashiap_program_test()
     TEST_ASSERT_NOT_EQUAL(0, sector_size);
     TEST_ASSERT_NOT_EQUAL(0, page_size);
     TEST_ASSERT_TRUE(sector_size % page_size == 0);
-    const uint8_t test_value = 0xCE;
-    uint8_t *data = new uint8_t[page_size];
-    for (uint32_t i = 0; i < page_size; i++) {
-        data[i] = test_value;
+    uint32_t prog_size = std::max(page_size, (uint32_t)8);
+    uint8_t *data = new uint8_t[prog_size + 2];
+    for (uint32_t i = 0; i < prog_size + 2; i++) {
+        data[i] = i;
     }
 
     // the one before the last sector in the system
@@ -61,19 +62,29 @@ void flashiap_program_test()
     TEST_ASSERT_EQUAL_INT32(0, ret);
 
 
-    for (uint32_t i = 0; i < sector_size / page_size; i++) {
-        uint32_t page_addr = address + i * page_size;
-        ret = flash_device.program(data, page_addr, page_size);
+    for (uint32_t i = 0; i < sector_size / prog_size; i++) {
+        uint32_t prog_addr = address + i * prog_size;
+        ret = flash_device.program(data, prog_addr, prog_size);
         TEST_ASSERT_EQUAL_INT32(0, ret);
     }
 
-    uint8_t *data_flashed = new uint8_t[page_size];
-    for (uint32_t i = 0; i < sector_size / page_size; i++) {
-        uint32_t page_addr = address + i * page_size;
-        ret = flash_device.read(data_flashed, page_addr, page_size);
+    uint8_t *data_flashed = new uint8_t[prog_size];
+    for (uint32_t i = 0; i < sector_size / prog_size; i++) {
+        uint32_t page_addr = address + i * prog_size;
+        ret = flash_device.read(data_flashed, page_addr, prog_size);
         TEST_ASSERT_EQUAL_INT32(0, ret);
-        TEST_ASSERT_EQUAL_UINT8_ARRAY(data, data_flashed, page_size);
+        TEST_ASSERT_EQUAL_UINT8_ARRAY(data, data_flashed, prog_size);
     }
+
+    // check programming of unaligned buffer and size
+    ret = flash_device.erase(address, sector_size);
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+    ret = flash_device.program(data + 2, address, prog_size);
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+    ret = flash_device.read(data_flashed, address, prog_size - 1);
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY(data + 2, data_flashed, prog_size - 1);
+
     delete[] data;
     delete[] data_flashed;
 

TESTS/mbed_drivers/rtc/main.cpp

@@ -144,7 +144,7 @@ void test_attach_RTC_stub_funtions()
     TEST_ASSERT_EQUAL(false, rtc_init_called);
 
     /* Check if time has been successfully set and retrieved. */
-    TEST_ASSERT_EQUAL(CUSTOM_TIME_1, seconds);
+    TEST_ASSERT_UINT32_WITHIN(RTC_DELTA, CUSTOM_TIME_1, seconds);
 }
 
 /* This test verifies if attach_rtc provides availability to
@@ -183,7 +183,7 @@ void test_attach_RTC_org_funtions()
     TEST_ASSERT_EQUAL(false, rtc_init_called);
 
     /* Check if time has been successfully set and retrieved. */
-    TEST_ASSERT_EQUAL(CUSTOM_TIME_1, seconds);
+    TEST_ASSERT_UINT32_WITHIN(RTC_DELTA, CUSTOM_TIME_1, seconds);
 }
 
 /* This test verifies if time() function returns
@@ -430,7 +430,7 @@ void test_functional_set()
     set_time(timeValue);
 
     /* Get current time and verify that new value has been set. */
-    TEST_ASSERT_EQUAL(timeValue, time(NULL));
+    TEST_ASSERT_UINT32_WITHIN(1, timeValue, time(NULL));
 }
 
 /* This test verifies if RTC counts seconds.

TESTS/mbed_hal/critical_section/main.cpp

@@ -20,7 +20,7 @@
 #include "greentea-client/test_env.h"
 #include "mbed.h"
 #include "cmsis.h"
-#if defined(TARGET_NRF5) || defined(TARGET_NRF5x) // for all NRF5x targets
+#if defined(TARGET_NRF5x) // for all NRF5x targets
 #include "nrf_nvic.h" // for __NRF_NVIC_APP_IRQS_0 / __NRF_NVIC_APP_IRQS_1
 #endif
 
@@ -30,11 +30,11 @@ bool test_are_interrupts_enabled(void)
 {
     // NRF5x targets don't disable interrupts when in critical section, instead they mask application interrupts this is due to BLE stack
     // (BLE to be operational requires some interrupts to be always enabled)
-#ifdef TARGET_NRF52
-	// check if APP interrupts are masked for NRF52_DK board
+#if defined(TARGET_NRF52)
+	// check if APP interrupts are masked for NRF52 boards
 	return (((NVIC->ISER[0] & __NRF_NVIC_APP_IRQS_0) != 0) || ((NVIC->ISER[1] & __NRF_NVIC_APP_IRQS_1) != 0));
-#elif TARGET_NRF5
-	// check if APP interrupts are masked for other NRF5 boards
+#elif defined(TARGET_NRF51)
+	// check if APP interrupts are masked for other NRF51 boards
 	return ((NVIC->ISER[0] & __NRF_NVIC_APP_IRQS_0) != 0);
 #else
 #if defined(__CORTEX_A9)

TESTS/mbed_platform/stats_thread/main.cpp

@@ -0,0 +1,176 @@
+
+/* mbed Microcontroller Library
+ * Copyright (c) 2018 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 "greentea-client/test_env.h"
+#include "unity/unity.h"
+#include "utest/utest.h"
+
+#include "mbed.h"
+
+#if !defined(MBED_THREAD_STATS_ENABLED)
+#error [NOT_SUPPORTED] test not supported
+#endif
+
+using namespace utest::v1;
+
+static EventFlags ef;
+static int32_t counter = 0;
+
+#define TEST_STACK_SIZE     320
+#define FLAG_SIGNAL_DEC     0x2
+#define MAX_THREAD_STATS    0x8
+
+void decrement_on_event()
+{
+    uint32_t ret = ef.wait_all(FLAG_SIGNAL_DEC);
+    TEST_ASSERT_FALSE(ret & osFlagsError);
+    TEST_ASSERT_EQUAL(FLAG_SIGNAL_DEC, ret);
+    counter--;
+}
+
+void increment_with_delay()
+{
+    while (1) {
+        counter++;
+        Thread::wait(500);
+    }
+}
+
+void test_case_single_thread_stats()
+{
+    mbed_stats_thread_t *stats = new mbed_stats_thread_t[MAX_THREAD_STATS];
+    int old_count = mbed_stats_thread_get_each(stats, MAX_THREAD_STATS);
+    Thread t1(osPriorityNormal, TEST_STACK_SIZE, NULL, "Th1");
+    t1.start(increment_with_delay);
+
+    // Read stats
+    int count = mbed_stats_thread_get_each(stats, MAX_THREAD_STATS);
+    TEST_ASSERT_EQUAL(1, (count - old_count));
+
+    for (int i = 0; i < count; i++) {
+        if (0 == strcmp(stats[i].name, "Th1")) {
+            TEST_ASSERT_EQUAL(TEST_STACK_SIZE, stats[i].stack_size);
+            TEST_ASSERT_EQUAL(osPriorityNormal, stats[i].priority);
+            break;
+        }
+    }
+
+    t1.terminate();
+    delete[] stats;
+}
+
+#define SINGLE_ELEMENT  1
+void test_case_less_count()
+{
+    // Default Mbed OS has 3 threads
+    mbed_stats_thread_t stats;
+    int count = mbed_stats_thread_get_each(&stats, SINGLE_ELEMENT);
+    TEST_ASSERT_EQUAL(SINGLE_ELEMENT, count);
+}
+
+void test_case_multi_threads_blocked()
+{
+    mbed_stats_thread_t *stats = new mbed_stats_thread_t[MAX_THREAD_STATS];
+    int old_count = mbed_stats_thread_get_each(stats, MAX_THREAD_STATS);
+
+    Thread t1(osPriorityNormal, TEST_STACK_SIZE, NULL, "Th1");
+    Thread t2(osPriorityNormal1, TEST_STACK_SIZE, NULL, "Th2");
+    t1.start(increment_with_delay);
+    t2.start(decrement_on_event);
+
+    // Read stats
+
+    int count = mbed_stats_thread_get_each(stats, MAX_THREAD_STATS);
+    TEST_ASSERT_EQUAL(2, (count - old_count));
+    for (int i = 0; i < count; i++) {
+        if (0 == strcmp(stats[i].name, "Th2")) {
+            TEST_ASSERT_EQUAL(TEST_STACK_SIZE, stats[i].stack_size);
+            TEST_ASSERT_EQUAL(osPriorityNormal1, stats[i].priority);
+            TEST_ASSERT_EQUAL(osThreadBlocked, stats[i].state);
+        } else if (0 == strcmp (stats[i].name, "Th1")) {
+            TEST_ASSERT_EQUAL(TEST_STACK_SIZE, stats[i].stack_size);
+            TEST_ASSERT_EQUAL(osPriorityNormal, stats[i].priority);
+        }
+    }
+
+    // Signal blocked thread
+    uint32_t ret = ef.set(FLAG_SIGNAL_DEC);
+    TEST_ASSERT_FALSE(ret & osFlagsError);
+
+    Thread::wait(100);
+
+    count = mbed_stats_thread_get_each(stats, MAX_THREAD_STATS);
+    TEST_ASSERT_EQUAL(1, (count - old_count));
+
+    t1.terminate();
+    delete[] stats;
+}
+
+void test_case_multi_threads_terminate()
+{
+    mbed_stats_thread_t *stats = new mbed_stats_thread_t[MAX_THREAD_STATS];
+    int old_count = mbed_stats_thread_get_each(stats, MAX_THREAD_STATS);
+
+    Thread t1(osPriorityNormal1, TEST_STACK_SIZE, NULL, "Th1");
+    Thread t2(osPriorityNormal2, TEST_STACK_SIZE, NULL, "Th2");
+    t2.start(increment_with_delay);
+    t1.start(decrement_on_event);
+
+    // Read stats
+
+    int count = mbed_stats_thread_get_each(stats, MAX_THREAD_STATS);
+    TEST_ASSERT_EQUAL(2, (count - old_count));
+
+    for (int i = 0; i < count; i++) {
+        if (0 == strcmp(stats[i].name, "Th2")) {
+            TEST_ASSERT_EQUAL(TEST_STACK_SIZE, stats[i].stack_size);
+            TEST_ASSERT_EQUAL(osPriorityNormal2, stats[i].priority);
+        } else if (0 == strcmp(stats[i].name, "Th1")) {
+            TEST_ASSERT_EQUAL(TEST_STACK_SIZE, stats[i].stack_size);
+            TEST_ASSERT_EQUAL(osPriorityNormal1, stats[i].priority);
+            TEST_ASSERT_EQUAL(osThreadBlocked, stats[i].state);
+        }
+    }
+
+    t1.terminate();
+    t2.terminate();
+
+    count = mbed_stats_thread_get_each(stats, MAX_THREAD_STATS);
+    TEST_ASSERT_EQUAL(count, old_count);
+
+    delete[] stats;
+}
+
+Case cases[] = {
+    Case("Single Thread Stats", test_case_single_thread_stats),
+    Case("Less count value", test_case_less_count),
+    Case("Multiple Threads blocked", test_case_multi_threads_blocked),
+    Case("Multiple Threads terminate", test_case_multi_threads_terminate),
+};
+
+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);
+}

drivers/FlashIAP.cpp

@@ -107,10 +107,18 @@ int FlashIAP::program(const void *buffer, uint32_t addr, uint32_t size)
     _mutex->lock();
     while (size) {
         uint32_t current_sector_size = flash_get_sector_size(&_flash, addr);
+        bool unaligned_src = (((size_t) buf / sizeof(uint32_t) * sizeof(uint32_t)) != (size_t) buf);
         chunk = std::min(current_sector_size - (addr % current_sector_size), size);
-        if (chunk < page_size) {
+        // Need to use the internal page buffer in any of these two cases:
+        // 1. Size is not page aligned
+        // 2. Source buffer is not aligned to uint32_t. This is not supported by many targets (although
+        //    the pointer they accept is of uint8_t).
+        if (unaligned_src || (chunk < page_size)) {
+            chunk = std::min(chunk, page_size);
             memcpy(_page_buf, buf, chunk);
-            memset(_page_buf + chunk, 0xFF, page_size - chunk);
+            if (chunk < page_size) {
+                memset(_page_buf + chunk, 0xFF, page_size - chunk);
+            }
             prog_buf = _page_buf;
             prog_size = page_size;
         } else {

features/FEATURE_BLE/targets/TARGET_NORDIC/TARGET_MCU_NRF51822/hal_patch/critical_section_api.c

@@ -72,7 +72,7 @@ void hal_critical_section_exit(void)
 
     // Restore the state as it was prior to entering the critical section.
     if (_use_softdevice_routine) {
-        sd_nvic_critical_region_exit(_state._sd_state)
+        sd_nvic_critical_region_exit(_state._sd_state);
     } else {
         __set_PRIMASK(_state._PRIMASK_state);
     }