mutex.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2015 Kaspar Schleiser <kaspar@schleiser.de>
 * SPDX-FileCopyrightText: 2013-2014 Freie Universität Berlin
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
 
#include "architecture.h"
#include "kernel_defines.h"
#include "list.h"
#include "thread.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct {
    list_node_t queue;
#if defined(DOXYGEN) || defined(MODULE_CORE_MUTEX_PRIORITY_INHERITANCE) \
    || defined(MODULE_CORE_MUTEX_DEBUG)
    kernel_pid_t owner;
#endif
#if defined(DOXYGEN) || defined(MODULE_CORE_MUTEX_DEBUG)
    uinttxtptr_t owner_calling_pc;
#endif
#if defined(DOXYGEN) || defined(MODULE_CORE_MUTEX_PRIORITY_INHERITANCE)
    uint8_t owner_original_priority;
#endif
} mutex_t;
 
bool mutex_lock_internal(mutex_t *mutex, bool block);
 
typedef struct {
    mutex_t *mutex;     
    thread_t *thread;   
    uint8_t cancelled;  
} mutex_cancel_t;
 
#ifndef __cplusplus
#  define MUTEX_INIT { .queue = { .next = NULL } }
 
#  define MUTEX_INIT_LOCKED { .queue = { .next = MUTEX_LOCKED } }
#else
#  define MUTEX_INIT {}
#  define MUTEX_INIT_LOCKED { { MUTEX_LOCKED } }
#endif /* __cplusplus */
 
#define MUTEX_LOCKED ((list_node_t *)-1)
static inline void mutex_init(mutex_t *mutex)
{
    mutex->queue.next = NULL;
}
 
static inline void mutex_init_locked(mutex_t *mutex)
{
    *mutex = (mutex_t)MUTEX_INIT_LOCKED;
}
 
static inline mutex_cancel_t mutex_cancel_init(mutex_t *mutex)
{
    mutex_cancel_t result = { mutex, thread_get_active(), 0 };
 
    return result;
}
 
static inline int mutex_trylock(mutex_t *mutex)
{
    return mutex_lock_internal(mutex, false);
}
 
static inline void mutex_lock(mutex_t *mutex)
{
#if (MAXTHREADS > 1)
    mutex_lock_internal(mutex, true);
#else
    /* dummy implementation for when no scheduler is used */
    /* (ab)use next pointer as lock variable */
    volatile uintptr_t *lock = (void *)&mutex->queue.next;
 
    /* spin until lock is released (e.g. by interrupt).
     *
     * Note: since only the numbers 0 and 1 are ever stored in lock, this
     * read does not need to be atomic here - even while a concurrent write
     * is performed on lock, a read will still either yield 0 or 1 (so the old
     * or new value, which both is fine), even if the lock is read out byte-wise
     * (e.g. on AVR).
     */
    while (*lock) {}
 
    /* set lock variable */
    *lock = 1;
#endif
}
 
int mutex_lock_cancelable(mutex_cancel_t *mc);
 
#if (MAXTHREADS > 1) || DOXYGEN
void mutex_unlock(mutex_t *mutex);
#else
static inline void mutex_unlock(mutex_t *mutex)
{
    /* (ab)use next pointer as lock variable */
    mutex->queue.next = NULL;
}
#endif
 
void mutex_unlock_and_sleep(mutex_t *mutex);
 
void mutex_cancel(mutex_cancel_t *mc);
 
#ifdef __cplusplus
}
#endif