common/lib/libc/sys/cpuset.c

   1 /*      $NetBSD: cpuset.c,v 1.14 2009/03/15 20:08:43 rmind Exp $        */
   2
   3 /*-
   4  * Copyright (c) 2008 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Christos Zoulas.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #ifndef _STANDALONE
  33 #include <sys/cdefs.h>
  34 #if defined(LIBC_SCCS) && !defined(lint)
  35 __RCSID("$NetBSD: cpuset.c,v 1.14 2009/03/15 20:08:43 rmind Exp $");
  36 #endif /* LIBC_SCCS and not lint */
  37
  38 #include <sys/param.h>
  39 #include <sys/sched.h>
  40 #ifdef _KERNEL
  41 #include <sys/kmem.h>
  42 #include <lib/libkern/libkern.h>
  43 #include <sys/atomic.h>
  44 #else
  45 #include <errno.h>
  46 #include <string.h>
  47 #include <stdlib.h>
  48 #include <sys/sysctl.h>
  49 #endif
  50
  51 #define CPUSET_SHIFT    5
  52 #define CPUSET_MASK     31
  53 #define CPUSET_NENTRIES(nc)     ((nc) > 32 ? ((nc) >> CPUSET_SHIFT) : 1)
  54 #ifndef __lint__
  55 #define CPUSET_SIZE(n)  (sizeof( \
  56         struct {  \
  57                 uint32_t bits[0]; \
  58         }) + sizeof(uint32_t) * (n))
  59 #else
  60 #define CPUSET_SIZE(n)  0
  61 #endif
  62
  63 struct _cpuset {
  64         uint32_t        bits[0];
  65 };
  66
  67 #ifdef _KERNEL
  68 struct _kcpuset {
  69         unsigned int    nused;
  70         struct _kcpuset *next;
  71         uint32_t        bits[0];
  72 };
  73 #define KCPUSET_SIZE(n) (sizeof( \
  74         struct {  \
  75                 unsigned int nused; \
  76                 struct _kcpuset *next; \
  77                 uint32_t bits[0]; \
  78         }) + sizeof(uint32_t) * (n))
  79 #endif
  80
  81 static size_t cpuset_size = 0;
  82 static size_t cpuset_nentries = 0;
  83
  84 #ifndef _KERNEL
  85 size_t
  86 /*ARGSUSED*/
  87 _cpuset_size(const cpuset_t *c)
  88 {
  89
  90         return cpuset_size;
  91 }
  92
  93 void
  94 _cpuset_zero(cpuset_t *c)
  95 {
  96
  97         memset(c->bits, 0, cpuset_nentries * sizeof(c->bits[0]));
  98 }
  99
 100 int
 101 _cpuset_isset(cpuid_t i, const cpuset_t *c)
 102 {
 103         const unsigned long j = i >> CPUSET_SHIFT;
 104
 105         if (j >= cpuset_nentries) {
 106                 errno = EINVAL;
 107                 return -1;
 108         }
 109         return ((1 << (i & CPUSET_MASK)) & c->bits[j]) != 0;
 110 }
 111
 112 int
 113 _cpuset_set(cpuid_t i, cpuset_t *c)
 114 {
 115         const unsigned long j = i >> CPUSET_SHIFT;
 116
 117         if (j >= cpuset_nentries) {
 118                 errno = EINVAL;
 119                 return -1;
 120         }
 121         c->bits[j] |= 1 << (i & CPUSET_MASK);
 122         return 0;
 123 }
 124
 125 int
 126 _cpuset_clr(cpuid_t i, cpuset_t *c)
 127 {
 128         const unsigned long j = i >> CPUSET_SHIFT;
 129
 130         if (j >= cpuset_nentries) {
 131                 errno = EINVAL;
 132                 return -1;
 133         }
 134         c->bits[j] &= ~(1 << (i & CPUSET_MASK));
 135         return 0;
 136 }
 137
 138 cpuset_t *
 139 _cpuset_create(void)
 140 {
 141
 142         if (cpuset_size == 0) {
 143                 static int mib[2] = { CTL_HW, HW_NCPU };
 144                 size_t len;
 145                 u_int nc;
 146
 147                 if (sysctl(mib, __arraycount(mib), &nc, &len, NULL, 0) == -1)
 148                         return NULL;
 149
 150                 cpuset_nentries = CPUSET_NENTRIES(nc);
 151                 cpuset_size = CPUSET_SIZE(cpuset_nentries);
 152         }
 153         return calloc(1, cpuset_size);
 154 }
 155
 156 void
 157 _cpuset_destroy(cpuset_t *c)
 158 {
 159
 160         free(c);
 161 }
 162
 163 #else
 164
 165 kcpuset_t *
 166 kcpuset_create(void)
 167 {
 168         kcpuset_t *c;
 169
 170         if (cpuset_size == 0) {
 171                 cpuset_nentries = CPUSET_NENTRIES(MAXCPUS);
 172                 cpuset_size = KCPUSET_SIZE(cpuset_nentries);
 173         }
 174         c = kmem_zalloc(cpuset_size, KM_SLEEP);
 175         c->next = NULL;
 176         c->nused = 1;
 177         return c;
 178 }
 179
 180 void
 181 kcpuset_destroy(kcpuset_t *c)
 182 {
 183         kcpuset_t *nc;
 184
 185         while (c) {
 186                 KASSERT(c->nused == 0);
 187                 nc = c->next;
 188                 kmem_free(c, cpuset_size);
 189                 c = nc;
 190         }
 191 }
 192
 193 void
 194 kcpuset_copy(kcpuset_t *d, const kcpuset_t *s)
 195 {
 196
 197         KASSERT(d->nused == 1);
 198         memcpy(d->bits, s->bits, cpuset_nentries * sizeof(s->bits[0]));
 199 }
 200
 201 void
 202 kcpuset_use(kcpuset_t *c)
 203 {
 204
 205         atomic_inc_uint(&c->nused);
 206 }
 207
 208 void
 209 kcpuset_unuse(kcpuset_t *c, kcpuset_t **lst)
 210 {
 211
 212         if (atomic_dec_uint_nv(&c->nused) != 0)
 213                 return;
 214         KASSERT(c->nused == 0);
 215         KASSERT(c->next == NULL);
 216         if (lst == NULL) {
 217                 kcpuset_destroy(c);
 218                 return;
 219         }
 220         c->next = *lst;
 221         *lst = c;
 222 }
 223
 224 int
 225 kcpuset_copyin(const cpuset_t *u, kcpuset_t *k, size_t len)
 226 {
 227
 228         KASSERT(k->nused > 0);
 229         KASSERT(k->next == NULL);
 230         if (len != CPUSET_SIZE(cpuset_nentries))
 231                 return EINVAL;
 232         return copyin(u->bits, k->bits, cpuset_nentries * sizeof(k->bits[0]));
 233 }
 234
 235 int
 236 kcpuset_copyout(const kcpuset_t *k, cpuset_t *u, size_t len)
 237 {
 238
 239         KASSERT(k->nused > 0);
 240         KASSERT(k->next == NULL);
 241         if (len != CPUSET_SIZE(cpuset_nentries))
 242                 return EINVAL;
 243         return copyout(k->bits, u->bits, cpuset_nentries * sizeof(u->bits[0]));
 244 }
 245
 246 void
 247 kcpuset_zero(kcpuset_t *c)
 248 {
 249
 250         KASSERT(c->nused > 0);
 251         KASSERT(c->next == NULL);
 252         memset(c->bits, 0, cpuset_nentries * sizeof(c->bits[0]));
 253 }
 254
 255 void
 256 kcpuset_fill(kcpuset_t *c)
 257 {
 258
 259         KASSERT(c->nused > 0);
 260         KASSERT(c->next == NULL);
 261         memset(c->bits, ~0, cpuset_nentries * sizeof(c->bits[0]));
 262 }
 263
 264 void
 265 kcpuset_set(cpuid_t i, kcpuset_t *c)
 266 {
 267         const unsigned long j = i >> CPUSET_SHIFT;
 268
 269         KASSERT(c->next == NULL);
 270         KASSERT(j < cpuset_nentries);
 271         c->bits[j] |= 1 << (i & CPUSET_MASK);
 272 }
 273
 274 int
 275 kcpuset_isset(cpuid_t i, const kcpuset_t *c)
 276 {
 277         const unsigned long j = i >> CPUSET_SHIFT;
 278
 279         KASSERT(c != NULL);
 280         KASSERT(c->nused > 0);
 281         KASSERT(c->next == NULL);
 282         KASSERT(j < cpuset_nentries);
 283         return ((1 << (i & CPUSET_MASK)) & c->bits[j]) != 0;
 284 }
 285
 286 bool
 287 kcpuset_iszero(const kcpuset_t *c)
 288 {
 289         unsigned long j;
 290
 291         for (j = 0; j < cpuset_nentries; j++)
 292                 if (c->bits[j] != 0)
 293                         return false;
 294         return true;
 295 }
 296
 297 bool
 298 kcpuset_match(const kcpuset_t *c1, const kcpuset_t *c2)
 299 {
 300         unsigned long j;
 301
 302         for (j = 0; j < cpuset_nentries; j++)
 303                 if ((c1->bits[j] & c2->bits[j]) != c2->bits[j])
 304                         return false;
 305         return true;
 306 }
 307
 308 #endif
 309 #endif