I would appreciate any donations. Wishlist or send e-mail type donations to maekawa AT daemon-systems.org.

Thank you.


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.

NetBSD 7.1.2                     July 17, 2013                    NetBSD 7.1.2