mutex.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_SYS_MUTEX_H_
#define ZEPHYR_INCLUDE_SYS_MUTEX_H_
 
/*
 * sys_mutex behaves almost exactly like k_mutex, with the added advantage
 * that a sys_mutex instance can reside in user memory.
 *
 * Further enhancements will support locking/unlocking uncontended sys_mutexes
 * with simple atomic ops instead of syscalls, similar to Linux's
 * FUTEX_LOCK_PI and FUTEX_UNLOCK_PI
 */
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifdef CONFIG_USERSPACE
#include <zephyr/sys/atomic.h>
#include <zephyr/types.h>
#include <zephyr/sys_clock.h>
 
struct sys_mutex {
        /* Currently unused, but will be used to store state for fast mutexes
         * that can be locked/unlocked with atomic ops if there is no
         * contention
         */
        atomic_t val;
};
 
#define SYS_MUTEX_DEFINE(name) \
        struct sys_mutex name
 
static inline void sys_mutex_init(struct sys_mutex *mutex)
{
        ARG_UNUSED(mutex);
 
        /* Nothing to do, kernel-side data structures are initialized at
         * boot
         */
}
 
__syscall int z_sys_mutex_kernel_lock(struct sys_mutex *mutex,
                                      k_timeout_t timeout);
 
__syscall int z_sys_mutex_kernel_unlock(struct sys_mutex *mutex);
 
static inline int sys_mutex_lock(struct sys_mutex *mutex, k_timeout_t timeout)
{
        /* For now, make the syscall unconditionally */
        return z_sys_mutex_kernel_lock(mutex, timeout);
}
 
static inline int sys_mutex_unlock(struct sys_mutex *mutex)
{
        /* For now, make the syscall unconditionally */
        return z_sys_mutex_kernel_unlock(mutex);
}
 
#include <syscalls/mutex.h>
 
#else
#include <zephyr/kernel.h>
#include <zephyr/kernel_structs.h>
 
struct sys_mutex {
        struct k_mutex kernel_mutex;
};
 
#define SYS_MUTEX_DEFINE(name) \
        struct sys_mutex name = { \
                .kernel_mutex = Z_MUTEX_INITIALIZER(name.kernel_mutex) \
        }
 
static inline void sys_mutex_init(struct sys_mutex *mutex)
{
        k_mutex_init(&mutex->kernel_mutex);
}
 
static inline int sys_mutex_lock(struct sys_mutex *mutex, k_timeout_t timeout)
{
        return k_mutex_lock(&mutex->kernel_mutex, timeout);
}
 
static inline int sys_mutex_unlock(struct sys_mutex *mutex)
{
        return k_mutex_unlock(&mutex->kernel_mutex);
}
 
#endif /* CONFIG_USERSPACE */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_SYS_MUTEX_H_ */