sem.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_SYS_SEM_H_
#define ZEPHYR_INCLUDE_SYS_SEM_H_
 
/*
 * sys_sem exists in user memory working as counter semaphore for
 * user mode thread when user mode enabled. When user mode isn't
 * enabled, sys_sem behaves like k_sem.
 */
 
#include <zephyr/kernel.h>
#include <zephyr/sys/atomic.h>
#include <zephyr/types.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/sys/__assert.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct sys_sem {
#ifdef CONFIG_USERSPACE
        struct k_futex futex;
        int limit;
#else
        struct k_sem kernel_sem;
#endif
};
 
#ifdef CONFIG_USERSPACE
#define SYS_SEM_DEFINE(_name, _initial_count, _count_limit) \
        struct sys_sem _name = { \
                .futex = { _initial_count }, \
                .limit = _count_limit \
        }; \
        BUILD_ASSERT(((_count_limit) != 0) && \
                     ((_initial_count) <= (_count_limit)))
#else
/* Stuff this in the section with the rest of the k_sem objects, since they
 * are identical and can be treated as a k_sem in the boot initialization code
 */
#define SYS_SEM_DEFINE(_name, _initial_count, _count_limit) \
        STRUCT_SECTION_ITERABLE_ALTERNATE(k_sem, sys_sem, _name) = { \
                .kernel_sem = Z_SEM_INITIALIZER(_name.kernel_sem, \
                                                _initial_count, _count_limit) \
        }; \
        BUILD_ASSERT(((_count_limit) != 0) && \
                     ((_initial_count) <= (_count_limit)))
#endif
 
int sys_sem_init(struct sys_sem *sem, unsigned int initial_count,
                unsigned int limit);
 
int sys_sem_give(struct sys_sem *sem);
 
int sys_sem_take(struct sys_sem *sem, k_timeout_t timeout);
 
unsigned int sys_sem_count_get(struct sys_sem *sem);
 
#if defined(__GNUC__)
static ALWAYS_INLINE void z_sys_sem_lock_onexit(__maybe_unused int *rc)
{
        __ASSERT(*rc == 1, "SYS_SEM_LOCK exited with goto, break or return, "
                           "use SYS_SEM_LOCK_BREAK instead.");
}
#define SYS_SEM_LOCK_ONEXIT __attribute__((__cleanup__(z_sys_sem_lock_onexit)))
#else
#define SYS_SEM_LOCK_ONEXIT
#endif
 
#define SYS_SEM_LOCK_BREAK continue
 
#define SYS_SEM_LOCK(sem)                                                                          \
        for (int __rc SYS_SEM_LOCK_ONEXIT = sys_sem_take((sem), K_FOREVER); ({                     \
                     __ASSERT(__rc >= 0, "Failed to take sem: %d", __rc);                          \
                     __rc == 0;                                                                    \
             });                                                                                   \
             ({                                                                                    \
                     __rc = sys_sem_give((sem));                                                   \
                     __ASSERT(__rc == 0, "Failed to give sem: %d", __rc);                          \
             }),                                                                                   \
                      __rc = 1)
 
#ifdef __cplusplus
}
#endif
 
#endif