A thread-safe function protects shared resources from concurrent access using locks. There are functions in the C library that you can re-implement, that enable you to manage the locking mechanisms and so prevent the corruption of shared data such as the heap. These functions are mutex functions, where the lifecycle of a mutex is one of initialization, iterative acquisition and releasing of the mutex as required, and then optionally freeing the mutex when it is never going to be required again. The mutex functions wrap onto your own Real-Time Operating System (RTOS) calls, and their function prototypes are:

The mutex data structure type that is used as the parameter to the _mutex_*() functions is not defined in any of the ARM compiler toolchain header files, but must be defined elsewhere. Typically, it is defined as part of RTOS code.

Functions that call _mutex_*() functions create 4 bytes of memory for holding the mutex data structure. __Heap_Initialize() is one such function.

For the C library, a mutex is specified as a single 32-bit word of memory that can be placed anywhere. However, if your mutex implementation requires more space than this, or demands that the mutex be in a special memory area, then you must treat the default mutex as a pointer to a real mutex.

A typical example of a re-implementation framework for _mutex_initialize(), _mutex_acquire(), and _mutex_release() is as follows, where SEMAPHORE_ID, CreateLock(), AcquireLock(), and ReleaseLock() are defined in the RTOS, and (...) implies additional parameters:

int _mutex_initialize(SEMAPHORE_ID sid)
{
   /* Create a mutex semaphore */
    sid = CreateLock(...);
    return 1;
}

void _mutex_acquire(SEMAPHORE_ID sid)
{
    /* Task sleep until get semaphore */
    AcquireLock(sid, ...);
}

void _mutex_release(SEMAPHORE_ID sid)
{
    /* Release the semaphore. */
    ReleaseLock(sid);
}

void _mutex_free(SEMAPHORE_ID sid)
{
    /* Free the semaphore. */
    FreeLock(sid, ...);
}