KCPUSET(9) | Kernel Developer's Manual | KCPUSET(9)

# 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` —
dynamic kernel CPU sets

# SYNOPSIS

`#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);

# 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.

# FUNCTIONS

`kcpuset_create`(retkcp, zero)
  The `kcpuset_create`() function 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.
`kcpuset_copy`(dkcp, skcp)
  Copies the CPU set pointed by skcp to dkcp.
`kcpuset_clone`(retkcp, skcp)
  Creates a dynamic CPU set and stores the result to retkcp and copies the CPU set pointed by skcp to the new CPU set.
`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.
`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.
`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.
`kcpuset_intersect`(kcp1, kcp2)
  Removes any CPU not set in kcp2 from the set kcp1.
`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. kcp
`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.
`kcpuset_atomic_set`(kcp, cpu)
  The `kcpuset_atomic_set`() function 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)
  The `kcpuset_atomicly_intersect`() function operates as `kcpuset_intersect`(), but the operation is performed using atomic operations; see atomic_ops(3) for more details.
`kcpuset_atomicly_merge`(kcp1, kcp2)
  The `kcpuset_atomicly_merge`() function operates as `kcpuset_merge`(), but the operation is performed using atomic operations; see atomic_ops(3) for more details.
`kcpuset_atomicly_remove`(kcp1, kcp2)
  The `kcpuset_atomicly_remove`() function 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 integers is in the host byte-order and represents a bit field. The first bit at index zero represents CPU number 0, and so on.

# CODE REFERENCES

The `kcpuset` subsystem is implemented within sys/kern/subr_kcpuset.c.

# SEE ALSO

cpuset(3)

# HISTORY

The `kcpuset` subsystem first appeared in NetBSD 6.0.

July 17, 2013 | NetBSD 9.2