OpenSolaris_b135/uts/common/os/pool_pset.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/pool.h>
#include <sys/pool_impl.h>
#include <sys/pool_pset.h>
#include <sys/cpuvar.h>
#include <sys/cpupart.h>
#include <sys/mutex.h>
#include <sys/errno.h>
#include <sys/systm.h>
#include <sys/cmn_err.h>
#include <sys/fss.h>
#include <sys/exacct.h>
#include <sys/time.h>
#include <sys/policy.h>
#include <sys/class.h>
#include <sys/list.h>
#include <sys/cred.h>
#include <sys/zone.h>
/*
* Processor set plugin for pools.
*
* This file contains various routines used by the common pools layer to create,
* modify, and destroy processor sets. All processor sets created by this
* plug-in are stored in the pool_pset_list doubly-linked list, which is
* guaranteed to always have an entry for the default processor set,
* pool_pset_default.
*
* Interaction with zones:
*
* If pools are enabled, non-global zones only have visibility into the
* pset of the pool to which they are bound. This is accomplished by
* changing the set of processors and processor sets which are visible
* through both systemcall interfaces and system kstats.
*
* To avoid grabbing pool_lock() during cpu change operations, we cache
* the pset the zone is currently bound to, and can read this value
* while under cpu_lock. The special psetid_t token ZONE_PS_INVAL means
* that pools are disabled, and provides a mechanism for determining if the
* status of pools without grabbing pool_lock().
*
* To avoid grabbing any locks to determine the instantaneous value of
* the number of configured and online cpus in the zone, we also cache
* these values in a zone_t. If these values are zero, the pools
* facility must be disabled, in which case relevant systemcall
* interfaces will return the values for the system as a whole.
*
* The various kstat interfaces are dealt with as follows: if pools are
* disabled all cpu-related kstats should be exported to all zones.
* When pools are enabled we begin maintaining a list of "permitted
* zones" on a per-kstat basis. There are various hooks throughout the
* code to update this list when certain pools- or cpu-related events
* occur.
*/
static list_t pool_pset_list; /* doubly-linked list of psets */
pool_pset_t *pool_pset_default; /* default pset */
hrtime_t pool_pset_mod; /* last modification time for psets */
hrtime_t pool_cpu_mod; /* last modification time for CPUs */
static pool_pset_t *
pool_lookup_pset_by_id(psetid_t psetid)
{
pool_pset_t *pset = pool_pset_default;
ASSERT(pool_lock_held());
for (pset = list_head(&pool_pset_list); pset;
pset = list_next(&pool_pset_list, pset)) {
if (pset->pset_id == psetid)
return (pset);
}
return (NULL);
}
struct setup_arg {
psetid_t psetid;
cpu_t *cpu;
cpu_setup_t what;
};
/*
* Callback function used to apply a cpu configuration event to a zone.
*/
static int
pool_pset_setup_cb(zone_t *zone, void *arg)
{
struct setup_arg *sa = arg;
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(INGLOBALZONE(curproc));
ASSERT(zone != NULL);
if (zone == global_zone)
return (0);
if (zone_pset_get(zone) != sa->psetid)
return (0); /* ignore */
switch (sa->what) {
case CPU_CONFIG:
cpu_visibility_configure(sa->cpu, zone);
break;
case CPU_UNCONFIG:
cpu_visibility_unconfigure(sa->cpu, zone);
break;
case CPU_ON:
cpu_visibility_online(sa->cpu, zone);
break;
case CPU_OFF:
cpu_visibility_offline(sa->cpu, zone);
break;
case CPU_CPUPART_IN:
cpu_visibility_add(sa->cpu, zone);
break;
case CPU_CPUPART_OUT:
cpu_visibility_remove(sa->cpu, zone);
break;
default:
cmn_err(CE_PANIC, "invalid cpu_setup_t value %d", sa->what);
}
return (0);
}
/*
* Callback function to be executed when a noteworthy cpu event takes
* place. Will ensure that the event is reflected by the zones which
* were affected by it.
*/
/* ARGSUSED */
static int
pool_pset_cpu_setup(cpu_setup_t what, int id, void *arg)
{
processorid_t cpuid = id;
struct setup_arg sarg;
int error;
cpu_t *c;
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(INGLOBALZONE(curproc));
if (!pool_pset_enabled())
return (0);
if (what != CPU_CONFIG && what != CPU_UNCONFIG &&
what != CPU_ON && what != CPU_OFF &&
what != CPU_CPUPART_IN && what != CPU_CPUPART_OUT)
return (0);
c = cpu_get(cpuid);
ASSERT(c != NULL);
sarg.psetid = cpupart_query_cpu(c);
sarg.cpu = c;
sarg.what = what;
error = zone_walk(pool_pset_setup_cb, &sarg);
ASSERT(error == 0);
return (0);
}
/*
* Initialize processor set plugin. Called once at boot time.
*/
void
pool_pset_init(void)
{
ASSERT(pool_pset_default == NULL);
pool_pset_default = kmem_zalloc(sizeof (pool_pset_t), KM_SLEEP);
pool_pset_default->pset_id = PS_NONE;
pool_pset_default->pset_npools = 1; /* for pool_default */
pool_default->pool_pset = pool_pset_default;
list_create(&pool_pset_list, sizeof (pool_pset_t),
offsetof(pool_pset_t, pset_link));
list_insert_head(&pool_pset_list, pool_pset_default);
mutex_enter(&cpu_lock);
register_cpu_setup_func(pool_pset_cpu_setup, NULL);
mutex_exit(&cpu_lock);
}
/*
* Dummy wrapper function that returns 0 to satisfy zone_walk().
*/
static int
pool_pset_zone_pset_set(zone_t *zone, void *arg)
{
psetid_t psetid = (psetid_t)(uintptr_t)arg;
ASSERT(MUTEX_HELD(&cpu_lock));
zone_pset_set(zone, psetid);
return (0);
}
/*
* Enable processor set plugin.
*/
int
pool_pset_enable(void)
{
int error;
nvlist_t *props;
ASSERT(pool_lock_held());
ASSERT(INGLOBALZONE(curproc));
/*
* Can't enable pools if there are existing cpu partitions.
*/
mutex_enter(&cpu_lock);
if (cp_numparts > 1) {
mutex_exit(&cpu_lock);
return (EEXIST);
}
/*
* We want to switch things such that everything that was tagged with
* the special ALL_ZONES token now is explicitly visible to all zones:
* first add individual zones to the visibility list then remove the
* special "ALL_ZONES" token. There must only be the default pset
* (PS_NONE) active if pools are being enabled, so we only need to
* deal with it.
*
* We want to make pool_pset_enabled() start returning B_TRUE before
* we call any of the visibility update functions.
*/
global_zone->zone_psetid = PS_NONE;
/*
* We need to explicitly handle the global zone since
* zone_pset_set() won't modify it.
*/
pool_pset_visibility_add(PS_NONE, global_zone);
/*
* A NULL argument means the ALL_ZONES token.
*/
pool_pset_visibility_remove(PS_NONE, NULL);
error = zone_walk(pool_pset_zone_pset_set, (void *)PS_NONE);
ASSERT(error == 0);
/*
* It is safe to drop cpu_lock here. We're still
* holding pool_lock so no new cpu partitions can
* be created while we're here.
*/
mutex_exit(&cpu_lock);
(void) nvlist_alloc(&pool_pset_default->pset_props,
NV_UNIQUE_NAME, KM_SLEEP);
props = pool_pset_default->pset_props;
(void) nvlist_add_string(props, "pset.name", "pset_default");
(void) nvlist_add_string(props, "pset.comment", "");
(void) nvlist_add_int64(props, "pset.sys_id", PS_NONE);
(void) nvlist_add_string(props, "pset.units", "population");
(void) nvlist_add_byte(props, "pset.default", 1);
(void) nvlist_add_uint64(props, "pset.max", 65536);
(void) nvlist_add_uint64(props, "pset.min", 1);
pool_pset_mod = pool_cpu_mod = gethrtime();
return (0);
}
/*
* Disable processor set plugin.
*/
int
pool_pset_disable(void)
{
processorid_t cpuid;
cpu_t *cpu;
int error;
ASSERT(pool_lock_held());
ASSERT(INGLOBALZONE(curproc));
mutex_enter(&cpu_lock);
if (cp_numparts > 1) { /* make sure only default pset is left */
mutex_exit(&cpu_lock);
return (EBUSY);
}
/*
* Remove all non-system CPU and processor set properties
*/
for (cpuid = 0; cpuid < NCPU; cpuid++) {
if ((cpu = cpu_get(cpuid)) == NULL)
continue;
if (cpu->cpu_props != NULL) {
(void) nvlist_free(cpu->cpu_props);
cpu->cpu_props = NULL;
}
}
/*
* We want to switch things such that everything is now visible
* to ALL_ZONES: first add the special "ALL_ZONES" token to the
* visibility list then remove individual zones. There must
* only be the default pset active if pools are being disabled,
* so we only need to deal with it.
*/
error = zone_walk(pool_pset_zone_pset_set, (void *)ZONE_PS_INVAL);
ASSERT(error == 0);
pool_pset_visibility_add(PS_NONE, NULL);
pool_pset_visibility_remove(PS_NONE, global_zone);
/*
* pool_pset_enabled() will henceforth return B_FALSE.
*/
global_zone->zone_psetid = ZONE_PS_INVAL;
mutex_exit(&cpu_lock);
if (pool_pset_default->pset_props != NULL) {
nvlist_free(pool_pset_default->pset_props);
pool_pset_default->pset_props = NULL;
}
return (0);
}
/*
* Create new processor set and give it a temporary name.
*/
int
pool_pset_create(psetid_t *id)
{
char pset_name[40];
pool_pset_t *pset;
psetid_t psetid;
int err;
ASSERT(pool_lock_held());
if ((err = cpupart_create(&psetid)) != 0)
return (err);
pset = kmem_alloc(sizeof (pool_pset_t), KM_SLEEP);
pset->pset_id = *id = psetid;
pset->pset_npools = 0;
(void) nvlist_alloc(&pset->pset_props, NV_UNIQUE_NAME, KM_SLEEP);
(void) nvlist_add_int64(pset->pset_props, "pset.sys_id", psetid);
(void) nvlist_add_byte(pset->pset_props, "pset.default", 0);
pool_pset_mod = gethrtime();
(void) snprintf(pset_name, sizeof (pset_name), "pset_%lld",
pool_pset_mod);
(void) nvlist_add_string(pset->pset_props, "pset.name", pset_name);
list_insert_tail(&pool_pset_list, pset);
return (0);
}
/*
* Destroy existing processor set.
*/
int
pool_pset_destroy(psetid_t psetid)
{
pool_pset_t *pset;
int ret;
ASSERT(pool_lock_held());
if (psetid == PS_NONE)
return (EINVAL);
if ((pset = pool_lookup_pset_by_id(psetid)) == NULL)
return (ESRCH);
if (pset->pset_npools > 0) /* can't destroy associated psets */
return (EBUSY);
if ((ret = cpupart_destroy(pset->pset_id)) != 0)
return (ret);
(void) nvlist_free(pset->pset_props);
list_remove(&pool_pset_list, pset);
pool_pset_mod = gethrtime();
kmem_free(pset, sizeof (pool_pset_t));
return (0);
}
/*
* Change the visibility of a pset (and all contained cpus) in a zone.
* A NULL zone argument implies the special ALL_ZONES token.
*/
static void
pool_pset_visibility_change(psetid_t psetid, zone_t *zone, boolean_t add)
{
zoneid_t zoneid = zone ? zone->zone_id : ALL_ZONES;
cpupart_t *cp;
cpu_t *c;
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(psetid != ZONE_PS_INVAL);
cp = cpupart_find(psetid);
ASSERT(cp != NULL);
if (cp->cp_kstat != NULL) {
if (add)
kstat_zone_add(cp->cp_kstat, zoneid);
else
kstat_zone_remove(cp->cp_kstat, zoneid);
}
c = cpu_list;
do {
ASSERT(c != NULL);
if (c->cpu_part == cp && !cpu_is_poweredoff(c)) {
if (add)
cpu_visibility_add(c, zone);
else
cpu_visibility_remove(c, zone);
}
} while ((c = c->cpu_next) != cpu_list);
}
/*
* Make the processor set visible to the zone. A NULL value for
* the zone means that the special ALL_ZONES token should be added to
* the visibility list.
*/
void
pool_pset_visibility_add(psetid_t psetid, zone_t *zone)
{
pool_pset_visibility_change(psetid, zone, B_TRUE);
}
/*
* Remove zone's visibility into the processor set. A NULL value for
* the zone means that the special ALL_ZONES token should be removed
* from the visibility list.
*/
void
pool_pset_visibility_remove(psetid_t psetid, zone_t *zone)
{
pool_pset_visibility_change(psetid, zone, B_FALSE);
}
/*
* Quick way of seeing if pools are enabled (as far as processor sets are
* concerned) without holding pool_lock().
*/
boolean_t
pool_pset_enabled(void)
{
ASSERT(MUTEX_HELD(&cpu_lock));
return (zone_pset_get(global_zone) != ZONE_PS_INVAL);
}
struct assoc_zone_arg {
poolid_t poolid;
psetid_t newpsetid;
};
/*
* Callback function to update a zone's processor set visibility when
* a pool is associated with a processor set.
*/
static int
pool_pset_assoc_zone_cb(zone_t *zone, void *arg)
{
struct assoc_zone_arg *aza = arg;
pool_t *pool;
zoneid_t zoneid = zone->zone_id;
ASSERT(pool_lock_held());
ASSERT(MUTEX_HELD(&cpu_lock));
if (zoneid == GLOBAL_ZONEID)
return (0);
pool = zone_pool_get(zone);
if (pool->pool_id == aza->poolid)
zone_pset_set(zone, aza->newpsetid);
return (0);
}
/*
* Associate pool with new processor set.
*/
int
pool_pset_assoc(poolid_t poolid, psetid_t psetid)
{
pool_t *pool;
pool_pset_t *pset, *oldpset;
int err = 0;
ASSERT(pool_lock_held());
if ((pool = pool_lookup_pool_by_id(poolid)) == NULL ||
(pset = pool_lookup_pset_by_id(psetid)) == NULL) {
return (ESRCH);
}
if (pool->pool_pset->pset_id == psetid) {
/*
* Already associated.
*/
return (0);
}
/*
* Hang the new pset off the pool, and rebind all of the pool's
* processes to it. If pool_do_bind fails, all processes will remain
* bound to the old set.
*/
oldpset = pool->pool_pset;
pool->pool_pset = pset;
err = pool_do_bind(pool, P_POOLID, poolid, POOL_BIND_PSET);
if (err) {
pool->pool_pset = oldpset;
} else {
struct assoc_zone_arg azarg;
/*
* Update zones' visibility to reflect changes.
*/
azarg.poolid = poolid;
azarg.newpsetid = pset->pset_id;
mutex_enter(&cpu_lock);
err = zone_walk(pool_pset_assoc_zone_cb, &azarg);
ASSERT(err == 0);
mutex_exit(&cpu_lock);
oldpset->pset_npools--;
pset->pset_npools++;
}
return (err);
}
/*
* Transfer specified CPUs between processor sets.
*/
int
pool_pset_xtransfer(psetid_t src, psetid_t dst, size_t size, id_t *ids)
{
struct cpu *cpu;
int ret = 0;
int id;
ASSERT(pool_lock_held());
ASSERT(INGLOBALZONE(curproc));
if (size == 0 || size > max_ncpus) /* quick sanity check */
return (EINVAL);
mutex_enter(&cpu_lock);
for (id = 0; id < size; id++) {
if ((cpu = cpu_get((processorid_t)ids[id])) == NULL ||
cpupart_query_cpu(cpu) != src) {
ret = EINVAL;
break;
}
if ((ret = cpupart_attach_cpu(dst, cpu, 1)) != 0)
break;
}
mutex_exit(&cpu_lock);
if (ret == 0)
pool_pset_mod = gethrtime();
return (ret);
}
/*
* Bind process to processor set. This should never fail because
* we should've done all preliminary checks before calling it.
*/
void
pool_pset_bind(proc_t *p, psetid_t psetid, void *projbuf, void *zonebuf)
{
kthread_t *t;
int ret;
ASSERT(pool_lock_held());
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(MUTEX_HELD(&pidlock));
ASSERT(MUTEX_HELD(&p->p_lock));
if ((t = p->p_tlist) == NULL)
return;
do {
ret = cpupart_bind_thread(t, psetid, 0, projbuf, zonebuf);
ASSERT(ret == 0);
t->t_bind_pset = psetid;
} while ((t = t->t_forw) != p->p_tlist);
}
/*
* See the comment above pool_do_bind() for the semantics of the pset_bind_*()
* functions. These must be kept in sync with cpupart_move_thread, and
* anything else that could fail a pool_pset_bind.
*
* Returns non-zero errno on failure and zero on success.
* Iff successful, cpu_lock is held on return.
*/
int
pset_bind_start(proc_t **procs, pool_t *pool)
{
cred_t *pcred;
proc_t *p, **pp;
kthread_t *t;
cpupart_t *newpp;
int ret;
extern int cpupart_movable_thread(kthread_id_t, cpupart_t *, int);
ASSERT(pool_lock_held());
ASSERT(INGLOBALZONE(curproc));
mutex_enter(&cpu_lock);
weakbinding_stop();
newpp = cpupart_find(pool->pool_pset->pset_id);
ASSERT(newpp != NULL);
if (newpp->cp_cpulist == NULL) {
weakbinding_start();
mutex_exit(&cpu_lock);
return (ENOTSUP);
}
pcred = crgetcred();
/*
* Check for the PRIV_PROC_PRIOCNTL privilege that is required
* to enter and exit scheduling classes. If other privileges
* are required by CL_ENTERCLASS/CL_CANEXIT types of routines
* in the future, this code will have to be updated.
*/
if (secpolicy_setpriority(pcred) != 0) {
weakbinding_start();
mutex_exit(&cpu_lock);
crfree(pcred);
return (EPERM);
}
for (pp = procs; (p = *pp) != NULL; pp++) {
mutex_enter(&p->p_lock);
if ((t = p->p_tlist) == NULL) {
mutex_exit(&p->p_lock);
continue;
}
/*
* Check our basic permissions to control this process.
*/
if (!prochasprocperm(p, curproc, pcred)) {
mutex_exit(&p->p_lock);
weakbinding_start();
mutex_exit(&cpu_lock);
crfree(pcred);
return (EPERM);
}
do {
/*
* Check that all threads can be moved to
* a new processor set.
*/
thread_lock(t);
ret = cpupart_movable_thread(t, newpp, 0);
thread_unlock(t);
if (ret != 0) {
mutex_exit(&p->p_lock);
weakbinding_start();
mutex_exit(&cpu_lock);
crfree(pcred);
return (ret);
}
} while ((t = t->t_forw) != p->p_tlist);
mutex_exit(&p->p_lock);
}
crfree(pcred);
return (0); /* with cpu_lock held and weakbinding stopped */
}
/*ARGSUSED*/
void
pset_bind_abort(proc_t **procs, pool_t *pool)
{
mutex_exit(&cpu_lock);
}
void
pset_bind_finish(void)
{
weakbinding_start();
mutex_exit(&cpu_lock);
}
static pool_property_t pool_pset_props[] = {
{ "pset.name", DATA_TYPE_STRING, PP_RDWR },
{ "pset.comment", DATA_TYPE_STRING, PP_RDWR },
{ "pset.sys_id", DATA_TYPE_UINT64, PP_READ },
{ "pset.units", DATA_TYPE_STRING, PP_RDWR },
{ "pset.default", DATA_TYPE_BYTE, PP_READ },
{ "pset.min", DATA_TYPE_UINT64, PP_RDWR },
{ "pset.max", DATA_TYPE_UINT64, PP_RDWR },
{ "pset.size", DATA_TYPE_UINT64, PP_READ },
{ "pset.load", DATA_TYPE_UINT64, PP_READ },
{ "pset.poold.objectives", DATA_TYPE_STRING,
PP_RDWR | PP_OPTIONAL },
{ NULL, 0, 0 }
};
static pool_property_t pool_cpu_props[] = {
{ "cpu.sys_id", DATA_TYPE_UINT64, PP_READ },
{ "cpu.comment", DATA_TYPE_STRING, PP_RDWR },
{ "cpu.status", DATA_TYPE_STRING, PP_RDWR },
{ "cpu.pinned", DATA_TYPE_BYTE,
PP_RDWR | PP_OPTIONAL },
{ NULL, 0, 0 }
};
/*
* Put property on the specified processor set.
*/
int
pool_pset_propput(psetid_t psetid, nvpair_t *pair)
{
pool_pset_t *pset;
int ret;
ASSERT(pool_lock_held());
if ((pset = pool_lookup_pset_by_id(psetid)) == NULL)
return (ESRCH);
ret = pool_propput_common(pset->pset_props, pair, pool_pset_props);
if (ret == 0)
pool_pset_mod = gethrtime();
return (ret);
}
/*
* Remove existing processor set property.
*/
int
pool_pset_proprm(psetid_t psetid, char *name)
{
pool_pset_t *pset;
int ret;
ASSERT(pool_lock_held());
if ((pset = pool_lookup_pset_by_id(psetid)) == NULL)
return (EINVAL);
ret = pool_proprm_common(pset->pset_props, name, pool_pset_props);
if (ret == 0)
pool_pset_mod = gethrtime();
return (ret);
}
/*
* Put new CPU property.
* Handle special case of "cpu.status".
*/
int
pool_cpu_propput(processorid_t cpuid, nvpair_t *pair)
{
int ret = 0;
cpu_t *cpu;
ASSERT(pool_lock_held());
ASSERT(INGLOBALZONE(curproc));
if (nvpair_type(pair) == DATA_TYPE_STRING &&
strcmp(nvpair_name(pair), "cpu.status") == 0) {
char *val;
int status;
int old_status;
(void) nvpair_value_string(pair, &val);
if (strcmp(val, PS_OFFLINE) == 0)
status = P_OFFLINE;
else if (strcmp(val, PS_ONLINE) == 0)
status = P_ONLINE;
else if (strcmp(val, PS_NOINTR) == 0)
status = P_NOINTR;
else if (strcmp(val, PS_FAULTED) == 0)
status = P_FAULTED;
else if (strcmp(val, PS_SPARE) == 0)
status = P_SPARE;
else
return (EINVAL);
ret = p_online_internal(cpuid, status, &old_status);
} else {
mutex_enter(&cpu_lock);
if ((cpu = cpu_get(cpuid)) == NULL)
ret = EINVAL;
if (cpu->cpu_props == NULL) {
(void) nvlist_alloc(&cpu->cpu_props,
NV_UNIQUE_NAME, KM_SLEEP);
(void) nvlist_add_string(cpu->cpu_props,
"cpu.comment", "");
}
ret = pool_propput_common(cpu->cpu_props, pair, pool_cpu_props);
if (ret == 0)
pool_cpu_mod = gethrtime();
mutex_exit(&cpu_lock);
}
return (ret);
}
/*
* Remove existing CPU property.
*/
int
pool_cpu_proprm(processorid_t cpuid, char *name)
{
int ret;
cpu_t *cpu;
ASSERT(pool_lock_held());
ASSERT(INGLOBALZONE(curproc));
mutex_enter(&cpu_lock);
if ((cpu = cpu_get(cpuid)) == NULL || cpu_is_poweredoff(cpu)) {
ret = EINVAL;
} else {
if (cpu->cpu_props == NULL)
ret = EINVAL;
else
ret = pool_proprm_common(cpu->cpu_props, name,
pool_cpu_props);
}
if (ret == 0)
pool_cpu_mod = gethrtime();
mutex_exit(&cpu_lock);
return (ret);
}
/*
* This macro returns load average multiplied by 1000 w/o losing precision
*/
#define PSET_LOAD(f) (((f >> 16) * 1000) + (((f & 0xffff) * 1000) / 0xffff))
/*
* Take a snapshot of the current state of processor sets and CPUs,
* pack it in the exacct format, and attach it to specified exacct record.
*/
int
pool_pset_pack(ea_object_t *eo_system)
{
ea_object_t *eo_pset, *eo_cpu;
cpupart_t *cpupart;
psetid_t mypsetid;
pool_pset_t *pset;
nvlist_t *nvl;
size_t bufsz;
cpu_t *cpu;
char *buf;
int ncpu;
ASSERT(pool_lock_held());
mutex_enter(&cpu_lock);
mypsetid = zone_pset_get(curproc->p_zone);
for (pset = list_head(&pool_pset_list); pset;
pset = list_next(&pool_pset_list, pset)) {
psetid_t psetid = pset->pset_id;
if (!INGLOBALZONE(curproc) && mypsetid != psetid)
continue;
cpupart = cpupart_find(psetid);
ASSERT(cpupart != NULL);
eo_pset = ea_alloc_group(EXT_GROUP |
EXC_LOCAL | EXD_GROUP_PSET);
(void) ea_attach_item(eo_pset, &psetid, sizeof (id_t),
EXC_LOCAL | EXD_PSET_PSETID | EXT_UINT32);
/*
* Pack info for all CPUs in this processor set.
*/
ncpu = 0;
cpu = cpu_list;
do {
if (cpu->cpu_part != cpupart) /* not our pset */
continue;
ncpu++;
eo_cpu = ea_alloc_group(EXT_GROUP
| EXC_LOCAL | EXD_GROUP_CPU);
(void) ea_attach_item(eo_cpu, &cpu->cpu_id,
sizeof (processorid_t),
EXC_LOCAL | EXD_CPU_CPUID | EXT_UINT32);
if (cpu->cpu_props == NULL) {
(void) nvlist_alloc(&cpu->cpu_props,
NV_UNIQUE_NAME, KM_SLEEP);
(void) nvlist_add_string(cpu->cpu_props,
"cpu.comment", "");
}
(void) nvlist_dup(cpu->cpu_props, &nvl, KM_SLEEP);
(void) nvlist_add_int64(nvl, "cpu.sys_id", cpu->cpu_id);
(void) nvlist_add_string(nvl, "cpu.status",
(char *)cpu_get_state_str(cpu));
buf = NULL;
bufsz = 0;
(void) nvlist_pack(nvl, &buf, &bufsz,
NV_ENCODE_NATIVE, 0);
(void) ea_attach_item(eo_cpu, buf, bufsz,
EXC_LOCAL | EXD_CPU_PROP | EXT_RAW);
(void) nvlist_free(nvl);
kmem_free(buf, bufsz);
(void) ea_attach_to_group(eo_pset, eo_cpu);
} while ((cpu = cpu->cpu_next) != cpu_list);
(void) nvlist_dup(pset->pset_props, &nvl, KM_SLEEP);
(void) nvlist_add_uint64(nvl, "pset.size", ncpu);
(void) nvlist_add_uint64(nvl, "pset.load",
(uint64_t)PSET_LOAD(cpupart->cp_hp_avenrun[0]));
buf = NULL;
bufsz = 0;
(void) nvlist_pack(nvl, &buf, &bufsz, NV_ENCODE_NATIVE, 0);
(void) ea_attach_item(eo_pset, buf, bufsz,
EXC_LOCAL | EXD_PSET_PROP | EXT_RAW);
(void) nvlist_free(nvl);
kmem_free(buf, bufsz);
(void) ea_attach_to_group(eo_system, eo_pset);
}
mutex_exit(&cpu_lock);
return (0);
}
/*
* Get dynamic property for processor sets.
* The only dynamic property currently implemented is "pset.load".
*/
int
pool_pset_propget(psetid_t psetid, char *name, nvlist_t *nvl)
{
cpupart_t *cpupart;
pool_pset_t *pset;
int ret = ESRCH;
ASSERT(pool_lock_held());
mutex_enter(&cpu_lock);
pset = pool_lookup_pset_by_id(psetid);
cpupart = cpupart_find(psetid);
if (cpupart == NULL || pset == NULL) {
mutex_exit(&cpu_lock);
return (EINVAL);
}
if (strcmp(name, "pset.load") == 0)
ret = nvlist_add_uint64(nvl, "pset.load",
(uint64_t)PSET_LOAD(cpupart->cp_hp_avenrun[0]));
else
ret = EINVAL;
mutex_exit(&cpu_lock);
return (ret);
}
/*
* Get dynamic property for CPUs.
* The only dynamic property currently implemented is "cpu.status".
*/
int
pool_cpu_propget(processorid_t cpuid, char *name, nvlist_t *nvl)
{
int ret = ESRCH;
cpu_t *cpu;
ASSERT(pool_lock_held());
mutex_enter(&cpu_lock);
if ((cpu = cpu_get(cpuid)) == NULL) {
mutex_exit(&cpu_lock);
return (ESRCH);
}
if (strcmp(name, "cpu.status") == 0) {
ret = nvlist_add_string(nvl, "cpu.status",
(char *)cpu_get_state_str(cpu));
} else {
ret = EINVAL;
}
mutex_exit(&cpu_lock);
return (ret);
}