Home | History | Annotate | Line # | Download | only in sys
cpuset.c revision 1.12.4.1
      1 /*	$NetBSD: cpuset.c,v 1.12.4.1 2013/10/20 14:02:51 bouyer 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.12.4.1 2013/10/20 14:02:51 bouyer 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()	sizeof( \
     56 	struct {  \
     57 		uint32_t bits[cpuset_nentries]; \
     58 	})
     59 #else
     60 #define CPUSET_SIZE()	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()	sizeof( \
     74 	struct {  \
     75 		unsigned int nused; \
     76 		struct _kcpuset *next; \
     77 		uint32_t bits[cpuset_nentries]; \
     78 	})
     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 	return cpuset_size;
     90 }
     91 
     92 void
     93 _cpuset_zero(cpuset_t *c)
     94 {
     95 	(void)memset(c->bits, 0, cpuset_nentries * sizeof(c->bits[0]));
     96 }
     97 
     98 int
     99 _cpuset_isset(cpuid_t i, const cpuset_t *c)
    100 {
    101 	const unsigned long j = i >> CPUSET_SHIFT;
    102 
    103 	if (j >= cpuset_nentries) {
    104 		errno = EINVAL;
    105 		return -1;
    106 	}
    107 	return ((1 << (i & CPUSET_MASK)) & c->bits[j]) != 0;
    108 }
    109 
    110 int
    111 _cpuset_set(cpuid_t i, cpuset_t *c)
    112 {
    113 	const unsigned long j = i >> CPUSET_SHIFT;
    114 
    115 	if (j >= cpuset_nentries) {
    116 		errno = EINVAL;
    117 		return -1;
    118 	}
    119 	c->bits[j] |= 1 << (i & CPUSET_MASK);
    120 	return 0;
    121 }
    122 
    123 int
    124 _cpuset_clr(cpuid_t i, cpuset_t *c)
    125 {
    126 	const unsigned long j = i >> CPUSET_SHIFT;
    127 
    128 	if (j >= cpuset_nentries) {
    129 		errno = EINVAL;
    130 		return -1;
    131 	}
    132 	c->bits[j] &= ~(1 << (i & CPUSET_MASK));
    133 	return 0;
    134 }
    135 
    136 cpuset_t *
    137 _cpuset_create(void)
    138 {
    139 	if (cpuset_size == 0) {
    140 		static int mib[2] = { CTL_HW, HW_NCPU };
    141 		size_t len;
    142 		u_int nc;
    143 
    144 		len = sizeof(nc);
    145 		if (sysctl(mib, __arraycount(mib), &nc, &len, NULL, 0) == -1)
    146 			return NULL;
    147 
    148 		cpuset_nentries = CPUSET_NENTRIES(nc);
    149 		cpuset_size = CPUSET_SIZE();
    150 	}
    151 	return calloc(1, cpuset_size);
    152 }
    153 
    154 void
    155 _cpuset_destroy(cpuset_t *c)
    156 {
    157 	free(c);
    158 }
    159 
    160 #else
    161 
    162 kcpuset_t *
    163 kcpuset_create(void)
    164 {
    165 	kcpuset_t *c;
    166 	if (cpuset_size == 0) {
    167 		cpuset_nentries = CPUSET_NENTRIES(MAXCPUS);
    168 		cpuset_size = KCPUSET_SIZE();
    169 	}
    170 	c = kmem_zalloc(cpuset_size, KM_SLEEP);
    171 	c->next = NULL;
    172 	c->nused = 1;
    173 	return c;
    174 }
    175 
    176 void
    177 kcpuset_destroy(kcpuset_t *c)
    178 {
    179 	kcpuset_t *nc;
    180 	while (c) {
    181 		KASSERT(c->nused == 0);
    182 		nc = c->next;
    183 		kmem_free(c, cpuset_size);
    184 		c = nc;
    185 	}
    186 }
    187 
    188 void
    189 kcpuset_copy(kcpuset_t *d, const kcpuset_t *s)
    190 {
    191 	KASSERT(d->nused == 1);
    192 	(void)memcpy(d->bits, s->bits, cpuset_nentries * sizeof(s->bits[0]));
    193 }
    194 
    195 void
    196 kcpuset_use(kcpuset_t *c)
    197 {
    198 	atomic_inc_uint(&c->nused);
    199 }
    200 
    201 void
    202 kcpuset_unuse(kcpuset_t *c, kcpuset_t **lst)
    203 {
    204 	if (atomic_dec_uint_nv(&c->nused) != 0)
    205 		return;
    206 	KASSERT(c->nused == 0);
    207 	KASSERT(c->next == NULL);
    208 	if (lst == NULL) {
    209 		kcpuset_destroy(c);
    210 		return;
    211 	}
    212 	c->next = *lst;
    213 	*lst = c;
    214 }
    215 
    216 int
    217 kcpuset_copyin(const cpuset_t *u, kcpuset_t *k, size_t len)
    218 {
    219 	KASSERT(k->nused > 0);
    220 	KASSERT(k->next == NULL);
    221 	if (len != CPUSET_SIZE())
    222 		return EINVAL;
    223 	return copyin(u->bits, k->bits, cpuset_nentries * sizeof(k->bits[0]));
    224 }
    225 
    226 int
    227 kcpuset_copyout(const kcpuset_t *k, cpuset_t *u, size_t len)
    228 {
    229 	KASSERT(k->nused > 0);
    230 	KASSERT(k->next == NULL);
    231 	if (len != CPUSET_SIZE())
    232 		return EINVAL;
    233 	return copyout(k->bits, u->bits, cpuset_nentries * sizeof(u->bits[0]));
    234 }
    235 
    236 void
    237 kcpuset_zero(kcpuset_t *c)
    238 {
    239 	KASSERT(c->nused > 0);
    240 	KASSERT(c->next == NULL);
    241 	(void)memset(c->bits, 0, cpuset_nentries * sizeof(c->bits[0]));
    242 }
    243 
    244 int
    245 kcpuset_isset(cpuid_t i, const kcpuset_t *c)
    246 {
    247 	const unsigned long j = i >> CPUSET_SHIFT;
    248 
    249 	KASSERT(c != NULL);
    250 	KASSERT(c->nused > 0);
    251 	KASSERT(c->next == NULL);
    252 	KASSERT(j < cpuset_nentries);
    253 	return ((1 << (i & CPUSET_MASK)) & c->bits[j]) != 0;
    254 }
    255 
    256 #endif
    257 #endif
    258