atomic.h

#ifndef KERNEL_ATOMIC_H
#define KERNEL_ATOMIC_H
 
#ifdef __STDC_NO_ATOMICS__
#error No standard atomic header available, are you compiling using C11 at least ?
#endif
 
#include <kernel/types.h>
 
#include <utils/compiler.h>
 
#include <stdatomic.h>
 
#define __atomic_t native_t
 
typedef struct {
    _Atomic __atomic_t val; 
} atomic_t;
 
static_assert(sizeof(atomic_t) == sizeof(__atomic_t));
static_assert(offsetof(atomic_t, val) == 0);
 
#define atomic_cast(val)                                                  \
    ({                                                                    \
        _Static_assert(same_size(atomic_t, *val), "Invalid atomic cast"); \
        (atomic_t *)(val);                                                \
    })
 
#define const_atomic_cast(val)                                            \
    ({                                                                    \
        _Static_assert(same_size(atomic_t, *val), "Invalid const atomic " \
                                                  "cast");                \
        (const atomic_t *)(val);                                          \
    })
 
#define READ_ONCE(_x)                                                         \
    ({                                                                        \
        _Static_assert(is_native_word(_x), "Variable is not of native size"); \
        *(const volatile typeof(_x) *)&(_x);                                  \
    })
 
#define WRITE_ONCE(_x, _val)                                                  \
    ({                                                                        \
        _Static_assert(is_native_word(_x), "Variable is not of native size"); \
        *(volatile typeof(_x) *)&(_x) = (_val);                               \
    })
 
#define stdatomic_read atomic_load
#define stdatomic_write atomic_store
#define stdatomic_add atomic_fetch_add
#define stdatomic_sub atomic_fetch_sub
 
/*
 * Defined inside stdatomic.h, but we need to redefine it ourselves to be able
 * to reuse the atomic_exchange() name. This definition is taken straight from
 * the original stdatomic.h implementation of atomic_exchange.
 */
#undef atomic_exchange
#define stdatomic_exchange(atomic, val) \
    atomic_exchange_explicit(atomic, val, memory_order_seq_cst);
 
static ALWAYS_INLINE __atomic_t atomic_read(const atomic_t *atomic)
{
    return stdatomic_read(&atomic->val);
}
 
static ALWAYS_INLINE void atomic_write(atomic_t *atomic, __atomic_t val)
{
    stdatomic_write(&atomic->val, val);
}
 
static ALWAYS_INLINE __atomic_t atomic_exchange(atomic_t *atomic,
                                                __atomic_t val)
{
    return stdatomic_exchange(&atomic->val, val);
}
 
static ALWAYS_INLINE __atomic_t atomic_add(atomic_t *atomic, __atomic_t val)
{
    return stdatomic_add(&atomic->val, val);
}
 
static ALWAYS_INLINE __atomic_t atomic_sub(atomic_t *atomic, __atomic_t val)
{
    return stdatomic_sub(&atomic->val, val);
}
 
static ALWAYS_INLINE __atomic_t atomic_inc(atomic_t *atomic)
{
    return atomic_add(atomic, 1);
}
 
static ALWAYS_INLINE __atomic_t atomic_dec(atomic_t *atomic)
{
    return atomic_sub(atomic, 1);
}
 
#endif /* KERNEL_ATOMIC_H */