COND_INIT(9)

💅 cond_init(9) — the wait condition API, explained by your local Unix bestie ✨

okay so bestie, we're in cond_init(9) territory today — kernel developer's manual, wait-condition edition. this is the whole "make a thread nap until something's done" situation and honestly? it's giving synchronization slay 🎀

---

✨ SYNOPSIS ✨

#include <sys/systm.h>

void
cond_init(struct cond *c);

void
cond_wait(struct cond *c, const char *wmesg);

void
cond_signal(struct cond *c);

void
cond_signal_handler(void *c);

COND_INITIALIZER();

---

🌸 DESCRIPTION 🌸

so the wait condition API is literally the "go to sleep, queen, I'll wake you when it's done" of the kernel 👑 it lets a thread sleep while it waits for a notification — aka a signal — that pending work has completed. no cap.

• cond_init() — initialises the wait condition c for use. that's it, that's the vibe check ✅
• cond_wait() — this is the actual napping function 💤 it sleeps on the wait condition c until whatever the thread is waiting on calls cond_signal() or cond_signal_handler(). and wmesg? it's a pointer to a character string that says why the thread is sleeping — like a little "do not disturb: tqbar" note on the door 🙈
• cond_signal() and cond_signal_handler() — these two are the "wake up bestie, the work is finished, you may proceed" notification 💖 and listen, they operate identically, the only difference is the type of argument they take. cond_signal_handler() takes a void * argument, which is lowkey iconic because it means you can use it directly with APIs such as task_set(9) and timeout_set(9) 🫶
• COND_INITIALIZER() — initialises a declaration of a cond for use 🌈

---

🦋 CONTEXT 🦋

where can you call these? good question, bestie:

• cond_init(), cond_signal(), and cond_signal_handler() can be called during autoconf, from process context, or from interrupt context 🔥 flexible queens.
• cond_wait() can be called from process context. that's the one.

---

🍓 EXAMPLES 🍓

not me about to show you real production code 😭 taskq_barrier(9) is implemented using the wait condition API, and here's a commented copy of the implementation — fr fr, this is the actual source:

static void     taskq_barrier_task(void *);

void
taskq_barrier(struct taskq *tq)
{
        struct cond c;
        struct task t;

        /*
         * any currently running work has to have finished
         * before this new task can be run.
         */

        cond_init(&c);
        task_init(&t, taskq_barrier_task, &c);

        task_add(tq, &t);

        /* wait until the task runs and signals completion */
        cond_wait(&c, "tqbar");
}

static void
taskq_barrier_task(void *p)
{
        struct cond *c = p;

        /*
         * all previous tasks have run, signal the thread waiting
         * in taskq_barrier
         */

        cond_signal(c);
}

see how it all comes together? cond_init(&c) sets it up, cond_wait(&c, "tqbar") has the thread chilling until the task signals, and then cond_signal(c) in the task function is the "you're up, babe" 💅 main character energy from start to finish.

---

okay that's the whole page, bestie 💜 this lil breakdown came to you from the Debian source, dated July 28, 2025 — go forth and synchronize your threads, you absolute icon 🧚✨