KCPUSET(9)

💅 KCPUSET(9) — dynamic kernel CPU sets, explained by your fave kernel dev bestie

okay so this is a page from the Kernel Developer's Manual, and it's all about kcpuset — the dynamic kernel CPU sets. if you live in kernel land and you've ever needed to keep track of "which CPUs are in my group", this is literally your girl. no cap, it's iconic. ✨

🌸 NAME 🌸

kcpuset, kcpuset_create, kcpuset_destroy, kcpuset_clone, kcpuset_copy, kcpuset_use, kcpuset_unuse, kcpuset_copyin, kcpuset_copyout, kcpuset_zero, kcpuset_fill, kcpuset_set, kcpuset_clear, kcpuset_isset, kcpuset_isotherset, kcpuset_iszero, kcpuset_match, kcpuset_intersect, kcpuset_merge, kcpuset_remove, kcpuset_ffs, kcpuset_ffs_intersecting, kcpuset_countset, kcpuset_atomic_set, kcpuset_atomic_clear, kcpuset_atomicly_intersect, kcpuset_atomicly_merge, kcpuset_atomicly_remove, kcpuset_export_32

...and that whole squad is just: dynamic kernel CPU sets. periodt. 👑

---

🎀 SYNOPSIS 🎀

like every good kernel page, we start with an include. here's the whole lineup, bestie, verbatim:

#include <sys/kcpuset.h>

void
kcpuset_create(kcpuset_t **retkcp, bool zero);

void
kcpuset_destroy(kcpuset_t *kcp);

void
kcpuset_clone(kcpuset_t **retkcp, const kcpuset_t *skcp);

void
kcpuset_copy(kcpuset_t *dkcp, const kcpuset_t *skcp);

void
kcpuset_use(kcpuset_t *kcp);

void
kcpuset_unuse(kcpuset_t *kcp, kcpuset_t **lst);

int
kcpuset_copyin(const cpuset_t *ucp, kcpuset_t *kcp, size_t len);

int
kcpuset_copyout(kcpuset_t *kcp, cpuset_t *ucp, size_t len);

void
kcpuset_zero(kcpuset_t *kcp);

void
kcpuset_fill(kcpuset_t *kcp);

void
kcpuset_set(kcpuset_t *kcp, cpuid_t cpu);

void
kcpuset_clear(kcpuset_t *kcp, cpuid_t cpu);

bool
kcpuset_isset(const kcpuset_t * kcp, cpuid_t cpu);

bool
kcpuset_isotherset(const kcpuset_t * kcp, cpuid_t cpu);

bool
kcpuset_iszero(const kcpuset_t *kcp);

bool
kcpuset_intersecting_p(const kcpuset_t *kcp1, const kcpuset_t *kcp2);

bool
kcpuset_match(const kcpuset_t *kcp1, const kcpuset_t *kcp2);

void
kcpuset_intersect(kcpuset_t *kcp1, const kcpuset_t *kcp2);

void
kcpuset_merge(kcpuset_t *kcp1, const kcpuset_t *kcp2);

void
kcpuset_remove(kcpuset_t *kcp1, const kcpuset_t *kcp2);

cpuid_t
kcpuset_ffs(const kcpuset_t *kcp);

cpuid_t
kcpuset_ffs_intersecting(const kcpuset_t *kcp1, const kcpuset_t *kcp2);

int
kcpuset_countset(const kcpuset_t *kcp);

void
kcpuset_atomic_set(kcpuset_t *kcp, cpuid_t cpu);

void
kcpuset_atomic_clear(kcpuset_t *kcp, cpuid_t cpu);

void
kcpuset_atomicly_intersect(kcpuset_t *kcp1, const kcpuset_t *kcp2);

void
kcpuset_atomicly_merge(kcpuset_t *kcp1, const kcpuset_t *kcp2);

void
kcpuset_atomicly_remove(kcpuset_t *kcp1, const kcpuset_t *kcp2);

void
kcpuset_export_u32(const kcpuset_t *kcp, uint32_t *bitfield,
    size_t len);

(quick note: the NAME list up there says kcpuset_export_32 and the prototype says kcpuset_export_u32 — the prototypes are the source of truth for what you actually type, so copy the code block, not my bullet list. iykyk 🫶)

🦋 DESCRIPTION 🦋

The machine-independent kcpuset subsystem provides support for dynamic processor sets. Conceptually kcpuset can be understood to be the kernel equivalent of the user space cpuset(3) interface — like, same vibes, but it's the kernel version, which is main character energy tbh. 💜

⭐ FUNCTIONS ⭐

one bullet per bestie, in the same order as the page, because we do not skip. ever.

• kcpuset_create(retkcp, zero) — creates a dynamic CPU set and stores the result to retkcp. if the boolean zero is not false, the allocated set is also initialized to zero. ✨
• kcpuset_destroy(kcp) — destroys the CPU set kcp and schedules any linked CPU sets for deferred destruction. it's giving "you can go, but your friends have to wait in the lobby" 😭
• kcpuset_copy(dkcp, skcp) — copies the CPU set pointed by skcp to dkcp.
• kcpuset_clone(retkcp, skcp) — creates a dynamic CPU set, stores the result to retkcp, and copies the CPU set pointed by skcp to that shiny new CPU set. new set, who dis 💅
• kcpuset_use(kcp) — marks kcp as being in use by increasing the reference count of the object. note that initially kcpuset_create() sets the reference count to 1.
• kcpuset_unuse(kcp, lst) — decreases the internal reference count of kcp, and on the last reference (when the count reaches zero), destroys kcp. if lst is not NULL, then instead of destroying, kcp will be added to the lst list for a deferred destruction. 🫶
• kcpuset_copyin(ucp, kcp, len) — copies the len bytes long user-space CPU set ucp to the kernel CPU set kcp.
• kcpuset_copyout(kcp, ucp, len) — copies the kernel CPU set kcp to the user-space CPU set ucp. it's the reverse of the one above, obviously, we stay consistent 🌈
• kcpuset_zero(kcp) — clears the set kcp.
• kcpuset_fill(kcp) — fills the whole set kcp with ones.
• kcpuset_set(kcp, cpu) — adds cpu to the set kcp.
• kcpuset_clear(kcp, cpu) — removes cpu from the set kcp.
• kcpuset_isset(kcp, cpu) — returns true if cpu is part of the CPU set kcp.
• kcpuset_isotherset(kcp, cpu) — returns true if there any CPUs other than cpu in the CPU set kcp. (yes, that's exactly how the page words it, do not come for me 🫶)
• kcpuset_iszero(kcp) — returns true if the set kcp is empty.
• kcpuset_match(kcp1, kcp2) — compares the sets kcp1 and kcp2, returning true if these are identical. twin check 👯
• kcpuset_intersect(kcp1, kcp2) — removes any CPU not set in kcp2 from the set kcp1. lowkey savage but necessary
• kcpuset_merge(kcp1, kcp2) — merges the set kcp2 to the set kcp1.
• kcpuset_remove(kcp1, kcp2) — removes any CPU present in kcp2 from the set kcp1.
• kcpuset_ffs(kcp) — returns the lowest numbered cpu present in kcp plus 1. if kcp is empty, a value of 0 is returned. (the page genuinely trails off with the word kcp right there at the end, bestie — i'm not making that up 😭)
• kcpuset_ffs_intersecting(kcp1, kcp2) — returns the lowest numbered cpu present in the intersection of kcp1 and kcp2 plus 1. if the intersection is empty, a value of 0 is returned.
• kcpuset_countset(kcp) — counts how many CPUs are in the set kcp. math girl summer 🔥
• kcpuset_atomic_set(kcp, cpu) — operates as kcpuset_set(), but the operation is atomic; see atomic_ops(3) for more details.
• kcpuset_atomic_clear(kcp, cpu) — removes cpu from the CPU set kcp atomically.
• kcpuset_atomicly_intersect(kcp1, kcp2) — operates as kcpuset_intersect(), but the operation is performed using atomic operations; see atomic_ops(3) for more details.
• kcpuset_atomicly_merge(kcp1, kcp2) — operates as kcpuset_merge(), but the operation is performed using atomic operations; see atomic_ops(3) for more details.
• kcpuset_atomicly_remove(kcp1, kcp2) — operates as kcpuset_remove(), but the operation is performed using atomic operations; see atomic_ops(3) for more details.
• kcpuset_export_u32(kcp, bitfield, len) — exports the CPU set kcp into a format of 32-bit integer array, specified by bitfield and length in bytes by len. an integer is in the host byte-order and represents a bit field. the first bit at index zero represents CPU number 0, and so on. 🎀

ok real talk — there's also kcpuset_intersecting_p up in the SYNOPSIS and #include list, and this page never gives it its own description paragraph. i'm not gonna invent one for you, bestie. it exists, it's declared, the manual is simply mysterious about it. 🙈

🧚 CODE REFERENCES 🧚

The kcpuset subsystem is implemented within sys/kern/subr_kcpuset.c. that's your file, go read it if you want the lore 👑

💖 SEE ALSO 💖

• cpuset(3)

🌸 HISTORY 🌸

The kcpuset subsystem first appeared in NetBSD 6.0. vintage ✨

---

and that's the whole page, bestie — 100% of the details, 0% of the boring. you're welcome 💅🦋

this cute little sign-off is brought to you by the Debian crew, dated July 17, 2013 — that's the source/version and date from the footer, preserved with love 🎀