static int
pset(int subcode, long arg1, long arg2, long arg3, long arg4)
{
switch (subcode) {
case PSET_CREATE:
return (pset_create((psetid_t *)arg1));
case PSET_DESTROY:
return (pset_destroy((psetid_t)arg1));
case PSET_ASSIGN:
return (pset_assign((psetid_t)arg1,
(processorid_t)arg2, (psetid_t *)arg3, 0));
case PSET_INFO:
return (pset_info((psetid_t)arg1, (int *)arg2,
(uint_t *)arg3, (processorid_t *)arg4));
case PSET_BIND:
return (pset_bind((psetid_t)arg1, (idtype_t)arg2,
(id_t)arg3, (psetid_t *)arg4));
case PSET_GETLOADAVG:
return (pset_getloadavg((psetid_t)arg1, (int *)arg2,
(int)arg3));
case PSET_LIST:
return (pset_list((psetid_t *)arg1, (uint_t *)arg2));
case PSET_SETATTR:
return (pset_setattr((psetid_t)arg1, (uint_t)arg2));
case PSET_GETATTR:
return (pset_getattr((psetid_t)arg1, (uint_t *)arg2));
case PSET_ASSIGN_FORCED:
return (pset_assign((psetid_t)arg1,
(processorid_t)arg2, (psetid_t *)arg3, 1));
default:
return (set_errno(EINVAL));
}
}
static int
acquire_cpus(struct snapshot *ss, kstat_ctl_t *kc)
{
size_t i;
ss->s_nr_cpus = sysconf(_SC_CPUID_MAX) + 1;
ss->s_cpus = calloc(ss->s_nr_cpus, sizeof (struct cpu_snapshot));
if (ss->s_cpus == NULL)
goto out;
for (i = 0; i < ss->s_nr_cpus; i++) {
kstat_t *ksp;
ss->s_cpus[i].cs_id = ID_NO_CPU;
ss->s_cpus[i].cs_state = p_online(i, P_STATUS);
/* If no valid CPU is present, move on to the next one */
if (ss->s_cpus[i].cs_state == -1)
continue;
ss->s_cpus[i].cs_id = i;
if ((ksp = kstat_lookup_read(kc, "cpu_info", i, NULL)) == NULL)
goto out;
(void) pset_assign(PS_QUERY, i, &ss->s_cpus[i].cs_pset_id);
if (ss->s_cpus[i].cs_pset_id == PS_NONE)
ss->s_cpus[i].cs_pset_id = ID_NO_PSET;
if (!CPU_ACTIVE(&ss->s_cpus[i]))
continue;
if ((ksp = kstat_lookup_read(kc, "cpu", i, "vm")) == NULL)
goto out;
if (kstat_copy(ksp, &ss->s_cpus[i].cs_vm))
goto out;
if ((ksp = kstat_lookup_read(kc, "cpu", i, "sys")) == NULL)
goto out;
if (kstat_copy(ksp, &ss->s_cpus[i].cs_sys))
goto out;
}
errno = 0;
out:
return (errno);
}
static int
cpustat(void)
{
cpc_setgrp_t *accum;
cpc_set_t *start;
int c, i, retval;
int lwps = 0;
psetid_t mypset, cpupset;
char *errstr;
cpc_buf_t **data1, **data2, **scratch;
int nreqs;
kstat_ctl_t *kc;
ncpus = (int)sysconf(_SC_NPROCESSORS_CONF);
if ((gstate = calloc(ncpus, sizeof (*gstate))) == NULL) {
(void) fprintf(stderr, gettext(
"%s: out of heap\n"), opts->pgmname);
return (1);
}
max_chip_id = sysconf(_SC_CPUID_MAX);
if ((chip_designees = malloc(max_chip_id * sizeof (int))) == NULL) {
(void) fprintf(stderr, gettext(
"%s: out of heap\n"), opts->pgmname);
return (1);
}
for (i = 0; i < max_chip_id; i++)
chip_designees[i] = -1;
if (smt) {
if ((kc = kstat_open()) == NULL) {
(void) fprintf(stderr, gettext(
"%s: kstat_open() failed: %s\n"), opts->pgmname,
strerror(errno));
return (1);
}
}
if (opts->dosoaker)
if (priocntl(0, 0, PC_GETCID, &fxinfo) == -1) {
(void) fprintf(stderr, gettext(
"%s: couldn't get FX scheduler class: %s\n"),
opts->pgmname, strerror(errno));
return (1);
}
/*
* Only include processors that are participating in the system
*/
for (c = 0, i = 0; i < ncpus; c++) {
switch (p_online(c, P_STATUS)) {
case P_ONLINE:
case P_NOINTR:
if (smt) {
gstate[i].chip_id = get_chipid(kc, c);
if (gstate[i].chip_id != -1 &&
chip_designees[gstate[i].chip_id] == -1)
chip_designees[gstate[i].chip_id] = c;
}
gstate[i++].cpuid = c;
break;
case P_OFFLINE:
case P_POWEROFF:
case P_FAULTED:
case P_SPARE:
gstate[i++].cpuid = -1;
break;
default:
gstate[i++].cpuid = -1;
(void) fprintf(stderr,
gettext("%s: cpu%d in unknown state\n"),
opts->pgmname, c);
break;
case -1:
break;
}
}
/*
* Examine the processor sets; if we're in one, only attempt
* to report on the set we're in.
*/
if (pset_bind(PS_QUERY, P_PID, P_MYID, &mypset) == -1) {
errstr = strerror(errno);
(void) fprintf(stderr, gettext("%s: pset_bind - %s\n"),
opts->pgmname, errstr);
} else {
for (i = 0; i < ncpus; i++) {
struct tstate *this = &gstate[i];
if (this->cpuid == -1)
continue;
if (pset_assign(PS_QUERY,
this->cpuid, &cpupset) == -1) {
errstr = strerror(errno);
(void) fprintf(stderr,
gettext("%s: pset_assign - %s\n"),
opts->pgmname, errstr);
continue;
}
if (mypset != cpupset)
this->cpuid = -1;
}
}
if (opts->dotitle)
print_title(opts->master);
zerotime();
for (i = 0; i < ncpus; i++) {
struct tstate *this = &gstate[i];
if (this->cpuid == -1)
continue;
this->sgrp = cpc_setgrp_clone(opts->master);
if (this->sgrp == NULL) {
this->cpuid = -1;
continue;
}
if (thr_create(NULL, 0, gtick, this,
THR_BOUND|THR_NEW_LWP, &this->tid) == 0)
lwps++;
else {
(void) fprintf(stderr,
gettext("%s: cannot create thread for cpu%d\n"),
opts->pgmname, this->cpuid);
this->status = 4;
}
}
if (lwps != 0)
for (i = 0; i < ncpus; i++)
(void) thr_join(gstate[i].tid, NULL, NULL);
if ((accum = cpc_setgrp_clone(opts->master)) == NULL) {
(void) fprintf(stderr, gettext("%s: out of heap\n"),
opts->pgmname);
return (1);
}
retval = 0;
for (i = 0; i < ncpus; i++) {
struct tstate *this = &gstate[i];
if (this->cpuid == -1)
continue;
cpc_setgrp_accum(accum, this->sgrp);
cpc_setgrp_free(this->sgrp);
this->sgrp = NULL;
if (this->status != 0)
retval = 1;
}
cpc_setgrp_reset(accum);
start = cpc_setgrp_getset(accum);
do {
nreqs = cpc_setgrp_getbufs(accum, &data1, &data2, &scratch);
print_total(lwps, *data1, nreqs, cpc_setgrp_getname(accum));
} while (cpc_setgrp_nextset(accum) != start);
cpc_setgrp_free(accum);
accum = NULL;
free(gstate);
return (retval);
}
