sig_thread.h

sig_mutex

typedef union {
    void *sig_align;
    unsigned char sig_opaque[64];
} sig_mutex;

Opaque buffers sized to hold the largest common pthread backing type with headroom; sig_thread_posix.c static_asserts this at compile time so a mismatch fails the build, not silently corrupts memory.

sig_mutex_attr

typedef union {
    void *sig_align;
    unsigned char sig_opaque[16];
} sig_mutex_attr;

shared with sig_mutex

Opaque buffers sized to hold the largest common pthread backing type with headroom; sig_thread_posix.c static_asserts this at compile time so a mismatch fails the build, not silently corrupts memory.

sig_condition

typedef union {
    void *sig_align;
    unsigned char sig_opaque[64];
} sig_condition;

shared with sig_mutex

Opaque buffers sized to hold the largest common pthread backing type with headroom; sig_thread_posix.c static_asserts this at compile time so a mismatch fails the build, not silently corrupts memory.

sig_rwlock

typedef struct {
    sig_mutex mtx;
    sig_condition cond;
    int readers;
    int writer_active;
    int writers_waiting;
} sig_rwlock;

Reader/writer lock built from sig_mutex + sig_condition so any port that provides those two gets it. Many readers or one writer; a waiting writer blocks new readers, so writers are not starved. Not recursive.

sig_tls_key

typedef union {
    void *sig_align;
    unsigned char sig_opaque[16];
} sig_tls_key;

shared with sig_rwlock

Reader/writer lock built from sig_mutex + sig_condition so any port that provides those two gets it. Many readers or one writer; a waiting writer blocks new readers, so writers are not starved. Not recursive.

sig_thread

typedef union {
    void *sig_align;
    unsigned char sig_opaque[16];
} sig_thread;

shared with sig_rwlock

Reader/writer lock built from sig_mutex + sig_condition so any port that provides those two gets it. Many readers or one writer; a waiting writer blocks new readers, so writers are not starved. Not recursive.

sig_thread_start_fn

typedef void *(*sig_thread_start_fn)(void *arg);

sig_mutex_attr_init

sig_status_t sig_mutex_attr_init(sig_mutex_attr * attr)

sig_mutex_attr_destroy

sig_status_t sig_mutex_attr_destroy(sig_mutex_attr * attr)

sig_mutex_init

sig_status_t sig_mutex_init(sig_mutex * mtx, sig_mutex_attr * attr)

sig_mutex_destroy

sig_status_t sig_mutex_destroy(sig_mutex * mtx)

sig_mutex_lock

sig_status_t sig_mutex_lock(sig_mutex * mtx)

sig_mutex_unlock

sig_status_t sig_mutex_unlock(sig_mutex * mtx)

sig_condition_init

sig_status_t sig_condition_init(sig_condition * cond)

sig_condition_destroy

sig_status_t sig_condition_destroy(sig_condition * cond)

sig_condition_wait

sig_status_t sig_condition_wait(sig_condition * cond, sig_mutex * mtx)

sig_condition_notify

sig_status_t sig_condition_notify(sig_condition * cond)

Wakes ALL waiters (broadcast semantics on every platform): the rwlock relies on it, and a port must not weaken it to wake a single waiter.

sig_condition_timedwait

sig_status_t sig_condition_timedwait(sig_condition * cond, sig_mutex * mtx, const struct timespec * abstime)

Waits on cond until either notified or *abstime (an absolute CLOCK_MONOTONIC deadline, e.g. from sig_time_now() plus an offset) is reached. Returns SIG_OK on either a real notify or a timeout -- callers distinguish "did my condition become true" by re-checking their own state after the call returns, exactly as with sig_condition_wait(). Returns SIG_ERR_PLATFORM only on a genuine underlying error.

sig_rwlock_init

sig_status_t sig_rwlock_init(sig_rwlock * l)

sig_rwlock_destroy

sig_status_t sig_rwlock_destroy(sig_rwlock * l)

sig_rwlock_rdlock

sig_status_t sig_rwlock_rdlock(sig_rwlock * l)

sig_rwlock_wrlock

sig_status_t sig_rwlock_wrlock(sig_rwlock * l)

sig_rwlock_unlock

sig_status_t sig_rwlock_unlock(sig_rwlock * l)

Releases whichever mode the calling thread holds.

sig_tls_key_create

sig_status_t sig_tls_key_create(sig_tls_key * key)

sig_tls_key_delete

sig_status_t sig_tls_key_delete(sig_tls_key * key)

sig_tls_get

sig_status_t sig_tls_get(sig_tls_key key, void ** out_value)

sig_tls_set

sig_status_t sig_tls_set(sig_tls_key key, void * value)

sig_thread_create

sig_status_t sig_thread_create(sig_thread * thread, sig_thread_start_fn start, void * arg)

sig_thread_join

sig_status_t sig_thread_join(sig_thread * thread, void ** out_ret)