OpenSolaris_b135/cmd/ps/ps.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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* ps -- print things about processes.
*/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <pwd.h>
#include <grp.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mkdev.h>
#include <unistd.h>
#include <stdlib.h>
#include <limits.h>
#include <dirent.h>
#include <sys/signal.h>
#include <sys/fault.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <procfs.h>
#include <locale.h>
#include <wctype.h>
#include <wchar.h>
#include <libw.h>
#include <stdarg.h>
#include <sys/proc.h>
#include <sys/pset.h>
#include <project.h>
#include <zone.h>
#define min(a, b) ((a) > (b) ? (b) : (a))
#define max(a, b) ((a) < (b) ? (b) : (a))
#define NTTYS 20 /* initial size of table for -t option */
#define SIZ 30 /* initial size of tables for -p, -s, -g, -h and -z */
/*
* Size of buffer holding args for t, p, s, g, u, U, G, z options.
* Set to ZONENAME_MAX, the minimum value needed to allow any
* zone to be specified.
*/
#define ARGSIZ ZONENAME_MAX
#define MAXUGNAME 10 /* max chars in a user/group name or printed u/g id */
/* Structure for storing user or group info */
struct ugdata {
id_t id; /* numeric user-id or group-id */
char name[MAXUGNAME+1]; /* user/group name, null terminated */
};
struct ughead {
size_t size; /* number of ugdata structs allocated */
size_t nent; /* number of active entries */
struct ugdata *ent; /* pointer to array of actual entries */
};
enum fname { /* enumeration of field names */
F_USER, /* effective user of the process */
F_RUSER, /* real user of the process */
F_GROUP, /* effective group of the process */
F_RGROUP, /* real group of the process */
F_UID, /* numeric effective uid of the process */
F_RUID, /* numeric real uid of the process */
F_GID, /* numeric effective gid of the process */
F_RGID, /* numeric real gid of the process */
F_PID, /* process id */
F_PPID, /* parent process id */
F_PGID, /* process group id */
F_SID, /* session id */
F_PSR, /* bound processor */
F_LWP, /* lwp-id */
F_NLWP, /* number of lwps */
F_OPRI, /* old priority (obsolete) */
F_PRI, /* new priority */
F_F, /* process flags */
F_S, /* letter indicating the state */
F_C, /* processor utilization (obsolete) */
F_PCPU, /* percent of recently used cpu time */
F_PMEM, /* percent of physical memory used (rss) */
F_OSZ, /* virtual size of the process in pages */
F_VSZ, /* virtual size of the process in kilobytes */
F_RSS, /* resident set size of the process in kilobytes */
F_NICE, /* "nice" value of the process */
F_CLASS, /* scheduler class */
F_STIME, /* start time of the process, hh:mm:ss or Month Day */
F_ETIME, /* elapsed time of the process, [[dd-]hh:]mm:ss */
F_TIME, /* cpu time of the process, [[dd-]hh:]mm:ss */
F_TTY, /* name of the controlling terminal */
F_ADDR, /* address of the process (obsolete) */
F_WCHAN, /* wait channel (sleep condition variable) */
F_FNAME, /* file name of command */
F_COMM, /* name of command (argv[0] value) */
F_ARGS, /* name of command plus all its arguments */
F_TASKID, /* task id */
F_PROJID, /* project id */
F_PROJECT, /* project name of the process */
F_PSET, /* bound processor set */
F_ZONE, /* zone name */
F_ZONEID, /* zone id */
F_CTID, /* process contract id */
F_LGRP /* process home lgroup */
};
struct field {
struct field *next; /* linked list */
int fname; /* field index */
const char *header; /* header to use */
int width; /* width of field */
};
static struct field *fields = NULL; /* fields selected via -o */
static struct field *last_field = NULL;
static int do_header = 0;
static struct timeval now;
/* array of defined fields, in fname order */
struct def_field {
const char *fname;
const char *header;
int width;
int minwidth;
};
static struct def_field fname[] = {
/* fname header width minwidth */
{ "user", "USER", 8, 8 },
{ "ruser", "RUSER", 8, 8 },
{ "group", "GROUP", 8, 8 },
{ "rgroup", "RGROUP", 8, 8 },
{ "uid", "UID", 5, 5 },
{ "ruid", "RUID", 5, 5 },
{ "gid", "GID", 5, 5 },
{ "rgid", "RGID", 5, 5 },
{ "pid", "PID", 5, 5 },
{ "ppid", "PPID", 5, 5 },
{ "pgid", "PGID", 5, 5 },
{ "sid", "SID", 5, 5 },
{ "psr", "PSR", 3, 2 },
{ "lwp", "LWP", 6, 2 },
{ "nlwp", "NLWP", 4, 2 },
{ "opri", "PRI", 3, 2 },
{ "pri", "PRI", 3, 2 },
{ "f", "F", 2, 2 },
{ "s", "S", 1, 1 },
{ "c", "C", 2, 2 },
{ "pcpu", "%CPU", 4, 4 },
{ "pmem", "%MEM", 4, 4 },
{ "osz", "SZ", 4, 4 },
{ "vsz", "VSZ", 4, 4 },
{ "rss", "RSS", 4, 4 },
{ "nice", "NI", 2, 2 },
{ "class", "CLS", 4, 2 },
{ "stime", "STIME", 8, 8 },
{ "etime", "ELAPSED", 11, 7 },
{ "time", "TIME", 11, 5 },
{ "tty", "TT", 7, 7 },
#ifdef _LP64
{ "addr", "ADDR", 16, 8 },
{ "wchan", "WCHAN", 16, 8 },
#else
{ "addr", "ADDR", 8, 8 },
{ "wchan", "WCHAN", 8, 8 },
#endif
{ "fname", "COMMAND", 8, 8 },
{ "comm", "COMMAND", 80, 8 },
{ "args", "COMMAND", 80, 80 },
{ "taskid", "TASKID", 5, 5 },
{ "projid", "PROJID", 5, 5 },
{ "project", "PROJECT", 8, 8 },
{ "pset", "PSET", 3, 3 },
{ "zone", "ZONE", 8, 8 },
{ "zoneid", "ZONEID", 5, 5 },
{ "ctid", "CTID", 5, 5 },
{ "lgrp", "LGRP", 4, 2 },
};
#define NFIELDS (sizeof (fname) / sizeof (fname[0]))
static int retcode = 1;
static int lflg;
static int Aflg;
static int uflg;
static int Uflg;
static int Gflg;
static int aflg;
static int dflg;
static int Lflg;
static int Pflg;
static int yflg;
static int pflg;
static int fflg;
static int cflg;
static int jflg;
static int gflg;
static int sflg;
static int tflg;
static int zflg;
static int Zflg;
static int hflg;
static int Hflg;
static uid_t tuid = (uid_t)-1;
static int errflg;
static int ndev; /* number of devices */
static int maxdev; /* number of devl structures allocated */
#define DNINCR 100
#define DNSIZE 14
static struct devl { /* device list */
char dname[DNSIZE]; /* device name */
dev_t ddev; /* device number */
} *devl;
static struct tty {
char *tname;
dev_t tdev;
} *tty = NULL; /* for t option */
static size_t ttysz = 0;
static int ntty = 0;
static pid_t *pid = NULL; /* for p option */
static size_t pidsz = 0;
static size_t npid = 0;
static int *lgrps = NULL; /* list of lgroup IDs for for h option */
static size_t lgrps_size = 0; /* size of the lgrps list */
static size_t nlgrps = 0; /* number elements in the list */
/* Maximum possible lgroup ID value */
#define MAX_LGRP_ID 256
static pid_t *grpid = NULL; /* for g option */
static size_t grpidsz = 0;
static int ngrpid = 0;
static pid_t *sessid = NULL; /* for s option */
static size_t sessidsz = 0;
static int nsessid = 0;
static zoneid_t *zoneid = NULL; /* for z option */
static size_t zoneidsz = 0;
static int nzoneid = 0;
static int kbytes_per_page;
static int pidwidth;
static char *procdir = "/proc"; /* standard /proc directory */
static struct ughead euid_tbl; /* table to store selected euid's */
static struct ughead ruid_tbl; /* table to store selected real uid's */
static struct ughead egid_tbl; /* table to store selected egid's */
static struct ughead rgid_tbl; /* table to store selected real gid's */
static prheader_t *lpsinfobuf; /* buffer to contain lpsinfo */
static size_t lpbufsize;
/*
* This constant defines the sentinal number of process IDs below which we
* only examine individual entries in /proc rather than scanning through
* /proc. This optimization is a huge win in the common case.
*/
#define PTHRESHOLD 40
#define UCB_OPTS "-aceglnrtuvwxSU"
static void usage(void);
static char *getarg(char **);
static char *parse_format(char *);
static char *gettty(psinfo_t *);
static int prfind(int, psinfo_t *, char **);
static void prcom(psinfo_t *, char *);
static void prtpct(ushort_t, int);
static void print_time(time_t, int);
static void print_field(psinfo_t *, struct field *, const char *);
static void print_zombie_field(psinfo_t *, struct field *, const char *);
static void pr_fields(psinfo_t *, const char *,
void (*print_fld)(psinfo_t *, struct field *, const char *));
static int search(pid_t *, int, pid_t);
static void add_ugentry(struct ughead *, char *);
static int uconv(struct ughead *);
static int gconv(struct ughead *);
static int ugfind(id_t, struct ughead *);
static void prtime(timestruc_t, int, int);
static void przom(psinfo_t *);
static int namencnt(char *, int, int);
static char *err_string(int);
static int print_proc(char *pname);
static time_t delta_secs(const timestruc_t *);
static int str2id(const char *, pid_t *, long, long);
static int str2uid(const char *, uid_t *, unsigned long, unsigned long);
static void *Realloc(void *, size_t);
static int pidcmp(const void *p1, const void *p2);
extern int ucbmain(int, char **);
static int stdmain(int, char **);
int
main(int argc, char **argv)
{
const char *me;
/*
* The original two ps'es are linked in a single binary;
* their main()s are renamed to stdmain for /usr/bin/ps and
* ucbmain for /usr/ucb/ps.
* We try to figure out which instance of ps the user wants to run.
* Traditionally, the UCB variant doesn't require the flag argument
* start with a "-". If the first argument doesn't start with a
* "-", we call "ucbmain".
* If there's a first argument and it starts with a "-", we check
* whether any of the options isn't acceptable to "ucbmain"; in that
* case we run "stdmain".
* If we can't tell from the options which main to call, we check
* the binary we are running. We default to "stdmain" but
* any mention in the executable name of "ucb" causes us to call
* ucbmain.
*/
if (argv[1] != NULL) {
if (argv[1][0] != '-')
return (ucbmain(argc, argv));
else if (argv[1][strspn(argv[1], UCB_OPTS)] != '\0')
return (stdmain(argc, argv));
}
me = getexecname();
if (me != NULL && strstr(me, "ucb") != NULL)
return (ucbmain(argc, argv));
else
return (stdmain(argc, argv));
}
static int
stdmain(int argc, char **argv)
{
char *p;
char *p1;
char *parg;
int c;
int i;
int pgerrflg = 0; /* err flg: non-numeric arg w/p & g options */
size_t size, len;
DIR *dirp;
struct dirent *dentp;
pid_t maxpid;
pid_t id;
int ret;
char loc_stime_str[32];
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
#endif
(void) textdomain(TEXT_DOMAIN);
(void) memset(&euid_tbl, 0, sizeof (euid_tbl));
(void) memset(&ruid_tbl, 0, sizeof (ruid_tbl));
(void) memset(&egid_tbl, 0, sizeof (egid_tbl));
(void) memset(&rgid_tbl, 0, sizeof (rgid_tbl));
kbytes_per_page = sysconf(_SC_PAGESIZE) / 1024;
(void) gettimeofday(&now, NULL);
/*
* calculate width of pid fields based on configured MAXPID
* (must be at least 5 to retain output format compatibility)
*/
id = maxpid = (pid_t)sysconf(_SC_MAXPID);
pidwidth = 1;
while ((id /= 10) > 0)
++pidwidth;
pidwidth = pidwidth < 5 ? 5 : pidwidth;
fname[F_PID].width = fname[F_PPID].width = pidwidth;
fname[F_PGID].width = fname[F_SID].width = pidwidth;
/*
* TRANSLATION_NOTE
* Specify the printf format with width and precision for
* the STIME field.
*/
len = snprintf(loc_stime_str, sizeof (loc_stime_str),
dcgettext(NULL, "%8.8s", LC_TIME), "STIME");
if (len >= sizeof (loc_stime_str))
len = sizeof (loc_stime_str) - 1;
fname[F_STIME].width = fname[F_STIME].minwidth = len;
while ((c = getopt(argc, argv, "jlfceAadLPyZHh:t:p:g:u:U:G:n:s:o:z:"))
!= EOF)
switch (c) {
case 'H': /* Show home lgroups */
Hflg++;
break;
case 'h':
/*
* Show processes/threads with given home lgroups
*/
hflg++;
p1 = optarg;
do {
int id;
/*
* Get all IDs in the list, verify for
* correctness and place in lgrps array.
*/
parg = getarg(&p1);
/* Convert string to integer */
ret = str2id(parg, (pid_t *)&id, 0,
MAX_LGRP_ID);
/* Complain if ID didn't parse correctly */
if (ret != 0) {
pgerrflg++;
(void) fprintf(stderr,
gettext("ps: %s "), parg);
if (ret == EINVAL)
(void) fprintf(stderr,
gettext("is an invalid "
"non-numeric argument"));
else
(void) fprintf(stderr,
gettext("exceeds valid "
"range"));
(void) fprintf(stderr,
gettext(" for -h option\n"));
continue;
}
/* Extend lgrps array if needed */
if (nlgrps == lgrps_size) {
/* Double the size of the lgrps array */
if (lgrps_size == 0)
lgrps_size = SIZ;
lgrps_size *= 2;
lgrps = Realloc(lgrps,
lgrps_size * sizeof (int));
}
/* place the id in the lgrps table */
lgrps[nlgrps++] = id;
} while (*p1);
break;
case 'l': /* long listing */
lflg++;
break;
case 'f': /* full listing */
fflg++;
break;
case 'j':
jflg++;
break;
case 'c':
/*
* Format output to reflect scheduler changes:
* high numbers for high priorities and don't
* print nice or p_cpu values. 'c' option only
* effective when used with 'l' or 'f' options.
*/
cflg++;
break;
case 'A': /* list every process */
case 'e': /* (obsolete) list every process */
Aflg++;
tflg = Gflg = Uflg = uflg = pflg = gflg = sflg = 0;
zflg = hflg = 0;
break;
case 'a':
/*
* Same as 'e' except no session group leaders
* and no non-terminal processes.
*/
aflg++;
break;
case 'd': /* same as e except no session leaders */
dflg++;
break;
case 'L': /* show lwps */
Lflg++;
break;
case 'P': /* show bound processor */
Pflg++;
break;
case 'y': /* omit F & ADDR, report RSS & SZ in Kby */
yflg++;
break;
case 'n': /* no longer needed; retain as no-op */
(void) fprintf(stderr,
gettext("ps: warning: -n option ignored\n"));
break;
case 't': /* terminals */
#define TSZ 30
tflg++;
p1 = optarg;
do {
char nambuf[TSZ+6]; /* for "/dev/" + '\0' */
struct stat64 s;
parg = getarg(&p1);
p = Realloc(NULL, TSZ+1); /* for '\0' */
/* zero the buffer before using it */
p[0] = '\0';
size = TSZ;
if (isdigit(*parg)) {
(void) strcpy(p, "tty");
size -= 3;
}
(void) strncat(p, parg, size);
if (ntty == ttysz) {
if ((ttysz *= 2) == 0)
ttysz = NTTYS;
tty = Realloc(tty,
(ttysz + 1) * sizeof (struct tty));
}
tty[ntty].tdev = PRNODEV;
(void) strcpy(nambuf, "/dev/");
(void) strcat(nambuf, p);
if (stat64(nambuf, &s) == 0)
tty[ntty].tdev = s.st_rdev;
tty[ntty++].tname = p;
} while (*p1);
break;
case 'p': /* proc ids */
pflg++;
p1 = optarg;
do {
pid_t id;
parg = getarg(&p1);
if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {
pgerrflg++;
(void) fprintf(stderr,
gettext("ps: %s "), parg);
if (ret == EINVAL)
(void) fprintf(stderr,
gettext("is an invalid "
"non-numeric argument"));
else
(void) fprintf(stderr,
gettext("exceeds valid "
"range"));
(void) fprintf(stderr,
gettext(" for -p option\n"));
continue;
}
if (npid == pidsz) {
if ((pidsz *= 2) == 0)
pidsz = SIZ;
pid = Realloc(pid,
pidsz * sizeof (pid_t));
}
pid[npid++] = id;
} while (*p1);
break;
case 's': /* session */
sflg++;
p1 = optarg;
do {
pid_t id;
parg = getarg(&p1);
if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {
pgerrflg++;
(void) fprintf(stderr,
gettext("ps: %s "), parg);
if (ret == EINVAL)
(void) fprintf(stderr,
gettext("is an invalid "
"non-numeric argument"));
else
(void) fprintf(stderr,
gettext("exceeds valid "
"range"));
(void) fprintf(stderr,
gettext(" for -s option\n"));
continue;
}
if (nsessid == sessidsz) {
if ((sessidsz *= 2) == 0)
sessidsz = SIZ;
sessid = Realloc(sessid,
sessidsz * sizeof (pid_t));
}
sessid[nsessid++] = id;
} while (*p1);
break;
case 'g': /* proc group */
gflg++;
p1 = optarg;
do {
pid_t id;
parg = getarg(&p1);
if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {
pgerrflg++;
(void) fprintf(stderr,
gettext("ps: %s "), parg);
if (ret == EINVAL)
(void) fprintf(stderr,
gettext("is an invalid "
"non-numeric argument"));
else
(void) fprintf(stderr,
gettext("exceeds valid "
"range"));
(void) fprintf(stderr,
gettext(" for -g option\n"));
continue;
}
if (ngrpid == grpidsz) {
if ((grpidsz *= 2) == 0)
grpidsz = SIZ;
grpid = Realloc(grpid,
grpidsz * sizeof (pid_t));
}
grpid[ngrpid++] = id;
} while (*p1);
break;
case 'u': /* effective user name or number */
uflg++;
p1 = optarg;
do {
parg = getarg(&p1);
add_ugentry(&euid_tbl, parg);
} while (*p1);
break;
case 'U': /* real user name or number */
Uflg++;
p1 = optarg;
do {
parg = getarg(&p1);
add_ugentry(&ruid_tbl, parg);
} while (*p1);
break;
case 'G': /* real group name or number */
Gflg++;
p1 = optarg;
do {
parg = getarg(&p1);
add_ugentry(&rgid_tbl, parg);
} while (*p1);
break;
case 'o': /* output format */
p = optarg;
while ((p = parse_format(p)) != NULL)
;
break;
case 'z': /* zone name or number */
zflg++;
p1 = optarg;
do {
zoneid_t id;
parg = getarg(&p1);
if (zone_get_id(parg, &id) != 0) {
pgerrflg++;
(void) fprintf(stderr,
gettext("ps: unknown zone %s\n"),
parg);
continue;
}
if (nzoneid == zoneidsz) {
if ((zoneidsz *= 2) == 0)
zoneidsz = SIZ;
zoneid = Realloc(zoneid,
zoneidsz * sizeof (zoneid_t));
}
zoneid[nzoneid++] = id;
} while (*p1);
break;
case 'Z': /* show zone name */
Zflg++;
break;
default: /* error on ? */
errflg++;
break;
}
if (errflg || optind < argc || pgerrflg)
usage();
if (tflg)
tty[ntty].tname = NULL;
/*
* If an appropriate option has not been specified, use the
* current terminal and effective uid as the default.
*/
if (!(aflg|Aflg|dflg|Gflg|hflg|Uflg|uflg|tflg|pflg|gflg|sflg|zflg)) {
psinfo_t info;
int procfd;
char *name;
char pname[100];
/* get our own controlling tty name using /proc */
(void) snprintf(pname, sizeof (pname),
"%s/self/psinfo", procdir);
if ((procfd = open(pname, O_RDONLY)) < 0 ||
read(procfd, (char *)&info, sizeof (info)) < 0 ||
info.pr_ttydev == PRNODEV) {
(void) fprintf(stderr,
gettext("ps: no controlling terminal\n"));
exit(1);
}
(void) close(procfd);
i = 0;
name = gettty(&info);
if (*name == '?') {
(void) fprintf(stderr,
gettext("ps: can't find controlling terminal\n"));
exit(1);
}
if (ntty == ttysz) {
if ((ttysz *= 2) == 0)
ttysz = NTTYS;
tty = Realloc(tty, (ttysz + 1) * sizeof (struct tty));
}
tty[ntty].tdev = info.pr_ttydev;
tty[ntty++].tname = name;
tty[ntty].tname = NULL;
tflg++;
tuid = getuid();
}
if (Aflg) {
Gflg = Uflg = uflg = pflg = sflg = gflg = aflg = dflg = 0;
zflg = hflg = 0;
}
if (Aflg | aflg | dflg)
tflg = 0;
i = 0; /* prepare to exit on name lookup errors */
i += uconv(&euid_tbl);
i += uconv(&ruid_tbl);
i += gconv(&egid_tbl);
i += gconv(&rgid_tbl);
if (i)
exit(1);
/* allocate a buffer for lwpsinfo structures */
lpbufsize = 4096;
if (Lflg && (lpsinfobuf = malloc(lpbufsize)) == NULL) {
(void) fprintf(stderr,
gettext("ps: no memory\n"));
exit(1);
}
if (fields) { /* print user-specified header */
if (do_header) {
struct field *f;
for (f = fields; f != NULL; f = f->next) {
if (f != fields)
(void) printf(" ");
switch (f->fname) {
case F_TTY:
(void) printf("%-*s",
f->width, f->header);
break;
case F_FNAME:
case F_COMM:
case F_ARGS:
/*
* Print these headers full width
* unless they appear at the end.
*/
if (f->next != NULL) {
(void) printf("%-*s",
f->width, f->header);
} else {
(void) printf("%s",
f->header);
}
break;
default:
(void) printf("%*s",
f->width, f->header);
break;
}
}
(void) printf("\n");
}
} else { /* print standard header */
/*
* All fields before 'PID' are printed with a trailing space
* as a separator and that is how we print the headers too.
*/
if (lflg) {
if (yflg)
(void) printf("S ");
else
(void) printf(" F S ");
}
if (Zflg)
(void) printf(" ZONE ");
if (fflg) {
(void) printf(" UID ");
} else if (lflg)
(void) printf(" UID ");
(void) printf("%*s", pidwidth, "PID");
if (lflg || fflg)
(void) printf(" %*s", pidwidth, "PPID");
if (jflg)
(void) printf(" %*s %*s", pidwidth, "PGID",
pidwidth, "SID");
if (Lflg)
(void) printf(" LWP");
if (Pflg)
(void) printf(" PSR");
if (Lflg && fflg)
(void) printf(" NLWP");
if (cflg)
(void) printf(" CLS PRI");
else if (lflg || fflg) {
(void) printf(" C");
if (lflg)
(void) printf(" PRI NI");
}
if (lflg) {
if (yflg)
(void) printf(" RSS SZ WCHAN");
else
(void) printf(" ADDR SZ WCHAN");
}
if (fflg)
(void) printf(" %s", loc_stime_str);
if (Hflg)
(void) printf(" LGRP");
if (Lflg)
(void) printf(" TTY LTIME CMD\n");
else
(void) printf(" TTY TIME CMD\n");
}
if (pflg && !(aflg|Aflg|dflg|Gflg|Uflg|uflg|hflg|tflg|gflg|sflg|zflg) &&
npid <= PTHRESHOLD) {
/*
* If we are looking at specific processes go straight
* to their /proc entries and don't scan /proc.
*/
int i;
(void) qsort(pid, npid, sizeof (pid_t), pidcmp);
for (i = 0; i < npid; i++) {
char pname[12];
if (i >= 1 && pid[i] == pid[i - 1])
continue;
(void) sprintf(pname, "%d", (int)pid[i]);
if (print_proc(pname) == 0)
retcode = 0;
}
} else {
/*
* Determine which processes to print info about by searching
* the /proc directory and looking at each process.
*/
if ((dirp = opendir(procdir)) == NULL) {
(void) fprintf(stderr,
gettext("ps: cannot open PROC directory %s\n"),
procdir);
exit(1);
}
/* for each active process --- */
while (dentp = readdir(dirp)) {
if (dentp->d_name[0] == '.') /* skip . and .. */
continue;
if (print_proc(dentp->d_name) == 0)
retcode = 0;
}
(void) closedir(dirp);
}
return (retcode);
}
int
print_proc(char *pid_name)
{
char pname[PATH_MAX];
int pdlen;
int found;
int procfd; /* filedescriptor for /proc/nnnnn/psinfo */
char *tp; /* ptr to ttyname, if any */
psinfo_t info; /* process information from /proc */
lwpsinfo_t *lwpsinfo; /* array of lwpsinfo structs */
pdlen = snprintf(pname, sizeof (pname), "%s/%s/", procdir, pid_name);
if (pdlen >= sizeof (pname) - 10)
return (1);
retry:
(void) strcpy(&pname[pdlen], "psinfo");
if ((procfd = open(pname, O_RDONLY)) == -1) {
/* Process may have exited meanwhile. */
return (1);
}
/*
* Get the info structure for the process and close quickly.
*/
if (read(procfd, (char *)&info, sizeof (info)) < 0) {
int saverr = errno;
(void) close(procfd);
if (saverr == EAGAIN)
goto retry;
if (saverr != ENOENT)
(void) fprintf(stderr,
gettext("ps: read() on %s: %s\n"),
pname, err_string(saverr));
return (1);
}
(void) close(procfd);
found = 0;
if (info.pr_lwp.pr_state == 0) /* can't happen? */
return (1);
/*
* Omit session group leaders for 'a' and 'd' options.
*/
if ((info.pr_pid == info.pr_sid) && (dflg || aflg))
return (1);
if (Aflg || dflg)
found++;
else if (pflg && search(pid, npid, info.pr_pid))
found++; /* ppid in p option arg list */
else if (uflg && ugfind((id_t)info.pr_euid, &euid_tbl))
found++; /* puid in u option arg list */
else if (Uflg && ugfind((id_t)info.pr_uid, &ruid_tbl))
found++; /* puid in U option arg list */
#ifdef NOT_YET
else if (gflg && ugfind((id_t)info.pr_egid, &egid_tbl))
found++; /* pgid in g option arg list */
#endif /* NOT_YET */
else if (Gflg && ugfind((id_t)info.pr_gid, &rgid_tbl))
found++; /* pgid in G option arg list */
else if (gflg && search(grpid, ngrpid, info.pr_pgid))
found++; /* grpid in g option arg list */
else if (sflg && search(sessid, nsessid, info.pr_sid))
found++; /* sessid in s option arg list */
else if (zflg && search(zoneid, nzoneid, info.pr_zoneid))
found++; /* zoneid in z option arg list */
else if (hflg && search((pid_t *)lgrps, nlgrps, info.pr_lwp.pr_lgrp))
found++; /* home lgroup in h option arg list */
if (!found && !tflg && !aflg)
return (1);
if (!prfind(found, &info, &tp))
return (1);
if (Lflg && (info.pr_nlwp + info.pr_nzomb) > 1) {
ssize_t prsz;
(void) strcpy(&pname[pdlen], "lpsinfo");
if ((procfd = open(pname, O_RDONLY)) == -1)
return (1);
/*
* Get the info structures for the lwps.
*/
prsz = read(procfd, lpsinfobuf, lpbufsize);
if (prsz == -1) {
int saverr = errno;
(void) close(procfd);
if (saverr == EAGAIN)
goto retry;
if (saverr != ENOENT)
(void) fprintf(stderr,
gettext("ps: read() on %s: %s\n"),
pname, err_string(saverr));
return (1);
}
(void) close(procfd);
if (prsz == lpbufsize) {
/*
* buffer overflow. Realloc new buffer.
* Error handling is done in Realloc().
*/
lpbufsize *= 2;
lpsinfobuf = Realloc(lpsinfobuf, lpbufsize);
goto retry;
}
if (lpsinfobuf->pr_nent != (info.pr_nlwp + info.pr_nzomb))
goto retry;
lwpsinfo = (lwpsinfo_t *)(lpsinfobuf + 1);
}
if (!Lflg || (info.pr_nlwp + info.pr_nzomb) <= 1) {
prcom(&info, tp);
} else {
int nlwp = 0;
do {
info.pr_lwp = *lwpsinfo;
prcom(&info, tp);
/* LINTED improper alignment */
lwpsinfo = (lwpsinfo_t *)((char *)lwpsinfo +
lpsinfobuf->pr_entsize);
} while (++nlwp < lpsinfobuf->pr_nent);
}
return (0);
}
static void
usage(void) /* print usage message and quit */
{
static char usage1[] =
"ps [ -aAdefHlcjLPyZ ] [ -o format ] [ -t termlist ]";
static char usage2[] =
"\t[ -u userlist ] [ -U userlist ] [ -G grouplist ]";
static char usage3[] =
"\t[ -p proclist ] [ -g pgrplist ] [ -s sidlist ] [ -z zonelist ] "
"[-h lgrplist]";
static char usage4[] =
" 'format' is one or more of:";
static char usage5[] =
"\tuser ruser group rgroup uid ruid gid rgid pid ppid pgid "
"sid taskid ctid";
static char usage6[] =
"\tpri opri pcpu pmem vsz rss osz nice class time etime stime zone "
"zoneid";
static char usage7[] =
"\tf s c lwp nlwp psr tty addr wchan fname comm args "
"projid project pset lgrp";
(void) fprintf(stderr,
gettext("usage: %s\n%s\n%s\n%s\n%s\n%s\n%s\n"),
gettext(usage1), gettext(usage2), gettext(usage3),
gettext(usage4), gettext(usage5), gettext(usage6), gettext(usage7));
exit(1);
}
/*
* getarg() finds the next argument in list and copies arg into argbuf.
* p1 first pts to arg passed back from getopt routine. p1 is then
* bumped to next character that is not a comma or blank -- p1 NULL
* indicates end of list.
*/
static char *
getarg(char **pp1)
{
static char argbuf[ARGSIZ];
char *p1 = *pp1;
char *parga = argbuf;
int c;
while ((c = *p1) != '\0' && (c == ',' || isspace(c)))
p1++;
while ((c = *p1) != '\0' && c != ',' && !isspace(c)) {
if (parga < argbuf + ARGSIZ - 1)
*parga++ = c;
p1++;
}
*parga = '\0';
while ((c = *p1) != '\0' && (c == ',' || isspace(c)))
p1++;
*pp1 = p1;
return (argbuf);
}
/*
* parse_format() takes the argument to the -o option,
* sets up the next output field structure, and returns
* a pointer to any further output field specifier(s).
* As a side-effect, it increments errflg if encounters a format error.
*/
static char *
parse_format(char *arg)
{
int c;
char *name;
char *header = NULL;
int width = 0;
struct def_field *df;
struct field *f;
while ((c = *arg) != '\0' && (c == ',' || isspace(c)))
arg++;
if (c == '\0')
return (NULL);
name = arg;
arg = strpbrk(arg, " \t\r\v\f\n,=");
if (arg != NULL) {
c = *arg;
*arg++ = '\0';
if (c == '=') {
char *s;
header = arg;
arg = NULL;
width = strlen(header);
s = header + width;
while (s > header && isspace(*--s))
*s = '\0';
while (isspace(*header))
header++;
}
}
for (df = &fname[0]; df < &fname[NFIELDS]; df++)
if (strcmp(name, df->fname) == 0) {
if (strcmp(name, "lwp") == 0)
Lflg++;
break;
}
if (df >= &fname[NFIELDS]) {
(void) fprintf(stderr,
gettext("ps: unknown output format: -o %s\n"),
name);
errflg++;
return (arg);
}
if ((f = malloc(sizeof (*f))) == NULL) {
(void) fprintf(stderr,
gettext("ps: malloc() for output format failed, %s\n"),
err_string(errno));
exit(1);
}
f->next = NULL;
f->fname = df - &fname[0];
f->header = header? header : df->header;
if (width == 0)
width = df->width;
if (*f->header != '\0')
do_header = 1;
f->width = max(width, df->minwidth);
if (fields == NULL)
fields = last_field = f;
else {
last_field->next = f;
last_field = f;
}
return (arg);
}
static char *
devlookup(dev_t ddev)
{
struct devl *dp;
int i;
for (dp = devl, i = 0; i < ndev; dp++, i++) {
if (dp->ddev == ddev)
return (dp->dname);
}
return (NULL);
}
static char *
devadd(char *name, dev_t ddev)
{
struct devl *dp;
int leng, start, i;
if (ndev == maxdev) {
maxdev += DNINCR;
devl = Realloc(devl, maxdev * sizeof (struct devl));
}
dp = &devl[ndev++];
dp->ddev = ddev;
if (name == NULL) {
(void) strcpy(dp->dname, "??");
return (dp->dname);
}
leng = strlen(name);
/* Strip off /dev/ */
if (leng < DNSIZE + 4)
(void) strcpy(dp->dname, &name[5]);
else {
start = leng - DNSIZE - 1;
for (i = start; i < leng && name[i] != '/'; i++)
;
if (i == leng)
(void) strncpy(dp->dname, &name[start], DNSIZE);
else
(void) strncpy(dp->dname, &name[i+1], DNSIZE);
}
return (dp->dname);
}
/*
* gettty returns the user's tty number or ? if none.
*/
static char *
gettty(psinfo_t *psinfo)
{
extern char *_ttyname_dev(dev_t, char *, size_t);
char devname[TTYNAME_MAX];
char *retval;
if (psinfo->pr_ttydev == PRNODEV)
return ("?");
if ((retval = devlookup(psinfo->pr_ttydev)) != NULL)
return (retval);
retval = _ttyname_dev(psinfo->pr_ttydev, devname, sizeof (devname));
return (devadd(retval, psinfo->pr_ttydev));
}
/*
* Find the process's tty and return 1 if process is to be printed.
*/
static int
prfind(int found, psinfo_t *psinfo, char **tpp)
{
char *tp;
struct tty *ttyp;
if (psinfo->pr_nlwp == 0) {
/* process is a zombie */
*tpp = "?";
if (tflg && !found)
return (0);
return (1);
}
/*
* Get current terminal. If none ("?") and 'a' is set, don't print
* info. If 't' is set, check if term is in list of desired terminals
* and print it if it is.
*/
tp = gettty(psinfo);
if (aflg && *tp == '?') {
*tpp = tp;
return (0);
}
if (tflg && !found) {
int match = 0;
char *other = NULL;
for (ttyp = tty; ttyp->tname != NULL; ttyp++) {
/*
* Look for a name match
*/
if (strcmp(tp, ttyp->tname) == 0) {
match = 1;
break;
}
/*
* Look for same device under different names.
*/
if ((other == NULL) &&
(ttyp->tdev != PRNODEV) &&
(psinfo->pr_ttydev == ttyp->tdev))
other = ttyp->tname;
}
if (!match && (other != NULL)) {
/*
* found under a different name
*/
match = 1;
tp = other;
}
if (!match || (tuid != (uid_t)-1 && tuid != psinfo->pr_euid)) {
/*
* not found OR not matching euid
*/
*tpp = tp;
return (0);
}
}
*tpp = tp;
return (1);
}
/*
* Print info about the process.
*/
static void
prcom(psinfo_t *psinfo, char *ttyp)
{
char *cp;
long tm;
int bytesleft;
int wcnt, length;
wchar_t wchar;
struct passwd *pwd;
int zombie_lwp;
char zonename[ZONENAME_MAX];
/*
* If process is zombie, call zombie print routine and return.
*/
if (psinfo->pr_nlwp == 0) {
if (fields != NULL)
pr_fields(psinfo, ttyp, print_zombie_field);
else
przom(psinfo);
return;
}
zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z');
/*
* If user specified '-o format', print requested fields and return.
*/
if (fields != NULL) {
pr_fields(psinfo, ttyp, print_field);
return;
}
/*
* All fields before 'PID' are printed with a trailing space as a
* separator, rather than keeping track of which column is first. All
* other fields are printed with a leading space.
*/
if (lflg) {
if (!yflg)
(void) printf("%2x ", psinfo->pr_flag & 0377); /* F */
(void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */
}
if (Zflg) { /* ZONE */
if (getzonenamebyid(psinfo->pr_zoneid, zonename,
sizeof (zonename)) < 0) {
(void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));
} else {
(void) printf("%8.8s ", zonename);
}
}
if (fflg) { /* UID */
if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
(void) printf("%8.8s ", pwd->pw_name);
else
(void) printf(" %7.7u ", psinfo->pr_euid);
} else if (lflg) {
(void) printf("%6u ", psinfo->pr_euid);
}
(void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */
if (lflg || fflg)
(void) printf(" %*d", pidwidth,
(int)psinfo->pr_ppid); /* PPID */
if (jflg) {
(void) printf(" %*d", pidwidth,
(int)psinfo->pr_pgid); /* PGID */
(void) printf(" %*d", pidwidth,
(int)psinfo->pr_sid); /* SID */
}
if (Lflg)
(void) printf(" %5d", (int)psinfo->pr_lwp.pr_lwpid); /* LWP */
if (Pflg) {
if (psinfo->pr_lwp.pr_bindpro == PBIND_NONE) /* PSR */
(void) printf(" -");
else
(void) printf(" %3d", psinfo->pr_lwp.pr_bindpro);
}
if (Lflg && fflg) /* NLWP */
(void) printf(" %5d", psinfo->pr_nlwp + psinfo->pr_nzomb);
if (cflg) {
if (zombie_lwp) /* CLS */
(void) printf(" ");
else
(void) printf(" %4s", psinfo->pr_lwp.pr_clname);
(void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */
} else if (lflg || fflg) {
(void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */
if (lflg) { /* PRI NI */
/*
* Print priorities the old way (lower numbers
* mean higher priority) and print nice value
* for time sharing procs.
*/
(void) printf(" %3d", psinfo->pr_lwp.pr_oldpri);
if (psinfo->pr_lwp.pr_oldpri != 0)
(void) printf(" %2d", psinfo->pr_lwp.pr_nice);
else
(void) printf(" %2.2s",
psinfo->pr_lwp.pr_clname);
}
}
if (lflg) {
if (yflg) {
if (psinfo->pr_flag & SSYS) /* RSS */
(void) printf(" 0");
else if (psinfo->pr_rssize)
(void) printf(" %5lu",
(ulong_t)psinfo->pr_rssize);
else
(void) printf(" ?");
if (psinfo->pr_flag & SSYS) /* SZ */
(void) printf(" 0");
else if (psinfo->pr_size)
(void) printf(" %6lu",
(ulong_t)psinfo->pr_size);
else
(void) printf(" ?");
} else {
#ifndef _LP64
if (psinfo->pr_addr) /* ADDR */
(void) printf(" %8lx",
(ulong_t)psinfo->pr_addr);
else
#endif
(void) printf(" ?");
if (psinfo->pr_flag & SSYS) /* SZ */
(void) printf(" 0");
else if (psinfo->pr_size)
(void) printf(" %6lu",
(ulong_t)psinfo->pr_size / kbytes_per_page);
else
(void) printf(" ?");
}
if (psinfo->pr_lwp.pr_sname != 'S') /* WCHAN */
(void) printf(" ");
#ifndef _LP64
else if (psinfo->pr_lwp.pr_wchan)
(void) printf(" %8lx",
(ulong_t)psinfo->pr_lwp.pr_wchan);
#endif
else
(void) printf(" ?");
}
if (fflg) { /* STIME */
int width = fname[F_STIME].width;
if (Lflg)
prtime(psinfo->pr_lwp.pr_start, width + 1, 1);
else
prtime(psinfo->pr_start, width + 1, 1);
}
if (Hflg) {
/* Display home lgroup */
(void) printf(" %4d", (int)psinfo->pr_lwp.pr_lgrp);
}
(void) printf(" %-8.14s", ttyp); /* TTY */
if (Lflg) {
tm = psinfo->pr_lwp.pr_time.tv_sec;
if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)
tm++;
} else {
tm = psinfo->pr_time.tv_sec;
if (psinfo->pr_time.tv_nsec > 500000000)
tm++;
}
(void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* [L]TIME */
if (zombie_lwp) {
(void) printf(" <defunct>\n");
return;
}
if (!fflg) { /* CMD */
wcnt = namencnt(psinfo->pr_fname, 16, 8);
(void) printf(" %.*s\n", wcnt, psinfo->pr_fname);
return;
}
/*
* PRARGSZ == length of cmd arg string.
*/
psinfo->pr_psargs[PRARGSZ-1] = '\0';
bytesleft = PRARGSZ;
for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {
length = mbtowc(&wchar, cp, MB_LEN_MAX);
if (length == 0)
break;
if (length < 0 || !iswprint(wchar)) {
if (length < 0)
length = 1;
if (bytesleft <= length) {
*cp = '\0';
break;
}
/* omit the unprintable character */
(void) memmove(cp, cp+length, bytesleft-length);
length = 0;
}
bytesleft -= length;
}
wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, lflg ? 35 : PRARGSZ);
(void) printf(" %.*s\n", wcnt, psinfo->pr_psargs);
}
/*
* Print percent from 16-bit binary fraction [0 .. 1]
* Round up .01 to .1 to indicate some small percentage (the 0x7000 below).
*/
static void
prtpct(ushort_t pct, int width)
{
uint_t value = pct; /* need 32 bits to compute with */
value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */
if (value >= 1000)
value = 999;
if ((width -= 2) < 2)
width = 2;
(void) printf("%*u.%u", width, value / 10, value % 10);
}
static void
print_time(time_t tim, int width)
{
char buf[30];
time_t seconds;
time_t minutes;
time_t hours;
time_t days;
if (tim < 0) {
(void) printf("%*s", width, "-");
return;
}
seconds = tim % 60;
tim /= 60;
minutes = tim % 60;
tim /= 60;
hours = tim % 24;
days = tim / 24;
if (days > 0) {
(void) snprintf(buf, sizeof (buf), "%ld-%2.2ld:%2.2ld:%2.2ld",
days, hours, minutes, seconds);
} else if (hours > 0) {
(void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld:%2.2ld",
hours, minutes, seconds);
} else {
(void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld",
minutes, seconds);
}
(void) printf("%*s", width, buf);
}
static void
print_field(psinfo_t *psinfo, struct field *f, const char *ttyp)
{
int width = f->width;
struct passwd *pwd;
struct group *grp;
time_t cputime;
int bytesleft;
int wcnt;
wchar_t wchar;
char *cp;
int length;
ulong_t mask;
char c, *csave;
int zombie_lwp;
zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z');
switch (f->fname) {
case F_RUSER:
if ((pwd = getpwuid(psinfo->pr_uid)) != NULL)
(void) printf("%*s", width, pwd->pw_name);
else
(void) printf("%*u", width, psinfo->pr_uid);
break;
case F_USER:
if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
(void) printf("%*s", width, pwd->pw_name);
else
(void) printf("%*u", width, psinfo->pr_euid);
break;
case F_RGROUP:
if ((grp = getgrgid(psinfo->pr_gid)) != NULL)
(void) printf("%*s", width, grp->gr_name);
else
(void) printf("%*u", width, psinfo->pr_gid);
break;
case F_GROUP:
if ((grp = getgrgid(psinfo->pr_egid)) != NULL)
(void) printf("%*s", width, grp->gr_name);
else
(void) printf("%*u", width, psinfo->pr_egid);
break;
case F_RUID:
(void) printf("%*u", width, psinfo->pr_uid);
break;
case F_UID:
(void) printf("%*u", width, psinfo->pr_euid);
break;
case F_RGID:
(void) printf("%*u", width, psinfo->pr_gid);
break;
case F_GID:
(void) printf("%*u", width, psinfo->pr_egid);
break;
case F_PID:
(void) printf("%*d", width, (int)psinfo->pr_pid);
break;
case F_PPID:
(void) printf("%*d", width, (int)psinfo->pr_ppid);
break;
case F_PGID:
(void) printf("%*d", width, (int)psinfo->pr_pgid);
break;
case F_SID:
(void) printf("%*d", width, (int)psinfo->pr_sid);
break;
case F_PSR:
if (zombie_lwp || psinfo->pr_lwp.pr_bindpro == PBIND_NONE)
(void) printf("%*s", width, "-");
else
(void) printf("%*d", width, psinfo->pr_lwp.pr_bindpro);
break;
case F_LWP:
(void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lwpid);
break;
case F_NLWP:
(void) printf("%*d", width, psinfo->pr_nlwp + psinfo->pr_nzomb);
break;
case F_OPRI:
if (zombie_lwp)
(void) printf("%*s", width, "-");
else
(void) printf("%*d", width, psinfo->pr_lwp.pr_oldpri);
break;
case F_PRI:
if (zombie_lwp)
(void) printf("%*s", width, "-");
else
(void) printf("%*d", width, psinfo->pr_lwp.pr_pri);
break;
case F_F:
mask = 0xffffffffUL;
if (width < 8)
mask >>= (8 - width) * 4;
(void) printf("%*lx", width, psinfo->pr_flag & mask);
break;
case F_S:
(void) printf("%*c", width, psinfo->pr_lwp.pr_sname);
break;
case F_C:
if (zombie_lwp)
(void) printf("%*s", width, "-");
else
(void) printf("%*d", width, psinfo->pr_lwp.pr_cpu);
break;
case F_PCPU:
if (zombie_lwp)
(void) printf("%*s", width, "-");
else if (Lflg)
prtpct(psinfo->pr_lwp.pr_pctcpu, width);
else
prtpct(psinfo->pr_pctcpu, width);
break;
case F_PMEM:
prtpct(psinfo->pr_pctmem, width);
break;
case F_OSZ:
(void) printf("%*lu", width,
(ulong_t)psinfo->pr_size / kbytes_per_page);
break;
case F_VSZ:
(void) printf("%*lu", width, (ulong_t)psinfo->pr_size);
break;
case F_RSS:
(void) printf("%*lu", width, (ulong_t)psinfo->pr_rssize);
break;
case F_NICE:
/* if pr_oldpri is zero, then this class has no nice */
if (zombie_lwp)
(void) printf("%*s", width, "-");
else if (psinfo->pr_lwp.pr_oldpri != 0)
(void) printf("%*d", width, psinfo->pr_lwp.pr_nice);
else
(void) printf("%*.*s", width, width,
psinfo->pr_lwp.pr_clname);
break;
case F_CLASS:
if (zombie_lwp)
(void) printf("%*s", width, "-");
else
(void) printf("%*.*s", width, width,
psinfo->pr_lwp.pr_clname);
break;
case F_STIME:
if (Lflg)
prtime(psinfo->pr_lwp.pr_start, width, 0);
else
prtime(psinfo->pr_start, width, 0);
break;
case F_ETIME:
if (Lflg)
print_time(delta_secs(&psinfo->pr_lwp.pr_start),
width);
else
print_time(delta_secs(&psinfo->pr_start), width);
break;
case F_TIME:
if (Lflg) {
cputime = psinfo->pr_lwp.pr_time.tv_sec;
if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)
cputime++;
} else {
cputime = psinfo->pr_time.tv_sec;
if (psinfo->pr_time.tv_nsec > 500000000)
cputime++;
}
print_time(cputime, width);
break;
case F_TTY:
(void) printf("%-*s", width, ttyp);
break;
case F_ADDR:
if (zombie_lwp)
(void) printf("%*s", width, "-");
else if (Lflg)
(void) printf("%*lx", width,
(long)psinfo->pr_lwp.pr_addr);
else
(void) printf("%*lx", width, (long)psinfo->pr_addr);
break;
case F_WCHAN:
if (!zombie_lwp && psinfo->pr_lwp.pr_wchan)
(void) printf("%*lx", width,
(long)psinfo->pr_lwp.pr_wchan);
else
(void) printf("%*.*s", width, width, "-");
break;
case F_FNAME:
/*
* Print full width unless this is the last output format.
*/
if (zombie_lwp) {
if (f->next != NULL)
(void) printf("%-*s", width, "<defunct>");
else
(void) printf("%s", "<defunct>");
break;
}
wcnt = namencnt(psinfo->pr_fname, 16, width);
if (f->next != NULL)
(void) printf("%-*.*s", width, wcnt, psinfo->pr_fname);
else
(void) printf("%-.*s", wcnt, psinfo->pr_fname);
break;
case F_COMM:
if (zombie_lwp) {
if (f->next != NULL)
(void) printf("%-*s", width, "<defunct>");
else
(void) printf("%s", "<defunct>");
break;
}
csave = strpbrk(psinfo->pr_psargs, " \t\r\v\f\n");
if (csave) {
c = *csave;
*csave = '\0';
}
/* FALLTHROUGH */
case F_ARGS:
/*
* PRARGSZ == length of cmd arg string.
*/
if (zombie_lwp) {
(void) printf("%-*s", width, "<defunct>");
break;
}
psinfo->pr_psargs[PRARGSZ-1] = '\0';
bytesleft = PRARGSZ;
for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {
length = mbtowc(&wchar, cp, MB_LEN_MAX);
if (length == 0)
break;
if (length < 0 || !iswprint(wchar)) {
if (length < 0)
length = 1;
if (bytesleft <= length) {
*cp = '\0';
break;
}
/* omit the unprintable character */
(void) memmove(cp, cp+length, bytesleft-length);
length = 0;
}
bytesleft -= length;
}
wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, width);
/*
* Print full width unless this is the last format.
*/
if (f->next != NULL)
(void) printf("%-*.*s", width, wcnt,
psinfo->pr_psargs);
else
(void) printf("%-.*s", wcnt,
psinfo->pr_psargs);
if (f->fname == F_COMM && csave)
*csave = c;
break;
case F_TASKID:
(void) printf("%*d", width, (int)psinfo->pr_taskid);
break;
case F_PROJID:
(void) printf("%*d", width, (int)psinfo->pr_projid);
break;
case F_PROJECT:
{
struct project cproj;
char proj_buf[PROJECT_BUFSZ];
if ((getprojbyid(psinfo->pr_projid, &cproj,
(void *)&proj_buf, PROJECT_BUFSZ)) == NULL)
(void) printf("%*d", width,
(int)psinfo->pr_projid);
else
(void) printf("%*s", width,
(cproj.pj_name != NULL) ?
cproj.pj_name : "---");
}
break;
case F_PSET:
if (zombie_lwp || psinfo->pr_lwp.pr_bindpset == PS_NONE)
(void) printf("%*s", width, "-");
else
(void) printf("%*d", width, psinfo->pr_lwp.pr_bindpset);
break;
case F_ZONEID:
(void) printf("%*d", width, (int)psinfo->pr_zoneid);
break;
case F_ZONE:
{
char zonename[ZONENAME_MAX];
if (getzonenamebyid(psinfo->pr_zoneid, zonename,
sizeof (zonename)) < 0) {
(void) printf("%*d", width,
((int)psinfo->pr_zoneid));
} else {
(void) printf("%*s", width, zonename);
}
}
break;
case F_CTID:
if (psinfo->pr_contract == -1)
(void) printf("%*s", width, "-");
else
(void) printf("%*ld", width, (long)psinfo->pr_contract);
break;
case F_LGRP:
/* Display home lgroup */
(void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lgrp);
break;
}
}
static void
print_zombie_field(psinfo_t *psinfo, struct field *f, const char *ttyp)
{
int wcnt;
int width = f->width;
switch (f->fname) {
case F_FNAME:
case F_COMM:
case F_ARGS:
/*
* Print full width unless this is the last output format.
*/
wcnt = min(width, sizeof ("<defunct>"));
if (f->next != NULL)
(void) printf("%-*.*s", width, wcnt, "<defunct>");
else
(void) printf("%-.*s", wcnt, "<defunct>");
break;
case F_PSR:
case F_PCPU:
case F_PMEM:
case F_NICE:
case F_CLASS:
case F_STIME:
case F_ETIME:
case F_WCHAN:
case F_PSET:
(void) printf("%*s", width, "-");
break;
case F_OPRI:
case F_PRI:
case F_OSZ:
case F_VSZ:
case F_RSS:
(void) printf("%*d", width, 0);
break;
default:
print_field(psinfo, f, ttyp);
break;
}
}
static void
pr_fields(psinfo_t *psinfo, const char *ttyp,
void (*print_fld)(psinfo_t *, struct field *, const char *))
{
struct field *f;
for (f = fields; f != NULL; f = f->next) {
print_fld(psinfo, f, ttyp);
if (f->next != NULL)
(void) printf(" ");
}
(void) printf("\n");
}
/*
* Returns 1 if arg is found in array arr, of length num; 0 otherwise.
*/
static int
search(pid_t *arr, int number, pid_t arg)
{
int i;
for (i = 0; i < number; i++)
if (arg == arr[i])
return (1);
return (0);
}
/*
* Add an entry (user, group) to the specified table.
*/
static void
add_ugentry(struct ughead *tbl, char *name)
{
struct ugdata *entp;
if (tbl->size == tbl->nent) { /* reallocate the table entries */
if ((tbl->size *= 2) == 0)
tbl->size = 32; /* first time */
tbl->ent = Realloc(tbl->ent, tbl->size*sizeof (struct ugdata));
}
entp = &tbl->ent[tbl->nent++];
entp->id = 0;
(void) strncpy(entp->name, name, MAXUGNAME);
entp->name[MAXUGNAME] = '\0';
}
static int
uconv(struct ughead *uhead)
{
struct ugdata *utbl = uhead->ent;
int n = uhead->nent;
struct passwd *pwd;
int i;
int fnd = 0;
uid_t uid;
/*
* Ask the name service for names.
*/
for (i = 0; i < n; i++) {
/*
* If name is numeric, ask for numeric id
*/
if (str2uid(utbl[i].name, &uid, 0, MAXEPHUID) == 0)
pwd = getpwuid(uid);
else
pwd = getpwnam(utbl[i].name);
/*
* If found, enter found index into tbl array.
*/
if (pwd == NULL) {
(void) fprintf(stderr,
gettext("ps: unknown user %s\n"), utbl[i].name);
continue;
}
utbl[fnd].id = pwd->pw_uid;
(void) strncpy(utbl[fnd].name, pwd->pw_name, MAXUGNAME);
fnd++;
}
uhead->nent = fnd; /* in case it changed */
return (n - fnd);
}
static int
gconv(struct ughead *ghead)
{
struct ugdata *gtbl = ghead->ent;
int n = ghead->nent;
struct group *grp;
gid_t gid;
int i;
int fnd = 0;
/*
* Ask the name service for names.
*/
for (i = 0; i < n; i++) {
/*
* If name is numeric, ask for numeric id
*/
if (str2uid(gtbl[i].name, (uid_t *)&gid, 0, MAXEPHUID) == 0)
grp = getgrgid(gid);
else
grp = getgrnam(gtbl[i].name);
/*
* If found, enter found index into tbl array.
*/
if (grp == NULL) {
(void) fprintf(stderr,
gettext("ps: unknown group %s\n"), gtbl[i].name);
continue;
}
gtbl[fnd].id = grp->gr_gid;
(void) strncpy(gtbl[fnd].name, grp->gr_name, MAXUGNAME);
fnd++;
}
ghead->nent = fnd; /* in case it changed */
return (n - fnd);
}
/*
* Return 1 if puid is in table, otherwise 0.
*/
static int
ugfind(id_t id, struct ughead *ughead)
{
struct ugdata *utbl = ughead->ent;
int n = ughead->nent;
int i;
for (i = 0; i < n; i++)
if (utbl[i].id == id)
return (1);
return (0);
}
/*
* Print starting time of process unless process started more than 24 hours
* ago, in which case the date is printed. The date is printed in the form
* "MMM dd" if old format, else the blank is replaced with an '_' so
* it appears as a single word (for parseability).
*/
static void
prtime(timestruc_t st, int width, int old)
{
char sttim[26];
time_t starttime;
starttime = st.tv_sec;
if (st.tv_nsec > 500000000)
starttime++;
if ((now.tv_sec - starttime) >= 24*60*60) {
(void) strftime(sttim, sizeof (sttim), old?
/*
* TRANSLATION_NOTE
* This time format is used by STIME field when -f option
* is specified. Used for processes that begun more than
* 24 hours.
*/
dcgettext(NULL, "%b %d", LC_TIME) :
/*
* TRANSLATION_NOTE
* This time format is used by STIME field when -o option
* is specified. Used for processes that begun more than
* 24 hours.
*/
dcgettext(NULL, "%b_%d", LC_TIME), localtime(&starttime));
} else {
/*
* TRANSLATION_NOTE
* This time format is used by STIME field when -f or -o option
* is specified. Used for processes that begun less than
* 24 hours.
*/
(void) strftime(sttim, sizeof (sttim),
dcgettext(NULL, "%H:%M:%S", LC_TIME),
localtime(&starttime));
}
(void) printf("%*.*s", width, width, sttim);
}
static void
przom(psinfo_t *psinfo)
{
long tm;
struct passwd *pwd;
char zonename[ZONENAME_MAX];
/*
* All fields before 'PID' are printed with a trailing space as a
* spearator, rather than keeping track of which column is first. All
* other fields are printed with a leading space.
*/
if (lflg) { /* F S */
if (!yflg)
(void) printf("%2x ", psinfo->pr_flag & 0377); /* F */
(void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */
}
if (Zflg) {
if (getzonenamebyid(psinfo->pr_zoneid, zonename,
sizeof (zonename)) < 0) {
(void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));
} else {
(void) printf("%8.8s ", zonename);
}
}
if (Hflg) {
/* Display home lgroup */
(void) printf(" %6d", (int)psinfo->pr_lwp.pr_lgrp); /* LGRP */
}
if (fflg) {
if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
(void) printf("%8.8s ", pwd->pw_name);
else
(void) printf(" %7.7u ", psinfo->pr_euid);
} else if (lflg)
(void) printf("%6u ", psinfo->pr_euid);
(void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */
if (lflg || fflg)
(void) printf(" %*d", pidwidth,
(int)psinfo->pr_ppid); /* PPID */
if (jflg) {
(void) printf(" %*d", pidwidth,
(int)psinfo->pr_pgid); /* PGID */
(void) printf(" %*d", pidwidth,
(int)psinfo->pr_sid); /* SID */
}
if (Lflg)
(void) printf(" %5d", 0); /* LWP */
if (Pflg)
(void) printf(" -"); /* PSR */
if (Lflg && fflg)
(void) printf(" %5d", 0); /* NLWP */
if (cflg) {
(void) printf(" %4s", "-"); /* zombies have no class */
(void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */
} else if (lflg || fflg) {
(void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */
if (lflg)
(void) printf(" %3d %2s",
psinfo->pr_lwp.pr_oldpri, "-"); /* PRI NI */
}
if (lflg) {
if (yflg) /* RSS SZ WCHAN */
(void) printf(" %5d %6d %8s", 0, 0, "-");
else /* ADDR SZ WCHAN */
(void) printf(" %8s %6d %8s", "-", 0, "-");
}
if (fflg) {
int width = fname[F_STIME].width;
(void) printf(" %*.*s", width, width, "-"); /* STIME */
}
(void) printf(" %-8.14s", "?"); /* TTY */
tm = psinfo->pr_time.tv_sec;
if (psinfo->pr_time.tv_nsec > 500000000)
tm++;
(void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* TIME */
(void) printf(" <defunct>\n");
}
/*
* Function to compute the number of printable bytes in a multibyte
* command string ("internationalization").
*/
static int
namencnt(char *cmd, int csisize, int scrsize)
{
int csiwcnt = 0, scrwcnt = 0;
int ncsisz, nscrsz;
wchar_t wchar;
int len;
while (*cmd != '\0') {
if ((len = csisize - csiwcnt) > (int)MB_CUR_MAX)
len = MB_CUR_MAX;
if ((ncsisz = mbtowc(&wchar, cmd, len)) < 0)
return (8); /* default to use for illegal chars */
if ((nscrsz = wcwidth(wchar)) <= 0)
return (8);
if (csiwcnt + ncsisz > csisize || scrwcnt + nscrsz > scrsize)
break;
csiwcnt += ncsisz;
scrwcnt += nscrsz;
cmd += ncsisz;
}
return (csiwcnt);
}
static char *
err_string(int err)
{
static char buf[32];
char *str = strerror(err);
if (str == NULL)
(void) snprintf(str = buf, sizeof (buf), "Errno #%d", err);
return (str);
}
/* If allocation fails, die */
static void *
Realloc(void *ptr, size_t size)
{
ptr = realloc(ptr, size);
if (ptr == NULL) {
(void) fprintf(stderr, gettext("ps: no memory\n"));
exit(1);
}
return (ptr);
}
static time_t
delta_secs(const timestruc_t *start)
{
time_t seconds = now.tv_sec - start->tv_sec;
long nanosecs = now.tv_usec * 1000 - start->tv_nsec;
if (nanosecs >= (NANOSEC / 2))
seconds++;
else if (nanosecs < -(NANOSEC / 2))
seconds--;
return (seconds);
}
/*
* Returns the following:
*
* 0 No error
* EINVAL Invalid number
* ERANGE Value exceeds (min, max) range
*/
static int
str2id(const char *p, pid_t *val, long min, long max)
{
char *q;
long number;
int error;
errno = 0;
number = strtol(p, &q, 10);
if (errno != 0 || q == p || *q != '\0') {
if ((error = errno) == 0) {
/*
* strtol() can fail without setting errno, or it can
* set it to EINVAL or ERANGE. In the case errno is
* still zero, return EINVAL.
*/
error = EINVAL;
}
} else if (number < min || number > max) {
error = ERANGE;
} else {
error = 0;
}
*val = number;
return (error);
}
/*
* Returns the following:
*
* 0 No error
* EINVAL Invalid number
* ERANGE Value exceeds (min, max) range
*/
static int
str2uid(const char *p, uid_t *val, unsigned long min, unsigned long max)
{
char *q;
unsigned long number;
int error;
errno = 0;
number = strtoul(p, &q, 10);
if (errno != 0 || q == p || *q != '\0') {
if ((error = errno) == 0) {
/*
* strtoul() can fail without setting errno, or it can
* set it to EINVAL or ERANGE. In the case errno is
* still zero, return EINVAL.
*/
error = EINVAL;
}
} else if (number < min || number > max) {
error = ERANGE;
} else {
error = 0;
}
*val = number;
return (error);
}
static int
pidcmp(const void *p1, const void *p2)
{
pid_t i = *((pid_t *)p1);
pid_t j = *((pid_t *)p2);
return (i - j);
}