Skip to content
charmOS docs

Sequence Lock

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

Structs

Section titled “Structs”

seqcount

Section titled “seqcount”
struct seqcount {
    _Atomic uint32_t  sequence;
};

seqlock

Section titled “seqlock”
struct seqlock {
    struct seqcount  seqcount;
    struct spinlock  lock;
};

Type Aliases

Section titled “Type Aliases”

seqcount_t

Section titled “seqcount_t”
typedef struct seqcount seqcount_t;

seqlock_t

Section titled “seqlock_t”
typedef struct seqlock seqlock_t;

Functions

Section titled “Functions”

seqcount_init

Section titled “seqcount_init”
void seqcount_init(struct seqcount *s);

seqcount_read_raw

Section titled “seqcount_read_raw”
uint32_t seqcount_read_raw(const struct seqcount *s);

seqcount_begin_read_raw

Section titled “seqcount_begin_read_raw”
uint32_t seqcount_begin_read_raw(const struct seqcount *s);

seqcount_begin_read

Section titled “seqcount_begin_read”
uint32_t seqcount_begin_read(const struct seqcount *s);

seqcount_read_retry

Section titled “seqcount_read_retry”
bool seqcount_read_retry(const struct seqcount *s, uint32_t start);

seqcount_begin_write

Section titled “seqcount_begin_write”
void seqcount_begin_write(struct seqcount *s);

seqcount_end_write

Section titled “seqcount_end_write”
void seqcount_end_write(struct seqcount *s);

seqlock_init_chk_internal

Section titled “seqlock_init_chk_internal”
void seqlock_init_chk_internal(struct seqlock *sl, const struct lock_chk_class *class, enum lock_chk_flags flags);

seq_begin_read

Section titled “seq_begin_read”
uint32_t seq_begin_read(const struct seqlock *sl);

seq_read_retry

Section titled “seq_read_retry”
bool seq_read_retry(const struct seqlock *sl, uint32_t start);

seq_begin_read_raw

Section titled “seq_begin_read_raw”
uint32_t seq_begin_read_raw(const struct seqlock *sl);

seq_read_raw

Section titled “seq_read_raw”
uint32_t seq_read_raw(const struct seqlock *sl);

seq_write_lock

Section titled “seq_write_lock”
enum irql seq_write_lock(struct seqlock *sl);

seq_write_lock_irq_disable

Section titled “seq_write_lock_irq_disable”
enum irql seq_write_lock_irq_disable(struct seqlock *sl);

seq_write_unlock

Section titled “seq_write_unlock”
void seq_write_unlock(struct seqlock *sl, enum irql old);

seq_write_lock_raw

Section titled “seq_write_lock_raw”
void seq_write_lock_raw(struct seqlock *sl);

seq_write_unlock_raw

Section titled “seq_write_unlock_raw”
void seq_write_unlock_raw(struct seqlock *sl);

seq_try_write_lock

Section titled “seq_try_write_lock”
bool seq_try_write_lock(struct seqlock *sl, enum irql *out);

seq_try_write_lock_irq_disable

Section titled “seq_try_write_lock_irq_disable”
bool seq_try_write_lock_irq_disable(struct seqlock *sl, enum irql *out);

seq_try_write_lock_raw

Section titled “seq_try_write_lock_raw”
bool seq_try_write_lock_raw(struct seqlock *sl);

seqlock_is_writing

Section titled “seqlock_is_writing”
bool seqlock_is_writing(const struct seqlock *sl);

seqlock_held

Section titled “seqlock_held”
bool seqlock_held(const struct seqlock *sl);

Macros

Section titled “Macros”

SEQCOUNT_INIT

Section titled “SEQCOUNT_INIT”
#define SEQCOUNT_INIT \
    (struct seqcount) { \
        .sequence = ATOMIC_VAR_INIT(0) \
    }

SEQLOCK_INIT_CHK

Section titled “SEQLOCK_INIT_CHK”
#define SEQLOCK_INIT_CHK(class_, flags_) \
    (struct seqlock) { \
        .seqcount = SEQCOUNT_INIT, \
        .lock = SPINLOCK_INIT_CHK((class_), (flags_)) \
    }

SEQLOCK_INIT

Section titled “SEQLOCK_INIT”
#define SEQLOCK_INIT SEQLOCK_INIT_CHK(NULL, LOCK_CHKD_FULL)

SEQLOCK_DEFINE

Section titled “SEQLOCK_DEFINE”
#define SEQLOCK_DEFINE(id) struct seqlock id = SEQLOCK_INIT

SEQLOCK_DEFINE_CHK

Section titled “SEQLOCK_DEFINE_CHK”
#define SEQLOCK_DEFINE_CHK(id, class_, flags_) \
    struct seqlock id = SEQLOCK_INIT_CHK((class_), (flags_))

seqlock_init_chk

Section titled “seqlock_init_chk”
#define seqlock_init_chk(sl_, class_, flags_) \
    seqlock_init_chk_internal((sl_), (class_), (flags_))

seqlock_init_auto_internal

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

seqlock_init_chk

Section titled “seqlock_init_chk”
#define seqlock_init_chk(sl_, class_, flags_) \
    seqlock_init_chk_internal((sl_), NULL, LOCK_UNCHKD)

seqlock_init_auto_internal

Section titled “seqlock_init_auto_internal”
#define seqlock_init_auto_internal(sl_, flags_) \
    seqlock_init_chk_internal((sl_), NULL, LOCK_UNCHKD)

seqlock_init_1

Section titled “seqlock_init_1”
#define seqlock_init_1(sl_) seqlock_init_auto_internal((sl_), LOCK_CHKD_FULL)

seqlock_init_2

Section titled “seqlock_init_2”
#define seqlock_init_2(sl_, flags_) seqlock_init_auto_internal((sl_), (flags_))

seqlock_init

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

SEQLOCK_ASSERT_HELD

Section titled “SEQLOCK_ASSERT_HELD”
#define SEQLOCK_ASSERT_HELD(sl) kassert(seqlock_held(sl))