/*
 * 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.
 */

/*
 * 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);
}