sync.h

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#ifndef OVE_SYNC_H
#define OVE_SYNC_H
 
#include "ove/types.h"
#include "ove_config.h"
#include "ove/storage.h"
#include "ove/time.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifdef CONFIG_OVE_SYNC
 
/* =========================================================================
 * Mutex — _init / _deinit (static storage)
 * ========================================================================= */
 
OVE_NODISCARD int ove_mutex_init(ove_mutex_t *mtx, ove_mutex_storage_t *storage) OVE_NONNULL(1, 2);
 
void ove_mutex_deinit(ove_mutex_t mtx);
 
/* =========================================================================
 * Semaphore — _init / _deinit (static storage)
 * ========================================================================= */
 
OVE_NODISCARD int ove_sem_init(ove_sem_t *sem, ove_sem_storage_t *storage, unsigned int initial,
                   unsigned int max) OVE_NONNULL(1, 2);
 
void ove_sem_deinit(ove_sem_t sem);
 
/* =========================================================================
 * Binary event — _init / _deinit (static storage)
 * ========================================================================= */
 
OVE_NODISCARD int ove_event_init(ove_event_t *evt, ove_event_storage_t *storage) OVE_NONNULL(1, 2);
 
void ove_event_deinit(ove_event_t evt);
 
/* =========================================================================
 * Recursive mutex — _init (static storage)
 * ========================================================================= */
 
OVE_NODISCARD int ove_recursive_mutex_init(ove_mutex_t *mtx, ove_mutex_storage_t *storage)
    OVE_NONNULL(1, 2);
 
/* =========================================================================
 * Condition variable — _init / _deinit (static storage)
 * ========================================================================= */
 
OVE_NODISCARD int ove_condvar_init(ove_condvar_t *cv, ove_condvar_storage_t *storage)
    OVE_NONNULL(1, 2);
 
void ove_condvar_deinit(ove_condvar_t cv);
 
/* =========================================================================
 * Heap-gated _create / _destroy variants
 * ========================================================================= */
 
#ifdef OVE_HEAP_SYNC
 
OVE_NODISCARD int ove_mutex_create(ove_mutex_t *mtx) OVE_NONNULL(1);
 
void ove_mutex_destroy(ove_mutex_t mtx);
 
OVE_NODISCARD int ove_sem_create(ove_sem_t *sem, unsigned int initial, unsigned int max)
    OVE_NONNULL(1);
 
void ove_sem_destroy(ove_sem_t sem);
 
OVE_NODISCARD int ove_event_create(ove_event_t *evt) OVE_NONNULL(1);
 
void ove_event_destroy(ove_event_t evt);
 
OVE_NODISCARD int ove_recursive_mutex_create(ove_mutex_t *mtx) OVE_NONNULL(1);
 
void ove_recursive_mutex_destroy(ove_mutex_t mtx);
 
OVE_NODISCARD int ove_condvar_create(ove_condvar_t *cv) OVE_NONNULL(1);
 
void ove_condvar_destroy(ove_condvar_t cv);
 
#endif /* OVE_HEAP_SYNC */
 
/* =========================================================================
 * Operations — always available (when CONFIG_OVE_SYNC is set)
 * ========================================================================= */
 
OVE_NODISCARD int ove_mutex_lock(ove_mutex_t mtx, uint64_t timeout_ns) OVE_NONNULL(1);
 
OVE_NODISCARD static inline int ove_mutex_lock_until(ove_mutex_t mtx, uint64_t deadline_ns)
{
    return ove_mutex_lock(mtx, ove_time_deadline_to_timeout_ns(deadline_ns));
}
 
void ove_mutex_unlock(ove_mutex_t mtx);
 
OVE_NODISCARD int ove_sem_take(ove_sem_t sem, uint64_t timeout_ns) OVE_NONNULL(1);
 
OVE_NODISCARD static inline int ove_sem_take_until(ove_sem_t sem, uint64_t deadline_ns)
{
    return ove_sem_take(sem, ove_time_deadline_to_timeout_ns(deadline_ns));
}
 
void ove_sem_give(ove_sem_t sem);
 
int ove_sem_set_notify(ove_sem_t sem, ove_notify_cb cb, void *user_data) OVE_NONNULL(1);
 
OVE_NODISCARD int ove_event_wait(ove_event_t evt, uint64_t timeout_ns) OVE_NONNULL(1);
 
OVE_NODISCARD static inline int ove_event_wait_until(ove_event_t evt, uint64_t deadline_ns)
{
    return ove_event_wait(evt, ove_time_deadline_to_timeout_ns(deadline_ns));
}
 
void ove_event_signal(ove_event_t evt);
 
void ove_event_signal_from_isr(ove_event_t evt);
 
OVE_NODISCARD int ove_recursive_mutex_lock(ove_mutex_t mtx, uint64_t timeout_ns) OVE_NONNULL(1);
 
OVE_NODISCARD static inline int ove_recursive_mutex_lock_until(ove_mutex_t mtx,
                                   uint64_t deadline_ns)
{
    return ove_recursive_mutex_lock(mtx, ove_time_deadline_to_timeout_ns(deadline_ns));
}
 
void ove_recursive_mutex_unlock(ove_mutex_t mtx);
 
OVE_NODISCARD int ove_condvar_wait(ove_condvar_t cv, ove_mutex_t mtx, uint64_t timeout_ns)
    OVE_NONNULL(1, 2);
 
OVE_NODISCARD static inline int ove_condvar_wait_until(ove_condvar_t cv, ove_mutex_t mtx,
                               uint64_t deadline_ns)
{
    return ove_condvar_wait(cv, mtx, ove_time_deadline_to_timeout_ns(deadline_ns));
}
 
void ove_condvar_signal(ove_condvar_t cv);
 
void ove_condvar_broadcast(ove_condvar_t cv);
 
#else /* !CONFIG_OVE_SYNC */
 
/* P0-3: _init/_deinit stubs so OVE_*_DEFINE_STATIC links cleanly when
 * CONFIG_OVE_SYNC=n. The macros expand to a constructor that calls the
 * _init function unconditionally; without these stubs, the link fails. */
static inline int ove_mutex_init(ove_mutex_t *m, ove_mutex_storage_t *s)
{
    (void)m;
    (void)s;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_mutex_deinit(ove_mutex_t m)
{
    (void)m;
}
static inline int ove_sem_init(ove_sem_t *s, ove_sem_storage_t *st, unsigned int i, unsigned int x)
{
    (void)s;
    (void)st;
    (void)i;
    (void)x;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_sem_deinit(ove_sem_t s)
{
    (void)s;
}
static inline int ove_event_init(ove_event_t *e, ove_event_storage_t *s)
{
    (void)e;
    (void)s;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_event_deinit(ove_event_t e)
{
    (void)e;
}
static inline int ove_recursive_mutex_init(ove_mutex_t *m, ove_mutex_storage_t *s)
{
    (void)m;
    (void)s;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline int ove_condvar_init(ove_condvar_t *c, ove_condvar_storage_t *s)
{
    (void)c;
    (void)s;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_condvar_deinit(ove_condvar_t c)
{
    (void)c;
}
 
static inline int ove_mutex_create(ove_mutex_t *m)
{
    (void)m;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_mutex_destroy(ove_mutex_t m)
{
    (void)m;
}
static inline int ove_mutex_lock(ove_mutex_t m, uint64_t t)
{
    (void)m;
    (void)t;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_mutex_unlock(ove_mutex_t m)
{
    (void)m;
}
static inline int ove_sem_create(ove_sem_t *s, unsigned int i, unsigned int x)
{
    (void)s;
    (void)i;
    (void)x;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_sem_destroy(ove_sem_t s)
{
    (void)s;
}
static inline int ove_sem_take(ove_sem_t s, uint64_t t)
{
    (void)s;
    (void)t;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline int ove_sem_set_notify(ove_sem_t s, ove_notify_cb cb, void *ud)
{
    (void)s;
    (void)cb;
    (void)ud;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_sem_give(ove_sem_t s)
{
    (void)s;
}
static inline int ove_event_create(ove_event_t *e)
{
    (void)e;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_event_destroy(ove_event_t e)
{
    (void)e;
}
static inline int ove_event_wait(ove_event_t e, uint64_t t)
{
    (void)e;
    (void)t;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_event_signal(ove_event_t e)
{
    (void)e;
}
static inline void ove_event_signal_from_isr(ove_event_t e)
{
    (void)e;
}
static inline int ove_recursive_mutex_create(ove_mutex_t *m)
{
    (void)m;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline int ove_recursive_mutex_lock(ove_mutex_t m, uint64_t t)
{
    (void)m;
    (void)t;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_recursive_mutex_unlock(ove_mutex_t m)
{
    (void)m;
}
static inline void ove_recursive_mutex_destroy(ove_mutex_t m)
{
    (void)m;
}
static inline int ove_condvar_create(ove_condvar_t *c)
{
    (void)c;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_condvar_destroy(ove_condvar_t c)
{
    (void)c;
}
static inline int ove_condvar_wait(ove_condvar_t c, ove_mutex_t m, uint64_t t)
{
    (void)c;
    (void)m;
    (void)t;
    return OVE_ERR_NOT_SUPPORTED;
}
static inline void ove_condvar_signal(ove_condvar_t c)
{
    (void)c;
}
static inline void ove_condvar_broadcast(ove_condvar_t c)
{
    (void)c;
}
 
#endif /* CONFIG_OVE_SYNC */
 
#ifdef __cplusplus
}
#endif
 
#endif /* OVE_SYNC_H */