17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 551223f18Sjonb * Common Development and Distribution License (the "License"). 651223f18Sjonb * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 2151223f18Sjonb 227c478bd9Sstevel@tonic-gate /* 230a1278f2SGary Mills * Copyright (c) 2013 Gary Mills 240a1278f2SGary Mills * 25f5c9e9f9SCasper H.S. Dik * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 267c478bd9Sstevel@tonic-gate * Use is subject to license terms. 277c478bd9Sstevel@tonic-gate */ 287c478bd9Sstevel@tonic-gate 29eaaa4d5fSBryan Cantrill /* 30*ab618543SJohn Levon * Copyright (c) 2018, Joyent, Inc. 31eaaa4d5fSBryan Cantrill */ 32eaaa4d5fSBryan Cantrill 337c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 34*ab618543SJohn Levon /* All Rights Reserved */ 357c478bd9Sstevel@tonic-gate 367c478bd9Sstevel@tonic-gate /* 377c478bd9Sstevel@tonic-gate * ps -- print things about processes. 387c478bd9Sstevel@tonic-gate */ 397c478bd9Sstevel@tonic-gate #include <stdio.h> 407c478bd9Sstevel@tonic-gate #include <ctype.h> 417c478bd9Sstevel@tonic-gate #include <string.h> 427c478bd9Sstevel@tonic-gate #include <errno.h> 437c478bd9Sstevel@tonic-gate #include <fcntl.h> 447c478bd9Sstevel@tonic-gate #include <pwd.h> 457c478bd9Sstevel@tonic-gate #include <grp.h> 467c478bd9Sstevel@tonic-gate #include <sys/types.h> 477c478bd9Sstevel@tonic-gate #include <sys/stat.h> 487c478bd9Sstevel@tonic-gate #include <sys/mkdev.h> 497c478bd9Sstevel@tonic-gate #include <unistd.h> 507c478bd9Sstevel@tonic-gate #include <stdlib.h> 517c478bd9Sstevel@tonic-gate #include <limits.h> 527c478bd9Sstevel@tonic-gate #include <dirent.h> 537c478bd9Sstevel@tonic-gate #include <sys/signal.h> 547c478bd9Sstevel@tonic-gate #include <sys/fault.h> 557c478bd9Sstevel@tonic-gate #include <sys/syscall.h> 567c478bd9Sstevel@tonic-gate #include <sys/time.h> 577c478bd9Sstevel@tonic-gate #include <procfs.h> 587c478bd9Sstevel@tonic-gate #include <locale.h> 597c478bd9Sstevel@tonic-gate #include <wctype.h> 607c478bd9Sstevel@tonic-gate #include <wchar.h> 617c478bd9Sstevel@tonic-gate #include <libw.h> 627c478bd9Sstevel@tonic-gate #include <stdarg.h> 637c478bd9Sstevel@tonic-gate #include <sys/proc.h> 647c478bd9Sstevel@tonic-gate #include <sys/pset.h> 657c478bd9Sstevel@tonic-gate #include <project.h> 667c478bd9Sstevel@tonic-gate #include <zone.h> 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate #define min(a, b) ((a) > (b) ? (b) : (a)) 697c478bd9Sstevel@tonic-gate #define max(a, b) ((a) < (b) ? (b) : (a)) 707c478bd9Sstevel@tonic-gate 717c478bd9Sstevel@tonic-gate #define NTTYS 20 /* initial size of table for -t option */ 72c6402783Sakolb #define SIZ 30 /* initial size of tables for -p, -s, -g, -h and -z */ 7351223f18Sjonb 7451223f18Sjonb /* 7551223f18Sjonb * Size of buffer holding args for t, p, s, g, u, U, G, z options. 7651223f18Sjonb * Set to ZONENAME_MAX, the minimum value needed to allow any 7751223f18Sjonb * zone to be specified. 7851223f18Sjonb */ 7951223f18Sjonb #define ARGSIZ ZONENAME_MAX 807c478bd9Sstevel@tonic-gate 810a1278f2SGary Mills /* Max chars in a user/group name or printed u/g id */ 820a1278f2SGary Mills #define MAXUGNAME (LOGNAME_MAX+2) 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate /* Structure for storing user or group info */ 857c478bd9Sstevel@tonic-gate struct ugdata { 867c478bd9Sstevel@tonic-gate id_t id; /* numeric user-id or group-id */ 877c478bd9Sstevel@tonic-gate char name[MAXUGNAME+1]; /* user/group name, null terminated */ 887c478bd9Sstevel@tonic-gate }; 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate struct ughead { 917c478bd9Sstevel@tonic-gate size_t size; /* number of ugdata structs allocated */ 927c478bd9Sstevel@tonic-gate size_t nent; /* number of active entries */ 937c478bd9Sstevel@tonic-gate struct ugdata *ent; /* pointer to array of actual entries */ 947c478bd9Sstevel@tonic-gate }; 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate enum fname { /* enumeration of field names */ 977c478bd9Sstevel@tonic-gate F_USER, /* effective user of the process */ 987c478bd9Sstevel@tonic-gate F_RUSER, /* real user of the process */ 997c478bd9Sstevel@tonic-gate F_GROUP, /* effective group of the process */ 1007c478bd9Sstevel@tonic-gate F_RGROUP, /* real group of the process */ 1017c478bd9Sstevel@tonic-gate F_UID, /* numeric effective uid of the process */ 1027c478bd9Sstevel@tonic-gate F_RUID, /* numeric real uid of the process */ 1037c478bd9Sstevel@tonic-gate F_GID, /* numeric effective gid of the process */ 1047c478bd9Sstevel@tonic-gate F_RGID, /* numeric real gid of the process */ 1057c478bd9Sstevel@tonic-gate F_PID, /* process id */ 1067c478bd9Sstevel@tonic-gate F_PPID, /* parent process id */ 1077c478bd9Sstevel@tonic-gate F_PGID, /* process group id */ 1087c478bd9Sstevel@tonic-gate F_SID, /* session id */ 1097c478bd9Sstevel@tonic-gate F_PSR, /* bound processor */ 1107c478bd9Sstevel@tonic-gate F_LWP, /* lwp-id */ 111*ab618543SJohn Levon F_LWPNAME, /* lwp name */ 1127c478bd9Sstevel@tonic-gate F_NLWP, /* number of lwps */ 1137c478bd9Sstevel@tonic-gate F_OPRI, /* old priority (obsolete) */ 1147c478bd9Sstevel@tonic-gate F_PRI, /* new priority */ 1157c478bd9Sstevel@tonic-gate F_F, /* process flags */ 1167c478bd9Sstevel@tonic-gate F_S, /* letter indicating the state */ 1177c478bd9Sstevel@tonic-gate F_C, /* processor utilization (obsolete) */ 1187c478bd9Sstevel@tonic-gate F_PCPU, /* percent of recently used cpu time */ 1197c478bd9Sstevel@tonic-gate F_PMEM, /* percent of physical memory used (rss) */ 1207c478bd9Sstevel@tonic-gate F_OSZ, /* virtual size of the process in pages */ 1217c478bd9Sstevel@tonic-gate F_VSZ, /* virtual size of the process in kilobytes */ 1227c478bd9Sstevel@tonic-gate F_RSS, /* resident set size of the process in kilobytes */ 1237c478bd9Sstevel@tonic-gate F_NICE, /* "nice" value of the process */ 1247c478bd9Sstevel@tonic-gate F_CLASS, /* scheduler class */ 1257c478bd9Sstevel@tonic-gate F_STIME, /* start time of the process, hh:mm:ss or Month Day */ 1267c478bd9Sstevel@tonic-gate F_ETIME, /* elapsed time of the process, [[dd-]hh:]mm:ss */ 1277c478bd9Sstevel@tonic-gate F_TIME, /* cpu time of the process, [[dd-]hh:]mm:ss */ 1287c478bd9Sstevel@tonic-gate F_TTY, /* name of the controlling terminal */ 1297c478bd9Sstevel@tonic-gate F_ADDR, /* address of the process (obsolete) */ 1307c478bd9Sstevel@tonic-gate F_WCHAN, /* wait channel (sleep condition variable) */ 1317c478bd9Sstevel@tonic-gate F_FNAME, /* file name of command */ 1327c478bd9Sstevel@tonic-gate F_COMM, /* name of command (argv[0] value) */ 1337c478bd9Sstevel@tonic-gate F_ARGS, /* name of command plus all its arguments */ 1347c478bd9Sstevel@tonic-gate F_TASKID, /* task id */ 1357c478bd9Sstevel@tonic-gate F_PROJID, /* project id */ 1367c478bd9Sstevel@tonic-gate F_PROJECT, /* project name of the process */ 1377c478bd9Sstevel@tonic-gate F_PSET, /* bound processor set */ 1387c478bd9Sstevel@tonic-gate F_ZONE, /* zone name */ 1397c478bd9Sstevel@tonic-gate F_ZONEID, /* zone id */ 140c6402783Sakolb F_CTID, /* process contract id */ 141eaaa4d5fSBryan Cantrill F_LGRP, /* process home lgroup */ 142eaaa4d5fSBryan Cantrill F_DMODEL /* process data model */ 1437c478bd9Sstevel@tonic-gate }; 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate struct field { 1467c478bd9Sstevel@tonic-gate struct field *next; /* linked list */ 1477c478bd9Sstevel@tonic-gate int fname; /* field index */ 1487c478bd9Sstevel@tonic-gate const char *header; /* header to use */ 1497c478bd9Sstevel@tonic-gate int width; /* width of field */ 1507c478bd9Sstevel@tonic-gate }; 1517c478bd9Sstevel@tonic-gate 1527c478bd9Sstevel@tonic-gate static struct field *fields = NULL; /* fields selected via -o */ 1537c478bd9Sstevel@tonic-gate static struct field *last_field = NULL; 1547c478bd9Sstevel@tonic-gate static int do_header = 0; 1557c478bd9Sstevel@tonic-gate static struct timeval now; 1567c478bd9Sstevel@tonic-gate 1577c478bd9Sstevel@tonic-gate /* array of defined fields, in fname order */ 1587c478bd9Sstevel@tonic-gate struct def_field { 1597c478bd9Sstevel@tonic-gate const char *fname; 1607c478bd9Sstevel@tonic-gate const char *header; 1617c478bd9Sstevel@tonic-gate int width; 1627c478bd9Sstevel@tonic-gate int minwidth; 1637c478bd9Sstevel@tonic-gate }; 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate static struct def_field fname[] = { 1667c478bd9Sstevel@tonic-gate /* fname header width minwidth */ 1677c478bd9Sstevel@tonic-gate { "user", "USER", 8, 8 }, 1687c478bd9Sstevel@tonic-gate { "ruser", "RUSER", 8, 8 }, 1697c478bd9Sstevel@tonic-gate { "group", "GROUP", 8, 8 }, 1707c478bd9Sstevel@tonic-gate { "rgroup", "RGROUP", 8, 8 }, 1717c478bd9Sstevel@tonic-gate { "uid", "UID", 5, 5 }, 1727c478bd9Sstevel@tonic-gate { "ruid", "RUID", 5, 5 }, 1737c478bd9Sstevel@tonic-gate { "gid", "GID", 5, 5 }, 1747c478bd9Sstevel@tonic-gate { "rgid", "RGID", 5, 5 }, 1757c478bd9Sstevel@tonic-gate { "pid", "PID", 5, 5 }, 1767c478bd9Sstevel@tonic-gate { "ppid", "PPID", 5, 5 }, 1777c478bd9Sstevel@tonic-gate { "pgid", "PGID", 5, 5 }, 1787c478bd9Sstevel@tonic-gate { "sid", "SID", 5, 5 }, 1797c478bd9Sstevel@tonic-gate { "psr", "PSR", 3, 2 }, 1807c478bd9Sstevel@tonic-gate { "lwp", "LWP", 6, 2 }, 181*ab618543SJohn Levon { "lwpname", "LWPNAME", 32, 8 }, 1827c478bd9Sstevel@tonic-gate { "nlwp", "NLWP", 4, 2 }, 1837c478bd9Sstevel@tonic-gate { "opri", "PRI", 3, 2 }, 1847c478bd9Sstevel@tonic-gate { "pri", "PRI", 3, 2 }, 1857c478bd9Sstevel@tonic-gate { "f", "F", 2, 2 }, 1867c478bd9Sstevel@tonic-gate { "s", "S", 1, 1 }, 1877c478bd9Sstevel@tonic-gate { "c", "C", 2, 2 }, 1887c478bd9Sstevel@tonic-gate { "pcpu", "%CPU", 4, 4 }, 1897c478bd9Sstevel@tonic-gate { "pmem", "%MEM", 4, 4 }, 1907c478bd9Sstevel@tonic-gate { "osz", "SZ", 4, 4 }, 1917c478bd9Sstevel@tonic-gate { "vsz", "VSZ", 4, 4 }, 1927c478bd9Sstevel@tonic-gate { "rss", "RSS", 4, 4 }, 1937c478bd9Sstevel@tonic-gate { "nice", "NI", 2, 2 }, 1947c478bd9Sstevel@tonic-gate { "class", "CLS", 4, 2 }, 1957c478bd9Sstevel@tonic-gate { "stime", "STIME", 8, 8 }, 1967c478bd9Sstevel@tonic-gate { "etime", "ELAPSED", 11, 7 }, 1977c478bd9Sstevel@tonic-gate { "time", "TIME", 11, 5 }, 1987c478bd9Sstevel@tonic-gate { "tty", "TT", 7, 7 }, 1997c478bd9Sstevel@tonic-gate #ifdef _LP64 2007c478bd9Sstevel@tonic-gate { "addr", "ADDR", 16, 8 }, 2017c478bd9Sstevel@tonic-gate { "wchan", "WCHAN", 16, 8 }, 2027c478bd9Sstevel@tonic-gate #else 2037c478bd9Sstevel@tonic-gate { "addr", "ADDR", 8, 8 }, 2047c478bd9Sstevel@tonic-gate { "wchan", "WCHAN", 8, 8 }, 2057c478bd9Sstevel@tonic-gate #endif 2067c478bd9Sstevel@tonic-gate { "fname", "COMMAND", 8, 8 }, 2077c478bd9Sstevel@tonic-gate { "comm", "COMMAND", 80, 8 }, 2087c478bd9Sstevel@tonic-gate { "args", "COMMAND", 80, 80 }, 2097c478bd9Sstevel@tonic-gate { "taskid", "TASKID", 5, 5 }, 2107c478bd9Sstevel@tonic-gate { "projid", "PROJID", 5, 5 }, 2117c478bd9Sstevel@tonic-gate { "project", "PROJECT", 8, 8 }, 2127c478bd9Sstevel@tonic-gate { "pset", "PSET", 3, 3 }, 2137c478bd9Sstevel@tonic-gate { "zone", "ZONE", 8, 8 }, 2147c478bd9Sstevel@tonic-gate { "zoneid", "ZONEID", 5, 5 }, 2157c478bd9Sstevel@tonic-gate { "ctid", "CTID", 5, 5 }, 216*ab618543SJohn Levon { "lgrp", "LGRP", 4, 2 }, 217*ab618543SJohn Levon { "dmodel", "DMODEL", 6, 6 }, 2187c478bd9Sstevel@tonic-gate }; 2197c478bd9Sstevel@tonic-gate 2207c478bd9Sstevel@tonic-gate #define NFIELDS (sizeof (fname) / sizeof (fname[0])) 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate static int retcode = 1; 2237c478bd9Sstevel@tonic-gate static int lflg; 2247c478bd9Sstevel@tonic-gate static int Aflg; 2257c478bd9Sstevel@tonic-gate static int uflg; 2267c478bd9Sstevel@tonic-gate static int Uflg; 2277c478bd9Sstevel@tonic-gate static int Gflg; 2287c478bd9Sstevel@tonic-gate static int aflg; 2297c478bd9Sstevel@tonic-gate static int dflg; 2307c478bd9Sstevel@tonic-gate static int Lflg; 2317c478bd9Sstevel@tonic-gate static int Pflg; 2320a1278f2SGary Mills static int Wflg; 2337c478bd9Sstevel@tonic-gate static int yflg; 2347c478bd9Sstevel@tonic-gate static int pflg; 2357c478bd9Sstevel@tonic-gate static int fflg; 2367c478bd9Sstevel@tonic-gate static int cflg; 2377c478bd9Sstevel@tonic-gate static int jflg; 2387c478bd9Sstevel@tonic-gate static int gflg; 2397c478bd9Sstevel@tonic-gate static int sflg; 2407c478bd9Sstevel@tonic-gate static int tflg; 2417c478bd9Sstevel@tonic-gate static int zflg; 2427c478bd9Sstevel@tonic-gate static int Zflg; 243c6402783Sakolb static int hflg; 244c6402783Sakolb static int Hflg; 245f48205beScasper static uid_t tuid = (uid_t)-1; 2467c478bd9Sstevel@tonic-gate static int errflg; 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate static int ndev; /* number of devices */ 2497c478bd9Sstevel@tonic-gate static int maxdev; /* number of devl structures allocated */ 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate #define DNINCR 100 2527c478bd9Sstevel@tonic-gate #define DNSIZE 14 2537c478bd9Sstevel@tonic-gate static struct devl { /* device list */ 2547c478bd9Sstevel@tonic-gate char dname[DNSIZE]; /* device name */ 2557c478bd9Sstevel@tonic-gate dev_t ddev; /* device number */ 2567c478bd9Sstevel@tonic-gate } *devl; 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate static struct tty { 2597c478bd9Sstevel@tonic-gate char *tname; 2607c478bd9Sstevel@tonic-gate dev_t tdev; 2617c478bd9Sstevel@tonic-gate } *tty = NULL; /* for t option */ 2627c478bd9Sstevel@tonic-gate static size_t ttysz = 0; 2637c478bd9Sstevel@tonic-gate static int ntty = 0; 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate static pid_t *pid = NULL; /* for p option */ 2667c478bd9Sstevel@tonic-gate static size_t pidsz = 0; 2677c478bd9Sstevel@tonic-gate static size_t npid = 0; 2687c478bd9Sstevel@tonic-gate 269c6402783Sakolb static int *lgrps = NULL; /* list of lgroup IDs for for h option */ 270c6402783Sakolb static size_t lgrps_size = 0; /* size of the lgrps list */ 271c6402783Sakolb static size_t nlgrps = 0; /* number elements in the list */ 272c6402783Sakolb 273c6402783Sakolb /* Maximum possible lgroup ID value */ 274c6402783Sakolb #define MAX_LGRP_ID 256 275c6402783Sakolb 2767c478bd9Sstevel@tonic-gate static pid_t *grpid = NULL; /* for g option */ 2777c478bd9Sstevel@tonic-gate static size_t grpidsz = 0; 2787c478bd9Sstevel@tonic-gate static int ngrpid = 0; 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate static pid_t *sessid = NULL; /* for s option */ 2817c478bd9Sstevel@tonic-gate static size_t sessidsz = 0; 2827c478bd9Sstevel@tonic-gate static int nsessid = 0; 2837c478bd9Sstevel@tonic-gate 2847c478bd9Sstevel@tonic-gate static zoneid_t *zoneid = NULL; /* for z option */ 2857c478bd9Sstevel@tonic-gate static size_t zoneidsz = 0; 2867c478bd9Sstevel@tonic-gate static int nzoneid = 0; 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate static int kbytes_per_page; 2897c478bd9Sstevel@tonic-gate static int pidwidth; 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate static char *procdir = "/proc"; /* standard /proc directory */ 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate static struct ughead euid_tbl; /* table to store selected euid's */ 2947c478bd9Sstevel@tonic-gate static struct ughead ruid_tbl; /* table to store selected real uid's */ 2957c478bd9Sstevel@tonic-gate static struct ughead egid_tbl; /* table to store selected egid's */ 2967c478bd9Sstevel@tonic-gate static struct ughead rgid_tbl; /* table to store selected real gid's */ 2977c478bd9Sstevel@tonic-gate static prheader_t *lpsinfobuf; /* buffer to contain lpsinfo */ 2987c478bd9Sstevel@tonic-gate static size_t lpbufsize; 2997c478bd9Sstevel@tonic-gate 3007c478bd9Sstevel@tonic-gate /* 3017c478bd9Sstevel@tonic-gate * This constant defines the sentinal number of process IDs below which we 3027c478bd9Sstevel@tonic-gate * only examine individual entries in /proc rather than scanning through 3037c478bd9Sstevel@tonic-gate * /proc. This optimization is a huge win in the common case. 3047c478bd9Sstevel@tonic-gate */ 3057c478bd9Sstevel@tonic-gate #define PTHRESHOLD 40 3067c478bd9Sstevel@tonic-gate 307f5c9e9f9SCasper H.S. Dik #define UCB_OPTS "-aceglnrtuvwxSU" 308f5c9e9f9SCasper H.S. Dik 3097c478bd9Sstevel@tonic-gate static void usage(void); 3107c478bd9Sstevel@tonic-gate static char *getarg(char **); 3117c478bd9Sstevel@tonic-gate static char *parse_format(char *); 3127c478bd9Sstevel@tonic-gate static char *gettty(psinfo_t *); 3137c478bd9Sstevel@tonic-gate static int prfind(int, psinfo_t *, char **); 3147c478bd9Sstevel@tonic-gate static void prcom(psinfo_t *, char *); 3157c478bd9Sstevel@tonic-gate static void prtpct(ushort_t, int); 3167c478bd9Sstevel@tonic-gate static void print_time(time_t, int); 3177c478bd9Sstevel@tonic-gate static void print_field(psinfo_t *, struct field *, const char *); 3187c478bd9Sstevel@tonic-gate static void print_zombie_field(psinfo_t *, struct field *, const char *); 3197c478bd9Sstevel@tonic-gate static void pr_fields(psinfo_t *, const char *, 3207c478bd9Sstevel@tonic-gate void (*print_fld)(psinfo_t *, struct field *, const char *)); 3217c478bd9Sstevel@tonic-gate static int search(pid_t *, int, pid_t); 3227c478bd9Sstevel@tonic-gate static void add_ugentry(struct ughead *, char *); 3237c478bd9Sstevel@tonic-gate static int uconv(struct ughead *); 3247c478bd9Sstevel@tonic-gate static int gconv(struct ughead *); 325f48205beScasper static int ugfind(id_t, struct ughead *); 3267c478bd9Sstevel@tonic-gate static void prtime(timestruc_t, int, int); 3277c478bd9Sstevel@tonic-gate static void przom(psinfo_t *); 3287c478bd9Sstevel@tonic-gate static int namencnt(char *, int, int); 3297c478bd9Sstevel@tonic-gate static char *err_string(int); 3307c478bd9Sstevel@tonic-gate static int print_proc(char *pname); 3317c478bd9Sstevel@tonic-gate static time_t delta_secs(const timestruc_t *); 3327c478bd9Sstevel@tonic-gate static int str2id(const char *, pid_t *, long, long); 333f48205beScasper static int str2uid(const char *, uid_t *, unsigned long, unsigned long); 3347c478bd9Sstevel@tonic-gate static void *Realloc(void *, size_t); 3357c478bd9Sstevel@tonic-gate static int pidcmp(const void *p1, const void *p2); 3367c478bd9Sstevel@tonic-gate 337f5c9e9f9SCasper H.S. Dik extern int ucbmain(int, char **); 338f5c9e9f9SCasper H.S. Dik static int stdmain(int, char **); 339f5c9e9f9SCasper H.S. Dik 3407c478bd9Sstevel@tonic-gate int 3417c478bd9Sstevel@tonic-gate main(int argc, char **argv) 342f5c9e9f9SCasper H.S. Dik { 343f5c9e9f9SCasper H.S. Dik const char *me; 344f5c9e9f9SCasper H.S. Dik 345f5c9e9f9SCasper H.S. Dik /* 346f5c9e9f9SCasper H.S. Dik * The original two ps'es are linked in a single binary; 347f5c9e9f9SCasper H.S. Dik * their main()s are renamed to stdmain for /usr/bin/ps and 348f5c9e9f9SCasper H.S. Dik * ucbmain for /usr/ucb/ps. 349f5c9e9f9SCasper H.S. Dik * We try to figure out which instance of ps the user wants to run. 350f5c9e9f9SCasper H.S. Dik * Traditionally, the UCB variant doesn't require the flag argument 351f5c9e9f9SCasper H.S. Dik * start with a "-". If the first argument doesn't start with a 352f5c9e9f9SCasper H.S. Dik * "-", we call "ucbmain". 353f5c9e9f9SCasper H.S. Dik * If there's a first argument and it starts with a "-", we check 354f5c9e9f9SCasper H.S. Dik * whether any of the options isn't acceptable to "ucbmain"; in that 355f5c9e9f9SCasper H.S. Dik * case we run "stdmain". 356f5c9e9f9SCasper H.S. Dik * If we can't tell from the options which main to call, we check 357f5c9e9f9SCasper H.S. Dik * the binary we are running. We default to "stdmain" but 358f5c9e9f9SCasper H.S. Dik * any mention in the executable name of "ucb" causes us to call 359f5c9e9f9SCasper H.S. Dik * ucbmain. 360f5c9e9f9SCasper H.S. Dik */ 361f5c9e9f9SCasper H.S. Dik if (argv[1] != NULL) { 362f5c9e9f9SCasper H.S. Dik if (argv[1][0] != '-') 363f5c9e9f9SCasper H.S. Dik return (ucbmain(argc, argv)); 364f5c9e9f9SCasper H.S. Dik else if (argv[1][strspn(argv[1], UCB_OPTS)] != '\0') 365f5c9e9f9SCasper H.S. Dik return (stdmain(argc, argv)); 366f5c9e9f9SCasper H.S. Dik } 367f5c9e9f9SCasper H.S. Dik 368f5c9e9f9SCasper H.S. Dik me = getexecname(); 369f5c9e9f9SCasper H.S. Dik 370f5c9e9f9SCasper H.S. Dik if (me != NULL && strstr(me, "ucb") != NULL) 371f5c9e9f9SCasper H.S. Dik return (ucbmain(argc, argv)); 372f5c9e9f9SCasper H.S. Dik else 373f5c9e9f9SCasper H.S. Dik return (stdmain(argc, argv)); 374f5c9e9f9SCasper H.S. Dik } 375f5c9e9f9SCasper H.S. Dik 376f5c9e9f9SCasper H.S. Dik static int 377f5c9e9f9SCasper H.S. Dik stdmain(int argc, char **argv) 3787c478bd9Sstevel@tonic-gate { 3797c478bd9Sstevel@tonic-gate char *p; 3807c478bd9Sstevel@tonic-gate char *p1; 3817c478bd9Sstevel@tonic-gate char *parg; 3827c478bd9Sstevel@tonic-gate int c; 3837c478bd9Sstevel@tonic-gate int i; 3847c478bd9Sstevel@tonic-gate int pgerrflg = 0; /* err flg: non-numeric arg w/p & g options */ 38516f94f58Ssayama size_t size, len; 3867c478bd9Sstevel@tonic-gate DIR *dirp; 3877c478bd9Sstevel@tonic-gate struct dirent *dentp; 3887c478bd9Sstevel@tonic-gate pid_t maxpid; 3897c478bd9Sstevel@tonic-gate pid_t id; 3907c478bd9Sstevel@tonic-gate int ret; 39116f94f58Ssayama char loc_stime_str[32]; 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 3947c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 3957c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 3967c478bd9Sstevel@tonic-gate #endif 3977c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 3987c478bd9Sstevel@tonic-gate 3997c478bd9Sstevel@tonic-gate (void) memset(&euid_tbl, 0, sizeof (euid_tbl)); 4007c478bd9Sstevel@tonic-gate (void) memset(&ruid_tbl, 0, sizeof (ruid_tbl)); 4017c478bd9Sstevel@tonic-gate (void) memset(&egid_tbl, 0, sizeof (egid_tbl)); 4027c478bd9Sstevel@tonic-gate (void) memset(&rgid_tbl, 0, sizeof (rgid_tbl)); 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate kbytes_per_page = sysconf(_SC_PAGESIZE) / 1024; 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate (void) gettimeofday(&now, NULL); 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate /* 4097c478bd9Sstevel@tonic-gate * calculate width of pid fields based on configured MAXPID 4107c478bd9Sstevel@tonic-gate * (must be at least 5 to retain output format compatibility) 4117c478bd9Sstevel@tonic-gate */ 4127c478bd9Sstevel@tonic-gate id = maxpid = (pid_t)sysconf(_SC_MAXPID); 4137c478bd9Sstevel@tonic-gate pidwidth = 1; 4147c478bd9Sstevel@tonic-gate while ((id /= 10) > 0) 4157c478bd9Sstevel@tonic-gate ++pidwidth; 4167c478bd9Sstevel@tonic-gate pidwidth = pidwidth < 5 ? 5 : pidwidth; 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate fname[F_PID].width = fname[F_PPID].width = pidwidth; 4197c478bd9Sstevel@tonic-gate fname[F_PGID].width = fname[F_SID].width = pidwidth; 4207c478bd9Sstevel@tonic-gate 42116f94f58Ssayama /* 42216f94f58Ssayama * TRANSLATION_NOTE 42316f94f58Ssayama * Specify the printf format with width and precision for 42416f94f58Ssayama * the STIME field. 42516f94f58Ssayama */ 42616f94f58Ssayama len = snprintf(loc_stime_str, sizeof (loc_stime_str), 42716f94f58Ssayama dcgettext(NULL, "%8.8s", LC_TIME), "STIME"); 42816f94f58Ssayama if (len >= sizeof (loc_stime_str)) 42916f94f58Ssayama len = sizeof (loc_stime_str) - 1; 43016f94f58Ssayama 43116f94f58Ssayama fname[F_STIME].width = fname[F_STIME].minwidth = len; 43216f94f58Ssayama 4330a1278f2SGary Mills while ((c = getopt(argc, argv, "jlfceAadLPWyZHh:t:p:g:u:U:G:n:s:o:z:")) 434c6402783Sakolb != EOF) 4357c478bd9Sstevel@tonic-gate switch (c) { 436c6402783Sakolb case 'H': /* Show home lgroups */ 437c6402783Sakolb Hflg++; 438c6402783Sakolb break; 439c6402783Sakolb case 'h': 440c6402783Sakolb /* 441c6402783Sakolb * Show processes/threads with given home lgroups 442c6402783Sakolb */ 443c6402783Sakolb hflg++; 444c6402783Sakolb p1 = optarg; 445c6402783Sakolb do { 446c6402783Sakolb int id; 447c6402783Sakolb 448c6402783Sakolb /* 449c6402783Sakolb * Get all IDs in the list, verify for 450c6402783Sakolb * correctness and place in lgrps array. 451c6402783Sakolb */ 452c6402783Sakolb parg = getarg(&p1); 453c6402783Sakolb /* Convert string to integer */ 454c6402783Sakolb ret = str2id(parg, (pid_t *)&id, 0, 455d21c64a5SDavid Edmondson MAX_LGRP_ID); 456c6402783Sakolb /* Complain if ID didn't parse correctly */ 457c6402783Sakolb if (ret != 0) { 458c6402783Sakolb pgerrflg++; 459c6402783Sakolb (void) fprintf(stderr, 460c6402783Sakolb gettext("ps: %s "), parg); 461c6402783Sakolb if (ret == EINVAL) 462c6402783Sakolb (void) fprintf(stderr, 463c6402783Sakolb gettext("is an invalid " 464c6402783Sakolb "non-numeric argument")); 465c6402783Sakolb else 466c6402783Sakolb (void) fprintf(stderr, 467c6402783Sakolb gettext("exceeds valid " 468c6402783Sakolb "range")); 469c6402783Sakolb (void) fprintf(stderr, 470c6402783Sakolb gettext(" for -h option\n")); 471c6402783Sakolb continue; 472c6402783Sakolb } 473c6402783Sakolb 474c6402783Sakolb /* Extend lgrps array if needed */ 475c6402783Sakolb if (nlgrps == lgrps_size) { 476c6402783Sakolb /* Double the size of the lgrps array */ 477c6402783Sakolb if (lgrps_size == 0) 478c6402783Sakolb lgrps_size = SIZ; 479c6402783Sakolb lgrps_size *= 2; 480c6402783Sakolb lgrps = Realloc(lgrps, 481c6402783Sakolb lgrps_size * sizeof (int)); 482c6402783Sakolb } 483c6402783Sakolb /* place the id in the lgrps table */ 484c6402783Sakolb lgrps[nlgrps++] = id; 485c6402783Sakolb } while (*p1); 486c6402783Sakolb break; 4877c478bd9Sstevel@tonic-gate case 'l': /* long listing */ 4887c478bd9Sstevel@tonic-gate lflg++; 4897c478bd9Sstevel@tonic-gate break; 4907c478bd9Sstevel@tonic-gate case 'f': /* full listing */ 4917c478bd9Sstevel@tonic-gate fflg++; 4927c478bd9Sstevel@tonic-gate break; 4937c478bd9Sstevel@tonic-gate case 'j': 4947c478bd9Sstevel@tonic-gate jflg++; 4957c478bd9Sstevel@tonic-gate break; 4967c478bd9Sstevel@tonic-gate case 'c': 4977c478bd9Sstevel@tonic-gate /* 4987c478bd9Sstevel@tonic-gate * Format output to reflect scheduler changes: 4997c478bd9Sstevel@tonic-gate * high numbers for high priorities and don't 5007c478bd9Sstevel@tonic-gate * print nice or p_cpu values. 'c' option only 5017c478bd9Sstevel@tonic-gate * effective when used with 'l' or 'f' options. 5027c478bd9Sstevel@tonic-gate */ 5037c478bd9Sstevel@tonic-gate cflg++; 5047c478bd9Sstevel@tonic-gate break; 5057c478bd9Sstevel@tonic-gate case 'A': /* list every process */ 5067c478bd9Sstevel@tonic-gate case 'e': /* (obsolete) list every process */ 5077c478bd9Sstevel@tonic-gate Aflg++; 5087c478bd9Sstevel@tonic-gate tflg = Gflg = Uflg = uflg = pflg = gflg = sflg = 0; 509c6402783Sakolb zflg = hflg = 0; 5107c478bd9Sstevel@tonic-gate break; 5117c478bd9Sstevel@tonic-gate case 'a': 5127c478bd9Sstevel@tonic-gate /* 5137c478bd9Sstevel@tonic-gate * Same as 'e' except no session group leaders 5147c478bd9Sstevel@tonic-gate * and no non-terminal processes. 5157c478bd9Sstevel@tonic-gate */ 5167c478bd9Sstevel@tonic-gate aflg++; 5177c478bd9Sstevel@tonic-gate break; 5187c478bd9Sstevel@tonic-gate case 'd': /* same as e except no session leaders */ 5197c478bd9Sstevel@tonic-gate dflg++; 5207c478bd9Sstevel@tonic-gate break; 5217c478bd9Sstevel@tonic-gate case 'L': /* show lwps */ 5227c478bd9Sstevel@tonic-gate Lflg++; 5237c478bd9Sstevel@tonic-gate break; 5247c478bd9Sstevel@tonic-gate case 'P': /* show bound processor */ 5257c478bd9Sstevel@tonic-gate Pflg++; 5267c478bd9Sstevel@tonic-gate break; 5270a1278f2SGary Mills case 'W': /* truncate long names */ 5280a1278f2SGary Mills Wflg++; 5290a1278f2SGary Mills break; 5307c478bd9Sstevel@tonic-gate case 'y': /* omit F & ADDR, report RSS & SZ in Kby */ 5317c478bd9Sstevel@tonic-gate yflg++; 5327c478bd9Sstevel@tonic-gate break; 5337c478bd9Sstevel@tonic-gate case 'n': /* no longer needed; retain as no-op */ 5347c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5357c478bd9Sstevel@tonic-gate gettext("ps: warning: -n option ignored\n")); 5367c478bd9Sstevel@tonic-gate break; 5377c478bd9Sstevel@tonic-gate case 't': /* terminals */ 5387c478bd9Sstevel@tonic-gate #define TSZ 30 5397c478bd9Sstevel@tonic-gate tflg++; 5407c478bd9Sstevel@tonic-gate p1 = optarg; 5417c478bd9Sstevel@tonic-gate do { 5427c478bd9Sstevel@tonic-gate char nambuf[TSZ+6]; /* for "/dev/" + '\0' */ 5437c478bd9Sstevel@tonic-gate struct stat64 s; 5447c478bd9Sstevel@tonic-gate parg = getarg(&p1); 5457c478bd9Sstevel@tonic-gate p = Realloc(NULL, TSZ+1); /* for '\0' */ 5467c478bd9Sstevel@tonic-gate /* zero the buffer before using it */ 5477c478bd9Sstevel@tonic-gate p[0] = '\0'; 5487c478bd9Sstevel@tonic-gate size = TSZ; 5497c478bd9Sstevel@tonic-gate if (isdigit(*parg)) { 5507c478bd9Sstevel@tonic-gate (void) strcpy(p, "tty"); 5517c478bd9Sstevel@tonic-gate size -= 3; 5527c478bd9Sstevel@tonic-gate } 5537c478bd9Sstevel@tonic-gate (void) strncat(p, parg, size); 5547c478bd9Sstevel@tonic-gate if (ntty == ttysz) { 5557c478bd9Sstevel@tonic-gate if ((ttysz *= 2) == 0) 5567c478bd9Sstevel@tonic-gate ttysz = NTTYS; 5577c478bd9Sstevel@tonic-gate tty = Realloc(tty, 5587c478bd9Sstevel@tonic-gate (ttysz + 1) * sizeof (struct tty)); 5597c478bd9Sstevel@tonic-gate } 5607c478bd9Sstevel@tonic-gate tty[ntty].tdev = PRNODEV; 5617c478bd9Sstevel@tonic-gate (void) strcpy(nambuf, "/dev/"); 5627c478bd9Sstevel@tonic-gate (void) strcat(nambuf, p); 5637c478bd9Sstevel@tonic-gate if (stat64(nambuf, &s) == 0) 5647c478bd9Sstevel@tonic-gate tty[ntty].tdev = s.st_rdev; 5657c478bd9Sstevel@tonic-gate tty[ntty++].tname = p; 5667c478bd9Sstevel@tonic-gate } while (*p1); 5677c478bd9Sstevel@tonic-gate break; 5687c478bd9Sstevel@tonic-gate case 'p': /* proc ids */ 5697c478bd9Sstevel@tonic-gate pflg++; 5707c478bd9Sstevel@tonic-gate p1 = optarg; 5717c478bd9Sstevel@tonic-gate do { 5727c478bd9Sstevel@tonic-gate pid_t id; 5737c478bd9Sstevel@tonic-gate 5747c478bd9Sstevel@tonic-gate parg = getarg(&p1); 5757c478bd9Sstevel@tonic-gate if ((ret = str2id(parg, &id, 0, maxpid)) != 0) { 5767c478bd9Sstevel@tonic-gate pgerrflg++; 5777c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5787c478bd9Sstevel@tonic-gate gettext("ps: %s "), parg); 5797c478bd9Sstevel@tonic-gate if (ret == EINVAL) 5807c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5817c478bd9Sstevel@tonic-gate gettext("is an invalid " 5827c478bd9Sstevel@tonic-gate "non-numeric argument")); 5837c478bd9Sstevel@tonic-gate else 5847c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5857c478bd9Sstevel@tonic-gate gettext("exceeds valid " 5867c478bd9Sstevel@tonic-gate "range")); 5877c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5887c478bd9Sstevel@tonic-gate gettext(" for -p option\n")); 5897c478bd9Sstevel@tonic-gate continue; 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate if (npid == pidsz) { 5937c478bd9Sstevel@tonic-gate if ((pidsz *= 2) == 0) 5947c478bd9Sstevel@tonic-gate pidsz = SIZ; 5957c478bd9Sstevel@tonic-gate pid = Realloc(pid, 5967c478bd9Sstevel@tonic-gate pidsz * sizeof (pid_t)); 5977c478bd9Sstevel@tonic-gate } 5987c478bd9Sstevel@tonic-gate pid[npid++] = id; 5997c478bd9Sstevel@tonic-gate } while (*p1); 6007c478bd9Sstevel@tonic-gate break; 6017c478bd9Sstevel@tonic-gate case 's': /* session */ 6027c478bd9Sstevel@tonic-gate sflg++; 6037c478bd9Sstevel@tonic-gate p1 = optarg; 6047c478bd9Sstevel@tonic-gate do { 6057c478bd9Sstevel@tonic-gate pid_t id; 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate parg = getarg(&p1); 6087c478bd9Sstevel@tonic-gate if ((ret = str2id(parg, &id, 0, maxpid)) != 0) { 6097c478bd9Sstevel@tonic-gate pgerrflg++; 6107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6117c478bd9Sstevel@tonic-gate gettext("ps: %s "), parg); 6127c478bd9Sstevel@tonic-gate if (ret == EINVAL) 6137c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6147c478bd9Sstevel@tonic-gate gettext("is an invalid " 6157c478bd9Sstevel@tonic-gate "non-numeric argument")); 6167c478bd9Sstevel@tonic-gate else 6177c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6187c478bd9Sstevel@tonic-gate gettext("exceeds valid " 6197c478bd9Sstevel@tonic-gate "range")); 6207c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6217c478bd9Sstevel@tonic-gate gettext(" for -s option\n")); 6227c478bd9Sstevel@tonic-gate continue; 6237c478bd9Sstevel@tonic-gate } 6247c478bd9Sstevel@tonic-gate 6257c478bd9Sstevel@tonic-gate if (nsessid == sessidsz) { 6267c478bd9Sstevel@tonic-gate if ((sessidsz *= 2) == 0) 6277c478bd9Sstevel@tonic-gate sessidsz = SIZ; 6287c478bd9Sstevel@tonic-gate sessid = Realloc(sessid, 6297c478bd9Sstevel@tonic-gate sessidsz * sizeof (pid_t)); 6307c478bd9Sstevel@tonic-gate } 6317c478bd9Sstevel@tonic-gate sessid[nsessid++] = id; 6327c478bd9Sstevel@tonic-gate } while (*p1); 6337c478bd9Sstevel@tonic-gate break; 6347c478bd9Sstevel@tonic-gate case 'g': /* proc group */ 6357c478bd9Sstevel@tonic-gate gflg++; 6367c478bd9Sstevel@tonic-gate p1 = optarg; 6377c478bd9Sstevel@tonic-gate do { 6387c478bd9Sstevel@tonic-gate pid_t id; 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate parg = getarg(&p1); 6417c478bd9Sstevel@tonic-gate if ((ret = str2id(parg, &id, 0, maxpid)) != 0) { 6427c478bd9Sstevel@tonic-gate pgerrflg++; 6437c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6447c478bd9Sstevel@tonic-gate gettext("ps: %s "), parg); 6457c478bd9Sstevel@tonic-gate if (ret == EINVAL) 6467c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6477c478bd9Sstevel@tonic-gate gettext("is an invalid " 6487c478bd9Sstevel@tonic-gate "non-numeric argument")); 6497c478bd9Sstevel@tonic-gate else 6507c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6517c478bd9Sstevel@tonic-gate gettext("exceeds valid " 6527c478bd9Sstevel@tonic-gate "range")); 6537c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6547c478bd9Sstevel@tonic-gate gettext(" for -g option\n")); 6557c478bd9Sstevel@tonic-gate continue; 6567c478bd9Sstevel@tonic-gate } 6577c478bd9Sstevel@tonic-gate 6587c478bd9Sstevel@tonic-gate if (ngrpid == grpidsz) { 6597c478bd9Sstevel@tonic-gate if ((grpidsz *= 2) == 0) 6607c478bd9Sstevel@tonic-gate grpidsz = SIZ; 6617c478bd9Sstevel@tonic-gate grpid = Realloc(grpid, 6627c478bd9Sstevel@tonic-gate grpidsz * sizeof (pid_t)); 6637c478bd9Sstevel@tonic-gate } 6647c478bd9Sstevel@tonic-gate grpid[ngrpid++] = id; 6657c478bd9Sstevel@tonic-gate } while (*p1); 6667c478bd9Sstevel@tonic-gate break; 6677c478bd9Sstevel@tonic-gate case 'u': /* effective user name or number */ 6687c478bd9Sstevel@tonic-gate uflg++; 6697c478bd9Sstevel@tonic-gate p1 = optarg; 6707c478bd9Sstevel@tonic-gate do { 6717c478bd9Sstevel@tonic-gate parg = getarg(&p1); 6727c478bd9Sstevel@tonic-gate add_ugentry(&euid_tbl, parg); 6737c478bd9Sstevel@tonic-gate } while (*p1); 6747c478bd9Sstevel@tonic-gate break; 6757c478bd9Sstevel@tonic-gate case 'U': /* real user name or number */ 6767c478bd9Sstevel@tonic-gate Uflg++; 6777c478bd9Sstevel@tonic-gate p1 = optarg; 6787c478bd9Sstevel@tonic-gate do { 6797c478bd9Sstevel@tonic-gate parg = getarg(&p1); 6807c478bd9Sstevel@tonic-gate add_ugentry(&ruid_tbl, parg); 6817c478bd9Sstevel@tonic-gate } while (*p1); 6827c478bd9Sstevel@tonic-gate break; 6837c478bd9Sstevel@tonic-gate case 'G': /* real group name or number */ 6847c478bd9Sstevel@tonic-gate Gflg++; 6857c478bd9Sstevel@tonic-gate p1 = optarg; 6867c478bd9Sstevel@tonic-gate do { 6877c478bd9Sstevel@tonic-gate parg = getarg(&p1); 6887c478bd9Sstevel@tonic-gate add_ugentry(&rgid_tbl, parg); 6897c478bd9Sstevel@tonic-gate } while (*p1); 6907c478bd9Sstevel@tonic-gate break; 6917c478bd9Sstevel@tonic-gate case 'o': /* output format */ 6927c478bd9Sstevel@tonic-gate p = optarg; 6937c478bd9Sstevel@tonic-gate while ((p = parse_format(p)) != NULL) 6947c478bd9Sstevel@tonic-gate ; 6957c478bd9Sstevel@tonic-gate break; 6967c478bd9Sstevel@tonic-gate case 'z': /* zone name or number */ 6977c478bd9Sstevel@tonic-gate zflg++; 6987c478bd9Sstevel@tonic-gate p1 = optarg; 6997c478bd9Sstevel@tonic-gate do { 7007c478bd9Sstevel@tonic-gate zoneid_t id; 7017c478bd9Sstevel@tonic-gate 7027c478bd9Sstevel@tonic-gate parg = getarg(&p1); 7037c478bd9Sstevel@tonic-gate if (zone_get_id(parg, &id) != 0) { 7047c478bd9Sstevel@tonic-gate pgerrflg++; 7057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7067c478bd9Sstevel@tonic-gate gettext("ps: unknown zone %s\n"), 7077c478bd9Sstevel@tonic-gate parg); 7087c478bd9Sstevel@tonic-gate continue; 7097c478bd9Sstevel@tonic-gate } 7107c478bd9Sstevel@tonic-gate 7117c478bd9Sstevel@tonic-gate if (nzoneid == zoneidsz) { 7127c478bd9Sstevel@tonic-gate if ((zoneidsz *= 2) == 0) 7137c478bd9Sstevel@tonic-gate zoneidsz = SIZ; 7147c478bd9Sstevel@tonic-gate zoneid = Realloc(zoneid, 7157c478bd9Sstevel@tonic-gate zoneidsz * sizeof (zoneid_t)); 7167c478bd9Sstevel@tonic-gate } 7177c478bd9Sstevel@tonic-gate zoneid[nzoneid++] = id; 7187c478bd9Sstevel@tonic-gate } while (*p1); 7197c478bd9Sstevel@tonic-gate break; 7207c478bd9Sstevel@tonic-gate case 'Z': /* show zone name */ 7217c478bd9Sstevel@tonic-gate Zflg++; 7227c478bd9Sstevel@tonic-gate break; 7237c478bd9Sstevel@tonic-gate default: /* error on ? */ 7247c478bd9Sstevel@tonic-gate errflg++; 7257c478bd9Sstevel@tonic-gate break; 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate if (errflg || optind < argc || pgerrflg) 7297c478bd9Sstevel@tonic-gate usage(); 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate if (tflg) 7327c478bd9Sstevel@tonic-gate tty[ntty].tname = NULL; 7337c478bd9Sstevel@tonic-gate /* 7347c478bd9Sstevel@tonic-gate * If an appropriate option has not been specified, use the 7357c478bd9Sstevel@tonic-gate * current terminal and effective uid as the default. 7367c478bd9Sstevel@tonic-gate */ 737c6402783Sakolb if (!(aflg|Aflg|dflg|Gflg|hflg|Uflg|uflg|tflg|pflg|gflg|sflg|zflg)) { 7387c478bd9Sstevel@tonic-gate psinfo_t info; 7397c478bd9Sstevel@tonic-gate int procfd; 7407c478bd9Sstevel@tonic-gate char *name; 7417c478bd9Sstevel@tonic-gate char pname[100]; 7427c478bd9Sstevel@tonic-gate 7437c478bd9Sstevel@tonic-gate /* get our own controlling tty name using /proc */ 7447c478bd9Sstevel@tonic-gate (void) snprintf(pname, sizeof (pname), 7457c478bd9Sstevel@tonic-gate "%s/self/psinfo", procdir); 7467c478bd9Sstevel@tonic-gate if ((procfd = open(pname, O_RDONLY)) < 0 || 7477c478bd9Sstevel@tonic-gate read(procfd, (char *)&info, sizeof (info)) < 0 || 7487c478bd9Sstevel@tonic-gate info.pr_ttydev == PRNODEV) { 7497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7507c478bd9Sstevel@tonic-gate gettext("ps: no controlling terminal\n")); 7517c478bd9Sstevel@tonic-gate exit(1); 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate (void) close(procfd); 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate i = 0; 7567c478bd9Sstevel@tonic-gate name = gettty(&info); 7577c478bd9Sstevel@tonic-gate if (*name == '?') { 7587c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7597c478bd9Sstevel@tonic-gate gettext("ps: can't find controlling terminal\n")); 7607c478bd9Sstevel@tonic-gate exit(1); 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate if (ntty == ttysz) { 7637c478bd9Sstevel@tonic-gate if ((ttysz *= 2) == 0) 7647c478bd9Sstevel@tonic-gate ttysz = NTTYS; 7657c478bd9Sstevel@tonic-gate tty = Realloc(tty, (ttysz + 1) * sizeof (struct tty)); 7667c478bd9Sstevel@tonic-gate } 7677c478bd9Sstevel@tonic-gate tty[ntty].tdev = info.pr_ttydev; 7687c478bd9Sstevel@tonic-gate tty[ntty++].tname = name; 7697c478bd9Sstevel@tonic-gate tty[ntty].tname = NULL; 7707c478bd9Sstevel@tonic-gate tflg++; 7717c478bd9Sstevel@tonic-gate tuid = getuid(); 7727c478bd9Sstevel@tonic-gate } 7737c478bd9Sstevel@tonic-gate if (Aflg) { 7747c478bd9Sstevel@tonic-gate Gflg = Uflg = uflg = pflg = sflg = gflg = aflg = dflg = 0; 775c6402783Sakolb zflg = hflg = 0; 7767c478bd9Sstevel@tonic-gate } 7777c478bd9Sstevel@tonic-gate if (Aflg | aflg | dflg) 7787c478bd9Sstevel@tonic-gate tflg = 0; 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate i = 0; /* prepare to exit on name lookup errors */ 7817c478bd9Sstevel@tonic-gate i += uconv(&euid_tbl); 7827c478bd9Sstevel@tonic-gate i += uconv(&ruid_tbl); 7837c478bd9Sstevel@tonic-gate i += gconv(&egid_tbl); 7847c478bd9Sstevel@tonic-gate i += gconv(&rgid_tbl); 7857c478bd9Sstevel@tonic-gate if (i) 7867c478bd9Sstevel@tonic-gate exit(1); 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate /* allocate a buffer for lwpsinfo structures */ 7897c478bd9Sstevel@tonic-gate lpbufsize = 4096; 7907c478bd9Sstevel@tonic-gate if (Lflg && (lpsinfobuf = malloc(lpbufsize)) == NULL) { 7917c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7927c478bd9Sstevel@tonic-gate gettext("ps: no memory\n")); 7937c478bd9Sstevel@tonic-gate exit(1); 7947c478bd9Sstevel@tonic-gate } 7957c478bd9Sstevel@tonic-gate 7967c478bd9Sstevel@tonic-gate if (fields) { /* print user-specified header */ 7977c478bd9Sstevel@tonic-gate if (do_header) { 7987c478bd9Sstevel@tonic-gate struct field *f; 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate for (f = fields; f != NULL; f = f->next) { 8017c478bd9Sstevel@tonic-gate if (f != fields) 8027c478bd9Sstevel@tonic-gate (void) printf(" "); 8037c478bd9Sstevel@tonic-gate switch (f->fname) { 8047c478bd9Sstevel@tonic-gate case F_TTY: 8057c478bd9Sstevel@tonic-gate (void) printf("%-*s", 8067c478bd9Sstevel@tonic-gate f->width, f->header); 8077c478bd9Sstevel@tonic-gate break; 808*ab618543SJohn Levon case F_LWPNAME: 8097c478bd9Sstevel@tonic-gate case F_FNAME: 8107c478bd9Sstevel@tonic-gate case F_COMM: 8117c478bd9Sstevel@tonic-gate case F_ARGS: 8127c478bd9Sstevel@tonic-gate /* 8137c478bd9Sstevel@tonic-gate * Print these headers full width 8147c478bd9Sstevel@tonic-gate * unless they appear at the end. 8157c478bd9Sstevel@tonic-gate */ 8167c478bd9Sstevel@tonic-gate if (f->next != NULL) { 8177c478bd9Sstevel@tonic-gate (void) printf("%-*s", 8187c478bd9Sstevel@tonic-gate f->width, f->header); 8197c478bd9Sstevel@tonic-gate } else { 8207c478bd9Sstevel@tonic-gate (void) printf("%s", 8217c478bd9Sstevel@tonic-gate f->header); 8227c478bd9Sstevel@tonic-gate } 8237c478bd9Sstevel@tonic-gate break; 8247c478bd9Sstevel@tonic-gate default: 8257c478bd9Sstevel@tonic-gate (void) printf("%*s", 8267c478bd9Sstevel@tonic-gate f->width, f->header); 8277c478bd9Sstevel@tonic-gate break; 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate } 8307c478bd9Sstevel@tonic-gate (void) printf("\n"); 8317c478bd9Sstevel@tonic-gate } 8327c478bd9Sstevel@tonic-gate } else { /* print standard header */ 833f5c9e9f9SCasper H.S. Dik /* 834f5c9e9f9SCasper H.S. Dik * All fields before 'PID' are printed with a trailing space 835f5c9e9f9SCasper H.S. Dik * as a separator and that is how we print the headers too. 836f5c9e9f9SCasper H.S. Dik */ 8377c478bd9Sstevel@tonic-gate if (lflg) { 8387c478bd9Sstevel@tonic-gate if (yflg) 839f5c9e9f9SCasper H.S. Dik (void) printf("S "); 8407c478bd9Sstevel@tonic-gate else 841f5c9e9f9SCasper H.S. Dik (void) printf(" F S "); 8427c478bd9Sstevel@tonic-gate } 8437c478bd9Sstevel@tonic-gate if (Zflg) 844f5c9e9f9SCasper H.S. Dik (void) printf(" ZONE "); 8457c478bd9Sstevel@tonic-gate if (fflg) { 846f5c9e9f9SCasper H.S. Dik (void) printf(" UID "); 8477c478bd9Sstevel@tonic-gate } else if (lflg) 848f5c9e9f9SCasper H.S. Dik (void) printf(" UID "); 8497c478bd9Sstevel@tonic-gate 850f5c9e9f9SCasper H.S. Dik (void) printf("%*s", pidwidth, "PID"); 8517c478bd9Sstevel@tonic-gate if (lflg || fflg) 8527c478bd9Sstevel@tonic-gate (void) printf(" %*s", pidwidth, "PPID"); 8537c478bd9Sstevel@tonic-gate if (jflg) 8547c478bd9Sstevel@tonic-gate (void) printf(" %*s %*s", pidwidth, "PGID", 8557c478bd9Sstevel@tonic-gate pidwidth, "SID"); 8567c478bd9Sstevel@tonic-gate if (Lflg) 8577c478bd9Sstevel@tonic-gate (void) printf(" LWP"); 8587c478bd9Sstevel@tonic-gate if (Pflg) 8597c478bd9Sstevel@tonic-gate (void) printf(" PSR"); 8607c478bd9Sstevel@tonic-gate if (Lflg && fflg) 8617c478bd9Sstevel@tonic-gate (void) printf(" NLWP"); 8627c478bd9Sstevel@tonic-gate if (cflg) 8637c478bd9Sstevel@tonic-gate (void) printf(" CLS PRI"); 8647c478bd9Sstevel@tonic-gate else if (lflg || fflg) { 8657c478bd9Sstevel@tonic-gate (void) printf(" C"); 8667c478bd9Sstevel@tonic-gate if (lflg) 8677c478bd9Sstevel@tonic-gate (void) printf(" PRI NI"); 8687c478bd9Sstevel@tonic-gate } 8697c478bd9Sstevel@tonic-gate if (lflg) { 8707c478bd9Sstevel@tonic-gate if (yflg) 8717c478bd9Sstevel@tonic-gate (void) printf(" RSS SZ WCHAN"); 8727c478bd9Sstevel@tonic-gate else 8737c478bd9Sstevel@tonic-gate (void) printf(" ADDR SZ WCHAN"); 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate if (fflg) 87616f94f58Ssayama (void) printf(" %s", loc_stime_str); 877c6402783Sakolb if (Hflg) 878c6402783Sakolb (void) printf(" LGRP"); 8797c478bd9Sstevel@tonic-gate if (Lflg) 8807c478bd9Sstevel@tonic-gate (void) printf(" TTY LTIME CMD\n"); 8817c478bd9Sstevel@tonic-gate else 8827c478bd9Sstevel@tonic-gate (void) printf(" TTY TIME CMD\n"); 8837c478bd9Sstevel@tonic-gate } 8847c478bd9Sstevel@tonic-gate 8857c478bd9Sstevel@tonic-gate 886c6402783Sakolb if (pflg && !(aflg|Aflg|dflg|Gflg|Uflg|uflg|hflg|tflg|gflg|sflg|zflg) && 8877c478bd9Sstevel@tonic-gate npid <= PTHRESHOLD) { 8887c478bd9Sstevel@tonic-gate /* 8897c478bd9Sstevel@tonic-gate * If we are looking at specific processes go straight 8907c478bd9Sstevel@tonic-gate * to their /proc entries and don't scan /proc. 8917c478bd9Sstevel@tonic-gate */ 8927c478bd9Sstevel@tonic-gate int i; 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate (void) qsort(pid, npid, sizeof (pid_t), pidcmp); 8957c478bd9Sstevel@tonic-gate for (i = 0; i < npid; i++) { 8967c478bd9Sstevel@tonic-gate char pname[12]; 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate if (i >= 1 && pid[i] == pid[i - 1]) 8997c478bd9Sstevel@tonic-gate continue; 9007c478bd9Sstevel@tonic-gate (void) sprintf(pname, "%d", (int)pid[i]); 9017c478bd9Sstevel@tonic-gate if (print_proc(pname) == 0) 9027c478bd9Sstevel@tonic-gate retcode = 0; 9037c478bd9Sstevel@tonic-gate } 9047c478bd9Sstevel@tonic-gate } else { 9057c478bd9Sstevel@tonic-gate /* 9067c478bd9Sstevel@tonic-gate * Determine which processes to print info about by searching 9077c478bd9Sstevel@tonic-gate * the /proc directory and looking at each process. 9087c478bd9Sstevel@tonic-gate */ 9097c478bd9Sstevel@tonic-gate if ((dirp = opendir(procdir)) == NULL) { 9107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 9117c478bd9Sstevel@tonic-gate gettext("ps: cannot open PROC directory %s\n"), 9127c478bd9Sstevel@tonic-gate procdir); 9137c478bd9Sstevel@tonic-gate exit(1); 9147c478bd9Sstevel@tonic-gate } 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate /* for each active process --- */ 917e503abb7SIgor Kozhukhov while ((dentp = readdir(dirp)) != NULL) { 9187c478bd9Sstevel@tonic-gate if (dentp->d_name[0] == '.') /* skip . and .. */ 9197c478bd9Sstevel@tonic-gate continue; 9207c478bd9Sstevel@tonic-gate if (print_proc(dentp->d_name) == 0) 9217c478bd9Sstevel@tonic-gate retcode = 0; 9227c478bd9Sstevel@tonic-gate } 9237c478bd9Sstevel@tonic-gate 9247c478bd9Sstevel@tonic-gate (void) closedir(dirp); 9257c478bd9Sstevel@tonic-gate } 9267c478bd9Sstevel@tonic-gate return (retcode); 9277c478bd9Sstevel@tonic-gate } 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate int 9317c478bd9Sstevel@tonic-gate print_proc(char *pid_name) 9327c478bd9Sstevel@tonic-gate { 9337c478bd9Sstevel@tonic-gate char pname[PATH_MAX]; 9347c478bd9Sstevel@tonic-gate int pdlen; 9357c478bd9Sstevel@tonic-gate int found; 9367c478bd9Sstevel@tonic-gate int procfd; /* filedescriptor for /proc/nnnnn/psinfo */ 9377c478bd9Sstevel@tonic-gate char *tp; /* ptr to ttyname, if any */ 9387c478bd9Sstevel@tonic-gate psinfo_t info; /* process information from /proc */ 9397c478bd9Sstevel@tonic-gate lwpsinfo_t *lwpsinfo; /* array of lwpsinfo structs */ 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate pdlen = snprintf(pname, sizeof (pname), "%s/%s/", procdir, pid_name); 9427c478bd9Sstevel@tonic-gate if (pdlen >= sizeof (pname) - 10) 9437c478bd9Sstevel@tonic-gate return (1); 9447c478bd9Sstevel@tonic-gate retry: 9457c478bd9Sstevel@tonic-gate (void) strcpy(&pname[pdlen], "psinfo"); 9467c478bd9Sstevel@tonic-gate if ((procfd = open(pname, O_RDONLY)) == -1) { 9477c478bd9Sstevel@tonic-gate /* Process may have exited meanwhile. */ 9487c478bd9Sstevel@tonic-gate return (1); 9497c478bd9Sstevel@tonic-gate } 9507c478bd9Sstevel@tonic-gate /* 9517c478bd9Sstevel@tonic-gate * Get the info structure for the process and close quickly. 9527c478bd9Sstevel@tonic-gate */ 9537c478bd9Sstevel@tonic-gate if (read(procfd, (char *)&info, sizeof (info)) < 0) { 9547c478bd9Sstevel@tonic-gate int saverr = errno; 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate (void) close(procfd); 9577c478bd9Sstevel@tonic-gate if (saverr == EAGAIN) 9587c478bd9Sstevel@tonic-gate goto retry; 9597c478bd9Sstevel@tonic-gate if (saverr != ENOENT) 9607c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 9617c478bd9Sstevel@tonic-gate gettext("ps: read() on %s: %s\n"), 9627c478bd9Sstevel@tonic-gate pname, err_string(saverr)); 9637c478bd9Sstevel@tonic-gate return (1); 9647c478bd9Sstevel@tonic-gate } 9657c478bd9Sstevel@tonic-gate (void) close(procfd); 9667c478bd9Sstevel@tonic-gate 9677c478bd9Sstevel@tonic-gate found = 0; 9687c478bd9Sstevel@tonic-gate if (info.pr_lwp.pr_state == 0) /* can't happen? */ 9697c478bd9Sstevel@tonic-gate return (1); 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate /* 9727c478bd9Sstevel@tonic-gate * Omit session group leaders for 'a' and 'd' options. 9737c478bd9Sstevel@tonic-gate */ 9747c478bd9Sstevel@tonic-gate if ((info.pr_pid == info.pr_sid) && (dflg || aflg)) 9757c478bd9Sstevel@tonic-gate return (1); 9767c478bd9Sstevel@tonic-gate if (Aflg || dflg) 9777c478bd9Sstevel@tonic-gate found++; 9787c478bd9Sstevel@tonic-gate else if (pflg && search(pid, npid, info.pr_pid)) 9797c478bd9Sstevel@tonic-gate found++; /* ppid in p option arg list */ 980f48205beScasper else if (uflg && ugfind((id_t)info.pr_euid, &euid_tbl)) 9817c478bd9Sstevel@tonic-gate found++; /* puid in u option arg list */ 982f48205beScasper else if (Uflg && ugfind((id_t)info.pr_uid, &ruid_tbl)) 9837c478bd9Sstevel@tonic-gate found++; /* puid in U option arg list */ 9847c478bd9Sstevel@tonic-gate #ifdef NOT_YET 985f48205beScasper else if (gflg && ugfind((id_t)info.pr_egid, &egid_tbl)) 9867c478bd9Sstevel@tonic-gate found++; /* pgid in g option arg list */ 9877c478bd9Sstevel@tonic-gate #endif /* NOT_YET */ 988f48205beScasper else if (Gflg && ugfind((id_t)info.pr_gid, &rgid_tbl)) 9897c478bd9Sstevel@tonic-gate found++; /* pgid in G option arg list */ 9907c478bd9Sstevel@tonic-gate else if (gflg && search(grpid, ngrpid, info.pr_pgid)) 9917c478bd9Sstevel@tonic-gate found++; /* grpid in g option arg list */ 9927c478bd9Sstevel@tonic-gate else if (sflg && search(sessid, nsessid, info.pr_sid)) 9937c478bd9Sstevel@tonic-gate found++; /* sessid in s option arg list */ 9947c478bd9Sstevel@tonic-gate else if (zflg && search(zoneid, nzoneid, info.pr_zoneid)) 9957c478bd9Sstevel@tonic-gate found++; /* zoneid in z option arg list */ 996c6402783Sakolb else if (hflg && search((pid_t *)lgrps, nlgrps, info.pr_lwp.pr_lgrp)) 997c6402783Sakolb found++; /* home lgroup in h option arg list */ 9987c478bd9Sstevel@tonic-gate if (!found && !tflg && !aflg) 9997c478bd9Sstevel@tonic-gate return (1); 10007c478bd9Sstevel@tonic-gate if (!prfind(found, &info, &tp)) 10017c478bd9Sstevel@tonic-gate return (1); 10027c478bd9Sstevel@tonic-gate if (Lflg && (info.pr_nlwp + info.pr_nzomb) > 1) { 10037c478bd9Sstevel@tonic-gate ssize_t prsz; 10047c478bd9Sstevel@tonic-gate 10057c478bd9Sstevel@tonic-gate (void) strcpy(&pname[pdlen], "lpsinfo"); 10067c478bd9Sstevel@tonic-gate if ((procfd = open(pname, O_RDONLY)) == -1) 10077c478bd9Sstevel@tonic-gate return (1); 10087c478bd9Sstevel@tonic-gate /* 10097c478bd9Sstevel@tonic-gate * Get the info structures for the lwps. 10107c478bd9Sstevel@tonic-gate */ 10117c478bd9Sstevel@tonic-gate prsz = read(procfd, lpsinfobuf, lpbufsize); 10127c478bd9Sstevel@tonic-gate if (prsz == -1) { 10137c478bd9Sstevel@tonic-gate int saverr = errno; 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate (void) close(procfd); 10167c478bd9Sstevel@tonic-gate if (saverr == EAGAIN) 10177c478bd9Sstevel@tonic-gate goto retry; 10187c478bd9Sstevel@tonic-gate if (saverr != ENOENT) 10197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 10207c478bd9Sstevel@tonic-gate gettext("ps: read() on %s: %s\n"), 10217c478bd9Sstevel@tonic-gate pname, err_string(saverr)); 10227c478bd9Sstevel@tonic-gate return (1); 10237c478bd9Sstevel@tonic-gate } 10247c478bd9Sstevel@tonic-gate (void) close(procfd); 10257c478bd9Sstevel@tonic-gate if (prsz == lpbufsize) { 10267c478bd9Sstevel@tonic-gate /* 10277c478bd9Sstevel@tonic-gate * buffer overflow. Realloc new buffer. 10287c478bd9Sstevel@tonic-gate * Error handling is done in Realloc(). 10297c478bd9Sstevel@tonic-gate */ 10307c478bd9Sstevel@tonic-gate lpbufsize *= 2; 10317c478bd9Sstevel@tonic-gate lpsinfobuf = Realloc(lpsinfobuf, lpbufsize); 10327c478bd9Sstevel@tonic-gate goto retry; 10337c478bd9Sstevel@tonic-gate } 10347c478bd9Sstevel@tonic-gate if (lpsinfobuf->pr_nent != (info.pr_nlwp + info.pr_nzomb)) 10357c478bd9Sstevel@tonic-gate goto retry; 10367c478bd9Sstevel@tonic-gate lwpsinfo = (lwpsinfo_t *)(lpsinfobuf + 1); 10377c478bd9Sstevel@tonic-gate } 10387c478bd9Sstevel@tonic-gate if (!Lflg || (info.pr_nlwp + info.pr_nzomb) <= 1) { 10397c478bd9Sstevel@tonic-gate prcom(&info, tp); 10407c478bd9Sstevel@tonic-gate } else { 10417c478bd9Sstevel@tonic-gate int nlwp = 0; 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate do { 10447c478bd9Sstevel@tonic-gate info.pr_lwp = *lwpsinfo; 10457c478bd9Sstevel@tonic-gate prcom(&info, tp); 10467c478bd9Sstevel@tonic-gate /* LINTED improper alignment */ 10477c478bd9Sstevel@tonic-gate lwpsinfo = (lwpsinfo_t *)((char *)lwpsinfo + 1048d21c64a5SDavid Edmondson lpsinfobuf->pr_entsize); 10497c478bd9Sstevel@tonic-gate } while (++nlwp < lpsinfobuf->pr_nent); 10507c478bd9Sstevel@tonic-gate } 10517c478bd9Sstevel@tonic-gate return (0); 10527c478bd9Sstevel@tonic-gate } 10537c478bd9Sstevel@tonic-gate 1054eaaa4d5fSBryan Cantrill static int 1055eaaa4d5fSBryan Cantrill field_cmp(const void *l, const void *r) 1056eaaa4d5fSBryan Cantrill { 1057eaaa4d5fSBryan Cantrill struct def_field *lhs = *((struct def_field **)l); 1058eaaa4d5fSBryan Cantrill struct def_field *rhs = *((struct def_field **)r); 1059eaaa4d5fSBryan Cantrill 1060eaaa4d5fSBryan Cantrill return (strcmp(lhs->fname, rhs->fname)); 1061eaaa4d5fSBryan Cantrill } 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate static void 10647c478bd9Sstevel@tonic-gate usage(void) /* print usage message and quit */ 10657c478bd9Sstevel@tonic-gate { 1066eaaa4d5fSBryan Cantrill struct def_field *df, *sorted[NFIELDS]; 1067eaaa4d5fSBryan Cantrill int pos = 80, i = 0; 1068eaaa4d5fSBryan Cantrill 10697c478bd9Sstevel@tonic-gate static char usage1[] = 10700a1278f2SGary Mills "ps [ -aAdefHlcjLPWyZ ] [ -o format ] [ -t termlist ]"; 10717c478bd9Sstevel@tonic-gate static char usage2[] = 10727c478bd9Sstevel@tonic-gate "\t[ -u userlist ] [ -U userlist ] [ -G grouplist ]"; 10737c478bd9Sstevel@tonic-gate static char usage3[] = 1074eaaa4d5fSBryan Cantrill "\t[ -p proclist ] [ -g pgrplist ] [ -s sidlist ]"; 10757c478bd9Sstevel@tonic-gate static char usage4[] = 1076eaaa4d5fSBryan Cantrill "\t[ -z zonelist ] [-h lgrplist]"; 10777c478bd9Sstevel@tonic-gate static char usage5[] = 1078eaaa4d5fSBryan Cantrill " 'format' is one or more of:"; 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 1081eaaa4d5fSBryan Cantrill gettext("usage: %s\n%s\n%s\n%s\n%s"), 10827c478bd9Sstevel@tonic-gate gettext(usage1), gettext(usage2), gettext(usage3), 1083eaaa4d5fSBryan Cantrill gettext(usage4), gettext(usage5)); 1084eaaa4d5fSBryan Cantrill 1085eaaa4d5fSBryan Cantrill /* 1086eaaa4d5fSBryan Cantrill * Now print out the possible output formats such that they neatly fit 1087eaaa4d5fSBryan Cantrill * into eighty columns. Note that the fact that we are determining 1088eaaa4d5fSBryan Cantrill * this output programmatically means that a gettext() is impossible -- 1089eaaa4d5fSBryan Cantrill * but it would be a mistake to localize the output formats anyway as 1090eaaa4d5fSBryan Cantrill * they are tokens for input, not output themselves. 1091eaaa4d5fSBryan Cantrill */ 1092eaaa4d5fSBryan Cantrill for (df = &fname[0]; df < &fname[NFIELDS]; df++) 1093eaaa4d5fSBryan Cantrill sorted[i++] = df; 1094eaaa4d5fSBryan Cantrill 1095eaaa4d5fSBryan Cantrill (void) qsort(sorted, NFIELDS, sizeof (void *), field_cmp); 1096eaaa4d5fSBryan Cantrill 1097eaaa4d5fSBryan Cantrill for (i = 0; i < NFIELDS; i++) { 1098eaaa4d5fSBryan Cantrill if (pos + strlen((df = sorted[i])->fname) + 1 >= 80) { 1099eaaa4d5fSBryan Cantrill (void) fprintf(stderr, "\n\t"); 1100eaaa4d5fSBryan Cantrill pos = 8; 1101eaaa4d5fSBryan Cantrill } 1102eaaa4d5fSBryan Cantrill 1103eaaa4d5fSBryan Cantrill (void) fprintf(stderr, "%s%s", pos > 8 ? " " : "", df->fname); 1104eaaa4d5fSBryan Cantrill pos += strlen(df->fname) + 1; 1105eaaa4d5fSBryan Cantrill } 1106eaaa4d5fSBryan Cantrill 1107eaaa4d5fSBryan Cantrill (void) fprintf(stderr, "\n"); 1108eaaa4d5fSBryan Cantrill 11097c478bd9Sstevel@tonic-gate exit(1); 11107c478bd9Sstevel@tonic-gate } 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate /* 11137c478bd9Sstevel@tonic-gate * getarg() finds the next argument in list and copies arg into argbuf. 11147c478bd9Sstevel@tonic-gate * p1 first pts to arg passed back from getopt routine. p1 is then 11157c478bd9Sstevel@tonic-gate * bumped to next character that is not a comma or blank -- p1 NULL 11167c478bd9Sstevel@tonic-gate * indicates end of list. 11177c478bd9Sstevel@tonic-gate */ 11187c478bd9Sstevel@tonic-gate static char * 11197c478bd9Sstevel@tonic-gate getarg(char **pp1) 11207c478bd9Sstevel@tonic-gate { 11217c478bd9Sstevel@tonic-gate static char argbuf[ARGSIZ]; 11227c478bd9Sstevel@tonic-gate char *p1 = *pp1; 11237c478bd9Sstevel@tonic-gate char *parga = argbuf; 11247c478bd9Sstevel@tonic-gate int c; 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate while ((c = *p1) != '\0' && (c == ',' || isspace(c))) 11277c478bd9Sstevel@tonic-gate p1++; 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate while ((c = *p1) != '\0' && c != ',' && !isspace(c)) { 11307c478bd9Sstevel@tonic-gate if (parga < argbuf + ARGSIZ - 1) 11317c478bd9Sstevel@tonic-gate *parga++ = c; 11327c478bd9Sstevel@tonic-gate p1++; 11337c478bd9Sstevel@tonic-gate } 11347c478bd9Sstevel@tonic-gate *parga = '\0'; 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate while ((c = *p1) != '\0' && (c == ',' || isspace(c))) 11377c478bd9Sstevel@tonic-gate p1++; 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate *pp1 = p1; 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate return (argbuf); 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate /* 11457c478bd9Sstevel@tonic-gate * parse_format() takes the argument to the -o option, 11467c478bd9Sstevel@tonic-gate * sets up the next output field structure, and returns 11477c478bd9Sstevel@tonic-gate * a pointer to any further output field specifier(s). 11487c478bd9Sstevel@tonic-gate * As a side-effect, it increments errflg if encounters a format error. 11497c478bd9Sstevel@tonic-gate */ 11507c478bd9Sstevel@tonic-gate static char * 11517c478bd9Sstevel@tonic-gate parse_format(char *arg) 11527c478bd9Sstevel@tonic-gate { 11537c478bd9Sstevel@tonic-gate int c; 11547c478bd9Sstevel@tonic-gate char *name; 11557c478bd9Sstevel@tonic-gate char *header = NULL; 11567c478bd9Sstevel@tonic-gate int width = 0; 11577c478bd9Sstevel@tonic-gate struct def_field *df; 11587c478bd9Sstevel@tonic-gate struct field *f; 11597c478bd9Sstevel@tonic-gate 11607c478bd9Sstevel@tonic-gate while ((c = *arg) != '\0' && (c == ',' || isspace(c))) 11617c478bd9Sstevel@tonic-gate arg++; 11627c478bd9Sstevel@tonic-gate if (c == '\0') 11637c478bd9Sstevel@tonic-gate return (NULL); 11647c478bd9Sstevel@tonic-gate name = arg; 11657c478bd9Sstevel@tonic-gate arg = strpbrk(arg, " \t\r\v\f\n,="); 11667c478bd9Sstevel@tonic-gate if (arg != NULL) { 11677c478bd9Sstevel@tonic-gate c = *arg; 11687c478bd9Sstevel@tonic-gate *arg++ = '\0'; 11697c478bd9Sstevel@tonic-gate if (c == '=') { 11707c478bd9Sstevel@tonic-gate char *s; 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate header = arg; 11737c478bd9Sstevel@tonic-gate arg = NULL; 11747c478bd9Sstevel@tonic-gate width = strlen(header); 11757c478bd9Sstevel@tonic-gate s = header + width; 11767c478bd9Sstevel@tonic-gate while (s > header && isspace(*--s)) 11777c478bd9Sstevel@tonic-gate *s = '\0'; 11787c478bd9Sstevel@tonic-gate while (isspace(*header)) 11797c478bd9Sstevel@tonic-gate header++; 11807c478bd9Sstevel@tonic-gate } 11817c478bd9Sstevel@tonic-gate } 11827c478bd9Sstevel@tonic-gate for (df = &fname[0]; df < &fname[NFIELDS]; df++) 11837c478bd9Sstevel@tonic-gate if (strcmp(name, df->fname) == 0) { 1184*ab618543SJohn Levon if (strcmp(name, "lwp") == 0 || 1185*ab618543SJohn Levon strcmp(name, "lwpname") == 0) 11867c478bd9Sstevel@tonic-gate Lflg++; 11877c478bd9Sstevel@tonic-gate break; 11887c478bd9Sstevel@tonic-gate } 11897c478bd9Sstevel@tonic-gate if (df >= &fname[NFIELDS]) { 11907c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 1191d21c64a5SDavid Edmondson gettext("ps: unknown output format: -o %s\n"), 1192d21c64a5SDavid Edmondson name); 11937c478bd9Sstevel@tonic-gate errflg++; 11947c478bd9Sstevel@tonic-gate return (arg); 11957c478bd9Sstevel@tonic-gate } 11967c478bd9Sstevel@tonic-gate if ((f = malloc(sizeof (*f))) == NULL) { 11977c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 11987c478bd9Sstevel@tonic-gate gettext("ps: malloc() for output format failed, %s\n"), 11997c478bd9Sstevel@tonic-gate err_string(errno)); 12007c478bd9Sstevel@tonic-gate exit(1); 12017c478bd9Sstevel@tonic-gate } 12027c478bd9Sstevel@tonic-gate f->next = NULL; 12037c478bd9Sstevel@tonic-gate f->fname = df - &fname[0]; 12047c478bd9Sstevel@tonic-gate f->header = header? header : df->header; 12057c478bd9Sstevel@tonic-gate if (width == 0) 12067c478bd9Sstevel@tonic-gate width = df->width; 12077c478bd9Sstevel@tonic-gate if (*f->header != '\0') 12087c478bd9Sstevel@tonic-gate do_header = 1; 12097c478bd9Sstevel@tonic-gate f->width = max(width, df->minwidth); 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate if (fields == NULL) 12127c478bd9Sstevel@tonic-gate fields = last_field = f; 12137c478bd9Sstevel@tonic-gate else { 12147c478bd9Sstevel@tonic-gate last_field->next = f; 12157c478bd9Sstevel@tonic-gate last_field = f; 12167c478bd9Sstevel@tonic-gate } 12177c478bd9Sstevel@tonic-gate 12187c478bd9Sstevel@tonic-gate return (arg); 12197c478bd9Sstevel@tonic-gate } 12207c478bd9Sstevel@tonic-gate 12217c478bd9Sstevel@tonic-gate static char * 12227c478bd9Sstevel@tonic-gate devlookup(dev_t ddev) 12237c478bd9Sstevel@tonic-gate { 12247c478bd9Sstevel@tonic-gate struct devl *dp; 12257c478bd9Sstevel@tonic-gate int i; 12267c478bd9Sstevel@tonic-gate 12277c478bd9Sstevel@tonic-gate for (dp = devl, i = 0; i < ndev; dp++, i++) { 12287c478bd9Sstevel@tonic-gate if (dp->ddev == ddev) 12297c478bd9Sstevel@tonic-gate return (dp->dname); 12307c478bd9Sstevel@tonic-gate } 12317c478bd9Sstevel@tonic-gate return (NULL); 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate static char * 12357c478bd9Sstevel@tonic-gate devadd(char *name, dev_t ddev) 12367c478bd9Sstevel@tonic-gate { 12377c478bd9Sstevel@tonic-gate struct devl *dp; 12387c478bd9Sstevel@tonic-gate int leng, start, i; 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate if (ndev == maxdev) { 12417c478bd9Sstevel@tonic-gate maxdev += DNINCR; 12427c478bd9Sstevel@tonic-gate devl = Realloc(devl, maxdev * sizeof (struct devl)); 12437c478bd9Sstevel@tonic-gate } 12447c478bd9Sstevel@tonic-gate dp = &devl[ndev++]; 12457c478bd9Sstevel@tonic-gate 12467c478bd9Sstevel@tonic-gate dp->ddev = ddev; 12477c478bd9Sstevel@tonic-gate if (name == NULL) { 12487c478bd9Sstevel@tonic-gate (void) strcpy(dp->dname, "??"); 12497c478bd9Sstevel@tonic-gate return (dp->dname); 12507c478bd9Sstevel@tonic-gate } 12517c478bd9Sstevel@tonic-gate 12527c478bd9Sstevel@tonic-gate leng = strlen(name); 12537c478bd9Sstevel@tonic-gate /* Strip off /dev/ */ 12547c478bd9Sstevel@tonic-gate if (leng < DNSIZE + 4) 12557c478bd9Sstevel@tonic-gate (void) strcpy(dp->dname, &name[5]); 12567c478bd9Sstevel@tonic-gate else { 12577c478bd9Sstevel@tonic-gate start = leng - DNSIZE - 1; 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate for (i = start; i < leng && name[i] != '/'; i++) 12607c478bd9Sstevel@tonic-gate ; 12617c478bd9Sstevel@tonic-gate if (i == leng) 12627c478bd9Sstevel@tonic-gate (void) strncpy(dp->dname, &name[start], DNSIZE); 12637c478bd9Sstevel@tonic-gate else 12647c478bd9Sstevel@tonic-gate (void) strncpy(dp->dname, &name[i+1], DNSIZE); 12657c478bd9Sstevel@tonic-gate } 12667c478bd9Sstevel@tonic-gate return (dp->dname); 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate /* 12707c478bd9Sstevel@tonic-gate * gettty returns the user's tty number or ? if none. 12717c478bd9Sstevel@tonic-gate */ 12727c478bd9Sstevel@tonic-gate static char * 12737c478bd9Sstevel@tonic-gate gettty(psinfo_t *psinfo) 12747c478bd9Sstevel@tonic-gate { 12757c478bd9Sstevel@tonic-gate extern char *_ttyname_dev(dev_t, char *, size_t); 1276fba40a47SBryan Cantrill static zoneid_t zid = -1; 12777c478bd9Sstevel@tonic-gate char devname[TTYNAME_MAX]; 12787c478bd9Sstevel@tonic-gate char *retval; 12797c478bd9Sstevel@tonic-gate 1280fba40a47SBryan Cantrill if (zid == -1) 1281fba40a47SBryan Cantrill zid = getzoneid(); 1282fba40a47SBryan Cantrill 1283fba40a47SBryan Cantrill if (psinfo->pr_ttydev == PRNODEV || psinfo->pr_zoneid != zid) 12847c478bd9Sstevel@tonic-gate return ("?"); 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate if ((retval = devlookup(psinfo->pr_ttydev)) != NULL) 12877c478bd9Sstevel@tonic-gate return (retval); 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate retval = _ttyname_dev(psinfo->pr_ttydev, devname, sizeof (devname)); 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate return (devadd(retval, psinfo->pr_ttydev)); 12927c478bd9Sstevel@tonic-gate } 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate /* 12957c478bd9Sstevel@tonic-gate * Find the process's tty and return 1 if process is to be printed. 12967c478bd9Sstevel@tonic-gate */ 12977c478bd9Sstevel@tonic-gate static int 12987c478bd9Sstevel@tonic-gate prfind(int found, psinfo_t *psinfo, char **tpp) 12997c478bd9Sstevel@tonic-gate { 13007c478bd9Sstevel@tonic-gate char *tp; 13017c478bd9Sstevel@tonic-gate struct tty *ttyp; 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate if (psinfo->pr_nlwp == 0) { 13047c478bd9Sstevel@tonic-gate /* process is a zombie */ 13057c478bd9Sstevel@tonic-gate *tpp = "?"; 13067c478bd9Sstevel@tonic-gate if (tflg && !found) 13077c478bd9Sstevel@tonic-gate return (0); 13087c478bd9Sstevel@tonic-gate return (1); 13097c478bd9Sstevel@tonic-gate } 13107c478bd9Sstevel@tonic-gate 13117c478bd9Sstevel@tonic-gate /* 13127c478bd9Sstevel@tonic-gate * Get current terminal. If none ("?") and 'a' is set, don't print 13137c478bd9Sstevel@tonic-gate * info. If 't' is set, check if term is in list of desired terminals 13147c478bd9Sstevel@tonic-gate * and print it if it is. 13157c478bd9Sstevel@tonic-gate */ 13167c478bd9Sstevel@tonic-gate tp = gettty(psinfo); 13177c478bd9Sstevel@tonic-gate if (aflg && *tp == '?') { 13187c478bd9Sstevel@tonic-gate *tpp = tp; 13197c478bd9Sstevel@tonic-gate return (0); 13207c478bd9Sstevel@tonic-gate } 13217c478bd9Sstevel@tonic-gate if (tflg && !found) { 13227c478bd9Sstevel@tonic-gate int match = 0; 13237c478bd9Sstevel@tonic-gate char *other = NULL; 13247c478bd9Sstevel@tonic-gate for (ttyp = tty; ttyp->tname != NULL; ttyp++) { 13257c478bd9Sstevel@tonic-gate /* 13267c478bd9Sstevel@tonic-gate * Look for a name match 13277c478bd9Sstevel@tonic-gate */ 13287c478bd9Sstevel@tonic-gate if (strcmp(tp, ttyp->tname) == 0) { 13297c478bd9Sstevel@tonic-gate match = 1; 13307c478bd9Sstevel@tonic-gate break; 13317c478bd9Sstevel@tonic-gate } 13327c478bd9Sstevel@tonic-gate /* 13337c478bd9Sstevel@tonic-gate * Look for same device under different names. 13347c478bd9Sstevel@tonic-gate */ 13357c478bd9Sstevel@tonic-gate if ((other == NULL) && 13367c478bd9Sstevel@tonic-gate (ttyp->tdev != PRNODEV) && 13377c478bd9Sstevel@tonic-gate (psinfo->pr_ttydev == ttyp->tdev)) 13387c478bd9Sstevel@tonic-gate other = ttyp->tname; 13397c478bd9Sstevel@tonic-gate } 13407c478bd9Sstevel@tonic-gate if (!match && (other != NULL)) { 13417c478bd9Sstevel@tonic-gate /* 13427c478bd9Sstevel@tonic-gate * found under a different name 13437c478bd9Sstevel@tonic-gate */ 13447c478bd9Sstevel@tonic-gate match = 1; 13457c478bd9Sstevel@tonic-gate tp = other; 13467c478bd9Sstevel@tonic-gate } 1347f48205beScasper if (!match || (tuid != (uid_t)-1 && tuid != psinfo->pr_euid)) { 13487c478bd9Sstevel@tonic-gate /* 13497c478bd9Sstevel@tonic-gate * not found OR not matching euid 13507c478bd9Sstevel@tonic-gate */ 13517c478bd9Sstevel@tonic-gate *tpp = tp; 13527c478bd9Sstevel@tonic-gate return (0); 13537c478bd9Sstevel@tonic-gate } 13547c478bd9Sstevel@tonic-gate } 13557c478bd9Sstevel@tonic-gate *tpp = tp; 13567c478bd9Sstevel@tonic-gate return (1); 13577c478bd9Sstevel@tonic-gate } 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate /* 13607c478bd9Sstevel@tonic-gate * Print info about the process. 13617c478bd9Sstevel@tonic-gate */ 13627c478bd9Sstevel@tonic-gate static void 13637c478bd9Sstevel@tonic-gate prcom(psinfo_t *psinfo, char *ttyp) 13647c478bd9Sstevel@tonic-gate { 13657c478bd9Sstevel@tonic-gate char *cp; 13667c478bd9Sstevel@tonic-gate long tm; 13677c478bd9Sstevel@tonic-gate int bytesleft; 13687c478bd9Sstevel@tonic-gate int wcnt, length; 13697c478bd9Sstevel@tonic-gate wchar_t wchar; 13707c478bd9Sstevel@tonic-gate struct passwd *pwd; 13717c478bd9Sstevel@tonic-gate int zombie_lwp; 13727c478bd9Sstevel@tonic-gate char zonename[ZONENAME_MAX]; 13737c478bd9Sstevel@tonic-gate 13747c478bd9Sstevel@tonic-gate /* 13757c478bd9Sstevel@tonic-gate * If process is zombie, call zombie print routine and return. 13767c478bd9Sstevel@tonic-gate */ 13777c478bd9Sstevel@tonic-gate if (psinfo->pr_nlwp == 0) { 13787c478bd9Sstevel@tonic-gate if (fields != NULL) 13797c478bd9Sstevel@tonic-gate pr_fields(psinfo, ttyp, print_zombie_field); 13807c478bd9Sstevel@tonic-gate else 13817c478bd9Sstevel@tonic-gate przom(psinfo); 13827c478bd9Sstevel@tonic-gate return; 13837c478bd9Sstevel@tonic-gate } 13847c478bd9Sstevel@tonic-gate 13857c478bd9Sstevel@tonic-gate zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z'); 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate /* 13887c478bd9Sstevel@tonic-gate * If user specified '-o format', print requested fields and return. 13897c478bd9Sstevel@tonic-gate */ 13907c478bd9Sstevel@tonic-gate if (fields != NULL) { 13917c478bd9Sstevel@tonic-gate pr_fields(psinfo, ttyp, print_field); 13927c478bd9Sstevel@tonic-gate return; 13937c478bd9Sstevel@tonic-gate } 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate /* 13967c478bd9Sstevel@tonic-gate * All fields before 'PID' are printed with a trailing space as a 1397f5c9e9f9SCasper H.S. Dik * separator, rather than keeping track of which column is first. All 13987c478bd9Sstevel@tonic-gate * other fields are printed with a leading space. 13997c478bd9Sstevel@tonic-gate */ 14007c478bd9Sstevel@tonic-gate if (lflg) { 14017c478bd9Sstevel@tonic-gate if (!yflg) 14027c478bd9Sstevel@tonic-gate (void) printf("%2x ", psinfo->pr_flag & 0377); /* F */ 14037c478bd9Sstevel@tonic-gate (void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */ 14047c478bd9Sstevel@tonic-gate } 14057c478bd9Sstevel@tonic-gate 14067c478bd9Sstevel@tonic-gate if (Zflg) { /* ZONE */ 14077c478bd9Sstevel@tonic-gate if (getzonenamebyid(psinfo->pr_zoneid, zonename, 14087c478bd9Sstevel@tonic-gate sizeof (zonename)) < 0) { 14090a1278f2SGary Mills if (snprintf(NULL, 0, "%d", 14100a1278f2SGary Mills ((int)psinfo->pr_zoneid)) > 7) 14110a1278f2SGary Mills (void) printf(" %6.6d%c ", 14120a1278f2SGary Mills ((int)psinfo->pr_zoneid), '*'); 14130a1278f2SGary Mills else 14140a1278f2SGary Mills (void) printf(" %7.7d ", 14150a1278f2SGary Mills ((int)psinfo->pr_zoneid)); 14167c478bd9Sstevel@tonic-gate } else { 14170a1278f2SGary Mills size_t nw; 14180a1278f2SGary Mills 14190a1278f2SGary Mills nw = mbstowcs(NULL, zonename, 0); 14200a1278f2SGary Mills if (nw == (size_t)-1) 14210a1278f2SGary Mills (void) printf("%8.8s ", "ERROR"); 14220a1278f2SGary Mills else if (nw > 8) 14230a1278f2SGary Mills (void) wprintf(L"%7.7s%c ", zonename, '*'); 14240a1278f2SGary Mills else 14250a1278f2SGary Mills (void) wprintf(L"%8.8s ", zonename); 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate } 14287c478bd9Sstevel@tonic-gate 14297c478bd9Sstevel@tonic-gate if (fflg) { /* UID */ 14300a1278f2SGary Mills if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) { 14310a1278f2SGary Mills size_t nw; 14320a1278f2SGary Mills 14330a1278f2SGary Mills nw = mbstowcs(NULL, pwd->pw_name, 0); 14340a1278f2SGary Mills if (nw == (size_t)-1) 14350a1278f2SGary Mills (void) printf("%8.8s ", "ERROR"); 14360a1278f2SGary Mills else if (nw > 8) 14370a1278f2SGary Mills (void) wprintf(L"%7.7s%c ", pwd->pw_name, '*'); 14380a1278f2SGary Mills else 14390a1278f2SGary Mills (void) wprintf(L"%8.8s ", pwd->pw_name); 14400a1278f2SGary Mills } else { 14410a1278f2SGary Mills if (snprintf(NULL, 0, "%u", 14420a1278f2SGary Mills (psinfo->pr_euid)) > 7) 14430a1278f2SGary Mills (void) printf(" %6.6u%c ", psinfo->pr_euid, 14440a1278f2SGary Mills '*'); 14450a1278f2SGary Mills else 14460a1278f2SGary Mills (void) printf(" %7.7u ", psinfo->pr_euid); 14470a1278f2SGary Mills } 14487c478bd9Sstevel@tonic-gate } else if (lflg) { 14490a1278f2SGary Mills if (snprintf(NULL, 0, "%u", (psinfo->pr_euid)) > 6) 14500a1278f2SGary Mills (void) printf("%5.5u%c ", psinfo->pr_euid, '*'); 14510a1278f2SGary Mills else 14520a1278f2SGary Mills (void) printf("%6u ", psinfo->pr_euid); 14537c478bd9Sstevel@tonic-gate } 14547c478bd9Sstevel@tonic-gate (void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */ 14557c478bd9Sstevel@tonic-gate if (lflg || fflg) 14567c478bd9Sstevel@tonic-gate (void) printf(" %*d", pidwidth, 14577c478bd9Sstevel@tonic-gate (int)psinfo->pr_ppid); /* PPID */ 14587c478bd9Sstevel@tonic-gate if (jflg) { 14597c478bd9Sstevel@tonic-gate (void) printf(" %*d", pidwidth, 14607c478bd9Sstevel@tonic-gate (int)psinfo->pr_pgid); /* PGID */ 14617c478bd9Sstevel@tonic-gate (void) printf(" %*d", pidwidth, 14627c478bd9Sstevel@tonic-gate (int)psinfo->pr_sid); /* SID */ 14637c478bd9Sstevel@tonic-gate } 14647c478bd9Sstevel@tonic-gate if (Lflg) 14657c478bd9Sstevel@tonic-gate (void) printf(" %5d", (int)psinfo->pr_lwp.pr_lwpid); /* LWP */ 14667c478bd9Sstevel@tonic-gate if (Pflg) { 14677c478bd9Sstevel@tonic-gate if (psinfo->pr_lwp.pr_bindpro == PBIND_NONE) /* PSR */ 14687c478bd9Sstevel@tonic-gate (void) printf(" -"); 14697c478bd9Sstevel@tonic-gate else 14707c478bd9Sstevel@tonic-gate (void) printf(" %3d", psinfo->pr_lwp.pr_bindpro); 14717c478bd9Sstevel@tonic-gate } 14727c478bd9Sstevel@tonic-gate if (Lflg && fflg) /* NLWP */ 14737c478bd9Sstevel@tonic-gate (void) printf(" %5d", psinfo->pr_nlwp + psinfo->pr_nzomb); 14747c478bd9Sstevel@tonic-gate if (cflg) { 14757c478bd9Sstevel@tonic-gate if (zombie_lwp) /* CLS */ 14767c478bd9Sstevel@tonic-gate (void) printf(" "); 14777c478bd9Sstevel@tonic-gate else 14787c478bd9Sstevel@tonic-gate (void) printf(" %4s", psinfo->pr_lwp.pr_clname); 14797c478bd9Sstevel@tonic-gate (void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */ 14807c478bd9Sstevel@tonic-gate } else if (lflg || fflg) { 14817c478bd9Sstevel@tonic-gate (void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */ 14827c478bd9Sstevel@tonic-gate if (lflg) { /* PRI NI */ 14837c478bd9Sstevel@tonic-gate /* 14847c478bd9Sstevel@tonic-gate * Print priorities the old way (lower numbers 14857c478bd9Sstevel@tonic-gate * mean higher priority) and print nice value 14867c478bd9Sstevel@tonic-gate * for time sharing procs. 14877c478bd9Sstevel@tonic-gate */ 14887c478bd9Sstevel@tonic-gate (void) printf(" %3d", psinfo->pr_lwp.pr_oldpri); 14897c478bd9Sstevel@tonic-gate if (psinfo->pr_lwp.pr_oldpri != 0) 14907c478bd9Sstevel@tonic-gate (void) printf(" %2d", psinfo->pr_lwp.pr_nice); 14917c478bd9Sstevel@tonic-gate else 14927c478bd9Sstevel@tonic-gate (void) printf(" %2.2s", 14937c478bd9Sstevel@tonic-gate psinfo->pr_lwp.pr_clname); 14947c478bd9Sstevel@tonic-gate } 14957c478bd9Sstevel@tonic-gate } 14967c478bd9Sstevel@tonic-gate if (lflg) { 14977c478bd9Sstevel@tonic-gate if (yflg) { 14987c478bd9Sstevel@tonic-gate if (psinfo->pr_flag & SSYS) /* RSS */ 14997c478bd9Sstevel@tonic-gate (void) printf(" 0"); 15007c478bd9Sstevel@tonic-gate else if (psinfo->pr_rssize) 15017c478bd9Sstevel@tonic-gate (void) printf(" %5lu", 1502d21c64a5SDavid Edmondson (ulong_t)psinfo->pr_rssize); 15037c478bd9Sstevel@tonic-gate else 15047c478bd9Sstevel@tonic-gate (void) printf(" ?"); 15057c478bd9Sstevel@tonic-gate if (psinfo->pr_flag & SSYS) /* SZ */ 15067c478bd9Sstevel@tonic-gate (void) printf(" 0"); 15077c478bd9Sstevel@tonic-gate else if (psinfo->pr_size) 15087c478bd9Sstevel@tonic-gate (void) printf(" %6lu", 1509d21c64a5SDavid Edmondson (ulong_t)psinfo->pr_size); 15107c478bd9Sstevel@tonic-gate else 15117c478bd9Sstevel@tonic-gate (void) printf(" ?"); 15127c478bd9Sstevel@tonic-gate } else { 15137c478bd9Sstevel@tonic-gate #ifndef _LP64 15147c478bd9Sstevel@tonic-gate if (psinfo->pr_addr) /* ADDR */ 15157c478bd9Sstevel@tonic-gate (void) printf(" %8lx", 1516d21c64a5SDavid Edmondson (ulong_t)psinfo->pr_addr); 15177c478bd9Sstevel@tonic-gate else 15187c478bd9Sstevel@tonic-gate #endif 15197c478bd9Sstevel@tonic-gate (void) printf(" ?"); 15207c478bd9Sstevel@tonic-gate if (psinfo->pr_flag & SSYS) /* SZ */ 15217c478bd9Sstevel@tonic-gate (void) printf(" 0"); 15227c478bd9Sstevel@tonic-gate else if (psinfo->pr_size) 15237c478bd9Sstevel@tonic-gate (void) printf(" %6lu", 15247c478bd9Sstevel@tonic-gate (ulong_t)psinfo->pr_size / kbytes_per_page); 15257c478bd9Sstevel@tonic-gate else 15267c478bd9Sstevel@tonic-gate (void) printf(" ?"); 15277c478bd9Sstevel@tonic-gate } 15287c478bd9Sstevel@tonic-gate if (psinfo->pr_lwp.pr_sname != 'S') /* WCHAN */ 15297c478bd9Sstevel@tonic-gate (void) printf(" "); 15307c478bd9Sstevel@tonic-gate #ifndef _LP64 15317c478bd9Sstevel@tonic-gate else if (psinfo->pr_lwp.pr_wchan) 15327c478bd9Sstevel@tonic-gate (void) printf(" %8lx", 1533d21c64a5SDavid Edmondson (ulong_t)psinfo->pr_lwp.pr_wchan); 15347c478bd9Sstevel@tonic-gate #endif 15357c478bd9Sstevel@tonic-gate else 15367c478bd9Sstevel@tonic-gate (void) printf(" ?"); 15377c478bd9Sstevel@tonic-gate } 15387c478bd9Sstevel@tonic-gate if (fflg) { /* STIME */ 153916f94f58Ssayama int width = fname[F_STIME].width; 15407c478bd9Sstevel@tonic-gate if (Lflg) 154116f94f58Ssayama prtime(psinfo->pr_lwp.pr_start, width + 1, 1); 15427c478bd9Sstevel@tonic-gate else 154316f94f58Ssayama prtime(psinfo->pr_start, width + 1, 1); 15447c478bd9Sstevel@tonic-gate } 1545c6402783Sakolb 1546c6402783Sakolb if (Hflg) { 1547c6402783Sakolb /* Display home lgroup */ 1548c6402783Sakolb (void) printf(" %4d", (int)psinfo->pr_lwp.pr_lgrp); 1549c6402783Sakolb } 1550c6402783Sakolb 15517c478bd9Sstevel@tonic-gate (void) printf(" %-8.14s", ttyp); /* TTY */ 15527c478bd9Sstevel@tonic-gate if (Lflg) { 15537c478bd9Sstevel@tonic-gate tm = psinfo->pr_lwp.pr_time.tv_sec; 15547c478bd9Sstevel@tonic-gate if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000) 15557c478bd9Sstevel@tonic-gate tm++; 15567c478bd9Sstevel@tonic-gate } else { 15577c478bd9Sstevel@tonic-gate tm = psinfo->pr_time.tv_sec; 15587c478bd9Sstevel@tonic-gate if (psinfo->pr_time.tv_nsec > 500000000) 15597c478bd9Sstevel@tonic-gate tm++; 15607c478bd9Sstevel@tonic-gate } 15617c478bd9Sstevel@tonic-gate (void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* [L]TIME */ 15627c478bd9Sstevel@tonic-gate 15637c478bd9Sstevel@tonic-gate if (zombie_lwp) { 15647c478bd9Sstevel@tonic-gate (void) printf(" <defunct>\n"); 15657c478bd9Sstevel@tonic-gate return; 15667c478bd9Sstevel@tonic-gate } 15677c478bd9Sstevel@tonic-gate 15687c478bd9Sstevel@tonic-gate if (!fflg) { /* CMD */ 15697c478bd9Sstevel@tonic-gate wcnt = namencnt(psinfo->pr_fname, 16, 8); 15707c478bd9Sstevel@tonic-gate (void) printf(" %.*s\n", wcnt, psinfo->pr_fname); 15717c478bd9Sstevel@tonic-gate return; 15727c478bd9Sstevel@tonic-gate } 15737c478bd9Sstevel@tonic-gate 1574c6402783Sakolb 15757c478bd9Sstevel@tonic-gate /* 15767c478bd9Sstevel@tonic-gate * PRARGSZ == length of cmd arg string. 15777c478bd9Sstevel@tonic-gate */ 15787c478bd9Sstevel@tonic-gate psinfo->pr_psargs[PRARGSZ-1] = '\0'; 15797c478bd9Sstevel@tonic-gate bytesleft = PRARGSZ; 15807c478bd9Sstevel@tonic-gate for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) { 15817c478bd9Sstevel@tonic-gate length = mbtowc(&wchar, cp, MB_LEN_MAX); 15827c478bd9Sstevel@tonic-gate if (length == 0) 15837c478bd9Sstevel@tonic-gate break; 15847c478bd9Sstevel@tonic-gate if (length < 0 || !iswprint(wchar)) { 15857c478bd9Sstevel@tonic-gate if (length < 0) 15867c478bd9Sstevel@tonic-gate length = 1; 15877c478bd9Sstevel@tonic-gate if (bytesleft <= length) { 15887c478bd9Sstevel@tonic-gate *cp = '\0'; 15897c478bd9Sstevel@tonic-gate break; 15907c478bd9Sstevel@tonic-gate } 15917c478bd9Sstevel@tonic-gate /* omit the unprintable character */ 15927c478bd9Sstevel@tonic-gate (void) memmove(cp, cp+length, bytesleft-length); 15937c478bd9Sstevel@tonic-gate length = 0; 15947c478bd9Sstevel@tonic-gate } 15957c478bd9Sstevel@tonic-gate bytesleft -= length; 15967c478bd9Sstevel@tonic-gate } 15977c478bd9Sstevel@tonic-gate wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, lflg ? 35 : PRARGSZ); 15987c478bd9Sstevel@tonic-gate (void) printf(" %.*s\n", wcnt, psinfo->pr_psargs); 15997c478bd9Sstevel@tonic-gate } 16007c478bd9Sstevel@tonic-gate 16017c478bd9Sstevel@tonic-gate /* 16027c478bd9Sstevel@tonic-gate * Print percent from 16-bit binary fraction [0 .. 1] 16037c478bd9Sstevel@tonic-gate * Round up .01 to .1 to indicate some small percentage (the 0x7000 below). 16047c478bd9Sstevel@tonic-gate */ 16057c478bd9Sstevel@tonic-gate static void 16067c478bd9Sstevel@tonic-gate prtpct(ushort_t pct, int width) 16077c478bd9Sstevel@tonic-gate { 16087c478bd9Sstevel@tonic-gate uint_t value = pct; /* need 32 bits to compute with */ 16097c478bd9Sstevel@tonic-gate 16107c478bd9Sstevel@tonic-gate value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */ 16117c478bd9Sstevel@tonic-gate if (value >= 1000) 16127c478bd9Sstevel@tonic-gate value = 999; 16137c478bd9Sstevel@tonic-gate if ((width -= 2) < 2) 16147c478bd9Sstevel@tonic-gate width = 2; 16157c478bd9Sstevel@tonic-gate (void) printf("%*u.%u", width, value / 10, value % 10); 16167c478bd9Sstevel@tonic-gate } 16177c478bd9Sstevel@tonic-gate 16187c478bd9Sstevel@tonic-gate static void 16197c478bd9Sstevel@tonic-gate print_time(time_t tim, int width) 16207c478bd9Sstevel@tonic-gate { 16217c478bd9Sstevel@tonic-gate char buf[30]; 16227c478bd9Sstevel@tonic-gate time_t seconds; 16237c478bd9Sstevel@tonic-gate time_t minutes; 16247c478bd9Sstevel@tonic-gate time_t hours; 16257c478bd9Sstevel@tonic-gate time_t days; 16267c478bd9Sstevel@tonic-gate 16277c478bd9Sstevel@tonic-gate if (tim < 0) { 16287c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 16297c478bd9Sstevel@tonic-gate return; 16307c478bd9Sstevel@tonic-gate } 16317c478bd9Sstevel@tonic-gate 16327c478bd9Sstevel@tonic-gate seconds = tim % 60; 16337c478bd9Sstevel@tonic-gate tim /= 60; 16347c478bd9Sstevel@tonic-gate minutes = tim % 60; 16357c478bd9Sstevel@tonic-gate tim /= 60; 16367c478bd9Sstevel@tonic-gate hours = tim % 24; 16377c478bd9Sstevel@tonic-gate days = tim / 24; 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate if (days > 0) { 16407c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%ld-%2.2ld:%2.2ld:%2.2ld", 16417c478bd9Sstevel@tonic-gate days, hours, minutes, seconds); 16427c478bd9Sstevel@tonic-gate } else if (hours > 0) { 16437c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld:%2.2ld", 16447c478bd9Sstevel@tonic-gate hours, minutes, seconds); 16457c478bd9Sstevel@tonic-gate } else { 16467c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld", 16477c478bd9Sstevel@tonic-gate minutes, seconds); 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate 16507c478bd9Sstevel@tonic-gate (void) printf("%*s", width, buf); 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate static void 16547c478bd9Sstevel@tonic-gate print_field(psinfo_t *psinfo, struct field *f, const char *ttyp) 16557c478bd9Sstevel@tonic-gate { 16567c478bd9Sstevel@tonic-gate int width = f->width; 16577c478bd9Sstevel@tonic-gate struct passwd *pwd; 16587c478bd9Sstevel@tonic-gate struct group *grp; 16597c478bd9Sstevel@tonic-gate time_t cputime; 16607c478bd9Sstevel@tonic-gate int bytesleft; 16617c478bd9Sstevel@tonic-gate int wcnt; 16627c478bd9Sstevel@tonic-gate wchar_t wchar; 16637c478bd9Sstevel@tonic-gate char *cp; 16647c478bd9Sstevel@tonic-gate int length; 16657c478bd9Sstevel@tonic-gate ulong_t mask; 1666e503abb7SIgor Kozhukhov char c = '\0', *csave = NULL; 16677c478bd9Sstevel@tonic-gate int zombie_lwp; 16687c478bd9Sstevel@tonic-gate 16697c478bd9Sstevel@tonic-gate zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z'); 16707c478bd9Sstevel@tonic-gate 16717c478bd9Sstevel@tonic-gate switch (f->fname) { 16727c478bd9Sstevel@tonic-gate case F_RUSER: 16730a1278f2SGary Mills if ((pwd = getpwuid(psinfo->pr_uid)) != NULL) { 16740a1278f2SGary Mills size_t nw; 16750a1278f2SGary Mills 16760a1278f2SGary Mills nw = mbstowcs(NULL, pwd->pw_name, 0); 16770a1278f2SGary Mills if (nw == (size_t)-1) 16780a1278f2SGary Mills (void) printf("%*s ", width, "ERROR"); 16790a1278f2SGary Mills else if (Wflg && nw > width) 16800a1278f2SGary Mills (void) wprintf(L"%.*s%c", width - 1, 16810a1278f2SGary Mills pwd->pw_name, '*'); 16820a1278f2SGary Mills else 16830a1278f2SGary Mills (void) wprintf(L"%*s", width, pwd->pw_name); 16840a1278f2SGary Mills } else { 16850a1278f2SGary Mills if (Wflg && snprintf(NULL, 0, "%u", 16860a1278f2SGary Mills (psinfo->pr_uid)) > width) 16870a1278f2SGary Mills 16880a1278f2SGary Mills (void) printf("%*u%c", width - 1, 16890a1278f2SGary Mills psinfo->pr_uid, '*'); 16900a1278f2SGary Mills else 16910a1278f2SGary Mills (void) printf("%*u", width, psinfo->pr_uid); 16920a1278f2SGary Mills } 16937c478bd9Sstevel@tonic-gate break; 16947c478bd9Sstevel@tonic-gate case F_USER: 16950a1278f2SGary Mills if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) { 16960a1278f2SGary Mills size_t nw; 16970a1278f2SGary Mills 16980a1278f2SGary Mills nw = mbstowcs(NULL, pwd->pw_name, 0); 16990a1278f2SGary Mills if (nw == (size_t)-1) 17000a1278f2SGary Mills (void) printf("%*s ", width, "ERROR"); 17010a1278f2SGary Mills else if (Wflg && nw > width) 17020a1278f2SGary Mills (void) wprintf(L"%.*s%c", width - 1, 17030a1278f2SGary Mills pwd->pw_name, '*'); 17040a1278f2SGary Mills else 17050a1278f2SGary Mills (void) wprintf(L"%*s", width, pwd->pw_name); 17060a1278f2SGary Mills } else { 17070a1278f2SGary Mills if (Wflg && snprintf(NULL, 0, "%u", 17080a1278f2SGary Mills (psinfo->pr_euid)) > width) 17090a1278f2SGary Mills 17100a1278f2SGary Mills (void) printf("%*u%c", width - 1, 17110a1278f2SGary Mills psinfo->pr_euid, '*'); 17120a1278f2SGary Mills else 17130a1278f2SGary Mills (void) printf("%*u", width, psinfo->pr_euid); 17140a1278f2SGary Mills } 17157c478bd9Sstevel@tonic-gate break; 17167c478bd9Sstevel@tonic-gate case F_RGROUP: 17177c478bd9Sstevel@tonic-gate if ((grp = getgrgid(psinfo->pr_gid)) != NULL) 17187c478bd9Sstevel@tonic-gate (void) printf("%*s", width, grp->gr_name); 17197c478bd9Sstevel@tonic-gate else 1720f48205beScasper (void) printf("%*u", width, psinfo->pr_gid); 17217c478bd9Sstevel@tonic-gate break; 17227c478bd9Sstevel@tonic-gate case F_GROUP: 17237c478bd9Sstevel@tonic-gate if ((grp = getgrgid(psinfo->pr_egid)) != NULL) 17247c478bd9Sstevel@tonic-gate (void) printf("%*s", width, grp->gr_name); 17257c478bd9Sstevel@tonic-gate else 1726f48205beScasper (void) printf("%*u", width, psinfo->pr_egid); 17277c478bd9Sstevel@tonic-gate break; 17287c478bd9Sstevel@tonic-gate case F_RUID: 1729f48205beScasper (void) printf("%*u", width, psinfo->pr_uid); 17307c478bd9Sstevel@tonic-gate break; 17317c478bd9Sstevel@tonic-gate case F_UID: 1732f48205beScasper (void) printf("%*u", width, psinfo->pr_euid); 17337c478bd9Sstevel@tonic-gate break; 17347c478bd9Sstevel@tonic-gate case F_RGID: 1735f48205beScasper (void) printf("%*u", width, psinfo->pr_gid); 17367c478bd9Sstevel@tonic-gate break; 17377c478bd9Sstevel@tonic-gate case F_GID: 1738f48205beScasper (void) printf("%*u", width, psinfo->pr_egid); 17397c478bd9Sstevel@tonic-gate break; 17407c478bd9Sstevel@tonic-gate case F_PID: 17417c478bd9Sstevel@tonic-gate (void) printf("%*d", width, (int)psinfo->pr_pid); 17427c478bd9Sstevel@tonic-gate break; 17437c478bd9Sstevel@tonic-gate case F_PPID: 17447c478bd9Sstevel@tonic-gate (void) printf("%*d", width, (int)psinfo->pr_ppid); 17457c478bd9Sstevel@tonic-gate break; 17467c478bd9Sstevel@tonic-gate case F_PGID: 17477c478bd9Sstevel@tonic-gate (void) printf("%*d", width, (int)psinfo->pr_pgid); 17487c478bd9Sstevel@tonic-gate break; 17497c478bd9Sstevel@tonic-gate case F_SID: 17507c478bd9Sstevel@tonic-gate (void) printf("%*d", width, (int)psinfo->pr_sid); 17517c478bd9Sstevel@tonic-gate break; 17527c478bd9Sstevel@tonic-gate case F_PSR: 17537c478bd9Sstevel@tonic-gate if (zombie_lwp || psinfo->pr_lwp.pr_bindpro == PBIND_NONE) 17547c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 17557c478bd9Sstevel@tonic-gate else 17567c478bd9Sstevel@tonic-gate (void) printf("%*d", width, psinfo->pr_lwp.pr_bindpro); 17577c478bd9Sstevel@tonic-gate break; 17587c478bd9Sstevel@tonic-gate case F_LWP: 17597c478bd9Sstevel@tonic-gate (void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lwpid); 17607c478bd9Sstevel@tonic-gate break; 1761*ab618543SJohn Levon case F_LWPNAME: { 1762*ab618543SJohn Levon char lwpname[THREAD_NAME_MAX] = ""; 1763*ab618543SJohn Levon char *path = NULL; 1764*ab618543SJohn Levon int fd; 1765*ab618543SJohn Levon 1766*ab618543SJohn Levon if (asprintf(&path, "%s/%d/lwp/%d/lwpname", procdir, 1767*ab618543SJohn Levon (int)psinfo->pr_pid, (int)psinfo->pr_lwp.pr_lwpid) != -1 && 1768*ab618543SJohn Levon (fd = open(path, O_RDONLY)) != -1) { 1769*ab618543SJohn Levon (void) read(fd, lwpname, sizeof (lwpname)); 1770*ab618543SJohn Levon lwpname[THREAD_NAME_MAX - 1] = '\0'; 1771*ab618543SJohn Levon (void) close(fd); 1772*ab618543SJohn Levon } 1773*ab618543SJohn Levon 1774*ab618543SJohn Levon free(path); 1775*ab618543SJohn Levon 1776*ab618543SJohn Levon if (f->next != NULL) 1777*ab618543SJohn Levon (void) printf("%-*s", width, lwpname); 1778*ab618543SJohn Levon else 1779*ab618543SJohn Levon (void) printf("%s", lwpname); 1780*ab618543SJohn Levon break; 1781*ab618543SJohn Levon } 17827c478bd9Sstevel@tonic-gate case F_NLWP: 17837c478bd9Sstevel@tonic-gate (void) printf("%*d", width, psinfo->pr_nlwp + psinfo->pr_nzomb); 17847c478bd9Sstevel@tonic-gate break; 17857c478bd9Sstevel@tonic-gate case F_OPRI: 17867c478bd9Sstevel@tonic-gate if (zombie_lwp) 17877c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 17887c478bd9Sstevel@tonic-gate else 17897c478bd9Sstevel@tonic-gate (void) printf("%*d", width, psinfo->pr_lwp.pr_oldpri); 17907c478bd9Sstevel@tonic-gate break; 17917c478bd9Sstevel@tonic-gate case F_PRI: 17927c478bd9Sstevel@tonic-gate if (zombie_lwp) 17937c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 17947c478bd9Sstevel@tonic-gate else 17957c478bd9Sstevel@tonic-gate (void) printf("%*d", width, psinfo->pr_lwp.pr_pri); 17967c478bd9Sstevel@tonic-gate break; 17977c478bd9Sstevel@tonic-gate case F_F: 17987c478bd9Sstevel@tonic-gate mask = 0xffffffffUL; 17997c478bd9Sstevel@tonic-gate if (width < 8) 18007c478bd9Sstevel@tonic-gate mask >>= (8 - width) * 4; 18017c478bd9Sstevel@tonic-gate (void) printf("%*lx", width, psinfo->pr_flag & mask); 18027c478bd9Sstevel@tonic-gate break; 18037c478bd9Sstevel@tonic-gate case F_S: 18047c478bd9Sstevel@tonic-gate (void) printf("%*c", width, psinfo->pr_lwp.pr_sname); 18057c478bd9Sstevel@tonic-gate break; 18067c478bd9Sstevel@tonic-gate case F_C: 18077c478bd9Sstevel@tonic-gate if (zombie_lwp) 18087c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 18097c478bd9Sstevel@tonic-gate else 18107c478bd9Sstevel@tonic-gate (void) printf("%*d", width, psinfo->pr_lwp.pr_cpu); 18117c478bd9Sstevel@tonic-gate break; 18127c478bd9Sstevel@tonic-gate case F_PCPU: 18137c478bd9Sstevel@tonic-gate if (zombie_lwp) 18147c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 18157c478bd9Sstevel@tonic-gate else if (Lflg) 18167c478bd9Sstevel@tonic-gate prtpct(psinfo->pr_lwp.pr_pctcpu, width); 18177c478bd9Sstevel@tonic-gate else 18187c478bd9Sstevel@tonic-gate prtpct(psinfo->pr_pctcpu, width); 18197c478bd9Sstevel@tonic-gate break; 18207c478bd9Sstevel@tonic-gate case F_PMEM: 18217c478bd9Sstevel@tonic-gate prtpct(psinfo->pr_pctmem, width); 18227c478bd9Sstevel@tonic-gate break; 18237c478bd9Sstevel@tonic-gate case F_OSZ: 18247c478bd9Sstevel@tonic-gate (void) printf("%*lu", width, 1825d21c64a5SDavid Edmondson (ulong_t)psinfo->pr_size / kbytes_per_page); 18267c478bd9Sstevel@tonic-gate break; 18277c478bd9Sstevel@tonic-gate case F_VSZ: 18287c478bd9Sstevel@tonic-gate (void) printf("%*lu", width, (ulong_t)psinfo->pr_size); 18297c478bd9Sstevel@tonic-gate break; 18307c478bd9Sstevel@tonic-gate case F_RSS: 18317c478bd9Sstevel@tonic-gate (void) printf("%*lu", width, (ulong_t)psinfo->pr_rssize); 18327c478bd9Sstevel@tonic-gate break; 18337c478bd9Sstevel@tonic-gate case F_NICE: 18347c478bd9Sstevel@tonic-gate /* if pr_oldpri is zero, then this class has no nice */ 18357c478bd9Sstevel@tonic-gate if (zombie_lwp) 18367c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 18377c478bd9Sstevel@tonic-gate else if (psinfo->pr_lwp.pr_oldpri != 0) 18387c478bd9Sstevel@tonic-gate (void) printf("%*d", width, psinfo->pr_lwp.pr_nice); 18397c478bd9Sstevel@tonic-gate else 18407c478bd9Sstevel@tonic-gate (void) printf("%*.*s", width, width, 1841d21c64a5SDavid Edmondson psinfo->pr_lwp.pr_clname); 18427c478bd9Sstevel@tonic-gate break; 18437c478bd9Sstevel@tonic-gate case F_CLASS: 18447c478bd9Sstevel@tonic-gate if (zombie_lwp) 18457c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 18467c478bd9Sstevel@tonic-gate else 18477c478bd9Sstevel@tonic-gate (void) printf("%*.*s", width, width, 1848d21c64a5SDavid Edmondson psinfo->pr_lwp.pr_clname); 18497c478bd9Sstevel@tonic-gate break; 18507c478bd9Sstevel@tonic-gate case F_STIME: 18517c478bd9Sstevel@tonic-gate if (Lflg) 18527c478bd9Sstevel@tonic-gate prtime(psinfo->pr_lwp.pr_start, width, 0); 18537c478bd9Sstevel@tonic-gate else 18547c478bd9Sstevel@tonic-gate prtime(psinfo->pr_start, width, 0); 18557c478bd9Sstevel@tonic-gate break; 18567c478bd9Sstevel@tonic-gate case F_ETIME: 18577c478bd9Sstevel@tonic-gate if (Lflg) 18587c478bd9Sstevel@tonic-gate print_time(delta_secs(&psinfo->pr_lwp.pr_start), 1859d21c64a5SDavid Edmondson width); 18607c478bd9Sstevel@tonic-gate else 18617c478bd9Sstevel@tonic-gate print_time(delta_secs(&psinfo->pr_start), width); 18627c478bd9Sstevel@tonic-gate break; 18637c478bd9Sstevel@tonic-gate case F_TIME: 18647c478bd9Sstevel@tonic-gate if (Lflg) { 18657c478bd9Sstevel@tonic-gate cputime = psinfo->pr_lwp.pr_time.tv_sec; 18667c478bd9Sstevel@tonic-gate if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000) 18677c478bd9Sstevel@tonic-gate cputime++; 18687c478bd9Sstevel@tonic-gate } else { 18697c478bd9Sstevel@tonic-gate cputime = psinfo->pr_time.tv_sec; 18707c478bd9Sstevel@tonic-gate if (psinfo->pr_time.tv_nsec > 500000000) 18717c478bd9Sstevel@tonic-gate cputime++; 18727c478bd9Sstevel@tonic-gate } 18737c478bd9Sstevel@tonic-gate print_time(cputime, width); 18747c478bd9Sstevel@tonic-gate break; 18757c478bd9Sstevel@tonic-gate case F_TTY: 18767c478bd9Sstevel@tonic-gate (void) printf("%-*s", width, ttyp); 18777c478bd9Sstevel@tonic-gate break; 18787c478bd9Sstevel@tonic-gate case F_ADDR: 18797c478bd9Sstevel@tonic-gate if (zombie_lwp) 18807c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 18817c478bd9Sstevel@tonic-gate else if (Lflg) 18827c478bd9Sstevel@tonic-gate (void) printf("%*lx", width, 1883d21c64a5SDavid Edmondson (long)psinfo->pr_lwp.pr_addr); 18847c478bd9Sstevel@tonic-gate else 18857c478bd9Sstevel@tonic-gate (void) printf("%*lx", width, (long)psinfo->pr_addr); 18867c478bd9Sstevel@tonic-gate break; 18877c478bd9Sstevel@tonic-gate case F_WCHAN: 18887c478bd9Sstevel@tonic-gate if (!zombie_lwp && psinfo->pr_lwp.pr_wchan) 18897c478bd9Sstevel@tonic-gate (void) printf("%*lx", width, 1890d21c64a5SDavid Edmondson (long)psinfo->pr_lwp.pr_wchan); 18917c478bd9Sstevel@tonic-gate else 18927c478bd9Sstevel@tonic-gate (void) printf("%*.*s", width, width, "-"); 18937c478bd9Sstevel@tonic-gate break; 18947c478bd9Sstevel@tonic-gate case F_FNAME: 18957c478bd9Sstevel@tonic-gate /* 18967c478bd9Sstevel@tonic-gate * Print full width unless this is the last output format. 18977c478bd9Sstevel@tonic-gate */ 18987c478bd9Sstevel@tonic-gate if (zombie_lwp) { 18997c478bd9Sstevel@tonic-gate if (f->next != NULL) 19007c478bd9Sstevel@tonic-gate (void) printf("%-*s", width, "<defunct>"); 19017c478bd9Sstevel@tonic-gate else 19027c478bd9Sstevel@tonic-gate (void) printf("%s", "<defunct>"); 19037c478bd9Sstevel@tonic-gate break; 19047c478bd9Sstevel@tonic-gate } 19057c478bd9Sstevel@tonic-gate wcnt = namencnt(psinfo->pr_fname, 16, width); 19067c478bd9Sstevel@tonic-gate if (f->next != NULL) 19077c478bd9Sstevel@tonic-gate (void) printf("%-*.*s", width, wcnt, psinfo->pr_fname); 19087c478bd9Sstevel@tonic-gate else 19097c478bd9Sstevel@tonic-gate (void) printf("%-.*s", wcnt, psinfo->pr_fname); 19107c478bd9Sstevel@tonic-gate break; 19117c478bd9Sstevel@tonic-gate case F_COMM: 19127c478bd9Sstevel@tonic-gate if (zombie_lwp) { 19137c478bd9Sstevel@tonic-gate if (f->next != NULL) 19147c478bd9Sstevel@tonic-gate (void) printf("%-*s", width, "<defunct>"); 19157c478bd9Sstevel@tonic-gate else 19167c478bd9Sstevel@tonic-gate (void) printf("%s", "<defunct>"); 19177c478bd9Sstevel@tonic-gate break; 19187c478bd9Sstevel@tonic-gate } 19197c478bd9Sstevel@tonic-gate csave = strpbrk(psinfo->pr_psargs, " \t\r\v\f\n"); 19207c478bd9Sstevel@tonic-gate if (csave) { 19217c478bd9Sstevel@tonic-gate c = *csave; 19227c478bd9Sstevel@tonic-gate *csave = '\0'; 19237c478bd9Sstevel@tonic-gate } 19247c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 19257c478bd9Sstevel@tonic-gate case F_ARGS: 19267c478bd9Sstevel@tonic-gate /* 19277c478bd9Sstevel@tonic-gate * PRARGSZ == length of cmd arg string. 19287c478bd9Sstevel@tonic-gate */ 19297c478bd9Sstevel@tonic-gate if (zombie_lwp) { 19307c478bd9Sstevel@tonic-gate (void) printf("%-*s", width, "<defunct>"); 19317c478bd9Sstevel@tonic-gate break; 19327c478bd9Sstevel@tonic-gate } 19337c478bd9Sstevel@tonic-gate psinfo->pr_psargs[PRARGSZ-1] = '\0'; 19347c478bd9Sstevel@tonic-gate bytesleft = PRARGSZ; 19357c478bd9Sstevel@tonic-gate for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) { 19367c478bd9Sstevel@tonic-gate length = mbtowc(&wchar, cp, MB_LEN_MAX); 19377c478bd9Sstevel@tonic-gate if (length == 0) 19387c478bd9Sstevel@tonic-gate break; 19397c478bd9Sstevel@tonic-gate if (length < 0 || !iswprint(wchar)) { 19407c478bd9Sstevel@tonic-gate if (length < 0) 19417c478bd9Sstevel@tonic-gate length = 1; 19427c478bd9Sstevel@tonic-gate if (bytesleft <= length) { 19437c478bd9Sstevel@tonic-gate *cp = '\0'; 19447c478bd9Sstevel@tonic-gate break; 19457c478bd9Sstevel@tonic-gate } 19467c478bd9Sstevel@tonic-gate /* omit the unprintable character */ 19477c478bd9Sstevel@tonic-gate (void) memmove(cp, cp+length, bytesleft-length); 19487c478bd9Sstevel@tonic-gate length = 0; 19497c478bd9Sstevel@tonic-gate } 19507c478bd9Sstevel@tonic-gate bytesleft -= length; 19517c478bd9Sstevel@tonic-gate } 19527c478bd9Sstevel@tonic-gate wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, width); 19537c478bd9Sstevel@tonic-gate /* 19547c478bd9Sstevel@tonic-gate * Print full width unless this is the last format. 19557c478bd9Sstevel@tonic-gate */ 19567c478bd9Sstevel@tonic-gate if (f->next != NULL) 19577c478bd9Sstevel@tonic-gate (void) printf("%-*.*s", width, wcnt, 19587c478bd9Sstevel@tonic-gate psinfo->pr_psargs); 19597c478bd9Sstevel@tonic-gate else 19607c478bd9Sstevel@tonic-gate (void) printf("%-.*s", wcnt, 19617c478bd9Sstevel@tonic-gate psinfo->pr_psargs); 19627c478bd9Sstevel@tonic-gate if (f->fname == F_COMM && csave) 19637c478bd9Sstevel@tonic-gate *csave = c; 19647c478bd9Sstevel@tonic-gate break; 19657c478bd9Sstevel@tonic-gate case F_TASKID: 19667c478bd9Sstevel@tonic-gate (void) printf("%*d", width, (int)psinfo->pr_taskid); 19677c478bd9Sstevel@tonic-gate break; 19687c478bd9Sstevel@tonic-gate case F_PROJID: 19697c478bd9Sstevel@tonic-gate (void) printf("%*d", width, (int)psinfo->pr_projid); 19707c478bd9Sstevel@tonic-gate break; 19717c478bd9Sstevel@tonic-gate case F_PROJECT: 19727c478bd9Sstevel@tonic-gate { 19737c478bd9Sstevel@tonic-gate struct project cproj; 19747c478bd9Sstevel@tonic-gate char proj_buf[PROJECT_BUFSZ]; 19757c478bd9Sstevel@tonic-gate 19767c478bd9Sstevel@tonic-gate if ((getprojbyid(psinfo->pr_projid, &cproj, 19770a1278f2SGary Mills (void *)&proj_buf, PROJECT_BUFSZ)) == NULL) { 19780a1278f2SGary Mills if (Wflg && snprintf(NULL, 0, "%d", 19790a1278f2SGary Mills ((int)psinfo->pr_projid)) > width) 19800a1278f2SGary Mills (void) printf("%.*d%c", width - 1, 19810a1278f2SGary Mills ((int)psinfo->pr_projid), '*'); 19820a1278f2SGary Mills else 19830a1278f2SGary Mills (void) printf("%*d", width, 19840a1278f2SGary Mills (int)psinfo->pr_projid); 19850a1278f2SGary Mills } else { 19860a1278f2SGary Mills size_t nw; 19870a1278f2SGary Mills 19880a1278f2SGary Mills if (cproj.pj_name != NULL) 19890a1278f2SGary Mills nw = mbstowcs(NULL, cproj.pj_name, 0); 19900a1278f2SGary Mills if (cproj.pj_name == NULL) 19910a1278f2SGary Mills (void) printf("%*s ", width, "---"); 19920a1278f2SGary Mills else if (nw == (size_t)-1) 19930a1278f2SGary Mills (void) printf("%*s ", width, "ERROR"); 19940a1278f2SGary Mills else if (Wflg && nw > width) 19950a1278f2SGary Mills (void) wprintf(L"%.*s%c", width - 1, 19960a1278f2SGary Mills cproj.pj_name, '*'); 19970a1278f2SGary Mills else 19980a1278f2SGary Mills (void) wprintf(L"%*s", width, 19990a1278f2SGary Mills cproj.pj_name); 20000a1278f2SGary Mills } 20017c478bd9Sstevel@tonic-gate } 20027c478bd9Sstevel@tonic-gate break; 20037c478bd9Sstevel@tonic-gate case F_PSET: 20047c478bd9Sstevel@tonic-gate if (zombie_lwp || psinfo->pr_lwp.pr_bindpset == PS_NONE) 20057c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 20067c478bd9Sstevel@tonic-gate else 20077c478bd9Sstevel@tonic-gate (void) printf("%*d", width, psinfo->pr_lwp.pr_bindpset); 20087c478bd9Sstevel@tonic-gate break; 20097c478bd9Sstevel@tonic-gate case F_ZONEID: 20107c478bd9Sstevel@tonic-gate (void) printf("%*d", width, (int)psinfo->pr_zoneid); 20117c478bd9Sstevel@tonic-gate break; 20127c478bd9Sstevel@tonic-gate case F_ZONE: 20137c478bd9Sstevel@tonic-gate { 20147c478bd9Sstevel@tonic-gate char zonename[ZONENAME_MAX]; 20157c478bd9Sstevel@tonic-gate 20167c478bd9Sstevel@tonic-gate if (getzonenamebyid(psinfo->pr_zoneid, zonename, 20177c478bd9Sstevel@tonic-gate sizeof (zonename)) < 0) { 20180a1278f2SGary Mills if (Wflg && snprintf(NULL, 0, "%d", 20190a1278f2SGary Mills ((int)psinfo->pr_zoneid)) > width) 20200a1278f2SGary Mills (void) printf("%.*d%c", width - 1, 20210a1278f2SGary Mills ((int)psinfo->pr_zoneid), '*'); 20220a1278f2SGary Mills else 20230a1278f2SGary Mills (void) printf("%*d", width, 20240a1278f2SGary Mills (int)psinfo->pr_zoneid); 20257c478bd9Sstevel@tonic-gate } else { 20260a1278f2SGary Mills size_t nw; 20270a1278f2SGary Mills 20280a1278f2SGary Mills nw = mbstowcs(NULL, zonename, 0); 20290a1278f2SGary Mills if (nw == (size_t)-1) 20300a1278f2SGary Mills (void) printf("%*s ", width, "ERROR"); 20310a1278f2SGary Mills else if (Wflg && nw > width) 20320a1278f2SGary Mills (void) wprintf(L"%.*s%c", width - 1, 20330a1278f2SGary Mills zonename, '*'); 20340a1278f2SGary Mills else 20350a1278f2SGary Mills (void) wprintf(L"%*s", width, zonename); 20367c478bd9Sstevel@tonic-gate } 20377c478bd9Sstevel@tonic-gate } 20387c478bd9Sstevel@tonic-gate break; 20397c478bd9Sstevel@tonic-gate case F_CTID: 20407c478bd9Sstevel@tonic-gate if (psinfo->pr_contract == -1) 20417c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 20427c478bd9Sstevel@tonic-gate else 20437c478bd9Sstevel@tonic-gate (void) printf("%*ld", width, (long)psinfo->pr_contract); 20447c478bd9Sstevel@tonic-gate break; 2045c6402783Sakolb case F_LGRP: 2046c6402783Sakolb /* Display home lgroup */ 2047c6402783Sakolb (void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lgrp); 2048c6402783Sakolb break; 2049eaaa4d5fSBryan Cantrill 2050eaaa4d5fSBryan Cantrill case F_DMODEL: 2051eaaa4d5fSBryan Cantrill (void) printf("%*s", width, 2052eaaa4d5fSBryan Cantrill psinfo->pr_dmodel == PR_MODEL_LP64 ? "_LP64" : "_ILP32"); 2053eaaa4d5fSBryan Cantrill break; 20547c478bd9Sstevel@tonic-gate } 20557c478bd9Sstevel@tonic-gate } 20567c478bd9Sstevel@tonic-gate 20577c478bd9Sstevel@tonic-gate static void 20587c478bd9Sstevel@tonic-gate print_zombie_field(psinfo_t *psinfo, struct field *f, const char *ttyp) 20597c478bd9Sstevel@tonic-gate { 20607c478bd9Sstevel@tonic-gate int wcnt; 20617c478bd9Sstevel@tonic-gate int width = f->width; 20627c478bd9Sstevel@tonic-gate 20637c478bd9Sstevel@tonic-gate switch (f->fname) { 20647c478bd9Sstevel@tonic-gate case F_FNAME: 20657c478bd9Sstevel@tonic-gate case F_COMM: 20667c478bd9Sstevel@tonic-gate case F_ARGS: 20677c478bd9Sstevel@tonic-gate /* 20687c478bd9Sstevel@tonic-gate * Print full width unless this is the last output format. 20697c478bd9Sstevel@tonic-gate */ 20707c478bd9Sstevel@tonic-gate wcnt = min(width, sizeof ("<defunct>")); 20717c478bd9Sstevel@tonic-gate if (f->next != NULL) 20727c478bd9Sstevel@tonic-gate (void) printf("%-*.*s", width, wcnt, "<defunct>"); 20737c478bd9Sstevel@tonic-gate else 20747c478bd9Sstevel@tonic-gate (void) printf("%-.*s", wcnt, "<defunct>"); 20757c478bd9Sstevel@tonic-gate break; 20767c478bd9Sstevel@tonic-gate 20777c478bd9Sstevel@tonic-gate case F_PSR: 20787c478bd9Sstevel@tonic-gate case F_PCPU: 20797c478bd9Sstevel@tonic-gate case F_PMEM: 20807c478bd9Sstevel@tonic-gate case F_NICE: 20817c478bd9Sstevel@tonic-gate case F_CLASS: 20827c478bd9Sstevel@tonic-gate case F_STIME: 20837c478bd9Sstevel@tonic-gate case F_ETIME: 20847c478bd9Sstevel@tonic-gate case F_WCHAN: 20857c478bd9Sstevel@tonic-gate case F_PSET: 20867c478bd9Sstevel@tonic-gate (void) printf("%*s", width, "-"); 20877c478bd9Sstevel@tonic-gate break; 20887c478bd9Sstevel@tonic-gate 20897c478bd9Sstevel@tonic-gate case F_OPRI: 20907c478bd9Sstevel@tonic-gate case F_PRI: 20917c478bd9Sstevel@tonic-gate case F_OSZ: 20927c478bd9Sstevel@tonic-gate case F_VSZ: 20937c478bd9Sstevel@tonic-gate case F_RSS: 20947c478bd9Sstevel@tonic-gate (void) printf("%*d", width, 0); 20957c478bd9Sstevel@tonic-gate break; 20967c478bd9Sstevel@tonic-gate 20977c478bd9Sstevel@tonic-gate default: 20987c478bd9Sstevel@tonic-gate print_field(psinfo, f, ttyp); 20997c478bd9Sstevel@tonic-gate break; 21007c478bd9Sstevel@tonic-gate } 21017c478bd9Sstevel@tonic-gate } 21027c478bd9Sstevel@tonic-gate 21037c478bd9Sstevel@tonic-gate static void 21047c478bd9Sstevel@tonic-gate pr_fields(psinfo_t *psinfo, const char *ttyp, 2105*ab618543SJohn Levon void (*print_fld)(psinfo_t *, struct field *, const char *)) 21067c478bd9Sstevel@tonic-gate { 21077c478bd9Sstevel@tonic-gate struct field *f; 21087c478bd9Sstevel@tonic-gate 21097c478bd9Sstevel@tonic-gate for (f = fields; f != NULL; f = f->next) { 21107c478bd9Sstevel@tonic-gate print_fld(psinfo, f, ttyp); 21117c478bd9Sstevel@tonic-gate if (f->next != NULL) 21127c478bd9Sstevel@tonic-gate (void) printf(" "); 21137c478bd9Sstevel@tonic-gate } 21147c478bd9Sstevel@tonic-gate (void) printf("\n"); 21157c478bd9Sstevel@tonic-gate } 21167c478bd9Sstevel@tonic-gate 21177c478bd9Sstevel@tonic-gate /* 21187c478bd9Sstevel@tonic-gate * Returns 1 if arg is found in array arr, of length num; 0 otherwise. 21197c478bd9Sstevel@tonic-gate */ 21207c478bd9Sstevel@tonic-gate static int 21217c478bd9Sstevel@tonic-gate search(pid_t *arr, int number, pid_t arg) 21227c478bd9Sstevel@tonic-gate { 21237c478bd9Sstevel@tonic-gate int i; 21247c478bd9Sstevel@tonic-gate 21257c478bd9Sstevel@tonic-gate for (i = 0; i < number; i++) 21267c478bd9Sstevel@tonic-gate if (arg == arr[i]) 21277c478bd9Sstevel@tonic-gate return (1); 21287c478bd9Sstevel@tonic-gate return (0); 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate 21317c478bd9Sstevel@tonic-gate /* 21327c478bd9Sstevel@tonic-gate * Add an entry (user, group) to the specified table. 21337c478bd9Sstevel@tonic-gate */ 21347c478bd9Sstevel@tonic-gate static void 21357c478bd9Sstevel@tonic-gate add_ugentry(struct ughead *tbl, char *name) 21367c478bd9Sstevel@tonic-gate { 21377c478bd9Sstevel@tonic-gate struct ugdata *entp; 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate if (tbl->size == tbl->nent) { /* reallocate the table entries */ 21407c478bd9Sstevel@tonic-gate if ((tbl->size *= 2) == 0) 21417c478bd9Sstevel@tonic-gate tbl->size = 32; /* first time */ 21427c478bd9Sstevel@tonic-gate tbl->ent = Realloc(tbl->ent, tbl->size*sizeof (struct ugdata)); 21437c478bd9Sstevel@tonic-gate } 21447c478bd9Sstevel@tonic-gate entp = &tbl->ent[tbl->nent++]; 21457c478bd9Sstevel@tonic-gate entp->id = 0; 21467c478bd9Sstevel@tonic-gate (void) strncpy(entp->name, name, MAXUGNAME); 21477c478bd9Sstevel@tonic-gate entp->name[MAXUGNAME] = '\0'; 21487c478bd9Sstevel@tonic-gate } 21497c478bd9Sstevel@tonic-gate 21507c478bd9Sstevel@tonic-gate static int 21517c478bd9Sstevel@tonic-gate uconv(struct ughead *uhead) 21527c478bd9Sstevel@tonic-gate { 21537c478bd9Sstevel@tonic-gate struct ugdata *utbl = uhead->ent; 21547c478bd9Sstevel@tonic-gate int n = uhead->nent; 21557c478bd9Sstevel@tonic-gate struct passwd *pwd; 21567c478bd9Sstevel@tonic-gate int i; 21577c478bd9Sstevel@tonic-gate int fnd = 0; 21587c478bd9Sstevel@tonic-gate uid_t uid; 21597c478bd9Sstevel@tonic-gate 21607c478bd9Sstevel@tonic-gate /* 21617c478bd9Sstevel@tonic-gate * Ask the name service for names. 21627c478bd9Sstevel@tonic-gate */ 21637c478bd9Sstevel@tonic-gate for (i = 0; i < n; i++) { 21647c478bd9Sstevel@tonic-gate /* 21657c478bd9Sstevel@tonic-gate * If name is numeric, ask for numeric id 21667c478bd9Sstevel@tonic-gate */ 2167f48205beScasper if (str2uid(utbl[i].name, &uid, 0, MAXEPHUID) == 0) 21687c478bd9Sstevel@tonic-gate pwd = getpwuid(uid); 21697c478bd9Sstevel@tonic-gate else 21707c478bd9Sstevel@tonic-gate pwd = getpwnam(utbl[i].name); 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate /* 21737c478bd9Sstevel@tonic-gate * If found, enter found index into tbl array. 21747c478bd9Sstevel@tonic-gate */ 21757c478bd9Sstevel@tonic-gate if (pwd == NULL) { 21767c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 21777c478bd9Sstevel@tonic-gate gettext("ps: unknown user %s\n"), utbl[i].name); 21787c478bd9Sstevel@tonic-gate continue; 21797c478bd9Sstevel@tonic-gate } 21807c478bd9Sstevel@tonic-gate 21817c478bd9Sstevel@tonic-gate utbl[fnd].id = pwd->pw_uid; 21827c478bd9Sstevel@tonic-gate (void) strncpy(utbl[fnd].name, pwd->pw_name, MAXUGNAME); 21837c478bd9Sstevel@tonic-gate fnd++; 21847c478bd9Sstevel@tonic-gate } 21857c478bd9Sstevel@tonic-gate 21867c478bd9Sstevel@tonic-gate uhead->nent = fnd; /* in case it changed */ 21877c478bd9Sstevel@tonic-gate return (n - fnd); 21887c478bd9Sstevel@tonic-gate } 21897c478bd9Sstevel@tonic-gate 21907c478bd9Sstevel@tonic-gate static int 21917c478bd9Sstevel@tonic-gate gconv(struct ughead *ghead) 21927c478bd9Sstevel@tonic-gate { 21937c478bd9Sstevel@tonic-gate struct ugdata *gtbl = ghead->ent; 21947c478bd9Sstevel@tonic-gate int n = ghead->nent; 21957c478bd9Sstevel@tonic-gate struct group *grp; 21967c478bd9Sstevel@tonic-gate gid_t gid; 21977c478bd9Sstevel@tonic-gate int i; 21987c478bd9Sstevel@tonic-gate int fnd = 0; 21997c478bd9Sstevel@tonic-gate 22007c478bd9Sstevel@tonic-gate /* 22017c478bd9Sstevel@tonic-gate * Ask the name service for names. 22027c478bd9Sstevel@tonic-gate */ 22037c478bd9Sstevel@tonic-gate for (i = 0; i < n; i++) { 22047c478bd9Sstevel@tonic-gate /* 22057c478bd9Sstevel@tonic-gate * If name is numeric, ask for numeric id 22067c478bd9Sstevel@tonic-gate */ 2207f48205beScasper if (str2uid(gtbl[i].name, (uid_t *)&gid, 0, MAXEPHUID) == 0) 22087c478bd9Sstevel@tonic-gate grp = getgrgid(gid); 22097c478bd9Sstevel@tonic-gate else 22107c478bd9Sstevel@tonic-gate grp = getgrnam(gtbl[i].name); 22117c478bd9Sstevel@tonic-gate /* 22127c478bd9Sstevel@tonic-gate * If found, enter found index into tbl array. 22137c478bd9Sstevel@tonic-gate */ 22147c478bd9Sstevel@tonic-gate if (grp == NULL) { 22157c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 22167c478bd9Sstevel@tonic-gate gettext("ps: unknown group %s\n"), gtbl[i].name); 22177c478bd9Sstevel@tonic-gate continue; 22187c478bd9Sstevel@tonic-gate } 22197c478bd9Sstevel@tonic-gate 22207c478bd9Sstevel@tonic-gate gtbl[fnd].id = grp->gr_gid; 22217c478bd9Sstevel@tonic-gate (void) strncpy(gtbl[fnd].name, grp->gr_name, MAXUGNAME); 22227c478bd9Sstevel@tonic-gate fnd++; 22237c478bd9Sstevel@tonic-gate } 22247c478bd9Sstevel@tonic-gate 22257c478bd9Sstevel@tonic-gate ghead->nent = fnd; /* in case it changed */ 22267c478bd9Sstevel@tonic-gate return (n - fnd); 22277c478bd9Sstevel@tonic-gate } 22287c478bd9Sstevel@tonic-gate 22297c478bd9Sstevel@tonic-gate /* 22307c478bd9Sstevel@tonic-gate * Return 1 if puid is in table, otherwise 0. 22317c478bd9Sstevel@tonic-gate */ 22327c478bd9Sstevel@tonic-gate static int 22337c478bd9Sstevel@tonic-gate ugfind(id_t id, struct ughead *ughead) 22347c478bd9Sstevel@tonic-gate { 22357c478bd9Sstevel@tonic-gate struct ugdata *utbl = ughead->ent; 22367c478bd9Sstevel@tonic-gate int n = ughead->nent; 22377c478bd9Sstevel@tonic-gate int i; 22387c478bd9Sstevel@tonic-gate 22397c478bd9Sstevel@tonic-gate for (i = 0; i < n; i++) 22407c478bd9Sstevel@tonic-gate if (utbl[i].id == id) 22417c478bd9Sstevel@tonic-gate return (1); 22427c478bd9Sstevel@tonic-gate return (0); 22437c478bd9Sstevel@tonic-gate } 22447c478bd9Sstevel@tonic-gate 22457c478bd9Sstevel@tonic-gate /* 22467c478bd9Sstevel@tonic-gate * Print starting time of process unless process started more than 24 hours 22477c478bd9Sstevel@tonic-gate * ago, in which case the date is printed. The date is printed in the form 22487c478bd9Sstevel@tonic-gate * "MMM dd" if old format, else the blank is replaced with an '_' so 22497c478bd9Sstevel@tonic-gate * it appears as a single word (for parseability). 22507c478bd9Sstevel@tonic-gate */ 22517c478bd9Sstevel@tonic-gate static void 22527c478bd9Sstevel@tonic-gate prtime(timestruc_t st, int width, int old) 22537c478bd9Sstevel@tonic-gate { 22547c478bd9Sstevel@tonic-gate char sttim[26]; 22557c478bd9Sstevel@tonic-gate time_t starttime; 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate starttime = st.tv_sec; 22587c478bd9Sstevel@tonic-gate if (st.tv_nsec > 500000000) 22597c478bd9Sstevel@tonic-gate starttime++; 22607c478bd9Sstevel@tonic-gate if ((now.tv_sec - starttime) >= 24*60*60) { 226116f94f58Ssayama (void) strftime(sttim, sizeof (sttim), old? 226216f94f58Ssayama /* 226316f94f58Ssayama * TRANSLATION_NOTE 226416f94f58Ssayama * This time format is used by STIME field when -f option 226516f94f58Ssayama * is specified. Used for processes that begun more than 226616f94f58Ssayama * 24 hours. 226716f94f58Ssayama */ 226816f94f58Ssayama dcgettext(NULL, "%b %d", LC_TIME) : 226916f94f58Ssayama /* 227016f94f58Ssayama * TRANSLATION_NOTE 227116f94f58Ssayama * This time format is used by STIME field when -o option 227216f94f58Ssayama * is specified. Used for processes that begun more than 227316f94f58Ssayama * 24 hours. 227416f94f58Ssayama */ 227516f94f58Ssayama dcgettext(NULL, "%b_%d", LC_TIME), localtime(&starttime)); 22767c478bd9Sstevel@tonic-gate } else { 227716f94f58Ssayama /* 227816f94f58Ssayama * TRANSLATION_NOTE 227916f94f58Ssayama * This time format is used by STIME field when -f or -o option 228016f94f58Ssayama * is specified. Used for processes that begun less than 228116f94f58Ssayama * 24 hours. 228216f94f58Ssayama */ 228316f94f58Ssayama (void) strftime(sttim, sizeof (sttim), 228416f94f58Ssayama dcgettext(NULL, "%H:%M:%S", LC_TIME), 228516f94f58Ssayama localtime(&starttime)); 22867c478bd9Sstevel@tonic-gate } 22877c478bd9Sstevel@tonic-gate (void) printf("%*.*s", width, width, sttim); 22887c478bd9Sstevel@tonic-gate } 22897c478bd9Sstevel@tonic-gate 22907c478bd9Sstevel@tonic-gate static void 22917c478bd9Sstevel@tonic-gate przom(psinfo_t *psinfo) 22927c478bd9Sstevel@tonic-gate { 22937c478bd9Sstevel@tonic-gate long tm; 22947c478bd9Sstevel@tonic-gate struct passwd *pwd; 22957c478bd9Sstevel@tonic-gate char zonename[ZONENAME_MAX]; 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate /* 22987c478bd9Sstevel@tonic-gate * All fields before 'PID' are printed with a trailing space as a 22997c478bd9Sstevel@tonic-gate * spearator, rather than keeping track of which column is first. All 23007c478bd9Sstevel@tonic-gate * other fields are printed with a leading space. 23017c478bd9Sstevel@tonic-gate */ 23027c478bd9Sstevel@tonic-gate if (lflg) { /* F S */ 23037c478bd9Sstevel@tonic-gate if (!yflg) 23047c478bd9Sstevel@tonic-gate (void) printf("%2x ", psinfo->pr_flag & 0377); /* F */ 23057c478bd9Sstevel@tonic-gate (void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */ 23067c478bd9Sstevel@tonic-gate } 23077c478bd9Sstevel@tonic-gate if (Zflg) { 23087c478bd9Sstevel@tonic-gate if (getzonenamebyid(psinfo->pr_zoneid, zonename, 23097c478bd9Sstevel@tonic-gate sizeof (zonename)) < 0) { 23100a1278f2SGary Mills if (snprintf(NULL, 0, "%d", 23110a1278f2SGary Mills ((int)psinfo->pr_zoneid)) > 7) 23120a1278f2SGary Mills (void) printf(" %6.6d%c ", 23130a1278f2SGary Mills ((int)psinfo->pr_zoneid), '*'); 23140a1278f2SGary Mills else 23150a1278f2SGary Mills (void) printf(" %7.7d ", 23160a1278f2SGary Mills ((int)psinfo->pr_zoneid)); 23177c478bd9Sstevel@tonic-gate } else { 23180a1278f2SGary Mills size_t nw; 23190a1278f2SGary Mills 23200a1278f2SGary Mills nw = mbstowcs(NULL, zonename, 0); 23210a1278f2SGary Mills if (nw == (size_t)-1) 23220a1278f2SGary Mills (void) printf("%8.8s ", "ERROR"); 23230a1278f2SGary Mills else if (nw > 8) 23240a1278f2SGary Mills (void) wprintf(L"%7.7s%c ", zonename, '*'); 23250a1278f2SGary Mills else 23260a1278f2SGary Mills (void) wprintf(L"%8.8s ", zonename); 23277c478bd9Sstevel@tonic-gate } 23287c478bd9Sstevel@tonic-gate } 2329c6402783Sakolb if (Hflg) { 2330c6402783Sakolb /* Display home lgroup */ 2331c6402783Sakolb (void) printf(" %6d", (int)psinfo->pr_lwp.pr_lgrp); /* LGRP */ 2332c6402783Sakolb } 23337c478bd9Sstevel@tonic-gate if (fflg) { 23340a1278f2SGary Mills if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) { 23350a1278f2SGary Mills size_t nw; 23360a1278f2SGary Mills 23370a1278f2SGary Mills nw = mbstowcs(NULL, pwd->pw_name, 0); 23380a1278f2SGary Mills if (nw == (size_t)-1) 23390a1278f2SGary Mills (void) printf("%8.8s ", "ERROR"); 23400a1278f2SGary Mills else if (nw > 8) 23410a1278f2SGary Mills (void) wprintf(L"%7.7s%c ", pwd->pw_name, '*'); 23420a1278f2SGary Mills else 23430a1278f2SGary Mills (void) wprintf(L"%8.8s ", pwd->pw_name); 23440a1278f2SGary Mills } else { 23450a1278f2SGary Mills if (snprintf(NULL, 0, "%u", 23460a1278f2SGary Mills (psinfo->pr_euid)) > 7) 23470a1278f2SGary Mills (void) printf(" %6.6u%c ", psinfo->pr_euid, 23480a1278f2SGary Mills '*'); 23490a1278f2SGary Mills else 23500a1278f2SGary Mills (void) printf(" %7.7u ", psinfo->pr_euid); 23510a1278f2SGary Mills } 23520a1278f2SGary Mills } else if (lflg) { 23530a1278f2SGary Mills if (snprintf(NULL, 0, "%u", (psinfo->pr_euid)) > 6) 23540a1278f2SGary Mills (void) printf("%5.5u%c ", psinfo->pr_euid, '*'); 23557c478bd9Sstevel@tonic-gate else 23560a1278f2SGary Mills (void) printf("%6u ", psinfo->pr_euid); 23570a1278f2SGary Mills } 23587c478bd9Sstevel@tonic-gate 23597c478bd9Sstevel@tonic-gate (void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */ 23607c478bd9Sstevel@tonic-gate if (lflg || fflg) 23617c478bd9Sstevel@tonic-gate (void) printf(" %*d", pidwidth, 23627c478bd9Sstevel@tonic-gate (int)psinfo->pr_ppid); /* PPID */ 23637c478bd9Sstevel@tonic-gate 23647c478bd9Sstevel@tonic-gate if (jflg) { 23657c478bd9Sstevel@tonic-gate (void) printf(" %*d", pidwidth, 23667c478bd9Sstevel@tonic-gate (int)psinfo->pr_pgid); /* PGID */ 23677c478bd9Sstevel@tonic-gate (void) printf(" %*d", pidwidth, 23687c478bd9Sstevel@tonic-gate (int)psinfo->pr_sid); /* SID */ 23697c478bd9Sstevel@tonic-gate } 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate if (Lflg) 23727c478bd9Sstevel@tonic-gate (void) printf(" %5d", 0); /* LWP */ 23737c478bd9Sstevel@tonic-gate if (Pflg) 23747c478bd9Sstevel@tonic-gate (void) printf(" -"); /* PSR */ 23757c478bd9Sstevel@tonic-gate if (Lflg && fflg) 23767c478bd9Sstevel@tonic-gate (void) printf(" %5d", 0); /* NLWP */ 23777c478bd9Sstevel@tonic-gate 23787c478bd9Sstevel@tonic-gate if (cflg) { 23797c478bd9Sstevel@tonic-gate (void) printf(" %4s", "-"); /* zombies have no class */ 23807c478bd9Sstevel@tonic-gate (void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */ 23817c478bd9Sstevel@tonic-gate } else if (lflg || fflg) { 23827c478bd9Sstevel@tonic-gate (void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */ 23837c478bd9Sstevel@tonic-gate if (lflg) 23847c478bd9Sstevel@tonic-gate (void) printf(" %3d %2s", 23857c478bd9Sstevel@tonic-gate psinfo->pr_lwp.pr_oldpri, "-"); /* PRI NI */ 23867c478bd9Sstevel@tonic-gate } 23877c478bd9Sstevel@tonic-gate if (lflg) { 23887c478bd9Sstevel@tonic-gate if (yflg) /* RSS SZ WCHAN */ 23897c478bd9Sstevel@tonic-gate (void) printf(" %5d %6d %8s", 0, 0, "-"); 23907c478bd9Sstevel@tonic-gate else /* ADDR SZ WCHAN */ 23917c478bd9Sstevel@tonic-gate (void) printf(" %8s %6d %8s", "-", 0, "-"); 23927c478bd9Sstevel@tonic-gate } 239316f94f58Ssayama if (fflg) { 239416f94f58Ssayama int width = fname[F_STIME].width; 2395*ab618543SJohn Levon (void) printf(" %*.*s", width, width, "-"); /* STIME */ 239616f94f58Ssayama } 23977c478bd9Sstevel@tonic-gate (void) printf(" %-8.14s", "?"); /* TTY */ 23987c478bd9Sstevel@tonic-gate 23997c478bd9Sstevel@tonic-gate tm = psinfo->pr_time.tv_sec; 24007c478bd9Sstevel@tonic-gate if (psinfo->pr_time.tv_nsec > 500000000) 24017c478bd9Sstevel@tonic-gate tm++; 24027c478bd9Sstevel@tonic-gate (void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* TIME */ 24037c478bd9Sstevel@tonic-gate (void) printf(" <defunct>\n"); 24047c478bd9Sstevel@tonic-gate } 24057c478bd9Sstevel@tonic-gate 24067c478bd9Sstevel@tonic-gate /* 24077c478bd9Sstevel@tonic-gate * Function to compute the number of printable bytes in a multibyte 24087c478bd9Sstevel@tonic-gate * command string ("internationalization"). 24097c478bd9Sstevel@tonic-gate */ 24107c478bd9Sstevel@tonic-gate static int 24117c478bd9Sstevel@tonic-gate namencnt(char *cmd, int csisize, int scrsize) 24127c478bd9Sstevel@tonic-gate { 24137c478bd9Sstevel@tonic-gate int csiwcnt = 0, scrwcnt = 0; 24147c478bd9Sstevel@tonic-gate int ncsisz, nscrsz; 24157c478bd9Sstevel@tonic-gate wchar_t wchar; 24167c478bd9Sstevel@tonic-gate int len; 24177c478bd9Sstevel@tonic-gate 24187c478bd9Sstevel@tonic-gate while (*cmd != '\0') { 24197c478bd9Sstevel@tonic-gate if ((len = csisize - csiwcnt) > (int)MB_CUR_MAX) 24207c478bd9Sstevel@tonic-gate len = MB_CUR_MAX; 24217c478bd9Sstevel@tonic-gate if ((ncsisz = mbtowc(&wchar, cmd, len)) < 0) 24227c478bd9Sstevel@tonic-gate return (8); /* default to use for illegal chars */ 24237c478bd9Sstevel@tonic-gate if ((nscrsz = wcwidth(wchar)) <= 0) 24247c478bd9Sstevel@tonic-gate return (8); 24257c478bd9Sstevel@tonic-gate if (csiwcnt + ncsisz > csisize || scrwcnt + nscrsz > scrsize) 24267c478bd9Sstevel@tonic-gate break; 24277c478bd9Sstevel@tonic-gate csiwcnt += ncsisz; 24287c478bd9Sstevel@tonic-gate scrwcnt += nscrsz; 24297c478bd9Sstevel@tonic-gate cmd += ncsisz; 24307c478bd9Sstevel@tonic-gate } 24317c478bd9Sstevel@tonic-gate return (csiwcnt); 24327c478bd9Sstevel@tonic-gate } 24337c478bd9Sstevel@tonic-gate 24347c478bd9Sstevel@tonic-gate static char * 24357c478bd9Sstevel@tonic-gate err_string(int err) 24367c478bd9Sstevel@tonic-gate { 24377c478bd9Sstevel@tonic-gate static char buf[32]; 24387c478bd9Sstevel@tonic-gate char *str = strerror(err); 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate if (str == NULL) 24417c478bd9Sstevel@tonic-gate (void) snprintf(str = buf, sizeof (buf), "Errno #%d", err); 24427c478bd9Sstevel@tonic-gate 24437c478bd9Sstevel@tonic-gate return (str); 24447c478bd9Sstevel@tonic-gate } 24457c478bd9Sstevel@tonic-gate 24467c478bd9Sstevel@tonic-gate /* If allocation fails, die */ 24477c478bd9Sstevel@tonic-gate static void * 24487c478bd9Sstevel@tonic-gate Realloc(void *ptr, size_t size) 24497c478bd9Sstevel@tonic-gate { 24507c478bd9Sstevel@tonic-gate ptr = realloc(ptr, size); 24517c478bd9Sstevel@tonic-gate if (ptr == NULL) { 24527c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("ps: no memory\n")); 24537c478bd9Sstevel@tonic-gate exit(1); 24547c478bd9Sstevel@tonic-gate } 24557c478bd9Sstevel@tonic-gate return (ptr); 24567c478bd9Sstevel@tonic-gate } 24577c478bd9Sstevel@tonic-gate 24587c478bd9Sstevel@tonic-gate static time_t 24597c478bd9Sstevel@tonic-gate delta_secs(const timestruc_t *start) 24607c478bd9Sstevel@tonic-gate { 24617c478bd9Sstevel@tonic-gate time_t seconds = now.tv_sec - start->tv_sec; 24627c478bd9Sstevel@tonic-gate long nanosecs = now.tv_usec * 1000 - start->tv_nsec; 24637c478bd9Sstevel@tonic-gate 24647c478bd9Sstevel@tonic-gate if (nanosecs >= (NANOSEC / 2)) 24657c478bd9Sstevel@tonic-gate seconds++; 24667c478bd9Sstevel@tonic-gate else if (nanosecs < -(NANOSEC / 2)) 24677c478bd9Sstevel@tonic-gate seconds--; 24687c478bd9Sstevel@tonic-gate 24697c478bd9Sstevel@tonic-gate return (seconds); 24707c478bd9Sstevel@tonic-gate } 24717c478bd9Sstevel@tonic-gate 24727c478bd9Sstevel@tonic-gate /* 24737c478bd9Sstevel@tonic-gate * Returns the following: 24747c478bd9Sstevel@tonic-gate * 2475*ab618543SJohn Levon * 0 No error 2476*ab618543SJohn Levon * EINVAL Invalid number 2477*ab618543SJohn Levon * ERANGE Value exceeds (min, max) range 24787c478bd9Sstevel@tonic-gate */ 24797c478bd9Sstevel@tonic-gate static int 24807c478bd9Sstevel@tonic-gate str2id(const char *p, pid_t *val, long min, long max) 24817c478bd9Sstevel@tonic-gate { 24827c478bd9Sstevel@tonic-gate char *q; 24837c478bd9Sstevel@tonic-gate long number; 24847c478bd9Sstevel@tonic-gate int error; 24857c478bd9Sstevel@tonic-gate 24867c478bd9Sstevel@tonic-gate errno = 0; 24877c478bd9Sstevel@tonic-gate number = strtol(p, &q, 10); 24887c478bd9Sstevel@tonic-gate 24897c478bd9Sstevel@tonic-gate if (errno != 0 || q == p || *q != '\0') { 24907c478bd9Sstevel@tonic-gate if ((error = errno) == 0) { 24917c478bd9Sstevel@tonic-gate /* 24927c478bd9Sstevel@tonic-gate * strtol() can fail without setting errno, or it can 24937c478bd9Sstevel@tonic-gate * set it to EINVAL or ERANGE. In the case errno is 24947c478bd9Sstevel@tonic-gate * still zero, return EINVAL. 24957c478bd9Sstevel@tonic-gate */ 24967c478bd9Sstevel@tonic-gate error = EINVAL; 24977c478bd9Sstevel@tonic-gate } 24987c478bd9Sstevel@tonic-gate } else if (number < min || number > max) { 24997c478bd9Sstevel@tonic-gate error = ERANGE; 25007c478bd9Sstevel@tonic-gate } else { 25017c478bd9Sstevel@tonic-gate error = 0; 25027c478bd9Sstevel@tonic-gate } 25037c478bd9Sstevel@tonic-gate 25047c478bd9Sstevel@tonic-gate *val = number; 25057c478bd9Sstevel@tonic-gate 25067c478bd9Sstevel@tonic-gate return (error); 25077c478bd9Sstevel@tonic-gate } 25087c478bd9Sstevel@tonic-gate 2509f48205beScasper /* 2510f48205beScasper * Returns the following: 2511f48205beScasper * 2512*ab618543SJohn Levon * 0 No error 2513*ab618543SJohn Levon * EINVAL Invalid number 2514*ab618543SJohn Levon * ERANGE Value exceeds (min, max) range 2515f48205beScasper */ 2516f48205beScasper static int 2517f48205beScasper str2uid(const char *p, uid_t *val, unsigned long min, unsigned long max) 2518f48205beScasper { 2519f48205beScasper char *q; 2520f48205beScasper unsigned long number; 2521f48205beScasper int error; 2522f48205beScasper 2523f48205beScasper errno = 0; 2524f48205beScasper number = strtoul(p, &q, 10); 2525f48205beScasper 2526f48205beScasper if (errno != 0 || q == p || *q != '\0') { 2527f48205beScasper if ((error = errno) == 0) { 2528f48205beScasper /* 2529f48205beScasper * strtoul() can fail without setting errno, or it can 2530f48205beScasper * set it to EINVAL or ERANGE. In the case errno is 2531f48205beScasper * still zero, return EINVAL. 2532f48205beScasper */ 2533f48205beScasper error = EINVAL; 2534f48205beScasper } 2535f48205beScasper } else if (number < min || number > max) { 2536f48205beScasper error = ERANGE; 2537f48205beScasper } else { 2538f48205beScasper error = 0; 2539f48205beScasper } 2540f48205beScasper 2541f48205beScasper *val = number; 2542f48205beScasper 2543f48205beScasper return (error); 2544f48205beScasper } 2545f48205beScasper 25467c478bd9Sstevel@tonic-gate static int 25477c478bd9Sstevel@tonic-gate pidcmp(const void *p1, const void *p2) 25487c478bd9Sstevel@tonic-gate { 25497c478bd9Sstevel@tonic-gate pid_t i = *((pid_t *)p1); 25507c478bd9Sstevel@tonic-gate pid_t j = *((pid_t *)p2); 25517c478bd9Sstevel@tonic-gate 25527c478bd9Sstevel@tonic-gate return (i - j); 25537c478bd9Sstevel@tonic-gate } 2554