NetBSD/sys/kern/sys_pset.c

558 lines
12 KiB
C

/* $NetBSD: sys_pset.c,v 1.9 2008/09/30 16:28:45 rmind Exp $ */
/*
* Copyright (c) 2008, Mindaugas Rasiukevicius <rmind at NetBSD org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Implementation of the Processor Sets.
*
* Locking
* The array of the processor-set structures and its members are protected
* by the global cpu_lock. Note that in scheduler, the very l_psid value
* might be used without lock held.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sys_pset.c,v 1.9 2008/09/30 16:28:45 rmind Exp $");
#include <sys/param.h>
#include <sys/cpu.h>
#include <sys/kauth.h>
#include <sys/kmem.h>
#include <sys/lwp.h>
#include <sys/mutex.h>
#include <sys/proc.h>
#include <sys/pset.h>
#include <sys/sched.h>
#include <sys/syscallargs.h>
#include <sys/sysctl.h>
#include <sys/systm.h>
#include <sys/types.h>
static pset_info_t ** psets;
static u_int psets_max;
static u_int psets_count;
static int psets_realloc(int);
static int psid_validate(psetid_t, bool);
static int kern_pset_create(psetid_t *);
static int kern_pset_destroy(psetid_t);
/*
* Initialization of the processor-sets.
*/
void
psets_init(void)
{
psets_max = max(MAXCPUS, 32);
psets = kmem_zalloc(psets_max * sizeof(void *), KM_SLEEP);
psets_count = 0;
}
/*
* Reallocate the array of the processor-set structures.
*/
static int
psets_realloc(int new_psets_max)
{
pset_info_t **new_psets, **old_psets;
const u_int newsize = new_psets_max * sizeof(void *);
u_int i, oldsize;
if (new_psets_max < 1)
return EINVAL;
new_psets = kmem_zalloc(newsize, KM_SLEEP);
mutex_enter(&cpu_lock);
old_psets = psets;
oldsize = psets_max * sizeof(void *);
/* Check if we can lower the size of the array */
if (new_psets_max < psets_max) {
for (i = new_psets_max; i < psets_max; i++) {
if (psets[i] == NULL)
continue;
mutex_exit(&cpu_lock);
kmem_free(new_psets, newsize);
return EBUSY;
}
}
/* Copy all pointers to the new array */
memcpy(new_psets, psets, newsize);
psets_max = new_psets_max;
psets = new_psets;
mutex_exit(&cpu_lock);
kmem_free(old_psets, oldsize);
return 0;
}
/*
* Validate processor-set ID.
*/
static int
psid_validate(psetid_t psid, bool chkps)
{
KASSERT(mutex_owned(&cpu_lock));
if (chkps && (psid == PS_NONE || psid == PS_QUERY || psid == PS_MYID))
return 0;
if (psid <= 0 || psid > psets_max)
return EINVAL;
if (psets[psid - 1] == NULL)
return EINVAL;
if (psets[psid - 1]->ps_flags & PSET_BUSY)
return EBUSY;
return 0;
}
/*
* Create a processor-set.
*/
static int
kern_pset_create(psetid_t *psid)
{
pset_info_t *pi;
u_int i;
if (psets_count == psets_max)
return ENOMEM;
pi = kmem_zalloc(sizeof(pset_info_t), KM_SLEEP);
mutex_enter(&cpu_lock);
if (psets_count == psets_max) {
mutex_exit(&cpu_lock);
kmem_free(pi, sizeof(pset_info_t));
return ENOMEM;
}
/* Find a free entry in the array */
for (i = 0; i < psets_max; i++)
if (psets[i] == NULL)
break;
KASSERT(i != psets_max);
psets[i] = pi;
psets_count++;
mutex_exit(&cpu_lock);
*psid = i + 1;
return 0;
}
/*
* Destroy a processor-set.
*/
static int
kern_pset_destroy(psetid_t psid)
{
struct cpu_info *ci;
pset_info_t *pi;
struct lwp *l;
CPU_INFO_ITERATOR cii;
int error;
mutex_enter(&cpu_lock);
if (psid == PS_MYID) {
/* Use caller's processor-set ID */
psid = curlwp->l_psid;
}
error = psid_validate(psid, false);
if (error) {
mutex_exit(&cpu_lock);
return error;
}
/* Release the processor-set from all CPUs */
for (CPU_INFO_FOREACH(cii, ci)) {
struct schedstate_percpu *spc;
spc = &ci->ci_schedstate;
if (spc->spc_psid != psid)
continue;
spc->spc_psid = PS_NONE;
}
/* Mark that processor-set is going to be destroyed */
pi = psets[psid - 1];
pi->ps_flags |= PSET_BUSY;
mutex_exit(&cpu_lock);
/* Unmark the processor-set ID from each thread */
mutex_enter(proc_lock);
LIST_FOREACH(l, &alllwp, l_list) {
/* Safe to check and set without lock held */
if (l->l_psid != psid)
continue;
l->l_psid = PS_NONE;
}
mutex_exit(proc_lock);
/* Destroy the processor-set */
mutex_enter(&cpu_lock);
psets[psid - 1] = NULL;
psets_count--;
mutex_exit(&cpu_lock);
kmem_free(pi, sizeof(pset_info_t));
return 0;
}
/*
* General system calls for the processor-sets.
*/
int
sys_pset_create(struct lwp *l, const struct sys_pset_create_args *uap,
register_t *retval)
{
/* {
syscallarg(psetid_t) *psid;
} */
psetid_t psid;
int error;
/* Available only for super-user */
if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_PSET,
KAUTH_REQ_SYSTEM_PSET_CREATE, NULL, NULL, NULL))
return EPERM;
error = kern_pset_create(&psid);
if (error)
return error;
error = copyout(&psid, SCARG(uap, psid), sizeof(psetid_t));
if (error)
(void)kern_pset_destroy(psid);
return error;
}
int
sys_pset_destroy(struct lwp *l, const struct sys_pset_destroy_args *uap,
register_t *retval)
{
/* {
syscallarg(psetid_t) psid;
} */
/* Available only for super-user */
if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_PSET,
KAUTH_REQ_SYSTEM_PSET_DESTROY,
KAUTH_ARG(SCARG(uap, psid)), NULL, NULL))
return EPERM;
return kern_pset_destroy(SCARG(uap, psid));
}
int
sys_pset_assign(struct lwp *l, const struct sys_pset_assign_args *uap,
register_t *retval)
{
/* {
syscallarg(psetid_t) psid;
syscallarg(cpuid_t) cpuid;
syscallarg(psetid_t) *opsid;
} */
struct cpu_info *ci;
struct schedstate_percpu *spc = NULL;
psetid_t psid = SCARG(uap, psid), opsid = 0;
CPU_INFO_ITERATOR cii;
int error = 0, nnone = 0;
/* Available only for super-user, except the case of PS_QUERY */
if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_PSET,
KAUTH_REQ_SYSTEM_PSET_ASSIGN, KAUTH_ARG(SCARG(uap, psid)), NULL,
NULL))
return EPERM;
/* Find the target CPU */
mutex_enter(&cpu_lock);
for (CPU_INFO_FOREACH(cii, ci)) {
if (cpu_index(ci) == SCARG(uap, cpuid))
spc = &ci->ci_schedstate;
nnone += (ci->ci_schedstate.spc_psid == PS_NONE);
}
if (spc == NULL) {
mutex_exit(&cpu_lock);
return EINVAL;
}
error = psid_validate(psid, true);
if (error) {
mutex_exit(&cpu_lock);
return error;
}
opsid = spc->spc_psid;
switch (psid) {
case PS_QUERY:
break;
case PS_MYID:
psid = curlwp->l_psid;
/* FALLTHROUGH */
default:
/*
* Ensure at least one CPU stays in the default set,
* and that specified CPU is not offline.
*/
if (psid != PS_NONE && ((spc->spc_flags & SPCF_OFFLINE) ||
(nnone == 1 && spc->spc_psid == PS_NONE))) {
mutex_exit(&cpu_lock);
return EBUSY;
}
spc->spc_psid = psid;
break;
}
mutex_exit(&cpu_lock);
if (SCARG(uap, opsid) != NULL)
error = copyout(&opsid, SCARG(uap, opsid), sizeof(psetid_t));
return error;
}
int
sys__pset_bind(struct lwp *l, const struct sys__pset_bind_args *uap,
register_t *retval)
{
/* {
syscallarg(idtype_t) idtype;
syscallarg(id_t) first_id;
syscallarg(id_t) second_id;
syscallarg(psetid_t) psid;
syscallarg(psetid_t) *opsid;
} */
struct cpu_info *ci;
struct proc *p;
struct lwp *t;
id_t id1, id2;
pid_t pid = 0;
lwpid_t lid = 0;
psetid_t psid, opsid;
int error = 0, lcnt;
psid = SCARG(uap, psid);
/* Available only for super-user, except the case of PS_QUERY */
if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_PSET,
KAUTH_REQ_SYSTEM_PSET_BIND, KAUTH_ARG(SCARG(uap, psid)), NULL,
NULL))
return EPERM;
mutex_enter(&cpu_lock);
error = psid_validate(psid, true);
if (error) {
mutex_exit(&cpu_lock);
return error;
}
if (psid == PS_MYID)
psid = curlwp->l_psid;
if (psid != PS_QUERY && psid != PS_NONE)
psets[psid - 1]->ps_flags |= PSET_BUSY;
mutex_exit(&cpu_lock);
/*
* Get PID and LID from the ID.
*/
p = l->l_proc;
id1 = SCARG(uap, first_id);
id2 = SCARG(uap, second_id);
switch (SCARG(uap, idtype)) {
case P_PID:
/*
* Process:
* First ID - PID;
* Second ID - ignored;
*/
pid = (id1 == P_MYID) ? p->p_pid : id1;
lid = 0;
break;
case P_LWPID:
/*
* Thread (LWP):
* First ID - LID;
* Second ID - PID;
*/
if (id1 == P_MYID) {
pid = p->p_pid;
lid = l->l_lid;
break;
}
lid = id1;
pid = (id2 == P_MYID) ? p->p_pid : id2;
break;
default:
error = EINVAL;
goto error;
}
/* Find the process */
mutex_enter(proc_lock);
p = p_find(pid, PFIND_LOCKED);
if (p == NULL) {
mutex_exit(proc_lock);
error = ESRCH;
goto error;
}
mutex_enter(p->p_lock);
mutex_exit(proc_lock);
/* Disallow modification of the system processes */
if (p->p_flag & PK_SYSTEM) {
mutex_exit(p->p_lock);
error = EPERM;
goto error;
}
/* Find the LWP(s) */
lcnt = 0;
ci = NULL;
LIST_FOREACH(t, &p->p_lwps, l_sibling) {
if (lid && lid != t->l_lid)
continue;
/*
* Bind the thread to the processor-set,
* take some CPU and migrate.
*/
lwp_lock(t);
opsid = t->l_psid;
t->l_psid = psid;
ci = sched_takecpu(l);
/* Unlocks LWP */
lwp_migrate(t, ci);
lcnt++;
}
mutex_exit(p->p_lock);
if (lcnt == 0) {
error = ESRCH;
goto error;
}
if (SCARG(uap, opsid))
error = copyout(&opsid, SCARG(uap, opsid), sizeof(psetid_t));
error:
if (psid != PS_QUERY && psid != PS_NONE) {
mutex_enter(&cpu_lock);
psets[psid - 1]->ps_flags &= ~PSET_BUSY;
mutex_exit(&cpu_lock);
}
return error;
}
/*
* Sysctl nodes and initialization.
*/
static int
sysctl_psets_max(SYSCTLFN_ARGS)
{
struct sysctlnode node;
int error, newsize;
node = *rnode;
node.sysctl_data = &newsize;
newsize = psets_max;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return error;
if (newsize <= 0)
return EINVAL;
sysctl_unlock();
error = psets_realloc(newsize);
sysctl_relock();
return error;
}
static int
sysctl_psets_list(SYSCTLFN_ARGS)
{
const size_t bufsz = 1024;
char *buf, tbuf[16];
int i, error;
size_t len;
sysctl_unlock();
buf = kmem_alloc(bufsz, KM_SLEEP);
snprintf(buf, bufsz, "%d:1", PS_NONE); /* XXX */
mutex_enter(&cpu_lock);
for (i = 0; i < psets_max; i++) {
if (psets[i] == NULL)
continue;
snprintf(tbuf, sizeof(tbuf), ",%d:2", i + 1); /* XXX */
strlcat(buf, tbuf, bufsz);
}
mutex_exit(&cpu_lock);
len = strlen(buf) + 1;
error = 0;
if (oldp != NULL)
error = copyout(buf, oldp, min(len, *oldlenp));
*oldlenp = len;
kmem_free(buf, bufsz);
sysctl_relock();
return error;
}
SYSCTL_SETUP(sysctl_pset_setup, "sysctl kern.pset subtree setup")
{
const struct sysctlnode *node = NULL;
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_NODE, "kern", NULL,
NULL, 0, NULL, 0,
CTL_KERN, CTL_EOL);
sysctl_createv(clog, 0, NULL, &node,
CTLFLAG_PERMANENT,
CTLTYPE_NODE, "pset",
SYSCTL_DESCR("Processor-set options"),
NULL, 0, NULL, 0,
CTL_KERN, CTL_CREATE, CTL_EOL);
if (node == NULL)
return;
sysctl_createv(clog, 0, &node, NULL,
CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
CTLTYPE_INT, "psets_max",
SYSCTL_DESCR("Maximal count of the processor-sets"),
sysctl_psets_max, 0, &psets_max, 0,
CTL_CREATE, CTL_EOL);
sysctl_createv(clog, 0, &node, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_STRING, "list",
SYSCTL_DESCR("List of active sets"),
sysctl_psets_list, 0, NULL, 0,
CTL_CREATE, CTL_EOL);
}