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

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved	*/


#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>
#include	<wait.h>
#include	<search.h>
#include	<unistd.h>
#include	<sys/types.h>
#include	<dirent.h>
#include	<fcntl.h>
#include	<sys/param.h>
#include	<sys/procset.h>
#include	<sys/priocntl.h>
#include	<procfs.h>
#include	<macros.h>
#include	<libgen.h>
#include	<limits.h>
#include	<errno.h>

#include	"priocntl.h"

/*
 * This file contains the code implementing the class independent part
 * of the priocntl command.  Most of the useful work for the priocntl
 * command is done by the class specific sub-commands, the code for
 * which is elsewhere.  The class independent part of the command is
 * responsible for executing the appropriate class specific sub-commands
 * and providing any necessary input to the sub-commands.
 * Code in this file should never assume any knowledge of any specific
 * scheduler class (other than the SYS class).
 */

#define	CLASSPATH	"/usr/lib/class"

typedef struct classpids {
	char	clp_clname[PC_CLNMSZ];
	pid_t	*clp_pidlist;
	int	clp_pidlistsz;
	int	clp_npids;
} classpids_t;

static char usage[] =
"usage:	priocntl -l\n\
	priocntl -d [-i idtype] [idlist]\n\
	priocntl -s [-c class] [c.s.o.] [-i idtype] [idlist]\n\
	priocntl -e [-c class] [c.s.o.] command [argument(s)]\n";

static char	basenm[BASENMSZ];
static char	cmdpath[MAXPATHLEN];

static char	*procdir = "/proc";

static int	print_classlist(void);
static void	set_procs(char *, idtype_t, int, char **, char **);
static void	exec_cmd(char *, char **);
static int	print_procs(idtype_t, int, char *[]);
static void	ids2pids(idtype_t, id_t *, int, classpids_t *, int);
static void	add_pid_tolist(classpids_t *, int, char *, pid_t);
static void	increase_pidlist(classpids_t *);
static boolean_t	idmatch(char *, char *, int, char **);

/*
 * These variables are defined to be used in prio_getopt() below.
 */
static	int	prio_getopt();
/* LINTED static unused */
static	int	prio_optopt = 0;
static	char	*prio_optarg = 0;
static	int	prio_optind = 1;
static	int	prio_sp = 1;

int
main(int argc, char *argv[])
{
	int		c;
	int		lflag, dflag, sflag, eflag, cflag, iflag, csoptsflag;
	char		*clname;
	char		*idtypnm;
	idtype_t	idtype;
	int		idargc;
	char		**idargv;

	(void) strlcpy(cmdpath, argv[0], MAXPATHLEN);
	(void) strlcpy(basenm, basename(argv[0]), BASENMSZ);
	lflag = dflag = sflag = eflag = cflag = iflag = csoptsflag = 0;
	while ((c = prio_getopt(argc, argv, "ldsec:i:")) != -1) {

		switch (c) {

		case 'l':
			lflag++;
			break;

		case 'd':
			dflag++;
			break;

		case 's':
			sflag++;
			break;

		case 'e':
			eflag++;
			break;

		case 'c':
			cflag++;
			clname = prio_optarg;
			break;

		case 'i':
			iflag++;
			idtypnm = prio_optarg;
			break;

		case '?':
			if (strcmp(argv[prio_optind - 1], "-c") == 0 ||
			    strcmp(argv[prio_optind - 1], "-i") == 0) {

				/*
				 * getopt() will return ? if either
				 * of these appear without an argument.
				 */
				fatalerr(usage);
			}

			/*
			 * We assume for now that any option that
			 * getopt() doesn't recognize (with the
			 * exception of c and i) is intended for a
			 * class specific subcommand.  For now we also
			 * require that all class specific options
			 * take an argument (until we can get smarter
			 * about parsing our options).
			 */
			csoptsflag++;
			prio_optind++;
			prio_sp = 1;
			break;

		default:
			break;
		}
	}

	if (lflag) {
		if (dflag || sflag || eflag || cflag || iflag || csoptsflag)
			fatalerr(usage);

		return (print_classlist());

	} else if (dflag) {
		if (lflag || sflag || eflag || cflag || csoptsflag)
			fatalerr(usage);
		if (iflag) {
			if (str2idtyp(idtypnm, &idtype) == -1)
				fatalerr("%s: bad idtype %s\n", cmdpath,
				    idtypnm);
		} else {
			idtype = P_PID;
		}

		if (prio_optind < argc) {
			idargc = argc - prio_optind;
			idargv = &argv[prio_optind];
		} else {
			idargc = 0;
		}

		return (print_procs(idtype, idargc, idargv));

	} else if (sflag) {
		if (lflag || dflag || eflag)
			fatalerr(usage);
		if (iflag) {
			if (str2idtyp(idtypnm, &idtype) == -1)
				fatalerr("%s: bad idtype %s\n", cmdpath,
				    idtypnm);
		} else {
			idtype = P_PID;
		}

		if (cflag == 0)
			clname = NULL;

		if (prio_optind < argc) {
			idargc = argc - prio_optind;
			idargv = &argv[prio_optind];
		} else {
			idargc = 0;
		}

		set_procs(clname, idtype, idargc, idargv, argv);

	} else if (eflag) {
		if (lflag || dflag || sflag || iflag)
			fatalerr(usage);

		if (cflag == 0)
			clname = NULL;

		if (prio_optind >= argc)
			fatalerr(usage);

		exec_cmd(clname, argv);

	} else {
		fatalerr(usage);
	}

	return (0);
}


/*
 * Print the heading for the class list and execute the class
 * specific sub-command with the -l option for each configured class.
 */
static int
print_classlist(void)
{
	id_t		cid;
	int		nclass;
	pcinfo_t	pcinfo;
	static char	subcmdpath[128];
	int		status;
	pid_t		pid;
	int		error = 0;

	/*
	 * No special privileges required for this operation.
	 * Set the effective UID back to the real UID.
	 */
	if (setuid(getuid()) == -1)
		fatalerr("%s: Can't set effective UID back to real UID\n",
		    cmdpath);

	if ((nclass = priocntl(0, 0, PC_GETCLINFO, NULL)) == -1)
		fatalerr("%s: Can't get number of configured classes, priocntl"
		    " system call failed with errno %d\n", cmdpath, errno);

	(void) printf("CONFIGURED CLASSES\n==================\n\n");
	(void) printf("SYS (System Class)\n");
	for (cid = 1; cid < nclass; cid++) {
		(void) printf("\n");
		(void) fflush(stdout);
		pcinfo.pc_cid = cid;
		if (priocntl(0, 0, PC_GETCLINFO, (caddr_t)&pcinfo) == -1)
			fatalerr("%s: can't get class name (class ID = %ld)\n",
			    cmdpath, cid);
		if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s",
		    CLASSPATH, pcinfo.pc_clname, pcinfo.pc_clname, basenm) >=
		    sizeof (subcmdpath))
			fatalerr("%s: can't generate %s specific subcommand\n",
			    cmdpath, pcinfo.pc_clname);
		if ((pid = fork()) == 0) {
			(void) execl(subcmdpath, subcmdpath, "-l", (char *)0);
			(void) printf("%s\n", pcinfo.pc_clname);
			fatalerr("\tCan't execute %s specific subcommand\n",
			    pcinfo.pc_clname);
		} else if (pid == (pid_t)-1) {
			(void) printf("%s\n", pcinfo.pc_clname);
			(void) fprintf(stderr,
			    "Can't execute %s specific subcommand)\n",
			    pcinfo.pc_clname);
			error = 1;
		} else {
			(void) wait(&status);
			if (status)
				error = 1;
		}
	}

	return (error);
}


/*
 * For each class represented within the set of processes specified by
 * idtype/idargv, print_procs() executes the class specific sub-command
 * with the -d option.  We pipe to each sub-command a list of pids in
 * the set belonging to that class.
 */
static int
print_procs(idtype_t idtype, int idargc, char *idargv[])
{
	int		i;
	id_t		id;
	id_t		idlist[NIDS];
	int		nids;
	classpids_t	*clpids;
	int		nclass;
	id_t		cid;
	pcinfo_t	pcinfo;
	int		pidexists;
	FILE		*pipe_to_subcmd;
	char		subcmd[128];
	int		error = 0;


	/*
	 * Build a list of ids eliminating any duplicates in idargv.
	 */
	if (idtype == P_ALL) {
		/*
		 * No idlist should be specified. If one is specified,
		 * it is ignored.
		 */
		nids = 0;
	} else if (idargc == 0) {

		/*
		 * No ids supplied by user; use current id.
		 */
		if (getmyid(idtype, &idlist[0]) == -1)
			fatalerr("%s: Can't get ID for current process,"
			    " idtype = %d\n", cmdpath, idtype);
		nids = 1;
	} else {
		nids = 0;
		for (i = 0; i < idargc && nids < NIDS; i++) {
			if (idtype == P_CID) {
				if ((id = clname2cid(idargv[i])) == -1) {
					(void) fprintf(stderr, "%s: Invalid or"
					    " unconfigured class %s in idlist"
					    " - ignored\n", cmdpath, idargv[i]);
					error = 1;
				}
			} else {
				id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX);
				if (errno) {
					(void) fprintf(stderr,
					    "%s: Invalid id \"%s\"\n",
					    cmdpath, idargv[i]);
					error = 1;
					id = BADPID;
				}
			}

			/*
			 * lsearch(3C) adds ids to the idlist,
			 * eliminating duplicates.
			 */
			(void) lsearch((void *)&id, (void *)idlist,
			    (size_t *)&nids, sizeof (id), (int (*)())idcompar);
		}
	}

	if ((nclass = priocntl(0, 0, PC_GETCLINFO, NULL)) == -1)
		fatalerr("%s: Can't get number of configured classes, priocntl"
		    " system call failed with errno %d\n", cmdpath, errno);

	if ((clpids = (classpids_t *)malloc(sizeof (classpids_t) * nclass)) ==
	    NULL)
		fatalerr("%s: Can't allocate memory for clpids.\n", cmdpath);

	for (cid = 1; cid < nclass; cid++) {
		pcinfo.pc_cid = cid;
		if (priocntl(0, 0, PC_GETCLINFO, (caddr_t)&pcinfo) == -1)
			fatalerr("%s: Can't get class name, cid = %ld\n",
			    cmdpath, cid);

		(void) strncpy(clpids[cid].clp_clname, pcinfo.pc_clname,
		    PC_CLNMSZ);

		/*
		 * The memory allocation for the pidlist uses realloc().
		 * A realloc() call is required, when "clp_npids" is
		 * equal to "clp_pidlistsz".
		 */
		clpids[cid].clp_pidlist = (pid_t *)NULL;
		clpids[cid].clp_pidlistsz = 0;
		clpids[cid].clp_npids = 0;
	}

	/*
	 * Build the pidlist.
	 */
	ids2pids(idtype, idlist, nids, clpids, nclass);

	/*
	 * No need for special privileges any more.
	 * Set the effective UID back to the real UID.
	 */
	if (setuid(getuid()) == -1)
		fatalerr("%s: Can't set effective UID back to real UID\n",
		    cmdpath);

	pidexists = 0;
	for (cid = 1; cid < nclass; cid++) {
		if (clpids[cid].clp_npids == 0)
			continue;

		pidexists = 1;
		if (snprintf(subcmd, sizeof (subcmd), "%s/%s/%s%s -d",
		    CLASSPATH, clpids[cid].clp_clname, clpids[cid].clp_clname,
		    basenm) >= sizeof (subcmd)) {
			(void) fprintf(stderr,
			    "Can't generate %s specific subcommand\n",
			    clpids[cid].clp_clname);
			error = 1;
			free(clpids[cid].clp_pidlist);
			continue;
		}
		if ((pipe_to_subcmd = popen(subcmd, "w")) == NULL) {
			(void) printf("%s\n", clpids[cid].clp_clname);
			(void) fprintf(stderr,
			    "Can't execute %s specific subcommand\n",
			    clpids[cid].clp_clname);
			error = 1;
			free(clpids[cid].clp_pidlist);
			continue;
		}
		(void) fwrite(clpids[cid].clp_pidlist, sizeof (pid_t),
		    clpids[cid].clp_npids, pipe_to_subcmd);
		if (pclose(pipe_to_subcmd))
			error = 1;

		free(clpids[cid].clp_pidlist);
	}

	free(clpids);

	if (pidexists == 0)
		fatalerr("%s: Process(es) not found.\n", cmdpath);

	return (error);
}


/*
 * Execute the appropriate class specific sub-command with the arguments
 * pointed to by subcmdargv.  If the user specified a class we simply
 * exec the sub-command for that class.  If no class was specified we
 * verify that the processes in the set specified by idtype/idargv are
 * all in the same class and then execute the sub-command for that class.
 */
static void
set_procs(char *clname, idtype_t idtype, int idargc, char **idargv,
    char **subcmdargv)
{
	char			idstr[PC_IDTYPNMSZ];
	char			myidstr[PC_IDTYPNMSZ];
	char			clnmbuf[PC_CLNMSZ];
	pcinfo_t		pcinfo;
	static psinfo_t		prinfo;
	static prcred_t		prcred;
	DIR			*dirp;
	struct dirent		*dentp;
	static char		pname[100];
	char			*fname;
	int			procfd;
	int			saverr;
	static char		subcmdpath[128];
	boolean_t		procinset;
	id_t			id;
	size_t			len;

	if (clname == NULL && idtype == P_PID && idargc <= 1) {

		/*
		 * No class specified by user but only one process
		 * in specified set.  Get the class the easy way.
		 */
		if (idargc == 0) {
			if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL,
			    PC_KY_CLNAME, clnmbuf, 0) == -1)
				if (errno == ESRCH)
					fatalerr("%s: Process not found.\n",
					    cmdpath);
				else
					fatalerr("%s: Can't get class of"
					    " current process\npriocntl"
					    " system call failed with"
					    " errno %d\n", cmdpath, errno);
		} else {
			/* idargc == 1 */
			id = (id_t)str2num(idargv[0], INT_MIN, INT_MAX);
			if (errno)
				fatalerr("%s: Invalid id \"%s\"\n", cmdpath,
				    idargv[0]);

			if (priocntl(P_PID, id, PC_GETXPARMS,
			    NULL, PC_KY_CLNAME, clnmbuf, 0) == -1)
				if (errno == ESRCH)
					fatalerr("%s: Process not found.\n",
					    cmdpath);
				else
					fatalerr("%s: Can't get class of "
					    " specified  process\npriocntl"
					    " system call failed with"
					    " errno %d\n", cmdpath, errno);
		}

		clname = clnmbuf;
	} else if (clname == NULL) {

		/*
		 * No class specified by user and potentially more
		 * than one process in specified set.  Verify that
		 * all procs in set are in the same class.
		 */
		if (idargc == 0 && idtype != P_ALL) {

			/*
			 * No ids supplied by user; use current id.
			 */
			if (getmyidstr(idtype, myidstr) == -1)
				fatalerr("%s: Can't get ID string for current"
				    " process, idtype = %d\n", cmdpath, idtype);
		}
		if ((dirp = opendir(procdir)) == NULL)
			fatalerr("%s: Can't open PROC directory %s\n",
			    cmdpath, procdir);

		while ((dentp = readdir(dirp)) != NULL) {
			if (dentp->d_name[0] == '.')	/* skip . and .. */
				continue;

			len = snprintf(pname, sizeof (pname), "%s/%s/",
			    procdir, dentp->d_name);
			/* Really max(sizeof ("psinfo"), sizeof ("cred")) */
			if (len + sizeof ("psinfo") > sizeof (pname)) {
				(void) fprintf(stderr,
				    "%s: skipping %s, name too long.\n",
				    cmdpath, dentp->d_name);
				continue;
			}
			fname = pname + len;
retry:
			(void) strcpy(fname, "psinfo");
			if ((procfd = open(pname, O_RDONLY)) < 0)
				continue;

			if (read(procfd, &prinfo, sizeof (prinfo)) !=
			    sizeof (prinfo)) {
				saverr = errno;
				(void) close(procfd);
				if (saverr == EAGAIN)
					goto retry;
				if (saverr != ENOENT) {
					(void) fprintf(stderr,
					    "%s: Can't get process info for"
					    " %s\n", cmdpath, pname);
				}
				continue;
			}
			(void) close(procfd);

			if (idtype == P_UID || idtype == P_GID) {
				(void) strcpy(fname, "cred");
				if ((procfd = open(pname, O_RDONLY)) < 0 ||
				    read(procfd, &prcred, sizeof (prcred)) !=
				    sizeof (prcred)) {
					saverr = errno;
					if (procfd >= 0)
						(void) close(procfd);
					if (saverr == EAGAIN)
						goto retry;
					if (saverr != ENOENT) {
						(void) fprintf(stderr,
						    "%s: Can't get process"
						    " credentials for %s\n",
						    cmdpath, pname);
					}
					continue;
				}
				(void) close(procfd);
			}

			if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0)
				continue;


			switch (idtype) {

			case P_PID:
				itoa((long)prinfo.pr_pid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_PPID:
				itoa((long)prinfo.pr_ppid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_PGID:
				itoa((long)prinfo.pr_pgid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_SID:
				itoa((long)prinfo.pr_sid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_CID:
				procinset = idmatch(prinfo.pr_lwp.pr_clname,
				    myidstr, idargc, idargv);
				break;

			case P_UID:
				itoa((long)prcred.pr_euid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_GID:
				itoa((long)prcred.pr_egid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_PROJID:
				itoa((long)prinfo.pr_projid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_TASKID:
				itoa((long)prinfo.pr_taskid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_ZONEID:
				itoa((long)prinfo.pr_zoneid, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_CTID:
				itoa((long)prinfo.pr_contract, idstr);
				procinset = idmatch(idstr, myidstr,
				    idargc, idargv);
				break;

			case P_ALL:
				procinset = B_TRUE;
				break;

			default:
				fatalerr("%s: Bad idtype %d in set_procs()\n",
				    cmdpath, idtype);
			}
			if (procinset == B_TRUE) {
				if (clname == NULL) {

					/*
					 * First proc found in set.
					 */
					(void) strcpy(clnmbuf,
					    prinfo.pr_lwp.pr_clname);
					clname = clnmbuf;
				} else if (strcmp(clname,
				    prinfo.pr_lwp.pr_clname) != 0) {
					fatalerr("%s: Specified processes"
					    " from different classes.\n",
					    cmdpath);
				}
			}
		}
		(void) closedir(dirp);
		if (clname == NULL)
			fatalerr("%s: Process(es) not found.\n", cmdpath);
	} else {

		/*
		 * User specified class. Check it for validity.
		 */
		(void) strcpy(pcinfo.pc_clname, clname);
		if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
			fatalerr("%s: Invalid or unconfigured class %s\n",
			    cmdpath, clname);
	}

	/*
	 * No need for special privileges any more.
	 * Set the effective UID back to the real UID.
	 */
	if (setuid(getuid()) == -1)
		fatalerr("%s: Can't set effective UID back to real UID\n",
		    cmdpath);

	if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s",
	    CLASSPATH, clname, clname, basenm) >= sizeof (subcmdpath))
		fatalerr("%s: can't generate %s specific subcommand\n",
		    cmdpath, clname);

	subcmdargv[0] = subcmdpath;
	(void) execv(subcmdpath, subcmdargv);
	fatalerr("%s: Can't execute %s sub-command\n", cmdpath, clname);
}


/*
 * Execute the appropriate class specific sub-command with the arguments
 * pointed to by subcmdargv.  If the user specified a class we simply
 * exec the sub-command for that class.  If no class was specified we
 * execute the sub-command for our own current class.
 */
static void
exec_cmd(char *clname, char **subcmdargv)
{
	pcinfo_t	pcinfo;
	char		clnmbuf[PC_CLNMSZ];
	char		subcmdpath[128];

	/*
	 * No special privileges required for this operation.
	 * Set the effective UID back to the real UID.
	 */
	if (setuid(getuid()) == -1)
		fatalerr("%s: Can't set effective UID back to real UID\n",
		    cmdpath);

	if (clname == NULL) {
		if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL,
		    PC_KY_CLNAME, clnmbuf, 0) == -1)
			fatalerr("%s: Can't get class name of current process\n"
			    "priocntl system call failed with errno %d\n",
			    cmdpath, errno);

		clname = clnmbuf;
	} else {

		/*
		 * User specified class. Check it for validity.
		 */
		(void) strcpy(pcinfo.pc_clname, clname);
		if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
			fatalerr("%s: Invalid or unconfigured class %s\n",
			    cmdpath, clname);
	}

	if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s",
	    CLASSPATH, clname, clname, basenm) >= sizeof (subcmdpath))
		fatalerr("%s: can't generate %s specific subcommand\n",
		    cmdpath, clname);
	subcmdargv[0] = subcmdpath;
	(void) execv(subcmdpath, subcmdargv);
	fatalerr("%s: Can't execute %s sub-command\n", cmdpath, clname);
}


/*
 * Fill in the classpids structures in the array pointed to by clpids
 * with pids for the processes in the set specified by idtype/idlist.
 * We read the /proc/<pid>/psinfo file to get the necessary process
 * information.
 */
static void
ids2pids(idtype_t idtype, id_t *idlist, int nids, classpids_t *clpids,
    int	 nclass)
{
	static psinfo_t		prinfo;
	static prcred_t		prcred;
	DIR			*dirp;
	struct dirent		*dentp;
	char			pname[100];
	char			*fname;
	int			procfd;
	int			saverr;
	int			i;
	char			*clname;
	size_t			len;

	if ((dirp = opendir(procdir)) == NULL)
		fatalerr("%s: Can't open PROC directory %s\n",
		    cmdpath, procdir);

	while ((dentp = readdir(dirp)) != NULL) {
		if (dentp->d_name[0] == '.')	/* skip . and .. */
			continue;

		len = snprintf(pname, sizeof (pname), "%s/%s/",
		    procdir, dentp->d_name);
		/* Really max(sizeof ("psinfo"), sizeof ("cred")) */
		if (len + sizeof ("psinfo") > sizeof (pname)) {
			(void) fprintf(stderr,
			    "%s: skipping %s, name too long.\n",
			    cmdpath, dentp->d_name);
			continue;
		}
		fname = pname + len;
retry:
		(void) strcpy(fname, "psinfo");
		if ((procfd = open(pname, O_RDONLY)) < 0)
			continue;
		if (read(procfd, &prinfo, sizeof (prinfo)) != sizeof (prinfo)) {
			saverr = errno;
			(void) close(procfd);
			if (saverr == EAGAIN)
				goto retry;
			if (saverr != ENOENT) {
				(void) fprintf(stderr,
				    "%s: Can't get process info for %s\n",
				    cmdpath, pname);
			}
			continue;
		}
		(void) close(procfd);

		if (idtype == P_UID || idtype == P_GID) {
			(void) strcpy(fname, "cred");
			if ((procfd = open(pname, O_RDONLY)) < 0 ||
			    read(procfd, &prcred, sizeof (prcred)) !=
			    sizeof (prcred)) {
				saverr = errno;
				(void) close(procfd);
				if (saverr == EAGAIN)
					goto retry;
				if (saverr != ENOENT) {
					(void) fprintf(stderr,
					    "%s: Can't get process credentials"
					    " for %s\n",
					    cmdpath, pname);
				}
				continue;
			}
			(void) close(procfd);
		}

		if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0)
			continue;

		switch (idtype) {

		case P_PID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prinfo.pr_pid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_PPID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prinfo.pr_ppid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_PGID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prinfo.pr_pgid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_SID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prinfo.pr_sid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_CID:
			for (i = 0; i < nids; i++) {
				clname = clpids[idlist[i]].clp_clname;
				if (strcmp(clname,
				    prinfo.pr_lwp.pr_clname) == 0)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_UID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prcred.pr_euid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_GID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prcred.pr_egid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_PROJID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prinfo.pr_projid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_TASKID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prinfo.pr_taskid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
		break;

		case P_ZONEID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prinfo.pr_zoneid)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_CTID:
			for (i = 0; i < nids; i++) {
				if (idlist[i] == (id_t)prinfo.pr_contract)
					add_pid_tolist(clpids, nclass,
					    prinfo.pr_lwp.pr_clname,
					    prinfo.pr_pid);
			}
			break;

		case P_ALL:
			add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname,
			    prinfo.pr_pid);
			break;

		default:
			fatalerr("%s: Bad idtype %d in ids2pids()\n",
			    cmdpath, idtype);
		}
	}
	(void) closedir(dirp);
}


/*
 * Search the array pointed to by clpids for the classpids
 * structure corresponding to clname and add pid to its
 * pidlist.
 */
static void
add_pid_tolist(classpids_t *clpids, int nclass, char *clname, pid_t pid)
{
	classpids_t	*clp;

	for (clp = clpids; clp != &clpids[nclass]; clp++) {
		if (strcmp(clp->clp_clname, clname) == 0) {
			if (clp->clp_npids == clp->clp_pidlistsz)
				increase_pidlist(clp);

			(clp->clp_pidlist)[clp->clp_npids] = pid;
			clp->clp_npids++;
			return;
		}
	}
}


static void
increase_pidlist(classpids_t *clp)
{
	if ((clp->clp_pidlist = realloc(clp->clp_pidlist,
	    (clp->clp_pidlistsz + NPIDS) * sizeof (pid_t))) == NULL)
		/*
		 * The pidlist is filled up and we cannot increase the size.
		 */
		fatalerr("%s: Can't allocate memory for pidlist.\n", cmdpath);

	clp->clp_pidlistsz += NPIDS;
}


/*
 * Compare id strings for equality.  If idargv contains ids
 * (idargc > 0) compare idstr to each id in idargv, otherwise
 * just compare to curidstr.
 */
static boolean_t
idmatch(char *idstr, char *curidstr, int idargc, char **idargv)
{
	int	i;

	if (idargc == 0) {
		if (strcmp(curidstr, idstr) == 0)
			return (B_TRUE);
	} else {
		for (i = 0; i < idargc; i++) {
			if (strcmp(idargv[i], idstr) == 0)
				return (B_TRUE);
		}
	}
	return (B_FALSE);
}

/*
 * This is a copy of the getopt() function found in libc:getopt.c. A separate
 * copy is required to fix the bug id #1114636. To fix the problem we need to
 * reset the _sp to 1. Since _sp in libc:getopt() is not exposed, a copy of
 * the getopt() is kept so that prio_sp can be reset to 1.
 */

static int
prio_getopt(int argc, char * const *argv, char *opts)
{
	char c;
	char *cp;

	if (prio_sp == 1)
		if (prio_optind >= argc ||
		    argv[prio_optind][0] != '-' || argv[prio_optind][1] == '\0')
			return (EOF);
		else if (strcmp(argv[prio_optind], "--") == 0) {
			prio_optind++;
			return (EOF);
		}
	prio_optopt = c = (unsigned char)argv[prio_optind][prio_sp];
	if (c == ':' || (cp = strchr(opts, c)) == NULL) {
		if (argv[prio_optind][++prio_sp] == '\0') {
			prio_optind++;
			prio_sp = 1;
		}
		return ('?');
	}
	if (*++cp == ':') {
		if (argv[prio_optind][prio_sp+1] != '\0')
			prio_optarg = &argv[prio_optind++][prio_sp+1];
		else if (++prio_optind >= argc) {
			prio_sp = 1;
			return ('?');
		} else
			prio_optarg = argv[prio_optind++];
		prio_sp = 1;
	} else {
		if (argv[prio_optind][++prio_sp] == '\0') {
			prio_sp = 1;
			prio_optind++;
		}
		prio_optarg = NULL;
	}
	return (c);
}