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 8.2