OpenSolaris_b135/cmd/ptools/plgrp/plgrp.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* The plgrp utility allows a user to display and modify the home lgroup and
* lgroup affinities of the specified threads
*/
#include <ctype.h>
#include <errno.h>
#include <libintl.h>
#include <libproc.h>
#include <locale.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <libgen.h>
#include <sys/lgrp_user.h>
/*
* Delimiters
*/
#define DELIMIT_AFF '/' /* lgroup affinity from lgroups */
#define DELIMIT_LGRP "," /* lgroups from each other */
#define DELIMIT_LWP "/" /* thread/LWP IDs from process ID */
#define DELIMIT_RANGE '-' /* range of IDs (eg. lgroup) */
#define DELIMIT_AFF_LST ',' /* list of affinities from another list */
/*
* Exit values other than EXIT_{SUCCESS,FAILURE}
*/
#define EXIT_NONFATAL 2 /* non-fatal errors */
/*
* Header and format strings
*/
#define HDR_PLGRP_AFF_GET " PID/LWPID HOME AFFINITY\n"
#define HDR_PLGRP_AFF_SET " PID/LWPID HOME AFFINITY\n"
#define HDR_PLGRP_HOME_GET " PID/LWPID HOME\n"
#define HDR_PLGRP_HOME_SET " PID/LWPID HOME\n"
/*
* Part of the HDR_PLGRP_AFF_SET header used to calculate space needed to
* represent changing home as old => new
*/
#define HDR_PLGRP_HOME_CHANGE "HOME "
#define FMT_AFF "%d/%s"
#define FMT_AFF_STR "%s"
#define FMT_HOME "%-6d"
#define FMT_NEWHOME "%d => %d"
#define FMT_THREAD "%8d/%-8d"
/*
* How much to allocate for lgroup bitmap array as it grows
*/
#define LGRP_BITMAP_CHUNK 8
/*
* Strings that can be given for lgroups
*/
#define LGRP_ALL_STR "all"
#define LGRP_LEAVES_STR "leaves"
#define LGRP_ROOT_STR "root"
/*
* Strings corresponding to lgroup affinities
*/
#define LGRP_AFF_NONE_STR "none"
#define LGRP_AFF_STRONG_STR "strong"
#define LGRP_AFF_WEAK_STR "weak"
/*
* Invalid value for lgroup affinity
*/
#define LGRP_AFF_INVALID -1
/*
* Number of args needed for lgroup system call
*/
#define LGRPSYS_NARGS 3
#ifndef TEXT_DOMAIN /* should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* use this only if it wasn't */
#endif
/*
* plgrp(1) operations
*/
typedef enum plgrp_ops {
PLGRP_AFFINITY_GET,
PLGRP_AFFINITY_SET,
PLGRP_HOME_GET,
PLGRP_HOME_SET,
PLGRP_NO_OP
} plgrp_ops_t;
/*
* Arguments specified to plgrp(1) and any state needed to do everything
* that plgrp(1) does for one operation from inside Plwp_iter_all()
*/
typedef struct plgrp_args {
struct ps_prochandle *Ph; /* proc handle for process */
const char *lwps; /* LWPs */
lgrp_id_t *lgrps; /* lgroups */
lgrp_affinity_t *affs; /* lgroup affinities */
int nlgrps; /* number of lgroups */
int nelements; /* number of elements */
int index; /* index */
int nthreads; /* threads processed */
plgrp_ops_t op; /* operation */
} plgrp_args_t;
/*
* How many signals caught from terminal
* We bail out as soon as possible when interrupt is set
*/
static int interrupt = 0;
/*
* How many non-fatal errors ocurred
*/
static int nerrors = 0;
/*
* Name of this program
*/
static char *progname;
/*
* Root of the lgroup hierarchy
*/
static lgrp_id_t root = LGRP_NONE;
/*
* Bitmap of all lgroups in the system
*/
static char *lgrps_bitmap = NULL;
/*
* Size of lgrps_bitmap array
*/
static int lgrps_bitmap_nelements = 0;
/*
* Macro LGRP_VALID returns true when lgrp is present in the system.
*/
#define LGRP_VALID(lgrp) (lgrps_bitmap[lgrp] != 0)
/*
* Maximum lgroup value.
*/
static int max_lgrpid = LGRP_NONE;
/*
* Total possible number of lgroups
*/
#define NLGRPS (max_lgrpid + 1)
static void
usage(int rc)
{
(void) fprintf(stderr,
gettext("Usage:\t%s [-h] <pid> | <core> [/lwps] ...\n"), progname);
(void) fprintf(stderr,
gettext("\t%s [-F] -a <lgroup list> <pid>[/lwps] ...\n"), progname);
(void) fprintf(stderr,
gettext("\t%s [-F] -A <lgroup list>/none|weak|strong[,...] "
" <pid>[/lwps] ...\n"), progname);
(void) fprintf(stderr,
gettext("\t%s [-F] -H <lgroup list> <pid>[/lwps] ...\n"), progname);
(void) fprintf(stderr,
gettext("\n\twhere <lgroup list> is a comma separated list of\n"
"\tone or more of the following:\n\n"
"\t - lgroup ID\n"
"\t - Range of lgroup IDs specified as\n"
"\t\t<start lgroup ID>-<end lgroup ID>\n"
"\t - \"all\"\n"
"\t - \"root\"\n"
"\t - \"leaves\"\n\n"));
exit(rc);
}
/*
* Handler for catching signals from terminal
*/
/* ARGSUSED */
static void
intr(int sig)
{
interrupt++;
}
/*
* Return string name for given lgroup affinity
*/
static char *
lgrp_affinity_string(lgrp_affinity_t aff)
{
char *rc = "unknown";
switch (aff) {
case LGRP_AFF_STRONG:
rc = "strong";
break;
case LGRP_AFF_WEAK:
rc = "weak";
break;
case LGRP_AFF_NONE:
rc = "none";
break;
default:
break;
}
return (rc);
}
/*
* Add a new lgroup into lgroup array in "arg", growing lgroup and affinity
* arrays if necessary
*/
static void
lgrps_add_lgrp(plgrp_args_t *arg, int id)
{
if (arg->nlgrps == arg->nelements) {
arg->nelements += LGRP_BITMAP_CHUNK;
arg->lgrps = realloc(arg->lgrps,
arg->nelements * sizeof (lgrp_id_t));
if (arg->lgrps == NULL) {
(void) fprintf(stderr, gettext("%s: out of memory\n"),
progname);
exit(EXIT_FAILURE);
}
arg->affs = realloc(arg->affs,
arg->nelements * sizeof (lgrp_affinity_t));
if (arg->affs == NULL) {
(void) fprintf(stderr, gettext("%s: out of memory\n"),
progname);
exit(EXIT_FAILURE);
}
}
arg->lgrps[arg->nlgrps] = id;
arg->affs[arg->nlgrps] = LGRP_AFF_INVALID;
arg->nlgrps++;
}
/*
* Return an array having '1' for each lgroup present in given subtree under
* specified lgroup in lgroup hierarchy
*/
static void
lgrps_bitmap_init(lgrp_cookie_t cookie, lgrp_id_t lgrpid, char **bitmap_array,
int *bitmap_nelements)
{
lgrp_id_t *children;
int i;
int nchildren;
if (lgrpid < 0) {
lgrpid = lgrp_root(cookie);
if (lgrpid < 0)
return;
}
/*
* If new lgroup cannot fit, grow the array and fill unused portion
* with zeroes.
*/
while (lgrpid >= *bitmap_nelements) {
*bitmap_nelements += LGRP_BITMAP_CHUNK;
*bitmap_array = realloc(*bitmap_array,
*bitmap_nelements * sizeof (char));
if (*bitmap_array == NULL) {
(void) fprintf(stderr, gettext("%s: out of memory\n"),
progname);
exit(EXIT_FAILURE);
}
bzero(*bitmap_array + NLGRPS,
(*bitmap_nelements - NLGRPS) * sizeof (char));
}
/*
* Insert lgroup into bitmap and update max lgroup ID seen so far
*/
(*bitmap_array)[lgrpid] = 1;
if (lgrpid > max_lgrpid)
max_lgrpid = lgrpid;
/*
* Get children of specified lgroup and insert descendants of each
* of them
*/
nchildren = lgrp_children(cookie, lgrpid, NULL, 0);
if (nchildren > 0) {
children = malloc(nchildren * sizeof (lgrp_id_t));
if (children == NULL) {
(void) fprintf(stderr, gettext("%s: out of memory\n"),
progname);
exit(EXIT_FAILURE);
}
if (lgrp_children(cookie, lgrpid, children, nchildren) !=
nchildren) {
free(children);
return;
}
for (i = 0; i < nchildren; i++)
lgrps_bitmap_init(cookie, children[i], bitmap_array,
bitmap_nelements);
free(children);
}
}
/*
* Parse lgroup affinity from given string
*
* Return lgroup affinity or LGRP_AFF_INVALID if string doesn't match any
* existing lgroup affinity and return pointer to position just after affinity
* string.
*/
static lgrp_affinity_t
parse_lgrp_affinity(char *string, char **next)
{
int rc = LGRP_AFF_INVALID;
if (string == NULL)
return (LGRP_AFF_INVALID);
/*
* Skip delimiter
*/
if (string[0] == DELIMIT_AFF)
string++;
/*
* Return lgroup affinity matching string
*/
if (strncmp(string, LGRP_AFF_NONE_STR, strlen(LGRP_AFF_NONE_STR))
== 0) {
rc = LGRP_AFF_NONE;
*next = string + strlen(LGRP_AFF_NONE_STR);
} else if (strncmp(string,
LGRP_AFF_WEAK_STR, strlen(LGRP_AFF_WEAK_STR)) == 0) {
rc = LGRP_AFF_WEAK;
*next = string + strlen(LGRP_AFF_WEAK_STR);
} else if (strncmp(string, LGRP_AFF_STRONG_STR,
strlen(LGRP_AFF_STRONG_STR)) == 0) {
rc = LGRP_AFF_STRONG;
*next = string + strlen(LGRP_AFF_STRONG_STR);
}
return (rc);
}
/*
* Parse lgroups from given string
* Returns the set containing all lgroups parsed or NULL.
*/
static int
parse_lgrps(lgrp_cookie_t cookie, plgrp_args_t *arg, char *s)
{
lgrp_id_t i;
char *token;
if (cookie == LGRP_COOKIE_NONE || s == NULL || NLGRPS <= 0)
return (0);
/*
* Parse first lgroup (if any)
*/
token = strtok(s, DELIMIT_LGRP);
if (token == NULL)
return (-1);
do {
/*
* Parse lgroups
*/
if (isdigit(*token)) {
lgrp_id_t first;
lgrp_id_t last;
char *p;
/*
* lgroup ID(s)
*
* Can be <lgroup ID>[-<lgroup ID>]
*/
p = strchr(token, DELIMIT_RANGE);
first = atoi(token);
if (p == NULL)
last = first;
else
last = atoi(++p);
for (i = first; i <= last; i++) {
/*
* Add valid lgroups to lgroup array
*/
if ((i >= 0) && (i < NLGRPS) && LGRP_VALID(i))
lgrps_add_lgrp(arg, i);
else {
(void) fprintf(stderr,
gettext("%s: bad lgroup %d\n"),
progname, i);
nerrors++;
}
}
} else if (strncmp(token, LGRP_ALL_STR,
strlen(LGRP_ALL_STR)) == 0) {
/*
* Add "all" lgroups to lgroups array
*/
for (i = 0; i < NLGRPS; i++) {
if (LGRP_VALID(i))
lgrps_add_lgrp(arg, i);
}
} else if (strncmp(token, LGRP_ROOT_STR,
strlen(LGRP_ROOT_STR)) == 0) {
if (root < 0)
root = lgrp_root(cookie);
lgrps_add_lgrp(arg, root);
} else if (strncmp(token, LGRP_LEAVES_STR,
strlen(LGRP_LEAVES_STR)) == 0) {
/*
* Add leaf lgroups to lgroups array
*/
for (i = 0; i < NLGRPS; i++) {
if (LGRP_VALID(i) &&
lgrp_children(cookie, i, NULL, 0) == 0)
lgrps_add_lgrp(arg, i);
}
} else {
return (-1);
}
} while (token = strtok(NULL, DELIMIT_LGRP));
return (0);
}
/*
* Print array of lgroup IDs, collapsing any consecutive runs of IDs into a
* range (eg. 2,3,4 into 2-4)
*/
static void
print_lgrps(lgrp_id_t *lgrps, int nlgrps)
{
lgrp_id_t start;
lgrp_id_t end;
int i;
/*
* Initial range consists of the first element
*/
start = end = lgrps[0];
for (i = 1; i < nlgrps; i++) {
lgrp_id_t lgrpid;
lgrpid = lgrps[i];
if (lgrpid == end + 1) {
/*
* Got consecutive lgroup ID, so extend end of range
* without printing anything since the range may extend
* further
*/
end = lgrpid;
} else {
/*
* Next lgroup ID is not consecutive, so print lgroup
* IDs gotten so far.
*/
if (end == start) { /* same value */
(void) printf("%d,", (int)start);
} else if (end > start + 1) { /* range */
(void) printf("%d-%d,", (int)start, (int)end);
} else { /* different values */
(void) printf("%d,%d,", (int)start, (int)end);
}
/*
* Try finding consecutive range starting from this
* lgroup ID
*/
start = end = lgrpid;
}
}
/*
* Print last lgroup ID(s)
*/
if (end == start) {
(void) printf("%d", (int)start);
} else if (end > start + 1) {
(void) printf("%d-%d", (int)start, (int)end);
} else {
(void) printf("%d,%d", (int)start, (int)end);
}
}
/*
* Print lgroup affinities given array of lgroups, corresponding array of
* affinities, and number of elements.
* Skip any lgroups set to LGRP_NONE or having invalid affinity.
*/
static void
print_affinities(lgrp_id_t *lgrps, lgrp_affinity_t *affs, int nelements)
{
int i;
lgrp_id_t *lgrps_none;
lgrp_id_t *lgrps_strong;
lgrp_id_t *lgrps_weak;
int nlgrps_none;
int nlgrps_strong;
int nlgrps_weak;
nlgrps_strong = nlgrps_weak = nlgrps_none = 0;
lgrps_strong = malloc(nelements * sizeof (lgrp_id_t));
lgrps_weak = malloc(nelements * sizeof (lgrp_id_t));
lgrps_none = malloc(nelements * sizeof (lgrp_id_t));
if (lgrps_strong == NULL || lgrps_weak == NULL || lgrps_none == NULL) {
(void) fprintf(stderr, gettext("%s: out of memory\n"),
progname);
interrupt = 1;
return;
}
/*
* Group lgroups by affinity
*/
for (i = 0; i < nelements; i++) {
lgrp_id_t lgrpid = lgrps[i];
/*
* Skip any lgroups set to LGRP_NONE
*/
if (lgrpid == LGRP_NONE)
continue;
switch (affs[i]) {
case LGRP_AFF_STRONG:
lgrps_strong[nlgrps_strong++] = lgrpid;
break;
case LGRP_AFF_WEAK:
lgrps_weak[nlgrps_weak++] = lgrpid;
break;
case LGRP_AFF_NONE:
lgrps_none[nlgrps_none++] = lgrpid;
break;
default:
/*
* Skip any lgroups with invalid affinity.
*/
break;
}
}
/*
* Print all lgroups with same affinity together
*/
if (nlgrps_strong) {
print_lgrps(lgrps_strong, nlgrps_strong);
(void) printf("/%s", lgrp_affinity_string(LGRP_AFF_STRONG));
if (nlgrps_weak || nlgrps_none)
(void) printf("%c", DELIMIT_AFF_LST);
}
if (nlgrps_weak) {
print_lgrps(lgrps_weak, nlgrps_weak);
(void) printf("/%s", lgrp_affinity_string(LGRP_AFF_WEAK));
if (nlgrps_none)
(void) printf("%c", DELIMIT_AFF_LST);
}
if (nlgrps_none) {
print_lgrps(lgrps_none, nlgrps_none);
(void) printf("/%s", lgrp_affinity_string(LGRP_AFF_NONE));
}
free(lgrps_strong);
free(lgrps_weak);
free(lgrps_none);
}
/*
* Print heading for specified operation
*/
static void
print_heading(plgrp_ops_t op)
{
switch (op) {
case PLGRP_AFFINITY_GET:
(void) printf(HDR_PLGRP_AFF_GET);
break;
case PLGRP_AFFINITY_SET:
(void) printf(HDR_PLGRP_AFF_SET);
break;
case PLGRP_HOME_GET:
(void) printf(HDR_PLGRP_HOME_GET);
break;
case PLGRP_HOME_SET:
(void) printf(HDR_PLGRP_HOME_SET);
break;
default:
break;
}
}
/*
* Use /proc to call lgrp_affinity_get() in another process
*/
static lgrp_affinity_t
Plgrp_affinity_get(struct ps_prochandle *Ph, idtype_t idtype, id_t id,
lgrp_id_t lgrp)
{
lgrp_affinity_args_t args;
argdes_t Pargd[3];
argdes_t *Pargdp;
int Pnargs;
int Pretval;
sysret_t retval;
int syscall;
/*
* Fill in arguments needed for syscall(SYS_lgrpsys,
* LGRP_SYS_AFFINITY_GET, 0, &args)
*/
syscall = SYS_lgrpsys;
args.idtype = idtype;
args.id = id;
args.lgrp = lgrp;
args.aff = LGRP_AFF_INVALID;
/*
* Fill out /proc argument descriptors for syscall(SYS_lgrpsys,
* LGRP_SYS_AFFINITY_GET, idtype, id)
*/
Pnargs = LGRPSYS_NARGS;
Pargdp = &Pargd[0];
Pargdp->arg_value = LGRP_SYS_AFFINITY_GET;
Pargdp->arg_object = NULL;
Pargdp->arg_type = AT_BYVAL;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = 0;
Pargdp++;
Pargdp->arg_value = 0;
Pargdp->arg_object = NULL;
Pargdp->arg_type = AT_BYVAL;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = 0;
Pargdp++;
Pargdp->arg_value = 0;
Pargdp->arg_object = &args;
Pargdp->arg_type = AT_BYREF;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = sizeof (lgrp_affinity_args_t);
Pargdp++;
/*
* Have agent LWP call syscall with appropriate arguments in target
* process
*/
Pretval = Psyscall(Ph, &retval, syscall, Pnargs, &Pargd[0]);
if (Pretval) {
errno = (Pretval < 0) ? ENOSYS : Pretval;
return (LGRP_AFF_INVALID);
}
return (retval.sys_rval1);
}
/*
* Use /proc to call lgrp_affinity_set() in another process
*/
static int
Plgrp_affinity_set(struct ps_prochandle *Ph, idtype_t idtype, id_t id,
lgrp_id_t lgrp, lgrp_affinity_t aff)
{
lgrp_affinity_args_t args;
argdes_t Pargd[3];
argdes_t *Pargdp;
int Pnargs;
int Pretval;
sysret_t retval;
int syscall;
/*
* Fill in arguments needed for syscall(SYS_lgrpsys,
* LGRP_SYS_AFFINITY_SET, 0, &args)
*/
syscall = SYS_lgrpsys;
args.idtype = idtype;
args.id = id;
args.lgrp = lgrp;
args.aff = aff;
/*
* Fill out /proc argument descriptors for syscall(SYS_lgrpsys,
* LGRP_SYS_AFFINITY_SET, idtype, id)
*/
Pnargs = LGRPSYS_NARGS;
Pargdp = &Pargd[0];
Pargdp->arg_value = LGRP_SYS_AFFINITY_SET;
Pargdp->arg_object = NULL;
Pargdp->arg_type = AT_BYVAL;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = 0;
Pargdp++;
Pargdp->arg_value = 0;
Pargdp->arg_object = NULL;
Pargdp->arg_type = AT_BYVAL;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = 0;
Pargdp++;
Pargdp->arg_value = 0;
Pargdp->arg_object = &args;
Pargdp->arg_type = AT_BYREF;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = sizeof (lgrp_affinity_args_t);
Pargdp++;
/*
* Have agent LWP call syscall with appropriate arguments in
* target process
*/
Pretval = Psyscall(Ph, &retval, syscall, Pnargs, &Pargd[0]);
if (Pretval) {
errno = (Pretval < 0) ? ENOSYS : Pretval;
return (-1);
}
return (retval.sys_rval1);
}
/*
* Use /proc to call lgrp_home() in another process
*/
static lgrp_id_t
Plgrp_home(struct ps_prochandle *Ph, idtype_t idtype, id_t id)
{
argdes_t Pargd[3];
argdes_t *Pargdp;
int Pnargs;
int Pretval;
sysret_t retval;
int syscall;
/*
* Fill in arguments needed for syscall(SYS_lgrpsys,
* LGRP_SYS_HOME, idtype, id)
*/
syscall = SYS_lgrpsys;
/*
* Fill out /proc argument descriptors for syscall(SYS_lgrpsys,
* LGRP_SYS_HOME, idtype, id)
*/
Pnargs = LGRPSYS_NARGS;
Pargdp = &Pargd[0];
Pargdp->arg_value = LGRP_SYS_HOME;
Pargdp->arg_object = NULL;
Pargdp->arg_type = AT_BYVAL;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = 0;
Pargdp++;
Pargdp->arg_value = idtype;
Pargdp->arg_object = NULL;
Pargdp->arg_type = AT_BYVAL;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = 0;
Pargdp++;
Pargdp->arg_value = id;
Pargdp->arg_object = NULL;
Pargdp->arg_type = AT_BYVAL;
Pargdp->arg_inout = AI_INPUT;
Pargdp->arg_size = 0;
Pargdp++;
/*
* Have agent LWP call syscall with appropriate arguments in
* target process
*/
Pretval = Psyscall(Ph, &retval, syscall, Pnargs, &Pargd[0]);
if (Pretval) {
errno = (Pretval < 0) ? ENOSYS : Pretval;
return (-1);
}
return (retval.sys_rval1);
}
/*
* Use /proc to call lgrp_affinity_set(3LGRP) to set home lgroup of given
* thread
*/
static int
Plgrp_home_set(struct ps_prochandle *Ph, idtype_t idtype, id_t id,
lgrp_id_t lgrp)
{
return (Plgrp_affinity_set(Ph, idtype, id, lgrp,
LGRP_AFF_STRONG));
}
/*
* Do plgrp(1) operation on specified thread
*/
static int
do_op(plgrp_args_t *plgrp_args, id_t pid, id_t lwpid,
const lwpsinfo_t *lwpsinfo)
{
lgrp_affinity_t *affs;
lgrp_affinity_t *cur_affs;
lgrp_id_t home;
int i;
lgrp_affinity_t *init_affs;
lgrp_id_t *lgrps;
lgrp_id_t *lgrps_changed;
int nlgrps;
lgrp_id_t old_home;
lgrp_id_t lgrpid;
struct ps_prochandle *Ph;
int nchanged;
/*
* No args, so nothing to do.
*/
if (plgrp_args == NULL)
return (0);
/*
* Unpack plgrp(1) arguments and state needed to process this LWP
*/
Ph = plgrp_args->Ph;
lgrps = plgrp_args->lgrps;
affs = plgrp_args->affs;
nlgrps = plgrp_args->nlgrps;
switch (plgrp_args->op) {
case PLGRP_HOME_GET:
/*
* Get and display home lgroup for given LWP
*/
home = lwpsinfo->pr_lgrp;
(void) printf(FMT_HOME"\n", (int)home);
break;
case PLGRP_AFFINITY_GET:
/*
* Get and display this LWP's home lgroup and affinities
* for specified lgroups
*/
home = lwpsinfo->pr_lgrp;
(void) printf(FMT_HOME, (int)home);
/*
* Collect affinity values
*/
for (i = 0; i < nlgrps; i++) {
affs[i] = Plgrp_affinity_get(Ph, P_LWPID, lwpid,
lgrps[i]);
if (affs[i] == LGRP_AFF_INVALID) {
nerrors++;
(void) fprintf(stderr,
gettext("%s: cannot get affinity"
" for lgroup %d for %d/%d: %s\n"),
progname, lgrps[i], pid, lwpid,
strerror(errno));
}
}
/*
* Print affinities for each type.
*/
print_affinities(lgrps, affs, nlgrps);
(void) printf("\n");
break;
case PLGRP_HOME_SET:
/*
* Get home lgroup before and after setting it and display
* change. If more than one lgroup and one LWP are specified,
* then home LWPs to lgroups in round robin fashion.
*/
old_home = lwpsinfo->pr_lgrp;
i = plgrp_args->index;
if (Plgrp_home_set(Ph, P_LWPID, lwpid, lgrps[i]) != 0) {
nerrors++;
(void) fprintf(stderr,
gettext("%s: cannot set home lgroup of %d/%d"
" to lgroup %d: %s\n"),
progname, pid, lwpid, lgrps[i],
strerror(errno));
(void) printf("\n");
} else {
int len;
int width = strlen(HDR_PLGRP_HOME_CHANGE);
home = Plgrp_home(Ph, P_LWPID, lwpid);
if (home < 0) {
(void) fprintf(stderr,
gettext("%s cannot get home lgroup for"
" %d/%d: %s\n"),
progname, pid, lwpid, strerror(errno));
nerrors++;
}
len = printf(FMT_NEWHOME, (int)old_home, (int)home);
if (len < width)
(void) printf("%*c\n", (int)(width - len), ' ');
}
plgrp_args->index = (i + 1) % nlgrps;
break;
case PLGRP_AFFINITY_SET:
/*
* Set affinities for specified lgroups and print old and new
* affinities and any resulting change in home lgroups
*/
/*
* Get initial home lgroup as it may change.
*/
old_home = lwpsinfo->pr_lgrp;
/*
* Need to allocate arrays indexed by lgroup (ID) for
* affinities and lgroups because user may specify affinity
* for same lgroup multiple times....
*
* Keeping these arrays by lgroup (ID) eliminates any
* duplication and makes it easier to just print initial and
* final lgroup affinities (instead of trying to keep a list
* of lgroups specified which may include duplicates)
*/
init_affs = malloc(NLGRPS * sizeof (lgrp_affinity_t));
cur_affs = malloc(NLGRPS * sizeof (lgrp_affinity_t));
lgrps_changed = malloc(NLGRPS * sizeof (lgrp_id_t));
if (init_affs == NULL || cur_affs == NULL ||
lgrps_changed == NULL) {
(void) fprintf(stderr, gettext("%s: out of memory\n"),
progname);
Prelease(Ph, PRELEASE_RETAIN);
if (init_affs != NULL)
free(init_affs);
if (cur_affs != NULL)
free(cur_affs);
nerrors++;
return (EXIT_NONFATAL);
}
/*
* Initialize current and initial lgroup affinities and
* lgroups changed
*/
for (lgrpid = 0; lgrpid < NLGRPS; lgrpid++) {
if (!LGRP_VALID(lgrpid)) {
init_affs[lgrpid] = LGRP_AFF_INVALID;
} else {
init_affs[lgrpid] =
Plgrp_affinity_get(Ph, P_LWPID,
lwpid, lgrpid);
if (init_affs[lgrpid] == LGRP_AFF_INVALID) {
nerrors++;
(void) fprintf(stderr,
gettext("%s: cannot get"
" affinity for lgroup %d"
" for %d/%d: %s\n"),
progname, lgrpid, pid, lwpid,
strerror(errno));
}
}
cur_affs[lgrpid] = init_affs[lgrpid];
lgrps_changed[lgrpid] = LGRP_NONE;
}
/*
* Change affinities.
*/
for (i = 0; i < nlgrps; i++) {
lgrp_affinity_t aff = affs[i];
lgrpid = lgrps[i];
/*
* If the suggested affinity is the same as the current
* one, skip this lgroup.
*/
if (aff == cur_affs[lgrpid])
continue;
/*
* Set affinity to the new value
*/
if (Plgrp_affinity_set(Ph, P_LWPID, lwpid, lgrpid,
aff) < 0) {
nerrors++;
(void) fprintf(stderr,
gettext("%s: cannot set"
" %s affinity for lgroup %d"
" for %d/%d: %s\n"),
progname, lgrp_affinity_string(aff),
lgrpid, pid, lwpid,
strerror(errno));
continue;
}
/*
* Get the new value and verify that it changed as
* expected.
*/
cur_affs[lgrpid] =
Plgrp_affinity_get(Ph, P_LWPID, lwpid, lgrpid);
if (cur_affs[lgrpid] == LGRP_AFF_INVALID) {
nerrors++;
(void) fprintf(stderr,
gettext("%s: cannot get"
" affinity for lgroup %d"
" for %d/%d: %s\n"),
progname, lgrpid, pid, lwpid,
strerror(errno));
continue;
}
if (aff != cur_affs[lgrpid]) {
(void) fprintf(stderr,
gettext("%s: affinity for"
" lgroup %d is set to %d instead of %d"
" for %d/%d\n"),
progname, lgrpid, cur_affs[lgrpid], aff,
pid, lwpid);
nerrors++;
}
}
/*
* Compare current and initial affinities and mark lgroups with
* changed affinities.
*/
nchanged = 0;
for (lgrpid = 0; lgrpid < NLGRPS; lgrpid++) {
if (init_affs[lgrpid] != cur_affs[lgrpid]) {
lgrps_changed[lgrpid] = lgrpid;
nchanged++;
}
}
if (nchanged == 0) {
/*
* Nothing changed, so just print current affinities for
* specified lgroups.
*/
for (i = 0; i < nlgrps; i++) {
lgrps_changed[lgrps[i]] = lgrps[i];
}
(void) printf("%-*d",
(int)strlen(HDR_PLGRP_HOME_CHANGE),
(int)old_home);
print_affinities(lgrps_changed, cur_affs, NLGRPS);
(void) printf("\n");
} else {
int width = strlen(HDR_PLGRP_HOME_CHANGE);
/*
* Some lgroup affinities changed, so display old
* and new home lgroups for thread and its old and new
* affinities for affected lgroups
*/
home = Plgrp_home(Ph, P_LWPID, lwpid);
if (home < 0) {
(void) fprintf(stderr,
gettext("%s: cannot get home"
" for %d/%d: %s\n"),
progname, pid, lwpid, strerror(errno));
nerrors++;
}
if (old_home != home) {
int len;
/*
* Fit string into fixed width
*/
len = printf(FMT_NEWHOME,
(int)old_home, (int)home);
if (len < width)
(void) printf("%*c", width - len, ' ');
} else {
(void) printf("%-*d", width, (int)home);
}
/*
* Print change in affinities from old to new
*/
print_affinities(lgrps_changed, init_affs, NLGRPS);
(void) printf(" => ");
print_affinities(lgrps_changed, cur_affs, NLGRPS);
(void) printf("\n");
}
free(lgrps_changed);
free(init_affs);
free(cur_affs);
break;
default:
break;
}
return (0);
}
/*
* Routine called by Plwp_iter_all() as it iterates through LWPs of another
* process
*/
/* ARGSUSED */
static int
Plwp_iter_handler(void *arg, const lwpstatus_t *lwpstatus,
const lwpsinfo_t *lwpsinfo)
{
id_t lwpid;
struct ps_prochandle *Ph;
const pstatus_t *pstatus;
plgrp_args_t *plgrp_args;
/*
* Nothing to do if no arguments
*/
if (arg == NULL || interrupt)
return (0);
/*
* Unpack plgrp(1) arguments and state needed to process this LWP
*/
plgrp_args = arg;
Ph = plgrp_args->Ph;
/*
* Just return if no /proc handle for process
*/
if (Ph == NULL)
return (0);
pstatus = Pstatus(Ph);
/*
* Skip agent LWP and any LWPs that weren't specified
*/
lwpid = lwpsinfo->pr_lwpid;
if (lwpid == pstatus->pr_agentid ||
!proc_lwp_in_set(plgrp_args->lwps, lwpid))
return (0);
plgrp_args->nthreads++;
/*
* Do all plgrp(1) operations specified on given thread
*/
(void) printf(FMT_THREAD" ", (int)pstatus->pr_pid, (int)lwpid);
return (do_op(plgrp_args, pstatus->pr_pid, lwpid, lwpsinfo));
}
/*
* Get target process specified in "pidstring" argument to do operation(s)
* specified in "plgrp_todo" using /proc and agent LWP
*/
static void
do_process(char *pidstring, plgrp_args_t *plgrp_todo, int force)
{
int error;
const char *lwps;
struct ps_prochandle *Ph;
/*
* Nothing to do, so return.
*/
if (plgrp_todo == NULL || interrupt)
return;
/*
* Grab target process or core and return
* /proc handle for process and string of LWP
* IDs
*/
Ph = proc_arg_xgrab(pidstring, NULL,
PR_ARG_ANY, force | PGRAB_RETAIN | PGRAB_NOSTOP, &error, &lwps);
if (Ph == NULL) {
(void) fprintf(stderr,
gettext("%s: Unable to grab process %s: %s\n"),
progname, pidstring, Pgrab_error(error));
nerrors++;
return;
}
/*
* Fill in remaining plgrp(1) arguments and state needed to do
* plgrp(1) operation(s) on desired LWPs in our handler
* called by Plwp_iter_all() as it iterates over LWPs
* in given process
*/
plgrp_todo->Ph = Ph;
plgrp_todo->lwps = lwps;
/*
* Iterate over LWPs in process and do specified
* operation(s) on those specified
*/
if (Plwp_iter_all(Ph, Plwp_iter_handler, plgrp_todo) != 0) {
(void) fprintf(stderr,
gettext("%s: error iterating over threads\n"),
progname);
nerrors++;
}
Prelease(Ph, PRELEASE_RETAIN);
}
/*
* Parse command line and kick off any resulting actions
*
* plgrp(1) has the following command line syntax:
*
* plgrp [-h] <pid> | <core> [/lwps] ...
* plgrp [-F] -a <lgroup>,... <pid>[/lwps] ...
* plgrp [-F] -H <lgroup>,... <pid>[/lwps] ...
* plgrp [-F] -A <lgroup>,... [/none|weak|strong] ... <pid>[/lwps] ...
*
* where <lgroup> is an lgroup ID, "all", "root", "leaves".
*/
int
main(int argc, char *argv[])
{
lgrp_affinity_t aff;
char *affstring;
int c;
lgrp_cookie_t cookie;
int Fflag;
int i;
int opt_seen;
plgrp_args_t plgrp_todo;
char *s;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
opt_seen = 0;
/*
* Get name of program
*/
progname = basename(argv[0]);
/*
* Not much to do when only name of program given
*/
if (argc == 1)
usage(0);
/*
* Catch signals from terminal, so they can be handled asynchronously
* when we're ready instead of when we're not (;-)
*/
if (sigset(SIGHUP, SIG_IGN) == SIG_DFL)
(void) sigset(SIGHUP, intr);
if (sigset(SIGINT, SIG_IGN) == SIG_DFL)
(void) sigset(SIGINT, intr);
if (sigset(SIGQUIT, SIG_IGN) == SIG_DFL)
(void) sigset(SIGQUIT, intr);
(void) sigset(SIGPIPE, intr);
(void) sigset(SIGTERM, intr);
/*
* Take snapshot of lgroup hierarchy
*/
cookie = lgrp_init(LGRP_VIEW_OS);
if (cookie == LGRP_COOKIE_NONE) {
(void) fprintf(stderr,
gettext("%s: Fatal error: cannot get lgroup"
" information from the OS: %s\n"),
progname, strerror(errno));
return (EXIT_FAILURE);
}
root = lgrp_root(cookie);
lgrps_bitmap_init(cookie, root, &lgrps_bitmap, &lgrps_bitmap_nelements);
/*
* Remember arguments and state needed to do plgrp(1) operation
* on desired LWPs
*/
bzero(&plgrp_todo, sizeof (plgrp_args_t));
plgrp_todo.op = PLGRP_HOME_GET;
/*
* Parse options
*/
opterr = 0;
Fflag = 0;
while (!interrupt && (c = getopt(argc, argv, "a:A:FhH:")) != -1) {
/*
* Parse option and only allow one option besides -F to be
* specified
*/
switch (c) {
case 'h': /* Get home lgroup */
/*
* Only allow one option (besides -F) to be specified
*/
if (opt_seen)
usage(EXIT_FAILURE);
opt_seen = 1;
plgrp_todo.op = PLGRP_HOME_GET;
break;
case 'H': /* Set home lgroup */
/*
* Fail if already specified option (besides -F)
* or no more arguments
*/
if (opt_seen || optind >= argc) {
usage(EXIT_FAILURE);
}
opt_seen = 1;
plgrp_todo.op = PLGRP_HOME_SET;
if (parse_lgrps(cookie, &plgrp_todo, optarg) < 0)
usage(EXIT_FAILURE);
/* If there are no valid lgroups exit immediately */
if (plgrp_todo.nlgrps == 0) {
(void) fprintf(stderr,
gettext("%s: no valid lgroups"
" specified for -%c\n\n"),
progname, c);
usage(EXIT_FAILURE);
}
break;
case 'a': /* Get lgroup affinity */
/*
* Fail if already specified option (besides -F)
* or no more arguments
*/
if (opt_seen || optind >= argc) {
usage(EXIT_FAILURE);
}
opt_seen = 1;
plgrp_todo.op = PLGRP_AFFINITY_GET;
if (parse_lgrps(cookie, &plgrp_todo, optarg) < 0)
usage(EXIT_FAILURE);
/* If there are no valid lgroups exit immediately */
if (plgrp_todo.nlgrps == 0) {
(void) fprintf(stderr,
gettext("%s: no valid lgroups specified"
" for -%c\n\n"),
progname, c);
usage(EXIT_FAILURE);
}
break;
case 'A': /* Set lgroup affinity */
/*
* Fail if already specified option (besides -F)
* or no more arguments
*/
if (opt_seen || optind >= argc) {
usage(EXIT_FAILURE);
}
opt_seen = 1;
plgrp_todo.op = PLGRP_AFFINITY_SET;
/*
* 'affstring' is the unparsed prtion of the affinity
* specification like 1,2/none,2/weak,0/strong
*
* 'next' is the next affinity specification to parse.
*/
affstring = optarg;
while (affstring != NULL && strlen(affstring) > 0) {
char *next;
/*
* affstring points to the first affinity
* specification. Split the string by
* DELIMIT_AFF separator and parse lgroups and
* affinity value separately.
*/
s = strchr(affstring, DELIMIT_AFF);
if (s == NULL) {
(void) fprintf(stderr,
gettext("%s: invalid "
"syntax >%s<\n"),
progname, affstring);
usage(EXIT_FAILURE);
}
aff = parse_lgrp_affinity(s, &next);
if (aff == LGRP_AFF_INVALID) {
(void) fprintf(stderr,
gettext("%s: invalid "
"affinity >%s<\n"),
progname, affstring);
usage(EXIT_FAILURE);
}
/*
* next should either point to the empty string
* or to the DELIMIT_AFF_LST separator.
*/
if (*next != '\0') {
if (*next != DELIMIT_AFF_LST) {
(void) fprintf(stderr,
gettext("%s: invalid "
"syntax >%s<\n"),
progname, next);
usage(EXIT_FAILURE);
}
*next = '\0';
next++;
}
/*
* Now parse the list of lgroups
*/
if (parse_lgrps(cookie, &plgrp_todo,
affstring) < 0) {
usage(EXIT_FAILURE);
}
/*
* Set desired affinity for specified lgroup to
* the specified affinity.
*/
for (i = 0; i < plgrp_todo.nlgrps; i++) {
if (plgrp_todo.affs[i] ==
LGRP_AFF_INVALID)
plgrp_todo.affs[i] = aff;
}
/*
* We processed the leftmost element of the
* list. Advance affstr to the remaining part of
* the list. and repeat.
*/
affstring = next;
}
/*
* If there are no valid lgroups, exit immediately
*/
if (plgrp_todo.nlgrps == 0) {
(void) fprintf(stderr,
gettext("%s: no valid lgroups specified "
"for -%c\n\n"), progname, c);
usage(EXIT_FAILURE);
}
break;
case 'F': /* Force */
/*
* Only allow one occurrence
*/
if (Fflag != 0) {
usage(EXIT_FAILURE);
}
/*
* Set flag to force /proc to grab process even though
* it's been grabbed by another process already
*/
Fflag = PGRAB_FORCE;
break;
case '?': /* Unrecognized option */
default:
usage(EXIT_FAILURE);
break;
}
}
/*
* Should have more arguments left at least for PID or core
*/
if (optind >= argc)
usage(EXIT_FAILURE);
(void) lgrp_fini(cookie);
/*
* Print heading and process each [pid | core]/lwps argument
*/
print_heading(plgrp_todo.op);
(void) proc_initstdio();
for (i = optind; i < argc && !interrupt; i++) {
(void) proc_flushstdio();
do_process(argv[i], &plgrp_todo, Fflag);
}
(void) proc_finistdio();
if (plgrp_todo.nthreads == 0) {
(void) fprintf(stderr, gettext("%s: no matching LWPs found\n"),
progname);
}
return ((nerrors ||interrupt) ? EXIT_NONFATAL : EXIT_SUCCESS);
}