Home | History | Annotate | Line # | Download | only in kern
sys_pset.c revision 1.19.18.1
      1 /*	$NetBSD: sys_pset.c,v 1.19.18.1 2019/06/10 22:09:03 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2008, Mindaugas Rasiukevicius <rmind at NetBSD org>
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     26  * SUCH DAMAGE.
     27  */
     28 
     29 /*
     30  * Implementation of the Processor Sets.
     31  *
     32  * Locking
     33  *  The array of the processor-set structures and its members are protected
     34  *  by the global cpu_lock.  Note that in scheduler, the very l_psid value
     35  *  might be used without lock held.
     36  */
     37 
     38 #include <sys/cdefs.h>
     39 __KERNEL_RCSID(0, "$NetBSD: sys_pset.c,v 1.19.18.1 2019/06/10 22:09:03 christos Exp $");
     40 
     41 #include <sys/param.h>
     42 
     43 #include <sys/cpu.h>
     44 #include <sys/kauth.h>
     45 #include <sys/kmem.h>
     46 #include <sys/lwp.h>
     47 #include <sys/mutex.h>
     48 #include <sys/proc.h>
     49 #include <sys/pset.h>
     50 #include <sys/sched.h>
     51 #include <sys/syscallargs.h>
     52 #include <sys/sysctl.h>
     53 #include <sys/systm.h>
     54 #include <sys/types.h>
     55 
     56 static pset_info_t **	psets;
     57 static u_int		psets_max;
     58 static u_int		psets_count;
     59 static kauth_listener_t	psets_listener;
     60 
     61 static int	psets_realloc(int);
     62 static int	psid_validate(psetid_t, bool);
     63 static int	kern_pset_create(psetid_t *);
     64 static int	kern_pset_destroy(psetid_t);
     65 
     66 static int
     67 psets_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
     68     void *arg0, void *arg1, void *arg2, void *arg3)
     69 {
     70 	psetid_t id;
     71 	enum kauth_system_req req;
     72 	int result;
     73 
     74 	result = KAUTH_RESULT_DEFER;
     75 	req = (enum kauth_system_req)arg0;
     76 	id = (psetid_t)(unsigned long)arg1;
     77 
     78 	if (action != KAUTH_SYSTEM_PSET)
     79 		return result;
     80 
     81 	if ((req == KAUTH_REQ_SYSTEM_PSET_ASSIGN) ||
     82 	    (req == KAUTH_REQ_SYSTEM_PSET_BIND)) {
     83 		if (id == PS_QUERY)
     84 			result = KAUTH_RESULT_ALLOW;
     85 	}
     86 
     87 	return result;
     88 }
     89 
     90 /*
     91  * Initialization of the processor-sets.
     92  */
     93 void
     94 psets_init(void)
     95 {
     96 
     97 	psets_max = uimax(maxcpus, 32);
     98 	psets = kmem_zalloc(psets_max * sizeof(void *), KM_SLEEP);
     99 	psets_count = 0;
    100 
    101 	psets_listener = kauth_listen_scope(KAUTH_SCOPE_SYSTEM,
    102 	    psets_listener_cb, NULL);
    103 }
    104 
    105 /*
    106  * Reallocate the array of the processor-set structures.
    107  */
    108 static int
    109 psets_realloc(int new_psets_max)
    110 {
    111 	pset_info_t **new_psets, **old_psets;
    112 	const u_int newsize = new_psets_max * sizeof(void *);
    113 	u_int i, oldsize;
    114 
    115 	if (new_psets_max < 1)
    116 		return EINVAL;
    117 
    118 	new_psets = kmem_zalloc(newsize, KM_SLEEP);
    119 	mutex_enter(&cpu_lock);
    120 	old_psets = psets;
    121 	oldsize = psets_max * sizeof(void *);
    122 
    123 	/* Check if we can lower the size of the array */
    124 	if (new_psets_max < psets_max) {
    125 		for (i = new_psets_max; i < psets_max; i++) {
    126 			if (psets[i] == NULL)
    127 				continue;
    128 			mutex_exit(&cpu_lock);
    129 			kmem_free(new_psets, newsize);
    130 			return EBUSY;
    131 		}
    132 	}
    133 
    134 	/* Copy all pointers to the new array */
    135 	memcpy(new_psets, psets, newsize);
    136 	psets_max = new_psets_max;
    137 	psets = new_psets;
    138 	mutex_exit(&cpu_lock);
    139 
    140 	kmem_free(old_psets, oldsize);
    141 	return 0;
    142 }
    143 
    144 /*
    145  * Validate processor-set ID.
    146  */
    147 static int
    148 psid_validate(psetid_t psid, bool chkps)
    149 {
    150 
    151 	KASSERT(mutex_owned(&cpu_lock));
    152 
    153 	if (chkps && (psid == PS_NONE || psid == PS_QUERY || psid == PS_MYID))
    154 		return 0;
    155 	if (psid <= 0 || psid > psets_max)
    156 		return EINVAL;
    157 	if (psets[psid - 1] == NULL)
    158 		return EINVAL;
    159 	if (psets[psid - 1]->ps_flags & PSET_BUSY)
    160 		return EBUSY;
    161 
    162 	return 0;
    163 }
    164 
    165 /*
    166  * Create a processor-set.
    167  */
    168 static int
    169 kern_pset_create(psetid_t *psid)
    170 {
    171 	pset_info_t *pi;
    172 	u_int i;
    173 
    174 	if (psets_count == psets_max)
    175 		return ENOMEM;
    176 
    177 	pi = kmem_zalloc(sizeof(pset_info_t), KM_SLEEP);
    178 
    179 	mutex_enter(&cpu_lock);
    180 	if (psets_count == psets_max) {
    181 		mutex_exit(&cpu_lock);
    182 		kmem_free(pi, sizeof(pset_info_t));
    183 		return ENOMEM;
    184 	}
    185 
    186 	/* Find a free entry in the array */
    187 	for (i = 0; i < psets_max; i++)
    188 		if (psets[i] == NULL)
    189 			break;
    190 	KASSERT(i != psets_max);
    191 
    192 	psets[i] = pi;
    193 	psets_count++;
    194 	mutex_exit(&cpu_lock);
    195 
    196 	*psid = i + 1;
    197 	return 0;
    198 }
    199 
    200 /*
    201  * Destroy a processor-set.
    202  */
    203 static int
    204 kern_pset_destroy(psetid_t psid)
    205 {
    206 	struct cpu_info *ci;
    207 	pset_info_t *pi;
    208 	struct lwp *l;
    209 	CPU_INFO_ITERATOR cii;
    210 	int error;
    211 
    212 	mutex_enter(&cpu_lock);
    213 	if (psid == PS_MYID) {
    214 		/* Use caller's processor-set ID */
    215 		psid = curlwp->l_psid;
    216 	}
    217 	error = psid_validate(psid, false);
    218 	if (error) {
    219 		mutex_exit(&cpu_lock);
    220 		return error;
    221 	}
    222 
    223 	/* Release the processor-set from all CPUs */
    224 	for (CPU_INFO_FOREACH(cii, ci)) {
    225 		struct schedstate_percpu *spc;
    226 
    227 		spc = &ci->ci_schedstate;
    228 		if (spc->spc_psid != psid)
    229 			continue;
    230 		spc->spc_psid = PS_NONE;
    231 	}
    232 	/* Mark that processor-set is going to be destroyed */
    233 	pi = psets[psid - 1];
    234 	pi->ps_flags |= PSET_BUSY;
    235 	mutex_exit(&cpu_lock);
    236 
    237 	/* Unmark the processor-set ID from each thread */
    238 	mutex_enter(proc_lock);
    239 	LIST_FOREACH(l, &alllwp, l_list) {
    240 		/* Safe to check and set without lock held */
    241 		if (l->l_psid != psid)
    242 			continue;
    243 		l->l_psid = PS_NONE;
    244 	}
    245 	mutex_exit(proc_lock);
    246 
    247 	/* Destroy the processor-set */
    248 	mutex_enter(&cpu_lock);
    249 	psets[psid - 1] = NULL;
    250 	psets_count--;
    251 	mutex_exit(&cpu_lock);
    252 
    253 	kmem_free(pi, sizeof(pset_info_t));
    254 	return 0;
    255 }
    256 
    257 /*
    258  * General system calls for the processor-sets.
    259  */
    260 
    261 int
    262 sys_pset_create(struct lwp *l, const struct sys_pset_create_args *uap,
    263     register_t *retval)
    264 {
    265 	/* {
    266 		syscallarg(psetid_t) *psid;
    267 	} */
    268 	psetid_t psid;
    269 	int error;
    270 
    271 	/* Available only for super-user */
    272 	if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_PSET,
    273 	    KAUTH_REQ_SYSTEM_PSET_CREATE, NULL, NULL, NULL))
    274 		return EPERM;
    275 
    276 	error = kern_pset_create(&psid);
    277 	if (error)
    278 		return error;
    279 
    280 	error = copyout(&psid, SCARG(uap, psid), sizeof(psetid_t));
    281 	if (error)
    282 		(void)kern_pset_destroy(psid);
    283 
    284 	return error;
    285 }
    286 
    287 int
    288 sys_pset_destroy(struct lwp *l, const struct sys_pset_destroy_args *uap,
    289     register_t *retval)
    290 {
    291 	/* {
    292 		syscallarg(psetid_t) psid;
    293 	} */
    294 
    295 	/* Available only for super-user */
    296 	if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_PSET,
    297 	    KAUTH_REQ_SYSTEM_PSET_DESTROY,
    298 	    KAUTH_ARG(SCARG(uap, psid)), NULL, NULL))
    299 		return EPERM;
    300 
    301 	return kern_pset_destroy(SCARG(uap, psid));
    302 }
    303 
    304 int
    305 sys_pset_assign(struct lwp *l, const struct sys_pset_assign_args *uap,
    306     register_t *retval)
    307 {
    308 	/* {
    309 		syscallarg(psetid_t) psid;
    310 		syscallarg(cpuid_t) cpuid;
    311 		syscallarg(psetid_t) *opsid;
    312 	} */
    313 	struct cpu_info *ici, *ci = NULL;
    314 	struct schedstate_percpu *spc = NULL;
    315 	struct lwp *t;
    316 	psetid_t psid = SCARG(uap, psid), opsid = 0;
    317 	CPU_INFO_ITERATOR cii;
    318 	int error = 0, nnone = 0;
    319 
    320 	/* Available only for super-user, except the case of PS_QUERY */
    321 	if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_PSET,
    322 	    KAUTH_REQ_SYSTEM_PSET_ASSIGN, KAUTH_ARG(SCARG(uap, psid)), NULL,
    323 	    NULL))
    324 		return EPERM;
    325 
    326 	/* Find the target CPU */
    327 	mutex_enter(&cpu_lock);
    328 	for (CPU_INFO_FOREACH(cii, ici)) {
    329 		struct schedstate_percpu *ispc;
    330 		ispc = &ici->ci_schedstate;
    331 		if (cpu_index(ici) == SCARG(uap, cpuid)) {
    332 			ci = ici;
    333 			spc = ispc;
    334 		}
    335 		nnone += (ispc->spc_psid == PS_NONE);
    336 	}
    337 	if (ci == NULL) {
    338 		mutex_exit(&cpu_lock);
    339 		return EINVAL;
    340 	}
    341 	error = psid_validate(psid, true);
    342 	if (error) {
    343 		mutex_exit(&cpu_lock);
    344 		return error;
    345 	}
    346 	opsid = spc->spc_psid;
    347 	switch (psid) {
    348 	case PS_QUERY:
    349 		break;
    350 	case PS_MYID:
    351 		psid = curlwp->l_psid;
    352 		/* FALLTHROUGH */
    353 	default:
    354 		/*
    355 		 * Just finish if old and new processor-sets are
    356 		 * the same.
    357 		 */
    358 		if (spc->spc_psid == psid)
    359 			break;
    360 		/*
    361 		 * Ensure at least one CPU stays in the default set,
    362 		 * and that specified CPU is not offline.
    363 		 */
    364 		if (psid != PS_NONE && ((spc->spc_flags & SPCF_OFFLINE) ||
    365 		    (nnone == 1 && spc->spc_psid == PS_NONE))) {
    366 			mutex_exit(&cpu_lock);
    367 			return EBUSY;
    368 		}
    369 		mutex_enter(proc_lock);
    370 		/*
    371 		 * Ensure that none of the threads are using affinity mask
    372 		 * with this target CPU in it.
    373 		 */
    374 		LIST_FOREACH(t, &alllwp, l_list) {
    375 			if (t->l_affinity == NULL) {
    376 				continue;
    377 			}
    378 			lwp_lock(t);
    379 			if (t->l_affinity == NULL) {
    380 				lwp_unlock(t);
    381 				continue;
    382 			}
    383 			if (kcpuset_isset(t->l_affinity, cpu_index(ci))) {
    384 				lwp_unlock(t);
    385 				mutex_exit(proc_lock);
    386 				mutex_exit(&cpu_lock);
    387 				return EPERM;
    388 			}
    389 			lwp_unlock(t);
    390 		}
    391 		/*
    392 		 * Set the processor-set ID.
    393 		 * Migrate out any threads running on this CPU.
    394 		 */
    395 		spc->spc_psid = psid;
    396 
    397 		LIST_FOREACH(t, &alllwp, l_list) {
    398 			struct cpu_info *tci;
    399 			if (t->l_cpu != ci)
    400 				continue;
    401 			if (t->l_pflag & (LP_BOUND | LP_INTR))
    402 				continue;
    403 			lwp_lock(t);
    404 			tci = sched_takecpu(t);
    405 			KASSERT(tci != ci);
    406 			lwp_migrate(t, tci);
    407 		}
    408 		mutex_exit(proc_lock);
    409 		break;
    410 	}
    411 	mutex_exit(&cpu_lock);
    412 
    413 	if (SCARG(uap, opsid) != NULL)
    414 		error = copyout(&opsid, SCARG(uap, opsid), sizeof(psetid_t));
    415 
    416 	return error;
    417 }
    418 
    419 int
    420 sys__pset_bind(struct lwp *l, const struct sys__pset_bind_args *uap,
    421     register_t *retval)
    422 {
    423 	/* {
    424 		syscallarg(idtype_t) idtype;
    425 		syscallarg(id_t) first_id;
    426 		syscallarg(id_t) second_id;
    427 		syscallarg(psetid_t) psid;
    428 		syscallarg(psetid_t) *opsid;
    429 	} */
    430 	struct cpu_info *ci;
    431 	struct proc *p;
    432 	struct lwp *t;
    433 	id_t id1, id2;
    434 	pid_t pid = 0;
    435 	lwpid_t lid = 0;
    436 	psetid_t psid, opsid;
    437 	int error = 0, lcnt;
    438 
    439 	psid = SCARG(uap, psid);
    440 
    441 	/* Available only for super-user, except the case of PS_QUERY */
    442 	if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_PSET,
    443 	    KAUTH_REQ_SYSTEM_PSET_BIND, KAUTH_ARG(SCARG(uap, psid)), NULL,
    444 	    NULL))
    445 		return EPERM;
    446 
    447 	mutex_enter(&cpu_lock);
    448 	error = psid_validate(psid, true);
    449 	if (error) {
    450 		mutex_exit(&cpu_lock);
    451 		return error;
    452 	}
    453 	if (psid == PS_MYID)
    454 		psid = curlwp->l_psid;
    455 	if (psid != PS_QUERY && psid != PS_NONE)
    456 		psets[psid - 1]->ps_flags |= PSET_BUSY;
    457 	mutex_exit(&cpu_lock);
    458 
    459 	/*
    460 	 * Get PID and LID from the ID.
    461 	 */
    462 	p = l->l_proc;
    463 	id1 = SCARG(uap, first_id);
    464 	id2 = SCARG(uap, second_id);
    465 
    466 	switch (SCARG(uap, idtype)) {
    467 	case P_PID:
    468 		/*
    469 		 * Process:
    470 		 *  First ID	- PID;
    471 		 *  Second ID	- ignored;
    472 		 */
    473 		pid = (id1 == P_MYID) ? p->p_pid : id1;
    474 		lid = 0;
    475 		break;
    476 	case P_LWPID:
    477 		/*
    478 		 * Thread (LWP):
    479 		 *  First ID	- LID;
    480 		 *  Second ID	- PID;
    481 		 */
    482 		if (id1 == P_MYID) {
    483 			pid = p->p_pid;
    484 			lid = l->l_lid;
    485 			break;
    486 		}
    487 		lid = id1;
    488 		pid = (id2 == P_MYID) ? p->p_pid : id2;
    489 		break;
    490 	default:
    491 		error = EINVAL;
    492 		goto error;
    493 	}
    494 
    495 	/* Find the process */
    496 	mutex_enter(proc_lock);
    497 	p = proc_find(pid);
    498 	if (p == NULL) {
    499 		mutex_exit(proc_lock);
    500 		error = ESRCH;
    501 		goto error;
    502 	}
    503 	mutex_enter(p->p_lock);
    504 	mutex_exit(proc_lock);
    505 
    506 	/* Disallow modification of the system processes */
    507 	if (p->p_flag & PK_SYSTEM) {
    508 		mutex_exit(p->p_lock);
    509 		error = EPERM;
    510 		goto error;
    511 	}
    512 
    513 	/* Find the LWP(s) */
    514 	lcnt = 0;
    515 	ci = NULL;
    516 	LIST_FOREACH(t, &p->p_lwps, l_sibling) {
    517 		if (lid && lid != t->l_lid)
    518 			continue;
    519 		/*
    520 		 * Bind the thread to the processor-set,
    521 		 * take some CPU and migrate.
    522 		 */
    523 		lwp_lock(t);
    524 		opsid = t->l_psid;
    525 		t->l_psid = psid;
    526 		ci = sched_takecpu(t);
    527 		/* Unlocks LWP */
    528 		lwp_migrate(t, ci);
    529 		lcnt++;
    530 	}
    531 	mutex_exit(p->p_lock);
    532 	if (lcnt == 0) {
    533 		error = ESRCH;
    534 		goto error;
    535 	}
    536 	if (SCARG(uap, opsid))
    537 		error = copyout(&opsid, SCARG(uap, opsid), sizeof(psetid_t));
    538 error:
    539 	if (psid != PS_QUERY && psid != PS_NONE) {
    540 		mutex_enter(&cpu_lock);
    541 		psets[psid - 1]->ps_flags &= ~PSET_BUSY;
    542 		mutex_exit(&cpu_lock);
    543 	}
    544 	return error;
    545 }
    546 
    547 /*
    548  * Sysctl nodes and initialization.
    549  */
    550 
    551 static int
    552 sysctl_psets_max(SYSCTLFN_ARGS)
    553 {
    554 	struct sysctlnode node;
    555 	int error, newsize;
    556 
    557 	node = *rnode;
    558 	node.sysctl_data = &newsize;
    559 
    560 	newsize = psets_max;
    561 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    562 	if (error || newp == NULL)
    563 		return error;
    564 
    565 	if (newsize <= 0)
    566 		return EINVAL;
    567 
    568 	sysctl_unlock();
    569 	error = psets_realloc(newsize);
    570 	sysctl_relock();
    571 	return error;
    572 }
    573 
    574 static int
    575 sysctl_psets_list(SYSCTLFN_ARGS)
    576 {
    577 	const size_t bufsz = 1024;
    578 	char *buf, tbuf[16];
    579 	int i, error;
    580 	size_t len;
    581 
    582 	sysctl_unlock();
    583 	buf = kmem_alloc(bufsz, KM_SLEEP);
    584 	snprintf(buf, bufsz, "%d:1", PS_NONE);	/* XXX */
    585 
    586 	mutex_enter(&cpu_lock);
    587 	for (i = 0; i < psets_max; i++) {
    588 		if (psets[i] == NULL)
    589 			continue;
    590 		snprintf(tbuf, sizeof(tbuf), ",%d:2", i + 1);	/* XXX */
    591 		strlcat(buf, tbuf, bufsz);
    592 	}
    593 	mutex_exit(&cpu_lock);
    594 	len = strlen(buf) + 1;
    595 	error = 0;
    596 	if (oldp != NULL)
    597 		error = copyout(buf, oldp, uimin(len, *oldlenp));
    598 	*oldlenp = len;
    599 	kmem_free(buf, bufsz);
    600 	sysctl_relock();
    601 	return error;
    602 }
    603 
    604 SYSCTL_SETUP(sysctl_pset_setup, "sysctl kern.pset subtree setup")
    605 {
    606 	const struct sysctlnode *node = NULL;
    607 
    608 	sysctl_createv(clog, 0, NULL, &node,
    609 		CTLFLAG_PERMANENT,
    610 		CTLTYPE_NODE, "pset",
    611 		SYSCTL_DESCR("Processor-set options"),
    612 		NULL, 0, NULL, 0,
    613 		CTL_KERN, CTL_CREATE, CTL_EOL);
    614 
    615 	if (node == NULL)
    616 		return;
    617 
    618 	sysctl_createv(clog, 0, &node, NULL,
    619 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
    620 		CTLTYPE_INT, "psets_max",
    621 		SYSCTL_DESCR("Maximal count of the processor-sets"),
    622 		sysctl_psets_max, 0, &psets_max, 0,
    623 		CTL_CREATE, CTL_EOL);
    624 	sysctl_createv(clog, 0, &node, NULL,
    625 		CTLFLAG_PERMANENT,
    626 		CTLTYPE_STRING, "list",
    627 		SYSCTL_DESCR("List of active sets"),
    628 		sysctl_psets_list, 0, NULL, 0,
    629 		CTL_CREATE, CTL_EOL);
    630 }
    631