RTOS API for bare metal ...

Provide partial RTOS API for bare metal builds - things that
can be done in a single threaded environment.

Allows more code to work in both RTOS and bare metal builds without
change, and in particular gives easy access to the ability to
efficiently wait for something occurring in interrupt.

Available in bare-metal:
* ThisThread
* osThreadFlagsSet to set flags on main thread (can be set from IRQ)
* EventFlags (can be set from IRQ)
* Semaphores (can be released from IRQ)
* Mutex (dummy implementation)

Not useful:
* ConditionVariable (could only be signalled from 2nd thread)
* RtosTimer (calls in a second thread context)
* Thread

Unimplemented:
* Mail, Queue, MemoryPool

Possible future work:
* ConditionVariableCS to act as IRQ signalled ConditionVariable

Introduce Semaphore::acquire methods ...

Deprecate wait() in favour of acquire(), try_acquire(),
try_acquire_for() and try_acquire_until().

Brings Semaphore more into line with CMSIS-RTOS 2 (which uses "acquire"),
itself (as it has "release"), and other classes having "try", "try for"
and "try until".

Also steps away from vague "wait" term - the primary operation here is
to acquire the semaphore, and this will of course sleep.

RTOS API: minor tidies ...

Remove unneeded memsets and an unneeded cast.

Add missing initialisation of EventFlags attributes - no all fields were
being initialised.

RTOS: Add required header file and namespace element instead add all

Make Thread methods const

Add ThisThread

Style clean-up of Thread-related files

Fix for max_stack not returning right value when OS_STACK_WATERMARK is enabled

Thread: fix rtx thread type

Splitting MBED_ERROR macros to support ones with/without error value argument

Adding mbed prefixes to all macros and functions to avoid namespace conflicts

Test application/cases optimization for some low memory targets, macro changes and test fixes

Change set_error/set_error_fatal to warning/error, add itm support and other changes

Error handling/logging implementation and tests

Added description of tz_module and MBED_TZ_DEFAULT_ACCESS

Overloaded ctor for new parameter tz_module

Trust zone module identifier added to thread class ...

Non-Secure threads can access secure calls only when tz_module attribute is set
as 1(OS_SECURE_CALLABLE_THREAD), while thread creation.
Hence adding tz_module as an argument to ctor.

Add Thread::wait_until ...

API is somewhat loose to cope with potential shift in the underlying
RTOS APIs.

Fixed whitespace

Fatal parameter error when deleting/terminating Thread object ...

Call to osThreadTerminate is guarded by local_id check, to avoid parameter error fault when deleting or terminating Thread object that was not started.

Ensure Thread stack is 8 byte aligned ...

Ensure both the stack and stack size used in the Thread class are
aligned to 8 bytes. This prevents the runtime error
"Thread 0 error -11: Unknown" due to incorrect stack alignment.

Remove use of internal RTX types ...

Make calls to cmsis-os to get thread state, stack size, and max stack
usage rather than accessing internal RTX data directly. Wrap RTX5
specific code in OS_BACKEND_RTX5.

Also refactor the code to use mbed types rather than RTX types:
os_timer_t -> mbed_rtos_storage_timer_t
os_event_flags_t -> mbed_rtos_storage_event_flags_t
osRtxMutex_t -> mbed_rtos_storage_thread_t

RTOS: Thread: Fix how free stack is calculated

RTOS: Thread: Fix return value for signal_wait ...

Signal wait was always returning success even in case of error.

RTOS: Thread: Update docs; make singal_clr static as it's affects running thread

Fix Thread class synchronization ...

Prevent osTheadTerminate from being called on an already terminated
thread. Also make sure the thread termination process is properly
synchronized.

Make sure all system threads and mutexes have clear names

Update codebase for CMSIS5/RTX5 ...

Update all of mbed-os to use RTX5.

rtos: Add Inactive return to thread get state ...

If a thread hasn't been started return Inactive as the status when
Thread::get_state() is called.

rtos: Return an error when a Thread is re-used ...

Calling Thread::start multiple times leads to undefined behavior since
the Thread class was not designed to handle being restarted.  Return an
error code if Thread::start is called a second time to prevent this
behavior.