Mbed os 5.1

.pylintrc

@@ -0,0 +1,2 @@
+[Format]
+max-line-length=80

.travis.yml

@@ -3,6 +3,7 @@ python:
 
 script:
   - PYTHONPATH=. python tools/test/config_test/config_test.py
+  - python tools/test/pylint.py
   - py.test tools/test/toolchains/api.py
   - python tools/build_travis.py
 before_install:
@@ -17,3 +18,4 @@ install:
   - sudo pip install prettytable
   - sudo pip install jinja2
   - sudo pip install pytest
+  - sudo pip install pylint

TESTS/mbedmicro-mbed/attributes/attributes.c

@@ -137,7 +137,17 @@ int testDeprecatedUsed() {
     return 0;
 }
 
+MBED_DEPRECATED_SINCE("mbed-os-3.14", "this message should not be displayed")
+void testDeprecatedSinceUnused();
+void testDeprecatedSinceUnused() { }
+
+MBED_DEPRECATED_SINCE("mbed-os-3.14", "this message should be displayed")
+int testDeprecatedSinceUsed();
+int testDeprecatedSinceUsed() {
+    return 0;
+}
+
 int testDeprecated() {
-    return testDeprecatedUsed();
+    return testDeprecatedUsed() + testDeprecatedSinceUsed();
 }
 

TESTS/mbedmicro-rtos-mbed/malloc/main.cpp

@@ -0,0 +1,68 @@
+#include "mbed.h"
+#include "test_env.h"
+#include "rtos.h"
+
+#if defined(MBED_RTOS_SINGLE_THREAD)
+  #error [NOT_SUPPORTED] test not supported
+#endif
+
+#define NUM_THREADS         5
+#define THREAD_STACK_SIZE   256
+
+DigitalOut led1(LED1);
+volatile bool should_exit = false;
+volatile bool allocation_failure = false;
+
+void task_using_malloc(void)
+{
+    void* data;
+    while (1) {
+        // Repeatedly allocate and free memory
+        data = malloc(100);
+        if (data != NULL) {
+            memset(data, 0, 100);
+        } else {
+            allocation_failure = true;
+        }
+        free(data);
+
+        if (should_exit) {
+            return;
+        }
+    }
+}
+
+int main()
+{
+    Thread *thread_list[NUM_THREADS];
+    int test_time = 15;
+    GREENTEA_SETUP(20, "default_auto");
+
+    // Allocate threads for the test
+    for (int i = 0; i < NUM_THREADS; i++) {
+        thread_list[i] = new Thread(osPriorityNormal, THREAD_STACK_SIZE);
+        if (NULL == thread_list[i]) {
+            allocation_failure = true;
+        }
+        thread_list[i]->start(task_using_malloc);
+    }
+
+    // Give the test time to run
+    while (test_time) {
+        led1 = !led1;
+        Thread::wait(1000);
+        test_time--;
+    }
+
+    // Join and delete all threads
+    should_exit = 1;
+    for (int i = 0; i < NUM_THREADS; i++) {
+        if (NULL == thread_list[i]) {
+            continue;
+        }
+        thread_list[i]->join();
+        delete thread_list[i];
+    }
+
+    GREENTEA_TESTSUITE_RESULT(!allocation_failure);
+}

docs/BUILDING.md

@@ -444,7 +444,7 @@ Build successes:
 ```
 * We can print all 'programs' (test cases) ```make.py``` can build for us:
 ```
-$ python make.py
+$ python make.py -L
 .
 [  0] MBED_A1: Basic
 [  1] MBED_A2: Semihost file system

features/FEATURE_UVISOR/README.md

@@ -129,15 +129,14 @@ In the code above we specified 3 elements:
 1. Main box Access Control Lists (ACLs). Since with uVisor enabled everything runs in unprivileged mode, we need to make sure that peripherals that are accessed by the OS and the main box are allowed. These peripherals are specified using a list like the one in the snippet above. For the purpose of this example we provide you the list of all the ACLs that we know you will need. For other platforms or other applications you need to determine those ACLs following a process that is described in a [section](#the-main-box-acls) below.
 1. App-specific uVisor configurations: `UVISOR_SET_MODE_ACL`. This macro sets the uVisor mode (enabled) and associates the list of ACLs we just created with the main box.
 
-Before compiling, we need to add a custom target that inherits all the features of the original `K64F` target, and enables the uVisor feature. To do so, add the file `~/code/uvisor-example/mbed_app.json` with the following content:
+Before compiling, we need to override the original `K64F` target to enable the uVisor feature. To do so, add the file `~/code/uvisor-example/mbed_app.json` with the following content:
 
 ```JSON
 {
-    "custom_targets": {
-        "K64F_SECURE": {
-            "inherits": ["K64F"],
-            "extra_labels_add":["K64F", "UVISOR_SUPPORTED"],
-            "features_add": ["UVISOR"]
+    "target_overrides": {
+        "K64F": {
+            "target.features_add": ["UVISOR"],
+            "target.extra_labels_add": ["UVISOR_SUPPORTED"]
         }
     }
 }
@@ -147,16 +146,16 @@ Before compiling, we need to add a custom target that inherits all the features
 
 **Checkpoint**
 
-Compile the application again, but this time targeting `K64F_SECURE`:
+Compile the application again. This time the `K64F` target will include the new features and labels we provided in `mbed_app.json`;
 
 ```bash
-$ mbed compile -m K64F_SECURE -t GCC_ARM
+$ mbed compile -m K64F -t GCC_ARM
 ```
 
 The binary will be located at:
 
 ```bash
-~/code/uvisor-example/.build/K64F_SECURE/GCC_ARM/uvisor-example.bin
+~/code/uvisor-example/.build/K64F/GCC_ARM/uvisor-example.bin
 ```
 
 Re-flash the device and press the reset button. The device LED should be blinking as in the previous case.
@@ -290,7 +289,13 @@ A few things to note in the code above:
 
 **Checkpoint**
 
-Compile the application again, re-flash the device, and press the reset button. The device LED should be blinking as in the previous case.
+Compile the application again:
+
+```bash
+$ mbed compile -m K64F -t GCC_ARM
+```
+
+Re-flash the device, and press the reset button. The device LED should be blinking as in the previous case.
 
 If you don't see the LED blinking, it means that the application halted somewhere, probably because uVisor captured a fault. You can setup the uVisor debug messages to see if there is any problem. Follow the [Debugging uVisor on mbed OS](DEBUGGING.md) document for a step-by-step guide.
 
@@ -374,7 +379,7 @@ static const UvisorBoxAclItem g_main_box_acls[] = {
 You now need to compile your application using uVisor in debug mode. This operation requires some more advanced steps, which are described in detail in the [Debugging uVisor on mbed OS](DEBUGGING.md) document. The main idea is that you compile the application in debug mode:
 
 ```bash
-$ mbed compile -m K64F_SECURE -t GCC_ARM -o "debug-info"
+$ mbed compile -m K64F -t GCC_ARM -o "debug-info"
 ```
 
 and then use a GDB-compatible interface to flash the device, enable semihosting, and access the uVisor debug messages. Please read the [Debugging uVisor on mbed OS](DEBUGGING.md) document for the detailed instructions.

features/FEATURE_UVISOR/includes/uvisor/api/inc/rpc.h

@@ -33,7 +33,6 @@
 typedef uint32_t uvisor_rpc_result_t;
 
 typedef uint32_t (*TFN_Ptr)(uint32_t, uint32_t, uint32_t, uint32_t);
-typedef int (*TFN_RPC_Callback)(int);
 
 /** Wait for incoming RPC.
  *
@@ -43,6 +42,21 @@ typedef int (*TFN_RPC_Callback)(int);
  * @param timeout_ms   specifies how long to wait (in ms) for an incoming RPC
  *                     message before returning
  */
-int rpc_fncall_waitfor(const TFN_Ptr fn_ptr_array[], size_t fn_count, uint32_t timeout_ms);
+UVISOR_EXTERN int rpc_fncall_waitfor(const TFN_Ptr fn_ptr_array[], size_t fn_count, uint32_t timeout_ms);
+
+/** Wait for an outgoing RPC to finish.
+ *
+ * Wait for the result of a previously started asynchronous RPC. After this
+ * call, ret will contain the return value of the RPC. The return value of this
+ * function may indicate that there was an error or a timeout with non-zero.
+ *
+ * @param result[in]     The token to wait on for the result of an asynchronous RPC
+ * @param timeout_ms[in] How long to wait (in ms) for the asynchronous RPC
+ *                       message to finish before returning
+ * @param ret[out]       The return value resulting from the finished RPC to
+ *                       the target function
+ * @returns              Non-zero on error or timeout, zero on successful wait
+ */
+UVISOR_EXTERN int rpc_fncall_wait(uvisor_rpc_result_t result, uint32_t timeout_ms, uint32_t * ret);
 
 #endif /* __UVISOR_API_RPC_H__ */

hal/api/FunctionPointer.h

@@ -29,12 +29,14 @@ namespace mbed {
 template <typename R, typename A1>
 class FunctionPointerArg1 : public Callback<R(A1)> {
 public:
-    MBED_DEPRECATED("FunctionPointerArg1<R, A> has been replaced by Callback<R(A)>")
+    MBED_DEPRECATED_SINCE("mbed-os-5.1",
+        "FunctionPointerArg1<R, A> has been replaced by Callback<R(A)>")
     FunctionPointerArg1(R (*function)(A1) = 0)
         : Callback<R(A1)>(function) {}
 
     template<typename T>
-    MBED_DEPRECATED("FunctionPointerArg1<R, A> has been replaced by Callback<R(A)>")
+    MBED_DEPRECATED_SINCE("mbed-os-5.1",
+        "FunctionPointerArg1<R, A> has been replaced by Callback<R(A)>")
     FunctionPointerArg1(T *object, R (T::*member)(A1))
         : Callback<R(A1)>(object, member) {}
 
@@ -46,12 +48,14 @@ class FunctionPointerArg1 : public Callback<R(A1)> {
 template <typename R>
 class FunctionPointerArg1<R, void> : public Callback<R()> {
 public:
-    MBED_DEPRECATED("FunctionPointer has been replaced by Callback<void()>")
+    MBED_DEPRECATED_SINCE("mbed-os-5.1",
+        "FunctionPointer has been replaced by Callback<void()>")
     FunctionPointerArg1(R (*function)() = 0)
         : Callback<R()>(function) {}
 
     template<typename T>
-    MBED_DEPRECATED("FunctionPointer has been replaced by Callback<void()>")
+    MBED_DEPRECATED_SINCE("mbed-os-5.1",
+        "FunctionPointer has been replaced by Callback<void()>")
     FunctionPointerArg1(T *object, R (T::*member)())
         : Callback<R()>(object, member) {}
 

hal/api/mbed.h

@@ -16,7 +16,7 @@
 #ifndef MBED_H
 #define MBED_H
 
-#define MBED_LIBRARY_VERSION 122
+#define MBED_LIBRARY_VERSION 124
 
 #if MBED_CONF_RTOS_PRESENT
 #include "rtos/rtos.h"

hal/api/toolchain.h

@@ -207,7 +207,7 @@
  *  Mark a function declaration as deprecated, if it used then a warning will be
  *  issued by the compiler possibly including the provided message. Note that not
  *  all compilers are able to display the message.
- *  
+ *
  *  @code
  *  #include "toolchain.h"
  *  
@@ -225,6 +225,21 @@
 #endif
 #endif
 
+/** MBED_DEPRECATED_SINCE("version", "message string")
+ *  Mark a function declaration as deprecated, noting that the declaration was
+ *  deprecated on the specified version. If the function is used then a warning
+ *  will be issued by the compiler possibly including the provided message.
+ *  Note that not all compilers are able to display this message.
+ *
+ *  @code
+ *  #include "toolchain.h"
+ *
+ *  MBED_DEPRECATED_SINCE("mbed-os-5.1", "don't foo any more, bar instead")
+ *  void foo(int arg);
+ *  @endcode
+ */
+#define MBED_DEPRECATED_SINCE(D, M) MBED_DEPRECATED(M " [since " D "]")
+
 
 // FILEHANDLE declaration
 #if defined(TOOLCHAIN_ARM)

hal/common/retarget.cpp

@@ -23,6 +23,8 @@
 #include "mbed_interface.h"
 #include "SingletonPtr.h"
 #include "PlatformMutex.h"
+#include "mbed_error.h"
+#include <stdlib.h>
 #if DEVICE_STDIO_MESSAGES
 #include <stdio.h>
 #endif
@@ -68,6 +70,10 @@ extern const char __stdout_name[] = "/stdout";
 extern const char __stderr_name[] = "/stderr";
 #endif
 
+// Heap limits - only used if set
+unsigned char *mbed_heap_start = 0;
+uint32_t mbed_heap_size = 0;
+
 /* newlib has the filehandle field in the FILE struct as a short, so
  * we can't just return a Filehandle* from _open and instead have to
  * put it in a filehandles array and return the index into that array
@@ -596,6 +602,12 @@ extern "C" caddr_t _sbrk(int incr) {
         return (caddr_t)-1;
     }
 
+    // Additional heap checking if set
+    if (mbed_heap_size && (new_heap >= mbed_heap_start + mbed_heap_size)) {
+        errno = ENOMEM;
+        return (caddr_t)-1;
+    }
+
     heap = new_heap;
     return (caddr_t) prev_heap;
 }
@@ -714,3 +726,34 @@ extern "C" void __env_unlock( struct _reent *_r )
 #endif
 
 } // namespace mbed
+
+void *operator new(std::size_t count)
+{
+    void *buffer = malloc(count);
+    if (NULL == buffer) {
+        error("Operator new out of memory\r\n");
+    }
+    return buffer;
+}
+
+void *operator new[](std::size_t count)
+{
+    void *buffer = malloc(count);
+    if (NULL == buffer) {
+        error("Operator new[] out of memory\r\n");
+    }
+    return buffer;
+}
+
+void operator delete(void *ptr)
+{
+    if (ptr != NULL) {
+        free(ptr);
+    }
+}
+void operator delete[](void *ptr)
+{
+    if (ptr != NULL) {
+        free(ptr);
+    }
+}