| KCPUSET(9) | Kernel Developer's Manual | KCPUSET(9) | 
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 —
#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);
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.
kcpuset_create(retkcp,
    zero)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)kcpuset_copy(dkcp,
    skcp)kcpuset_clone(retkcp,
    skcp)kcpuset_use(kcp)kcpuset_create() sets the reference count to
    1.kcpuset_unuse(kcp,
    lst)NULL, then instead of destroying,
      kcp will be added to the lst
      list for a deferred destruction.kcpuset_copyin(ucp,
    kcp, len)kcpuset_copyout(kcp,
    ucp, len)kcpuset_zero(kcp)kcpuset_fill(kcp)kcpuset_set(kcp,
    cpu)kcpuset_clear(kcp,
    cpu)kcpuset_isset(kcp,
    cpu)kcpuset_isotherset(kcp,
    cpu)kcpuset_iszero(kcp)kcpuset_match(kcp1,
    kcp2)kcpuset_intersect(kcp1,
    kcp2)kcpuset_merge(kcp1,
    kcp2)kcpuset_remove(kcp1,
    kcp2)kcpuset_ffs(kcp)kcpuset_ffs_intersecting(kcp1,
    kcp2)kcpuset_countset(kcp)kcpuset_atomic_set(kcp,
    cpu)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)kcpuset_atomicly_intersect(kcp1,
    kcp2)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)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)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)kcpuset subsystem is implemented within
  sys/kern/subr_kcpuset.c.
kcpuset subsystem first appeared in
  NetBSD 6.0.
| July 17, 2013 | NetBSD 10.0 |