os.h

Go to the documentation of this file.

 
#ifndef _OS_OS_H_
#define _OS_OS_H_
 
#include <sys/time.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <stdint.h>
 
#include "openmrn_features.h"
 
#if OPENMRN_FEATURE_MUTEX_FREERTOS
#include "freertos_includes.h"
#endif
#if OPENMRN_FEATURE_DEVICE_SELECT
#include <event_groups.h>
#endif
 
#if OPENMRN_FEATURE_MUTEX_PTHREAD
#include <pthread.h>
#include <semaphore.h>
#endif
 
#if defined (__MACH__)
#include <mach/mach_time.h>
#endif
 
#if defined (__WIN32__)
#include <sys/time.h>
#include <unistd.h>
#endif
 
#include "utils/macros.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
#ifndef OS_INLINE
#define OS_INLINE extern inline __attribute__((__gnu_inline__))
#endif
 
int appl_main(int argc, char *argv[]);
 
ssize_t os_get_free_heap(void);
 
#if defined (__FreeRTOS__)
 
extern void hw_init(void);
 
extern const size_t main_stack_size;
 
extern const int main_priority;
#endif
 
#if OPENMRN_FEATURE_MUTEX_FREERTOS
typedef xTaskHandle os_thread_t; 
typedef struct
{
    xSemaphoreHandle sem; 
    char recursive; 
} os_mutex_t; 
typedef xQueueHandle os_mq_t; 
typedef struct
{
    unsigned char state; 
} os_thread_once_t; 
typedef xSemaphoreHandle os_sem_t; 
#endif
#if OPENMRN_FEATURE_MUTEX_FAKE
typedef struct {
    int locked;
    uint8_t recursive;
} os_mutex_t;
typedef struct
{
    unsigned char state; 
} os_thread_once_t; 
typedef struct {
    unsigned counter;
} os_sem_t;
 
typedef unsigned os_thread_t;
typedef void *os_mq_t; 
#endif
#if OPENMRN_FEATURE_MUTEX_PTHREAD
typedef pthread_t os_thread_t; 
typedef pthread_mutex_t os_mutex_t; 
typedef void *os_mq_t; 
typedef pthread_once_t os_thread_once_t; 
typedef struct
{
    pthread_cond_t cond;
    pthread_mutex_t mutex;
    int counter;
} os_sem_t;
#endif
 
#ifndef container_of
#define container_of(_ptr, _type, _member)                  \
({                                                       \
    const typeof( ((_type *)0)->_member ) *__mptr = (_ptr); \
    (_type *)( (char *)__mptr - offsetof(_type,_member) );  \
})
#endif
 
extern long long os_get_time_monotonic(void);
 
extern long long os_get_fake_time(void);
 
#ifndef OPENMRN_FEATURE_MUTEX_PTHREAD
enum
{
    OS_THREAD_ONCE_NEVER = 0, 
    OS_THREAD_ONCE_INPROGRESS, 
    OS_THREAD_ONCE_DONE 
};
#define OS_THREAD_ONCE_INIT { OS_THREAD_ONCE_NEVER }
#else
#define OS_THREAD_ONCE_INIT PTHREAD_ONCE_INIT
#endif
 
#ifndef OPENMRN_FEATURE_MUTEX_PTHREAD
int os_thread_once(os_thread_once_t *once, void (*routine)(void));
#else
OS_INLINE int os_thread_once(os_thread_once_t *once, void (*routine)(void))
{
    return pthread_once(once, routine);
}
#endif
 
#define OS_PRIO_MIN 1 
#define OS_PRIO_DEFAULT 0 
#define OS_PRIO_MAX 32 
#define OS_MQ_NONE     0 
#define OS_MQ_TIMEDOUT 1 
#define OS_MQ_EMPTY    2 
#define OS_MQ_FULL     3 
#if defined LLONG_MAX
#define OPENMRN_OS_WAIT_FOREVER LLONG_MAX 
#else
#define OPENMRN_OS_WAIT_FOREVER __LONG_LONG_MAX__ 
#endif
 
#define NSEC_TO_USEC(_nsec) (((long long)_nsec) / 1000LL)
 
#define NSEC_TO_MSEC(_nsec) (((long long)_nsec) / 1000000LL)
 
#define NSEC_TO_SEC(_nsec) (((long long)_nsec) / 1000000000LL)
 
#define NSEC_TO_MIN(_nsec) (((long long)_nsec) / 60000000000LL)
 
#define USEC_TO_NSEC(_usec) (((long long)_usec) * 1000LL)
 
#define USEC_TO_MSEC(_usec) (((long long)_usec) / 1000LL)
 
#define USEC_TO_SEC(_usec) (((long long)_usec) / 1000000LL)
 
#define MSEC_TO_NSEC(_msec) (((long long)_msec) * 1000000LL)
 
#define MSEC_TO_USEC(_msec) (((long long)_msec) * 1000LL)
 
#define MSEC_TO_SEC(_msec) (((long long)_msec) / 1000LL)
 
#define SEC_TO_NSEC(_sec) (((long long)_sec) * 1000000000LL)
 
#define SEC_TO_USEC(_sec) (((long long)_sec) * 1000000LL)
 
#define SEC_TO_MSEC(_sec) (((long long)_sec) * 1000LL)
 
#define NSEC_TO_USEC_ROUNDED(_nsec) \
    ((((long long)_nsec) + 500LL) / 1000LL)
 
#define NSEC_TO_MSEC_ROUNDED(_nsec) \
    ((((long long)_nsec) + 500000LL) / 1000000LL)
 
#define NSEC_TO_SEC_ROUNDED(_nsec) \
    ((((long long)_nsec) + 500000000LL) / 1000000000LL)
 
#define NSEC_TO_MIN_ROUNDED(_nsec) \
    ((((long long)_nsec) + 30000000000LL) / 60000000000LL)
 
#define USEC_TO_MSEC_ROUNDED(_usec) \
    ((((long long)_usec) + 500LL) / 1000LL)
 
#define USEC_TO_SEC_ROUNDED(_usec) \
    ((((long long)_usec) +500000LL) / 1000000LL)
 
#define MSEC_TO_SEC_ROUNDED(_msec) \
    ((((long long)_msec) + 500LL) / 1000LL)
 
int os_thread_create(os_thread_t *thread, const char *name, int priority,
                     size_t stack_size,
                     void *(*start_routine) (void *), void *arg);
 
void os_thread_cancel(os_thread_t thread);
 
OS_INLINE os_thread_t os_thread_self(void)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return xTaskGetCurrentTaskHandle();
#elif OPENMRN_FEATURE_SINGLE_THREADED
    return 0xdeadbeef;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    return pthread_self();
#endif
}
 
OS_INLINE int os_thread_get_priority(os_thread_t thread)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return uxTaskPriorityGet(thread);
#elif OPENMRN_FEATURE_SINGLE_THREADED
    return 2;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    struct sched_param params;
    int policy;
    pthread_getschedparam(thread, &policy, &params);
    return params.sched_priority;
#endif
}
 
OS_INLINE int os_thread_get_priority_min(void)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return 1;
#elif OPENMRN_FEATURE_SINGLE_THREADED
    return 2;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    return sched_get_priority_min(SCHED_FIFO);
#endif
}
 
OS_INLINE int os_thread_get_priority_max(void)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return configMAX_PRIORITIES - 1;
#elif OPENMRN_FEATURE_SINGLE_THREADED
    return 2;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    return sched_get_priority_max(SCHED_FIFO);
#endif
}
 
#if OPENMRN_FEATURE_MUTEX_FREERTOS
#define OS_MUTEX_INITIALIZER {NULL, 0}
#define OS_RECURSIVE_MUTEX_INITIALIZER {NULL, 1}
#elif OPENMRN_FEATURE_MUTEX_FAKE
#define OS_MUTEX_INITIALIZER {0, 0}
#define OS_RECURSIVE_MUTEX_INITIALIZER {0, 1}
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
#define OS_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
 
#if defined (__nuttx__)
#define OS_RECURSIVE_MUTEX_INITIALIZER {0, SEM_INITIALIZER(1), PTHREAD_MUTEX_RECURSIVE, 0}
#elif defined (__MACH__)
#define OS_RECURSIVE_MUTEX_INITIALIZER PTHREAD_RECURSIVE_MUTEX_INITIALIZER
#else
#define OS_RECURSIVE_MUTEX_INITIALIZER PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
#endif
#endif
 
#ifdef __EMSCRIPTEN__
extern void os_emscripten_yield();
#endif
 
OS_INLINE int os_mutex_init(os_mutex_t *mutex)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    mutex->recursive = 0;
    mutex->sem = xSemaphoreCreateMutex();
 
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    mutex->locked = 0;
    mutex->recursive = 0;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    return pthread_mutex_init(mutex, NULL);
#endif
}
 
OS_INLINE int os_recursive_mutex_init(os_mutex_t *mutex)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    mutex->recursive = 1;
    mutex->sem = xSemaphoreCreateRecursiveMutex();
 
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    mutex->locked = 0;
    mutex->recursive = 1;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    pthread_mutexattr_t attr;
    int result;
 
    result = pthread_mutexattr_init(&attr);
    if (result != 0)
    {
        return result;
    }
 
    result = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    if (result != 0)
    {
        return result;
    }
 
    return pthread_mutex_init(mutex, &attr);
#endif
}
 
OS_INLINE int os_mutex_destroy(os_mutex_t *mutex)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    vSemaphoreDelete(mutex->sem);
 
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    mutex->locked = 0;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    return pthread_mutex_destroy(mutex);
#endif
}
 
OS_INLINE int os_mutex_lock(os_mutex_t *mutex)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    vTaskSuspendAll();
    if (mutex->sem == NULL)
    {
        if (mutex->recursive)
        {
            mutex->sem = xSemaphoreCreateRecursiveMutex();
        }
        else
        {
            mutex->sem = xSemaphoreCreateMutex();
        }
    }
    xTaskResumeAll();
 
    if (mutex->recursive)
    {
        xSemaphoreTakeRecursive(mutex->sem, portMAX_DELAY);
    }
    else
    {
        xSemaphoreTake(mutex->sem, portMAX_DELAY);
    }
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    if (mutex->locked && !mutex->recursive)
    {
        DIE("Mutex deadlock.");
    }
    mutex->locked++;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    return pthread_mutex_lock(mutex);
#endif
}
 
OS_INLINE int os_mutex_unlock(os_mutex_t *mutex)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    if (mutex->recursive)
    {
        xSemaphoreGiveRecursive(mutex->sem);
    }
    else
    {
        xSemaphoreGive(mutex->sem);
    }
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    if (mutex->locked <= 0)
    {
        DIE("Unlocking a not locked mutex");
    }
    --mutex->locked;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    return pthread_mutex_unlock(mutex);
#endif
}
 
OS_INLINE int os_sem_init(os_sem_t *sem, unsigned int value)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    *sem = xSemaphoreCreateCounting(LONG_MAX, value);
    if (!*sem) {
      abort();
    }
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    sem->counter = value;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    pthread_cond_init(&sem->cond, NULL);
    pthread_mutex_init(&sem->mutex, NULL);
    sem->counter = value;
    return 0;
#endif
}
 
OS_INLINE int os_sem_destroy(os_sem_t *sem)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    vSemaphoreDelete(*sem);
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    pthread_cond_destroy(&sem->cond);
    pthread_mutex_destroy(&sem->mutex);
    return 0;
#endif
}
 
OS_INLINE int os_sem_post(os_sem_t *sem)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    xSemaphoreGive(*sem);
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    sem->counter++;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    pthread_mutex_lock(&sem->mutex);
    sem->counter++;
    pthread_cond_signal(&sem->cond);
    pthread_mutex_unlock(&sem->mutex);
    return 0;
#endif
}
 
#if OPENMRN_FEATURE_RTOS_FROM_ISR
OS_INLINE int os_sem_post_from_isr(os_sem_t *sem, int *woken)
{
    portBASE_TYPE local_woken = 0;
    xSemaphoreGiveFromISR(*sem, &local_woken);
    *woken |= local_woken;
    return 0;
}
#endif // OPENMRN_FEATURE_RTOS_FROM_ISR
 
OS_INLINE int os_sem_wait(os_sem_t *sem)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    xSemaphoreTake(*sem, portMAX_DELAY);
    return 0;
#elif defined(__EMSCRIPTEN__)
    while (!sem->counter)
    {
        os_emscripten_yield();
    }
    --sem->counter;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_FAKE
    if (!sem->counter) {
        DIE("Semaphore deadlock.");
    }
    --sem->counter;
    return 0;
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    pthread_mutex_lock(&sem->mutex);
    while (sem->counter == 0)
    {
        pthread_cond_wait(&sem->cond, &sem->mutex);
    }
    sem->counter--;
    pthread_mutex_unlock(&sem->mutex);
    return 0;
#endif
}
 
#if OPENMRN_FEATURE_SEM_TIMEDWAIT
OS_INLINE int os_sem_timedwait(os_sem_t *sem, long long timeout)
{
    if (timeout == OPENMRN_OS_WAIT_FOREVER)
    {
        return os_sem_wait(sem);
    }
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    if (xSemaphoreTake(*sem, NSEC_TO_TICK(timeout)) == pdTRUE)
    {
        return 0;
    }
    else
    {
        errno = ETIMEDOUT;
        return -1;
    }
#elif defined(__EMSCRIPTEN__)
    long long end_time = 0;
    do
    {
        if (sem->counter)
        {
            --sem->counter;
            return 0;
        }
        else if (end_time)
        {
            errno = ETIMEDOUT;
            return -1;
        }
        end_time = os_get_time_monotonic() + timeout;
        while (!sem->counter && os_get_time_monotonic() < end_time)
        {
            os_emscripten_yield();
        }
    } while(1);
#elif OPENMRN_FEATURE_MUTEX_PTHREAD
    struct timeval tv;
    struct timespec ts;
    gettimeofday(&tv, NULL);
    timeout += ((long long)tv.tv_sec * 1000000000LL) + ((long long) tv.tv_usec * 1000LL);
    ts.tv_sec = timeout / 1000000000LL;
    ts.tv_nsec = timeout % 1000000000LL;
    pthread_mutex_lock(&sem->mutex);
    while (sem->counter == 0)
    {
        if (pthread_cond_timedwait(&sem->cond, &sem->mutex, &ts) == ETIMEDOUT)
        {
            pthread_mutex_unlock(&sem->mutex);
            errno = ETIMEDOUT;
            return -1;
        }
    }
    sem->counter--;
    pthread_mutex_unlock(&sem->mutex);
    return 0;
#endif
}
 
#endif // OPENMRN_FEATURE_SEM_TIMEDWAIT
 
 
#if !defined (OPENMRN_FEATURE_MUTEX_FREERTOS)
typedef struct queue_priv
{
    os_sem_t semSend; 
    os_sem_t semReceive; 
    char *buffer; 
    size_t itemSize; 
    size_t bytes; 
    unsigned int indexSend; 
    unsigned int indexReceive; 
    os_mutex_t mutex; 
} QueuePriv;
#endif
 
OS_INLINE os_mq_t os_mq_create(size_t length, size_t item_size)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return xQueueCreate(length, item_size);
#else
    QueuePriv *q = (QueuePriv*)malloc(sizeof(QueuePriv));
    if (!q)
    {
        errno = ENOMEM;
        return NULL;
    }
    os_sem_init(&q->semSend, length);
    os_sem_init(&q->semReceive, 0);
    q->buffer = (char*)malloc(length * item_size);
    q->itemSize = item_size;
    q->bytes = length * item_size;
    q->indexSend = 0;
    q->indexReceive = 0;
    os_mutex_init(&q->mutex);
 
    return q;
#endif
}
 
OS_INLINE void os_mq_send(os_mq_t queue, const void *data)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    xQueueSend(queue, data, portMAX_DELAY);
#else
    QueuePriv *q = (QueuePriv*)queue;
    
    os_sem_wait(&q->semSend);
 
    os_mutex_lock(&q->mutex);
    memcpy(q->buffer + q->indexSend, data, q->itemSize);
    q->indexSend += q->itemSize;
    if (q->indexSend >= q->bytes)
    {
        q->indexSend = 0;
    }
    os_mutex_unlock(&q->mutex);
    os_sem_post(&q->semReceive);
#endif
}
 
OS_INLINE int os_mq_timedsend(os_mq_t queue, const void *data, long long timeout)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    portTickType ticks = NSEC_TO_TICK(timeout);
    
    if (xQueueSend(queue, data, ticks) != pdTRUE)
    {
        return OS_MQ_TIMEDOUT;
    }
#else
    DIE("unimplemented.");
#endif
    return OS_MQ_NONE;
}
 
 
OS_INLINE void os_mq_receive(os_mq_t queue, void *data)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    xQueueReceive(queue, data, portMAX_DELAY);
#else
    QueuePriv *q = (QueuePriv*)queue;
    
    os_sem_wait(&q->semReceive);
 
    os_mutex_lock(&q->mutex);
    memcpy(q->buffer + q->indexReceive, data, q->itemSize);
    q->indexReceive += q->itemSize;
    if (q->indexReceive >= q->bytes)
    {
        q->indexReceive = 0;
    }
    os_mutex_unlock(&q->mutex);
    os_sem_post(&q->semSend);
#endif
}
 
OS_INLINE int os_mq_timedreceive(os_mq_t queue, void *data, long long timeout)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    portTickType ticks = NSEC_TO_TICK(timeout);
 
    if (xQueueReceive(queue, data, ticks) != pdTRUE)
    {
        return OS_MQ_TIMEDOUT;
    }
#else
    DIE("unimplemented.");
#endif
    return OS_MQ_NONE;
}
 
OS_INLINE int os_mq_send_from_isr(os_mq_t queue, const void *data, int *woken)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    portBASE_TYPE local_woken;
    if (xQueueSendFromISR(queue, data, &local_woken) != pdTRUE)
    {
        return OS_MQ_FULL;
    }
    *woken |= local_woken;
#else
    DIE("unimplemented.");
#endif
    return OS_MQ_NONE;
}
 
OS_INLINE int os_mq_is_full_from_isr(os_mq_t queue)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return xQueueIsQueueFullFromISR(queue);
#else
    DIE("unimplemented.");
#endif
    return 1;
}
 
 
OS_INLINE int os_mq_receive_from_isr(os_mq_t queue, void *data, int *woken)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    portBASE_TYPE local_woken;
    if (xQueueReceiveFromISR(queue, data, &local_woken) != pdTRUE)
    {
        return OS_MQ_EMPTY;
    }
    *woken |= local_woken;
#else
    DIE("unimplemented.");
#endif
    return OS_MQ_NONE;
}
 
OS_INLINE int os_mq_num_pending(os_mq_t queue)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return uxQueueMessagesWaiting(queue);
#else
    DIE("unimplemented.");
    return 0;
#endif
}
 
OS_INLINE int os_mq_num_pending_from_isr(os_mq_t queue)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return uxQueueMessagesWaitingFromISR(queue);
#else
    DIE("unimplemented.");
    return 0;
#endif
}
 
OS_INLINE int os_mq_num_spaces(os_mq_t queue)
{
#if OPENMRN_FEATURE_MUTEX_FREERTOS
    return uxQueueSpacesAvailable(queue);
#else
    DIE("unimplemented.");
    return 0;
#endif
}
 
#if defined (__FreeRTOS__)
#if !defined (portEND_SWITCHING_ISR)
#define portEND_SWITCHING_ISR(_woken) \
    if( _woken )                      \
    {                                 \
        portYIELD_FROM_ISR();         \
    }
#endif
 
#ifdef TARGET_PIC32MX
 
void __attribute__((nomips16)) os_isr_exit_yield_test(int woken);
 
#else
#define os_isr_exit_yield_test(_woken) \
do                                     \
{                                      \
    portEND_SWITCHING_ISR(_woken);     \
} while(0);
 
#endif // PIC32 or general
#endif
 
extern long long os_get_time_monotonic(void);
 
#if defined (__WIN32__)
OS_INLINE unsigned sleep(unsigned seconds)
{
    usleep(seconds * 1000);
    return 0;
}
#endif
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* _OS_OS_H_ */