Skip to content
charmOS docs

Reader writer lock

include/sync/rwlock.h View source View on GitHub

Structs

Section titled “Structs”

rwlock

Section titled “rwlock”
struct rwlock {
    _Atomic (uintptr_t)  lock_word;
};

Enums

Section titled “Enums”

rwlock_acquire_type

Section titled “rwlock_acquire_type”
enum rwlock_acquire_type {
    RWLOCK_ACQUIRE_READ = 0,
    RWLOCK_ACQUIRE_WRITE = 1,
};

Functions

Section titled “Functions”

rw_lock_internal

Section titled “rw_lock_internal”
void rw_lock_internal(struct rwlock *lock, enum rwlock_acquire_type type, uint8_t subclass, const struct lock_chk_site *site);

rw_unlock_internal

Section titled “rw_unlock_internal”
void rw_unlock_internal(struct rwlock *lock, const struct lock_chk_site *site);

rwlock_init_chk_internal

Section titled “rwlock_init_chk_internal”
void rwlock_init_chk_internal(struct rwlock *lock, enum thread_prio_class ceiling, const struct lock_chk_class *class, enum lock_chk_flags flags);

rwlock_set_chk_flags

Section titled “rwlock_set_chk_flags”
void rwlock_set_chk_flags(struct rwlock *lock, enum lock_chk_flags flags);

rwlock_reinit_chk

Section titled “rwlock_reinit_chk”
void rwlock_reinit_chk(struct rwlock *lock, enum thread_prio_class ceiling, const struct lock_chk_class *class, enum lock_chk_flags flags);

rwlock_locked

Section titled “rwlock_locked”
bool rwlock_locked(struct rwlock *lock, enum rwlock_acquire_type type);

rwlock_assert_held_internal

Section titled “rwlock_assert_held_internal”
void rwlock_assert_held_internal(struct rwlock *lock, enum rwlock_acquire_type type, const struct lock_chk_site *site);

rwlock_assert_not_held_internal

Section titled “rwlock_assert_not_held_internal”
void rwlock_assert_not_held_internal(struct rwlock *lock, const struct lock_chk_site *site);

Macros

Section titled “Macros”

RWLOCK_ASSERT_HELD

Section titled “RWLOCK_ASSERT_HELD”
#define RWLOCK_ASSERT_HELD(lock, type) \
    rwlock_assert_held_internal((lock), (type), LOCK_CHK_SITE_HERE())

RWLOCK_ASSERT_READ

Section titled “RWLOCK_ASSERT_READ”
#define RWLOCK_ASSERT_READ(lock) RWLOCK_ASSERT_HELD((lock), RWLOCK_ACQUIRE_READ)

RWLOCK_ASSERT_WRITE

Section titled “RWLOCK_ASSERT_WRITE”
#define RWLOCK_ASSERT_WRITE(lock) \
    RWLOCK_ASSERT_HELD((lock), RWLOCK_ACQUIRE_WRITE)

RWLOCK_ASSERT_NOT_HELD

Section titled “RWLOCK_ASSERT_NOT_HELD”
#define RWLOCK_ASSERT_NOT_HELD(lock) \
    rwlock_assert_not_held_internal((lock), LOCK_CHK_SITE_HERE())

RWLOCK_PRIO_CEIL_SHIFT

Section titled “RWLOCK_PRIO_CEIL_SHIFT”
#define RWLOCK_PRIO_CEIL_SHIFT (1)

RWLOCK_INIT_CHK

Section titled “RWLOCK_INIT_CHK”
#define RWLOCK_INIT_CHK(ceil_, class_, flags_) \
    ((struct rwlock) { \
        .lock_word = ATOMIC_VAR_INIT((ceil_) << RWLOCK_PRIO_CEIL_SHIFT), \
        .chk = LOCK_CHK_LOCK_VALUE_INIT((class_), (flags_)), \
    })

rwlock_init_chk

Section titled “rwlock_init_chk”
#define rwlock_init_chk(lock_, ceil_, class_, flags_) \
    rwlock_init_chk_internal((lock_), (ceil_), (class_), (flags_))

rwlock_init_auto_internal

Section titled “rwlock_init_auto_internal”
#define rwlock_init_auto_internal(lock_, ceil_, flags_) \
    do { \
        static const struct lock_chk_class __auto_class = { \
            .name = #lock_, \
            .file = __RELFILE__, \
            .line = __LINE__, \
        }; \
        rwlock_init_chk_internal((lock_), (ceil_), &__auto_class, (flags_)); \
    } while (0)

RWLOCK_INIT_CHK

Section titled “RWLOCK_INIT_CHK”
#define RWLOCK_INIT_CHK(ceil_, class_, flags_) \
    ((struct rwlock) { \
        .lock_word = ATOMIC_VAR_INIT((ceil_) << RWLOCK_PRIO_CEIL_SHIFT), \
    })

rwlock_init_chk

Section titled “rwlock_init_chk”
#define rwlock_init_chk(lock_, ceil_, class_, flags_) \
    rwlock_init_chk_internal((lock_), (ceil_), NULL, LOCK_UNCHKD)

rwlock_init_auto_internal

Section titled “rwlock_init_auto_internal”
#define rwlock_init_auto_internal(lock_, ceil_, flags_) \
    rwlock_init_chk_internal((lock_), (ceil_), NULL, LOCK_UNCHKD)

RWLOCK_INIT

Section titled “RWLOCK_INIT”
#define RWLOCK_INIT(ceil_) RWLOCK_INIT_CHK((ceil_), NULL, LOCK_CHKD_FULL)

RWLOCK_DEFINE

Section titled “RWLOCK_DEFINE”
#define RWLOCK_DEFINE(id, ceil_) struct rwlock id = RWLOCK_INIT(ceil_)

RWLOCK_DEFINE_CHK

Section titled “RWLOCK_DEFINE_CHK”
#define RWLOCK_DEFINE_CHK(id, ceil_, class_, flags_) \
    struct rwlock id = RWLOCK_INIT_CHK((ceil_), (class_), (flags_))

rwlock_init_2

Section titled “rwlock_init_2”
#define rwlock_init_2(lock_, ceil_) \
    rwlock_init_auto_internal((lock_), (ceil_), LOCK_CHKD_FULL)

rwlock_init_3

Section titled “rwlock_init_3”
#define rwlock_init_3(lock_, ceil_, flags_) \
    rwlock_init_auto_internal((lock_), (ceil_), (flags_))

rwlock_init

Section titled “rwlock_init”
#define rwlock_init(...) \
    _DISPATCH(rwlock_init, PP_NARG(__VA_ARGS__))(__VA_ARGS__)

rw_lock

Section titled “rw_lock”
#define rw_lock(lock_, type_) \
    rw_lock_internal((lock_), (type_), 0, LOCK_CHK_SITE_HERE())

rw_read_lock

Section titled “rw_read_lock”
#define rw_read_lock(lock_) \
    rw_lock_internal((lock_), RWLOCK_ACQUIRE_READ, 0, LOCK_CHK_SITE_HERE())

rw_write_lock

Section titled “rw_write_lock”
#define rw_write_lock(lock_) \
    rw_lock_internal((lock_), RWLOCK_ACQUIRE_WRITE, 0, LOCK_CHK_SITE_HERE())

rw_read_lock_subclass

Section titled “rw_read_lock_subclass”
#define rw_read_lock_subclass(lock_, subclass_) \
    rw_lock_internal((lock_), RWLOCK_ACQUIRE_READ, (subclass_), \
                     LOCK_CHK_SITE_HERE())

rw_write_lock_subclass

Section titled “rw_write_lock_subclass”
#define rw_write_lock_subclass(lock_, subclass_) \
    rw_lock_internal((lock_), RWLOCK_ACQUIRE_WRITE, (subclass_), \
                     LOCK_CHK_SITE_HERE())

rw_unlock

Section titled “rw_unlock”
#define rw_unlock(lock_) rw_unlock_internal((lock_), LOCK_CHK_SITE_HERE())