Print this page
2989 Eliminate use of LOGNAME_MAX in ON
1166 useradd have warning with name more 8 chars
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/ps/ps.c
+++ new/usr/src/cmd/ps/ps.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 + * Copyright (c) 2013 Gary Mills
24 + *
23 25 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 26 * Use is subject to license terms.
25 27 */
26 28
27 29 /*
28 30 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
29 31 */
30 32
31 33 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
32 34 /* All Rights Reserved */
33 35
34 36 /*
35 37 * ps -- print things about processes.
36 38 */
37 39 #include <stdio.h>
38 40 #include <ctype.h>
39 41 #include <string.h>
40 42 #include <errno.h>
41 43 #include <fcntl.h>
42 44 #include <pwd.h>
43 45 #include <grp.h>
44 46 #include <sys/types.h>
45 47 #include <sys/stat.h>
46 48 #include <sys/mkdev.h>
47 49 #include <unistd.h>
48 50 #include <stdlib.h>
49 51 #include <limits.h>
50 52 #include <dirent.h>
51 53 #include <sys/signal.h>
52 54 #include <sys/fault.h>
53 55 #include <sys/syscall.h>
54 56 #include <sys/time.h>
55 57 #include <procfs.h>
56 58 #include <locale.h>
57 59 #include <wctype.h>
58 60 #include <wchar.h>
59 61 #include <libw.h>
60 62 #include <stdarg.h>
61 63 #include <sys/proc.h>
62 64 #include <sys/pset.h>
63 65 #include <project.h>
64 66 #include <zone.h>
65 67
66 68 #define min(a, b) ((a) > (b) ? (b) : (a))
67 69 #define max(a, b) ((a) < (b) ? (b) : (a))
68 70
|
↓ open down ↓ |
36 lines elided |
↑ open up ↑ |
69 71 #define NTTYS 20 /* initial size of table for -t option */
70 72 #define SIZ 30 /* initial size of tables for -p, -s, -g, -h and -z */
71 73
72 74 /*
73 75 * Size of buffer holding args for t, p, s, g, u, U, G, z options.
74 76 * Set to ZONENAME_MAX, the minimum value needed to allow any
75 77 * zone to be specified.
76 78 */
77 79 #define ARGSIZ ZONENAME_MAX
78 80
81 +#ifdef LOGNAME_MAX_ILLUMOS
82 +#define MAXUGNAME (LOGNAME_MAX_ILLUMOS+2) /* max chars in a user/group */
83 + /* name or printed u/g id */
84 +#else /* LOGNAME_MAX_ILLUMOS */
79 85 #define MAXUGNAME 10 /* max chars in a user/group name or printed u/g id */
86 +#endif /* LOGNAME_MAX_ILLUMOS */
80 87
81 88 /* Structure for storing user or group info */
82 89 struct ugdata {
83 90 id_t id; /* numeric user-id or group-id */
84 91 char name[MAXUGNAME+1]; /* user/group name, null terminated */
85 92 };
86 93
87 94 struct ughead {
88 95 size_t size; /* number of ugdata structs allocated */
89 96 size_t nent; /* number of active entries */
90 97 struct ugdata *ent; /* pointer to array of actual entries */
91 98 };
92 99
93 100 enum fname { /* enumeration of field names */
94 101 F_USER, /* effective user of the process */
95 102 F_RUSER, /* real user of the process */
96 103 F_GROUP, /* effective group of the process */
97 104 F_RGROUP, /* real group of the process */
98 105 F_UID, /* numeric effective uid of the process */
99 106 F_RUID, /* numeric real uid of the process */
100 107 F_GID, /* numeric effective gid of the process */
101 108 F_RGID, /* numeric real gid of the process */
102 109 F_PID, /* process id */
103 110 F_PPID, /* parent process id */
104 111 F_PGID, /* process group id */
105 112 F_SID, /* session id */
106 113 F_PSR, /* bound processor */
107 114 F_LWP, /* lwp-id */
108 115 F_NLWP, /* number of lwps */
109 116 F_OPRI, /* old priority (obsolete) */
110 117 F_PRI, /* new priority */
111 118 F_F, /* process flags */
112 119 F_S, /* letter indicating the state */
113 120 F_C, /* processor utilization (obsolete) */
114 121 F_PCPU, /* percent of recently used cpu time */
115 122 F_PMEM, /* percent of physical memory used (rss) */
116 123 F_OSZ, /* virtual size of the process in pages */
117 124 F_VSZ, /* virtual size of the process in kilobytes */
118 125 F_RSS, /* resident set size of the process in kilobytes */
119 126 F_NICE, /* "nice" value of the process */
120 127 F_CLASS, /* scheduler class */
121 128 F_STIME, /* start time of the process, hh:mm:ss or Month Day */
122 129 F_ETIME, /* elapsed time of the process, [[dd-]hh:]mm:ss */
123 130 F_TIME, /* cpu time of the process, [[dd-]hh:]mm:ss */
124 131 F_TTY, /* name of the controlling terminal */
125 132 F_ADDR, /* address of the process (obsolete) */
126 133 F_WCHAN, /* wait channel (sleep condition variable) */
127 134 F_FNAME, /* file name of command */
128 135 F_COMM, /* name of command (argv[0] value) */
129 136 F_ARGS, /* name of command plus all its arguments */
130 137 F_TASKID, /* task id */
131 138 F_PROJID, /* project id */
132 139 F_PROJECT, /* project name of the process */
133 140 F_PSET, /* bound processor set */
134 141 F_ZONE, /* zone name */
135 142 F_ZONEID, /* zone id */
136 143 F_CTID, /* process contract id */
137 144 F_LGRP, /* process home lgroup */
138 145 F_DMODEL /* process data model */
139 146 };
140 147
141 148 struct field {
142 149 struct field *next; /* linked list */
143 150 int fname; /* field index */
144 151 const char *header; /* header to use */
145 152 int width; /* width of field */
146 153 };
147 154
148 155 static struct field *fields = NULL; /* fields selected via -o */
149 156 static struct field *last_field = NULL;
150 157 static int do_header = 0;
151 158 static struct timeval now;
152 159
153 160 /* array of defined fields, in fname order */
154 161 struct def_field {
155 162 const char *fname;
156 163 const char *header;
157 164 int width;
158 165 int minwidth;
159 166 };
160 167
161 168 static struct def_field fname[] = {
162 169 /* fname header width minwidth */
163 170 { "user", "USER", 8, 8 },
164 171 { "ruser", "RUSER", 8, 8 },
165 172 { "group", "GROUP", 8, 8 },
166 173 { "rgroup", "RGROUP", 8, 8 },
167 174 { "uid", "UID", 5, 5 },
168 175 { "ruid", "RUID", 5, 5 },
169 176 { "gid", "GID", 5, 5 },
170 177 { "rgid", "RGID", 5, 5 },
171 178 { "pid", "PID", 5, 5 },
172 179 { "ppid", "PPID", 5, 5 },
173 180 { "pgid", "PGID", 5, 5 },
174 181 { "sid", "SID", 5, 5 },
175 182 { "psr", "PSR", 3, 2 },
176 183 { "lwp", "LWP", 6, 2 },
177 184 { "nlwp", "NLWP", 4, 2 },
178 185 { "opri", "PRI", 3, 2 },
179 186 { "pri", "PRI", 3, 2 },
180 187 { "f", "F", 2, 2 },
181 188 { "s", "S", 1, 1 },
182 189 { "c", "C", 2, 2 },
183 190 { "pcpu", "%CPU", 4, 4 },
184 191 { "pmem", "%MEM", 4, 4 },
185 192 { "osz", "SZ", 4, 4 },
186 193 { "vsz", "VSZ", 4, 4 },
187 194 { "rss", "RSS", 4, 4 },
188 195 { "nice", "NI", 2, 2 },
189 196 { "class", "CLS", 4, 2 },
190 197 { "stime", "STIME", 8, 8 },
191 198 { "etime", "ELAPSED", 11, 7 },
192 199 { "time", "TIME", 11, 5 },
193 200 { "tty", "TT", 7, 7 },
194 201 #ifdef _LP64
195 202 { "addr", "ADDR", 16, 8 },
196 203 { "wchan", "WCHAN", 16, 8 },
197 204 #else
198 205 { "addr", "ADDR", 8, 8 },
199 206 { "wchan", "WCHAN", 8, 8 },
200 207 #endif
201 208 { "fname", "COMMAND", 8, 8 },
202 209 { "comm", "COMMAND", 80, 8 },
203 210 { "args", "COMMAND", 80, 80 },
204 211 { "taskid", "TASKID", 5, 5 },
205 212 { "projid", "PROJID", 5, 5 },
206 213 { "project", "PROJECT", 8, 8 },
207 214 { "pset", "PSET", 3, 3 },
208 215 { "zone", "ZONE", 8, 8 },
209 216 { "zoneid", "ZONEID", 5, 5 },
210 217 { "ctid", "CTID", 5, 5 },
211 218 { "lgrp", "LGRP", 4, 2 },
212 219 { "dmodel", "DMODEL", 6, 6 },
213 220 };
214 221
215 222 #define NFIELDS (sizeof (fname) / sizeof (fname[0]))
216 223
217 224 static int retcode = 1;
218 225 static int lflg;
219 226 static int Aflg;
220 227 static int uflg;
221 228 static int Uflg;
222 229 static int Gflg;
223 230 static int aflg;
224 231 static int dflg;
225 232 static int Lflg;
226 233 static int Pflg;
227 234 static int yflg;
228 235 static int pflg;
229 236 static int fflg;
230 237 static int cflg;
231 238 static int jflg;
232 239 static int gflg;
233 240 static int sflg;
234 241 static int tflg;
235 242 static int zflg;
236 243 static int Zflg;
237 244 static int hflg;
238 245 static int Hflg;
239 246 static uid_t tuid = (uid_t)-1;
240 247 static int errflg;
241 248
242 249 static int ndev; /* number of devices */
243 250 static int maxdev; /* number of devl structures allocated */
244 251
245 252 #define DNINCR 100
246 253 #define DNSIZE 14
247 254 static struct devl { /* device list */
248 255 char dname[DNSIZE]; /* device name */
249 256 dev_t ddev; /* device number */
250 257 } *devl;
251 258
252 259 static struct tty {
253 260 char *tname;
254 261 dev_t tdev;
255 262 } *tty = NULL; /* for t option */
256 263 static size_t ttysz = 0;
257 264 static int ntty = 0;
258 265
259 266 static pid_t *pid = NULL; /* for p option */
260 267 static size_t pidsz = 0;
261 268 static size_t npid = 0;
262 269
263 270 static int *lgrps = NULL; /* list of lgroup IDs for for h option */
264 271 static size_t lgrps_size = 0; /* size of the lgrps list */
265 272 static size_t nlgrps = 0; /* number elements in the list */
266 273
267 274 /* Maximum possible lgroup ID value */
268 275 #define MAX_LGRP_ID 256
269 276
270 277 static pid_t *grpid = NULL; /* for g option */
271 278 static size_t grpidsz = 0;
272 279 static int ngrpid = 0;
273 280
274 281 static pid_t *sessid = NULL; /* for s option */
275 282 static size_t sessidsz = 0;
276 283 static int nsessid = 0;
277 284
278 285 static zoneid_t *zoneid = NULL; /* for z option */
279 286 static size_t zoneidsz = 0;
280 287 static int nzoneid = 0;
281 288
282 289 static int kbytes_per_page;
283 290 static int pidwidth;
284 291
285 292 static char *procdir = "/proc"; /* standard /proc directory */
286 293
287 294 static struct ughead euid_tbl; /* table to store selected euid's */
288 295 static struct ughead ruid_tbl; /* table to store selected real uid's */
289 296 static struct ughead egid_tbl; /* table to store selected egid's */
290 297 static struct ughead rgid_tbl; /* table to store selected real gid's */
291 298 static prheader_t *lpsinfobuf; /* buffer to contain lpsinfo */
292 299 static size_t lpbufsize;
293 300
294 301 /*
295 302 * This constant defines the sentinal number of process IDs below which we
296 303 * only examine individual entries in /proc rather than scanning through
297 304 * /proc. This optimization is a huge win in the common case.
298 305 */
299 306 #define PTHRESHOLD 40
300 307
301 308 #define UCB_OPTS "-aceglnrtuvwxSU"
302 309
303 310 static void usage(void);
304 311 static char *getarg(char **);
305 312 static char *parse_format(char *);
306 313 static char *gettty(psinfo_t *);
307 314 static int prfind(int, psinfo_t *, char **);
308 315 static void prcom(psinfo_t *, char *);
309 316 static void prtpct(ushort_t, int);
310 317 static void print_time(time_t, int);
311 318 static void print_field(psinfo_t *, struct field *, const char *);
312 319 static void print_zombie_field(psinfo_t *, struct field *, const char *);
313 320 static void pr_fields(psinfo_t *, const char *,
314 321 void (*print_fld)(psinfo_t *, struct field *, const char *));
315 322 static int search(pid_t *, int, pid_t);
316 323 static void add_ugentry(struct ughead *, char *);
317 324 static int uconv(struct ughead *);
318 325 static int gconv(struct ughead *);
319 326 static int ugfind(id_t, struct ughead *);
320 327 static void prtime(timestruc_t, int, int);
321 328 static void przom(psinfo_t *);
322 329 static int namencnt(char *, int, int);
323 330 static char *err_string(int);
324 331 static int print_proc(char *pname);
325 332 static time_t delta_secs(const timestruc_t *);
326 333 static int str2id(const char *, pid_t *, long, long);
327 334 static int str2uid(const char *, uid_t *, unsigned long, unsigned long);
328 335 static void *Realloc(void *, size_t);
329 336 static int pidcmp(const void *p1, const void *p2);
330 337
331 338 extern int ucbmain(int, char **);
332 339 static int stdmain(int, char **);
333 340
334 341 int
335 342 main(int argc, char **argv)
336 343 {
337 344 const char *me;
338 345
339 346 /*
340 347 * The original two ps'es are linked in a single binary;
341 348 * their main()s are renamed to stdmain for /usr/bin/ps and
342 349 * ucbmain for /usr/ucb/ps.
343 350 * We try to figure out which instance of ps the user wants to run.
344 351 * Traditionally, the UCB variant doesn't require the flag argument
345 352 * start with a "-". If the first argument doesn't start with a
346 353 * "-", we call "ucbmain".
347 354 * If there's a first argument and it starts with a "-", we check
348 355 * whether any of the options isn't acceptable to "ucbmain"; in that
349 356 * case we run "stdmain".
350 357 * If we can't tell from the options which main to call, we check
351 358 * the binary we are running. We default to "stdmain" but
352 359 * any mention in the executable name of "ucb" causes us to call
353 360 * ucbmain.
354 361 */
355 362 if (argv[1] != NULL) {
356 363 if (argv[1][0] != '-')
357 364 return (ucbmain(argc, argv));
358 365 else if (argv[1][strspn(argv[1], UCB_OPTS)] != '\0')
359 366 return (stdmain(argc, argv));
360 367 }
361 368
362 369 me = getexecname();
363 370
364 371 if (me != NULL && strstr(me, "ucb") != NULL)
365 372 return (ucbmain(argc, argv));
366 373 else
367 374 return (stdmain(argc, argv));
368 375 }
369 376
370 377 static int
371 378 stdmain(int argc, char **argv)
372 379 {
373 380 char *p;
374 381 char *p1;
375 382 char *parg;
376 383 int c;
377 384 int i;
378 385 int pgerrflg = 0; /* err flg: non-numeric arg w/p & g options */
379 386 size_t size, len;
380 387 DIR *dirp;
381 388 struct dirent *dentp;
382 389 pid_t maxpid;
383 390 pid_t id;
384 391 int ret;
385 392 char loc_stime_str[32];
386 393
387 394 (void) setlocale(LC_ALL, "");
388 395 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
389 396 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
390 397 #endif
391 398 (void) textdomain(TEXT_DOMAIN);
392 399
393 400 (void) memset(&euid_tbl, 0, sizeof (euid_tbl));
394 401 (void) memset(&ruid_tbl, 0, sizeof (ruid_tbl));
395 402 (void) memset(&egid_tbl, 0, sizeof (egid_tbl));
396 403 (void) memset(&rgid_tbl, 0, sizeof (rgid_tbl));
397 404
398 405 kbytes_per_page = sysconf(_SC_PAGESIZE) / 1024;
399 406
400 407 (void) gettimeofday(&now, NULL);
401 408
402 409 /*
403 410 * calculate width of pid fields based on configured MAXPID
404 411 * (must be at least 5 to retain output format compatibility)
405 412 */
406 413 id = maxpid = (pid_t)sysconf(_SC_MAXPID);
407 414 pidwidth = 1;
408 415 while ((id /= 10) > 0)
409 416 ++pidwidth;
410 417 pidwidth = pidwidth < 5 ? 5 : pidwidth;
411 418
412 419 fname[F_PID].width = fname[F_PPID].width = pidwidth;
413 420 fname[F_PGID].width = fname[F_SID].width = pidwidth;
414 421
415 422 /*
416 423 * TRANSLATION_NOTE
417 424 * Specify the printf format with width and precision for
418 425 * the STIME field.
419 426 */
420 427 len = snprintf(loc_stime_str, sizeof (loc_stime_str),
421 428 dcgettext(NULL, "%8.8s", LC_TIME), "STIME");
422 429 if (len >= sizeof (loc_stime_str))
423 430 len = sizeof (loc_stime_str) - 1;
424 431
425 432 fname[F_STIME].width = fname[F_STIME].minwidth = len;
426 433
427 434 while ((c = getopt(argc, argv, "jlfceAadLPyZHh:t:p:g:u:U:G:n:s:o:z:"))
428 435 != EOF)
429 436 switch (c) {
430 437 case 'H': /* Show home lgroups */
431 438 Hflg++;
432 439 break;
433 440 case 'h':
434 441 /*
435 442 * Show processes/threads with given home lgroups
436 443 */
437 444 hflg++;
438 445 p1 = optarg;
439 446 do {
440 447 int id;
441 448
442 449 /*
443 450 * Get all IDs in the list, verify for
444 451 * correctness and place in lgrps array.
445 452 */
446 453 parg = getarg(&p1);
447 454 /* Convert string to integer */
448 455 ret = str2id(parg, (pid_t *)&id, 0,
449 456 MAX_LGRP_ID);
450 457 /* Complain if ID didn't parse correctly */
451 458 if (ret != 0) {
452 459 pgerrflg++;
453 460 (void) fprintf(stderr,
454 461 gettext("ps: %s "), parg);
455 462 if (ret == EINVAL)
456 463 (void) fprintf(stderr,
457 464 gettext("is an invalid "
458 465 "non-numeric argument"));
459 466 else
460 467 (void) fprintf(stderr,
461 468 gettext("exceeds valid "
462 469 "range"));
463 470 (void) fprintf(stderr,
464 471 gettext(" for -h option\n"));
465 472 continue;
466 473 }
467 474
468 475 /* Extend lgrps array if needed */
469 476 if (nlgrps == lgrps_size) {
470 477 /* Double the size of the lgrps array */
471 478 if (lgrps_size == 0)
472 479 lgrps_size = SIZ;
473 480 lgrps_size *= 2;
474 481 lgrps = Realloc(lgrps,
475 482 lgrps_size * sizeof (int));
476 483 }
477 484 /* place the id in the lgrps table */
478 485 lgrps[nlgrps++] = id;
479 486 } while (*p1);
480 487 break;
481 488 case 'l': /* long listing */
482 489 lflg++;
483 490 break;
484 491 case 'f': /* full listing */
485 492 fflg++;
486 493 break;
487 494 case 'j':
488 495 jflg++;
489 496 break;
490 497 case 'c':
491 498 /*
492 499 * Format output to reflect scheduler changes:
493 500 * high numbers for high priorities and don't
494 501 * print nice or p_cpu values. 'c' option only
495 502 * effective when used with 'l' or 'f' options.
496 503 */
497 504 cflg++;
498 505 break;
499 506 case 'A': /* list every process */
500 507 case 'e': /* (obsolete) list every process */
501 508 Aflg++;
502 509 tflg = Gflg = Uflg = uflg = pflg = gflg = sflg = 0;
503 510 zflg = hflg = 0;
504 511 break;
505 512 case 'a':
506 513 /*
507 514 * Same as 'e' except no session group leaders
508 515 * and no non-terminal processes.
509 516 */
510 517 aflg++;
511 518 break;
512 519 case 'd': /* same as e except no session leaders */
513 520 dflg++;
514 521 break;
515 522 case 'L': /* show lwps */
516 523 Lflg++;
517 524 break;
518 525 case 'P': /* show bound processor */
519 526 Pflg++;
520 527 break;
521 528 case 'y': /* omit F & ADDR, report RSS & SZ in Kby */
522 529 yflg++;
523 530 break;
524 531 case 'n': /* no longer needed; retain as no-op */
525 532 (void) fprintf(stderr,
526 533 gettext("ps: warning: -n option ignored\n"));
527 534 break;
528 535 case 't': /* terminals */
529 536 #define TSZ 30
530 537 tflg++;
531 538 p1 = optarg;
532 539 do {
533 540 char nambuf[TSZ+6]; /* for "/dev/" + '\0' */
534 541 struct stat64 s;
535 542 parg = getarg(&p1);
536 543 p = Realloc(NULL, TSZ+1); /* for '\0' */
537 544 /* zero the buffer before using it */
538 545 p[0] = '\0';
539 546 size = TSZ;
540 547 if (isdigit(*parg)) {
541 548 (void) strcpy(p, "tty");
542 549 size -= 3;
543 550 }
544 551 (void) strncat(p, parg, size);
545 552 if (ntty == ttysz) {
546 553 if ((ttysz *= 2) == 0)
547 554 ttysz = NTTYS;
548 555 tty = Realloc(tty,
549 556 (ttysz + 1) * sizeof (struct tty));
550 557 }
551 558 tty[ntty].tdev = PRNODEV;
552 559 (void) strcpy(nambuf, "/dev/");
553 560 (void) strcat(nambuf, p);
554 561 if (stat64(nambuf, &s) == 0)
555 562 tty[ntty].tdev = s.st_rdev;
556 563 tty[ntty++].tname = p;
557 564 } while (*p1);
558 565 break;
559 566 case 'p': /* proc ids */
560 567 pflg++;
561 568 p1 = optarg;
562 569 do {
563 570 pid_t id;
564 571
565 572 parg = getarg(&p1);
566 573 if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {
567 574 pgerrflg++;
568 575 (void) fprintf(stderr,
569 576 gettext("ps: %s "), parg);
570 577 if (ret == EINVAL)
571 578 (void) fprintf(stderr,
572 579 gettext("is an invalid "
573 580 "non-numeric argument"));
574 581 else
575 582 (void) fprintf(stderr,
576 583 gettext("exceeds valid "
577 584 "range"));
578 585 (void) fprintf(stderr,
579 586 gettext(" for -p option\n"));
580 587 continue;
581 588 }
582 589
583 590 if (npid == pidsz) {
584 591 if ((pidsz *= 2) == 0)
585 592 pidsz = SIZ;
586 593 pid = Realloc(pid,
587 594 pidsz * sizeof (pid_t));
588 595 }
589 596 pid[npid++] = id;
590 597 } while (*p1);
591 598 break;
592 599 case 's': /* session */
593 600 sflg++;
594 601 p1 = optarg;
595 602 do {
596 603 pid_t id;
597 604
598 605 parg = getarg(&p1);
599 606 if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {
600 607 pgerrflg++;
601 608 (void) fprintf(stderr,
602 609 gettext("ps: %s "), parg);
603 610 if (ret == EINVAL)
604 611 (void) fprintf(stderr,
605 612 gettext("is an invalid "
606 613 "non-numeric argument"));
607 614 else
608 615 (void) fprintf(stderr,
609 616 gettext("exceeds valid "
610 617 "range"));
611 618 (void) fprintf(stderr,
612 619 gettext(" for -s option\n"));
613 620 continue;
614 621 }
615 622
616 623 if (nsessid == sessidsz) {
617 624 if ((sessidsz *= 2) == 0)
618 625 sessidsz = SIZ;
619 626 sessid = Realloc(sessid,
620 627 sessidsz * sizeof (pid_t));
621 628 }
622 629 sessid[nsessid++] = id;
623 630 } while (*p1);
624 631 break;
625 632 case 'g': /* proc group */
626 633 gflg++;
627 634 p1 = optarg;
628 635 do {
629 636 pid_t id;
630 637
631 638 parg = getarg(&p1);
632 639 if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {
633 640 pgerrflg++;
634 641 (void) fprintf(stderr,
635 642 gettext("ps: %s "), parg);
636 643 if (ret == EINVAL)
637 644 (void) fprintf(stderr,
638 645 gettext("is an invalid "
639 646 "non-numeric argument"));
640 647 else
641 648 (void) fprintf(stderr,
642 649 gettext("exceeds valid "
643 650 "range"));
644 651 (void) fprintf(stderr,
645 652 gettext(" for -g option\n"));
646 653 continue;
647 654 }
648 655
649 656 if (ngrpid == grpidsz) {
650 657 if ((grpidsz *= 2) == 0)
651 658 grpidsz = SIZ;
652 659 grpid = Realloc(grpid,
653 660 grpidsz * sizeof (pid_t));
654 661 }
655 662 grpid[ngrpid++] = id;
656 663 } while (*p1);
657 664 break;
658 665 case 'u': /* effective user name or number */
659 666 uflg++;
660 667 p1 = optarg;
661 668 do {
662 669 parg = getarg(&p1);
663 670 add_ugentry(&euid_tbl, parg);
664 671 } while (*p1);
665 672 break;
666 673 case 'U': /* real user name or number */
667 674 Uflg++;
668 675 p1 = optarg;
669 676 do {
670 677 parg = getarg(&p1);
671 678 add_ugentry(&ruid_tbl, parg);
672 679 } while (*p1);
673 680 break;
674 681 case 'G': /* real group name or number */
675 682 Gflg++;
676 683 p1 = optarg;
677 684 do {
678 685 parg = getarg(&p1);
679 686 add_ugentry(&rgid_tbl, parg);
680 687 } while (*p1);
681 688 break;
682 689 case 'o': /* output format */
683 690 p = optarg;
684 691 while ((p = parse_format(p)) != NULL)
685 692 ;
686 693 break;
687 694 case 'z': /* zone name or number */
688 695 zflg++;
689 696 p1 = optarg;
690 697 do {
691 698 zoneid_t id;
692 699
693 700 parg = getarg(&p1);
694 701 if (zone_get_id(parg, &id) != 0) {
695 702 pgerrflg++;
696 703 (void) fprintf(stderr,
697 704 gettext("ps: unknown zone %s\n"),
698 705 parg);
699 706 continue;
700 707 }
701 708
702 709 if (nzoneid == zoneidsz) {
703 710 if ((zoneidsz *= 2) == 0)
704 711 zoneidsz = SIZ;
705 712 zoneid = Realloc(zoneid,
706 713 zoneidsz * sizeof (zoneid_t));
707 714 }
708 715 zoneid[nzoneid++] = id;
709 716 } while (*p1);
710 717 break;
711 718 case 'Z': /* show zone name */
712 719 Zflg++;
713 720 break;
714 721 default: /* error on ? */
715 722 errflg++;
716 723 break;
717 724 }
718 725
719 726 if (errflg || optind < argc || pgerrflg)
720 727 usage();
721 728
722 729 if (tflg)
723 730 tty[ntty].tname = NULL;
724 731 /*
725 732 * If an appropriate option has not been specified, use the
726 733 * current terminal and effective uid as the default.
727 734 */
728 735 if (!(aflg|Aflg|dflg|Gflg|hflg|Uflg|uflg|tflg|pflg|gflg|sflg|zflg)) {
729 736 psinfo_t info;
730 737 int procfd;
731 738 char *name;
732 739 char pname[100];
733 740
734 741 /* get our own controlling tty name using /proc */
735 742 (void) snprintf(pname, sizeof (pname),
736 743 "%s/self/psinfo", procdir);
737 744 if ((procfd = open(pname, O_RDONLY)) < 0 ||
738 745 read(procfd, (char *)&info, sizeof (info)) < 0 ||
739 746 info.pr_ttydev == PRNODEV) {
740 747 (void) fprintf(stderr,
741 748 gettext("ps: no controlling terminal\n"));
742 749 exit(1);
743 750 }
744 751 (void) close(procfd);
745 752
746 753 i = 0;
747 754 name = gettty(&info);
748 755 if (*name == '?') {
749 756 (void) fprintf(stderr,
750 757 gettext("ps: can't find controlling terminal\n"));
751 758 exit(1);
752 759 }
753 760 if (ntty == ttysz) {
754 761 if ((ttysz *= 2) == 0)
755 762 ttysz = NTTYS;
756 763 tty = Realloc(tty, (ttysz + 1) * sizeof (struct tty));
757 764 }
758 765 tty[ntty].tdev = info.pr_ttydev;
759 766 tty[ntty++].tname = name;
760 767 tty[ntty].tname = NULL;
761 768 tflg++;
762 769 tuid = getuid();
763 770 }
764 771 if (Aflg) {
765 772 Gflg = Uflg = uflg = pflg = sflg = gflg = aflg = dflg = 0;
766 773 zflg = hflg = 0;
767 774 }
768 775 if (Aflg | aflg | dflg)
769 776 tflg = 0;
770 777
771 778 i = 0; /* prepare to exit on name lookup errors */
772 779 i += uconv(&euid_tbl);
773 780 i += uconv(&ruid_tbl);
774 781 i += gconv(&egid_tbl);
775 782 i += gconv(&rgid_tbl);
776 783 if (i)
777 784 exit(1);
778 785
779 786 /* allocate a buffer for lwpsinfo structures */
780 787 lpbufsize = 4096;
781 788 if (Lflg && (lpsinfobuf = malloc(lpbufsize)) == NULL) {
782 789 (void) fprintf(stderr,
783 790 gettext("ps: no memory\n"));
784 791 exit(1);
785 792 }
786 793
787 794 if (fields) { /* print user-specified header */
788 795 if (do_header) {
789 796 struct field *f;
790 797
791 798 for (f = fields; f != NULL; f = f->next) {
792 799 if (f != fields)
793 800 (void) printf(" ");
794 801 switch (f->fname) {
795 802 case F_TTY:
796 803 (void) printf("%-*s",
797 804 f->width, f->header);
798 805 break;
799 806 case F_FNAME:
800 807 case F_COMM:
801 808 case F_ARGS:
802 809 /*
803 810 * Print these headers full width
804 811 * unless they appear at the end.
805 812 */
806 813 if (f->next != NULL) {
807 814 (void) printf("%-*s",
808 815 f->width, f->header);
809 816 } else {
810 817 (void) printf("%s",
811 818 f->header);
812 819 }
813 820 break;
814 821 default:
815 822 (void) printf("%*s",
816 823 f->width, f->header);
817 824 break;
818 825 }
819 826 }
820 827 (void) printf("\n");
821 828 }
822 829 } else { /* print standard header */
823 830 /*
824 831 * All fields before 'PID' are printed with a trailing space
825 832 * as a separator and that is how we print the headers too.
826 833 */
827 834 if (lflg) {
828 835 if (yflg)
829 836 (void) printf("S ");
830 837 else
831 838 (void) printf(" F S ");
832 839 }
833 840 if (Zflg)
834 841 (void) printf(" ZONE ");
835 842 if (fflg) {
836 843 (void) printf(" UID ");
837 844 } else if (lflg)
838 845 (void) printf(" UID ");
839 846
840 847 (void) printf("%*s", pidwidth, "PID");
841 848 if (lflg || fflg)
842 849 (void) printf(" %*s", pidwidth, "PPID");
843 850 if (jflg)
844 851 (void) printf(" %*s %*s", pidwidth, "PGID",
845 852 pidwidth, "SID");
846 853 if (Lflg)
847 854 (void) printf(" LWP");
848 855 if (Pflg)
849 856 (void) printf(" PSR");
850 857 if (Lflg && fflg)
851 858 (void) printf(" NLWP");
852 859 if (cflg)
853 860 (void) printf(" CLS PRI");
854 861 else if (lflg || fflg) {
855 862 (void) printf(" C");
856 863 if (lflg)
857 864 (void) printf(" PRI NI");
858 865 }
859 866 if (lflg) {
860 867 if (yflg)
861 868 (void) printf(" RSS SZ WCHAN");
862 869 else
863 870 (void) printf(" ADDR SZ WCHAN");
864 871 }
865 872 if (fflg)
866 873 (void) printf(" %s", loc_stime_str);
867 874 if (Hflg)
868 875 (void) printf(" LGRP");
869 876 if (Lflg)
870 877 (void) printf(" TTY LTIME CMD\n");
871 878 else
872 879 (void) printf(" TTY TIME CMD\n");
873 880 }
874 881
875 882
876 883 if (pflg && !(aflg|Aflg|dflg|Gflg|Uflg|uflg|hflg|tflg|gflg|sflg|zflg) &&
877 884 npid <= PTHRESHOLD) {
878 885 /*
879 886 * If we are looking at specific processes go straight
880 887 * to their /proc entries and don't scan /proc.
881 888 */
882 889 int i;
883 890
884 891 (void) qsort(pid, npid, sizeof (pid_t), pidcmp);
885 892 for (i = 0; i < npid; i++) {
886 893 char pname[12];
887 894
888 895 if (i >= 1 && pid[i] == pid[i - 1])
889 896 continue;
890 897 (void) sprintf(pname, "%d", (int)pid[i]);
891 898 if (print_proc(pname) == 0)
892 899 retcode = 0;
893 900 }
894 901 } else {
895 902 /*
896 903 * Determine which processes to print info about by searching
897 904 * the /proc directory and looking at each process.
898 905 */
899 906 if ((dirp = opendir(procdir)) == NULL) {
900 907 (void) fprintf(stderr,
901 908 gettext("ps: cannot open PROC directory %s\n"),
902 909 procdir);
903 910 exit(1);
904 911 }
905 912
906 913 /* for each active process --- */
907 914 while (dentp = readdir(dirp)) {
908 915 if (dentp->d_name[0] == '.') /* skip . and .. */
909 916 continue;
910 917 if (print_proc(dentp->d_name) == 0)
911 918 retcode = 0;
912 919 }
913 920
914 921 (void) closedir(dirp);
915 922 }
916 923 return (retcode);
917 924 }
918 925
919 926
920 927 int
921 928 print_proc(char *pid_name)
922 929 {
923 930 char pname[PATH_MAX];
924 931 int pdlen;
925 932 int found;
926 933 int procfd; /* filedescriptor for /proc/nnnnn/psinfo */
927 934 char *tp; /* ptr to ttyname, if any */
928 935 psinfo_t info; /* process information from /proc */
929 936 lwpsinfo_t *lwpsinfo; /* array of lwpsinfo structs */
930 937
931 938 pdlen = snprintf(pname, sizeof (pname), "%s/%s/", procdir, pid_name);
932 939 if (pdlen >= sizeof (pname) - 10)
933 940 return (1);
934 941 retry:
935 942 (void) strcpy(&pname[pdlen], "psinfo");
936 943 if ((procfd = open(pname, O_RDONLY)) == -1) {
937 944 /* Process may have exited meanwhile. */
938 945 return (1);
939 946 }
940 947 /*
941 948 * Get the info structure for the process and close quickly.
942 949 */
943 950 if (read(procfd, (char *)&info, sizeof (info)) < 0) {
944 951 int saverr = errno;
945 952
946 953 (void) close(procfd);
947 954 if (saverr == EAGAIN)
948 955 goto retry;
949 956 if (saverr != ENOENT)
950 957 (void) fprintf(stderr,
951 958 gettext("ps: read() on %s: %s\n"),
952 959 pname, err_string(saverr));
953 960 return (1);
954 961 }
955 962 (void) close(procfd);
956 963
957 964 found = 0;
958 965 if (info.pr_lwp.pr_state == 0) /* can't happen? */
959 966 return (1);
960 967
961 968 /*
962 969 * Omit session group leaders for 'a' and 'd' options.
963 970 */
964 971 if ((info.pr_pid == info.pr_sid) && (dflg || aflg))
965 972 return (1);
966 973 if (Aflg || dflg)
967 974 found++;
968 975 else if (pflg && search(pid, npid, info.pr_pid))
969 976 found++; /* ppid in p option arg list */
970 977 else if (uflg && ugfind((id_t)info.pr_euid, &euid_tbl))
971 978 found++; /* puid in u option arg list */
972 979 else if (Uflg && ugfind((id_t)info.pr_uid, &ruid_tbl))
973 980 found++; /* puid in U option arg list */
974 981 #ifdef NOT_YET
975 982 else if (gflg && ugfind((id_t)info.pr_egid, &egid_tbl))
976 983 found++; /* pgid in g option arg list */
977 984 #endif /* NOT_YET */
978 985 else if (Gflg && ugfind((id_t)info.pr_gid, &rgid_tbl))
979 986 found++; /* pgid in G option arg list */
980 987 else if (gflg && search(grpid, ngrpid, info.pr_pgid))
981 988 found++; /* grpid in g option arg list */
982 989 else if (sflg && search(sessid, nsessid, info.pr_sid))
983 990 found++; /* sessid in s option arg list */
984 991 else if (zflg && search(zoneid, nzoneid, info.pr_zoneid))
985 992 found++; /* zoneid in z option arg list */
986 993 else if (hflg && search((pid_t *)lgrps, nlgrps, info.pr_lwp.pr_lgrp))
987 994 found++; /* home lgroup in h option arg list */
988 995 if (!found && !tflg && !aflg)
989 996 return (1);
990 997 if (!prfind(found, &info, &tp))
991 998 return (1);
992 999 if (Lflg && (info.pr_nlwp + info.pr_nzomb) > 1) {
993 1000 ssize_t prsz;
994 1001
995 1002 (void) strcpy(&pname[pdlen], "lpsinfo");
996 1003 if ((procfd = open(pname, O_RDONLY)) == -1)
997 1004 return (1);
998 1005 /*
999 1006 * Get the info structures for the lwps.
1000 1007 */
1001 1008 prsz = read(procfd, lpsinfobuf, lpbufsize);
1002 1009 if (prsz == -1) {
1003 1010 int saverr = errno;
1004 1011
1005 1012 (void) close(procfd);
1006 1013 if (saverr == EAGAIN)
1007 1014 goto retry;
1008 1015 if (saverr != ENOENT)
1009 1016 (void) fprintf(stderr,
1010 1017 gettext("ps: read() on %s: %s\n"),
1011 1018 pname, err_string(saverr));
1012 1019 return (1);
1013 1020 }
1014 1021 (void) close(procfd);
1015 1022 if (prsz == lpbufsize) {
1016 1023 /*
1017 1024 * buffer overflow. Realloc new buffer.
1018 1025 * Error handling is done in Realloc().
1019 1026 */
1020 1027 lpbufsize *= 2;
1021 1028 lpsinfobuf = Realloc(lpsinfobuf, lpbufsize);
1022 1029 goto retry;
1023 1030 }
1024 1031 if (lpsinfobuf->pr_nent != (info.pr_nlwp + info.pr_nzomb))
1025 1032 goto retry;
1026 1033 lwpsinfo = (lwpsinfo_t *)(lpsinfobuf + 1);
1027 1034 }
1028 1035 if (!Lflg || (info.pr_nlwp + info.pr_nzomb) <= 1) {
1029 1036 prcom(&info, tp);
1030 1037 } else {
1031 1038 int nlwp = 0;
1032 1039
1033 1040 do {
1034 1041 info.pr_lwp = *lwpsinfo;
1035 1042 prcom(&info, tp);
1036 1043 /* LINTED improper alignment */
1037 1044 lwpsinfo = (lwpsinfo_t *)((char *)lwpsinfo +
1038 1045 lpsinfobuf->pr_entsize);
1039 1046 } while (++nlwp < lpsinfobuf->pr_nent);
1040 1047 }
1041 1048 return (0);
1042 1049 }
1043 1050
1044 1051 static int
1045 1052 field_cmp(const void *l, const void *r)
1046 1053 {
1047 1054 struct def_field *lhs = *((struct def_field **)l);
1048 1055 struct def_field *rhs = *((struct def_field **)r);
1049 1056
1050 1057 return (strcmp(lhs->fname, rhs->fname));
1051 1058 }
1052 1059
1053 1060 static void
1054 1061 usage(void) /* print usage message and quit */
1055 1062 {
1056 1063 struct def_field *df, *sorted[NFIELDS];
1057 1064 int pos = 80, i = 0;
1058 1065
1059 1066 static char usage1[] =
1060 1067 "ps [ -aAdefHlcjLPyZ ] [ -o format ] [ -t termlist ]";
1061 1068 static char usage2[] =
1062 1069 "\t[ -u userlist ] [ -U userlist ] [ -G grouplist ]";
1063 1070 static char usage3[] =
1064 1071 "\t[ -p proclist ] [ -g pgrplist ] [ -s sidlist ]";
1065 1072 static char usage4[] =
1066 1073 "\t[ -z zonelist ] [-h lgrplist]";
1067 1074 static char usage5[] =
1068 1075 " 'format' is one or more of:";
1069 1076
1070 1077 (void) fprintf(stderr,
1071 1078 gettext("usage: %s\n%s\n%s\n%s\n%s"),
1072 1079 gettext(usage1), gettext(usage2), gettext(usage3),
1073 1080 gettext(usage4), gettext(usage5));
1074 1081
1075 1082 /*
1076 1083 * Now print out the possible output formats such that they neatly fit
1077 1084 * into eighty columns. Note that the fact that we are determining
1078 1085 * this output programmatically means that a gettext() is impossible --
1079 1086 * but it would be a mistake to localize the output formats anyway as
1080 1087 * they are tokens for input, not output themselves.
1081 1088 */
1082 1089 for (df = &fname[0]; df < &fname[NFIELDS]; df++)
1083 1090 sorted[i++] = df;
1084 1091
1085 1092 (void) qsort(sorted, NFIELDS, sizeof (void *), field_cmp);
1086 1093
1087 1094 for (i = 0; i < NFIELDS; i++) {
1088 1095 if (pos + strlen((df = sorted[i])->fname) + 1 >= 80) {
1089 1096 (void) fprintf(stderr, "\n\t");
1090 1097 pos = 8;
1091 1098 }
1092 1099
1093 1100 (void) fprintf(stderr, "%s%s", pos > 8 ? " " : "", df->fname);
1094 1101 pos += strlen(df->fname) + 1;
1095 1102 }
1096 1103
1097 1104 (void) fprintf(stderr, "\n");
1098 1105
1099 1106 exit(1);
1100 1107 }
1101 1108
1102 1109 /*
1103 1110 * getarg() finds the next argument in list and copies arg into argbuf.
1104 1111 * p1 first pts to arg passed back from getopt routine. p1 is then
1105 1112 * bumped to next character that is not a comma or blank -- p1 NULL
1106 1113 * indicates end of list.
1107 1114 */
1108 1115 static char *
1109 1116 getarg(char **pp1)
1110 1117 {
1111 1118 static char argbuf[ARGSIZ];
1112 1119 char *p1 = *pp1;
1113 1120 char *parga = argbuf;
1114 1121 int c;
1115 1122
1116 1123 while ((c = *p1) != '\0' && (c == ',' || isspace(c)))
1117 1124 p1++;
1118 1125
1119 1126 while ((c = *p1) != '\0' && c != ',' && !isspace(c)) {
1120 1127 if (parga < argbuf + ARGSIZ - 1)
1121 1128 *parga++ = c;
1122 1129 p1++;
1123 1130 }
1124 1131 *parga = '\0';
1125 1132
1126 1133 while ((c = *p1) != '\0' && (c == ',' || isspace(c)))
1127 1134 p1++;
1128 1135
1129 1136 *pp1 = p1;
1130 1137
1131 1138 return (argbuf);
1132 1139 }
1133 1140
1134 1141 /*
1135 1142 * parse_format() takes the argument to the -o option,
1136 1143 * sets up the next output field structure, and returns
1137 1144 * a pointer to any further output field specifier(s).
1138 1145 * As a side-effect, it increments errflg if encounters a format error.
1139 1146 */
1140 1147 static char *
1141 1148 parse_format(char *arg)
1142 1149 {
1143 1150 int c;
1144 1151 char *name;
1145 1152 char *header = NULL;
1146 1153 int width = 0;
1147 1154 struct def_field *df;
1148 1155 struct field *f;
1149 1156
1150 1157 while ((c = *arg) != '\0' && (c == ',' || isspace(c)))
1151 1158 arg++;
1152 1159 if (c == '\0')
1153 1160 return (NULL);
1154 1161 name = arg;
1155 1162 arg = strpbrk(arg, " \t\r\v\f\n,=");
1156 1163 if (arg != NULL) {
1157 1164 c = *arg;
1158 1165 *arg++ = '\0';
1159 1166 if (c == '=') {
1160 1167 char *s;
1161 1168
1162 1169 header = arg;
1163 1170 arg = NULL;
1164 1171 width = strlen(header);
1165 1172 s = header + width;
1166 1173 while (s > header && isspace(*--s))
1167 1174 *s = '\0';
1168 1175 while (isspace(*header))
1169 1176 header++;
1170 1177 }
1171 1178 }
1172 1179 for (df = &fname[0]; df < &fname[NFIELDS]; df++)
1173 1180 if (strcmp(name, df->fname) == 0) {
1174 1181 if (strcmp(name, "lwp") == 0)
1175 1182 Lflg++;
1176 1183 break;
1177 1184 }
1178 1185 if (df >= &fname[NFIELDS]) {
1179 1186 (void) fprintf(stderr,
1180 1187 gettext("ps: unknown output format: -o %s\n"),
1181 1188 name);
1182 1189 errflg++;
1183 1190 return (arg);
1184 1191 }
1185 1192 if ((f = malloc(sizeof (*f))) == NULL) {
1186 1193 (void) fprintf(stderr,
1187 1194 gettext("ps: malloc() for output format failed, %s\n"),
1188 1195 err_string(errno));
1189 1196 exit(1);
1190 1197 }
1191 1198 f->next = NULL;
1192 1199 f->fname = df - &fname[0];
1193 1200 f->header = header? header : df->header;
1194 1201 if (width == 0)
1195 1202 width = df->width;
1196 1203 if (*f->header != '\0')
1197 1204 do_header = 1;
1198 1205 f->width = max(width, df->minwidth);
1199 1206
1200 1207 if (fields == NULL)
1201 1208 fields = last_field = f;
1202 1209 else {
1203 1210 last_field->next = f;
1204 1211 last_field = f;
1205 1212 }
1206 1213
1207 1214 return (arg);
1208 1215 }
1209 1216
1210 1217 static char *
1211 1218 devlookup(dev_t ddev)
1212 1219 {
1213 1220 struct devl *dp;
1214 1221 int i;
1215 1222
1216 1223 for (dp = devl, i = 0; i < ndev; dp++, i++) {
1217 1224 if (dp->ddev == ddev)
1218 1225 return (dp->dname);
1219 1226 }
1220 1227 return (NULL);
1221 1228 }
1222 1229
1223 1230 static char *
1224 1231 devadd(char *name, dev_t ddev)
1225 1232 {
1226 1233 struct devl *dp;
1227 1234 int leng, start, i;
1228 1235
1229 1236 if (ndev == maxdev) {
1230 1237 maxdev += DNINCR;
1231 1238 devl = Realloc(devl, maxdev * sizeof (struct devl));
1232 1239 }
1233 1240 dp = &devl[ndev++];
1234 1241
1235 1242 dp->ddev = ddev;
1236 1243 if (name == NULL) {
1237 1244 (void) strcpy(dp->dname, "??");
1238 1245 return (dp->dname);
1239 1246 }
1240 1247
1241 1248 leng = strlen(name);
1242 1249 /* Strip off /dev/ */
1243 1250 if (leng < DNSIZE + 4)
1244 1251 (void) strcpy(dp->dname, &name[5]);
1245 1252 else {
1246 1253 start = leng - DNSIZE - 1;
1247 1254
1248 1255 for (i = start; i < leng && name[i] != '/'; i++)
1249 1256 ;
1250 1257 if (i == leng)
1251 1258 (void) strncpy(dp->dname, &name[start], DNSIZE);
1252 1259 else
1253 1260 (void) strncpy(dp->dname, &name[i+1], DNSIZE);
1254 1261 }
1255 1262 return (dp->dname);
1256 1263 }
1257 1264
1258 1265 /*
1259 1266 * gettty returns the user's tty number or ? if none.
1260 1267 */
1261 1268 static char *
1262 1269 gettty(psinfo_t *psinfo)
1263 1270 {
1264 1271 extern char *_ttyname_dev(dev_t, char *, size_t);
1265 1272 static zoneid_t zid = -1;
1266 1273 char devname[TTYNAME_MAX];
1267 1274 char *retval;
1268 1275
1269 1276 if (zid == -1)
1270 1277 zid = getzoneid();
1271 1278
1272 1279 if (psinfo->pr_ttydev == PRNODEV || psinfo->pr_zoneid != zid)
1273 1280 return ("?");
1274 1281
1275 1282 if ((retval = devlookup(psinfo->pr_ttydev)) != NULL)
1276 1283 return (retval);
1277 1284
1278 1285 retval = _ttyname_dev(psinfo->pr_ttydev, devname, sizeof (devname));
1279 1286
1280 1287 return (devadd(retval, psinfo->pr_ttydev));
1281 1288 }
1282 1289
1283 1290 /*
1284 1291 * Find the process's tty and return 1 if process is to be printed.
1285 1292 */
1286 1293 static int
1287 1294 prfind(int found, psinfo_t *psinfo, char **tpp)
1288 1295 {
1289 1296 char *tp;
1290 1297 struct tty *ttyp;
1291 1298
1292 1299 if (psinfo->pr_nlwp == 0) {
1293 1300 /* process is a zombie */
1294 1301 *tpp = "?";
1295 1302 if (tflg && !found)
1296 1303 return (0);
1297 1304 return (1);
1298 1305 }
1299 1306
1300 1307 /*
1301 1308 * Get current terminal. If none ("?") and 'a' is set, don't print
1302 1309 * info. If 't' is set, check if term is in list of desired terminals
1303 1310 * and print it if it is.
1304 1311 */
1305 1312 tp = gettty(psinfo);
1306 1313 if (aflg && *tp == '?') {
1307 1314 *tpp = tp;
1308 1315 return (0);
1309 1316 }
1310 1317 if (tflg && !found) {
1311 1318 int match = 0;
1312 1319 char *other = NULL;
1313 1320 for (ttyp = tty; ttyp->tname != NULL; ttyp++) {
1314 1321 /*
1315 1322 * Look for a name match
1316 1323 */
1317 1324 if (strcmp(tp, ttyp->tname) == 0) {
1318 1325 match = 1;
1319 1326 break;
1320 1327 }
1321 1328 /*
1322 1329 * Look for same device under different names.
1323 1330 */
1324 1331 if ((other == NULL) &&
1325 1332 (ttyp->tdev != PRNODEV) &&
1326 1333 (psinfo->pr_ttydev == ttyp->tdev))
1327 1334 other = ttyp->tname;
1328 1335 }
1329 1336 if (!match && (other != NULL)) {
1330 1337 /*
1331 1338 * found under a different name
1332 1339 */
1333 1340 match = 1;
1334 1341 tp = other;
1335 1342 }
1336 1343 if (!match || (tuid != (uid_t)-1 && tuid != psinfo->pr_euid)) {
1337 1344 /*
1338 1345 * not found OR not matching euid
1339 1346 */
1340 1347 *tpp = tp;
1341 1348 return (0);
1342 1349 }
1343 1350 }
1344 1351 *tpp = tp;
1345 1352 return (1);
1346 1353 }
1347 1354
1348 1355 /*
1349 1356 * Print info about the process.
1350 1357 */
1351 1358 static void
1352 1359 prcom(psinfo_t *psinfo, char *ttyp)
1353 1360 {
1354 1361 char *cp;
1355 1362 long tm;
1356 1363 int bytesleft;
1357 1364 int wcnt, length;
1358 1365 wchar_t wchar;
1359 1366 struct passwd *pwd;
1360 1367 int zombie_lwp;
1361 1368 char zonename[ZONENAME_MAX];
1362 1369
1363 1370 /*
1364 1371 * If process is zombie, call zombie print routine and return.
1365 1372 */
1366 1373 if (psinfo->pr_nlwp == 0) {
1367 1374 if (fields != NULL)
1368 1375 pr_fields(psinfo, ttyp, print_zombie_field);
1369 1376 else
1370 1377 przom(psinfo);
1371 1378 return;
1372 1379 }
1373 1380
1374 1381 zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z');
1375 1382
1376 1383 /*
1377 1384 * If user specified '-o format', print requested fields and return.
1378 1385 */
1379 1386 if (fields != NULL) {
1380 1387 pr_fields(psinfo, ttyp, print_field);
1381 1388 return;
1382 1389 }
1383 1390
1384 1391 /*
1385 1392 * All fields before 'PID' are printed with a trailing space as a
1386 1393 * separator, rather than keeping track of which column is first. All
1387 1394 * other fields are printed with a leading space.
1388 1395 */
1389 1396 if (lflg) {
1390 1397 if (!yflg)
1391 1398 (void) printf("%2x ", psinfo->pr_flag & 0377); /* F */
1392 1399 (void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */
1393 1400 }
1394 1401
1395 1402 if (Zflg) { /* ZONE */
1396 1403 if (getzonenamebyid(psinfo->pr_zoneid, zonename,
1397 1404 sizeof (zonename)) < 0) {
1398 1405 (void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));
1399 1406 } else {
1400 1407 (void) printf("%8.8s ", zonename);
1401 1408 }
1402 1409 }
1403 1410
1404 1411 if (fflg) { /* UID */
1405 1412 if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
1406 1413 (void) printf("%8.8s ", pwd->pw_name);
1407 1414 else
1408 1415 (void) printf(" %7.7u ", psinfo->pr_euid);
1409 1416 } else if (lflg) {
1410 1417 (void) printf("%6u ", psinfo->pr_euid);
1411 1418 }
1412 1419 (void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */
1413 1420 if (lflg || fflg)
1414 1421 (void) printf(" %*d", pidwidth,
1415 1422 (int)psinfo->pr_ppid); /* PPID */
1416 1423 if (jflg) {
1417 1424 (void) printf(" %*d", pidwidth,
1418 1425 (int)psinfo->pr_pgid); /* PGID */
1419 1426 (void) printf(" %*d", pidwidth,
1420 1427 (int)psinfo->pr_sid); /* SID */
1421 1428 }
1422 1429 if (Lflg)
1423 1430 (void) printf(" %5d", (int)psinfo->pr_lwp.pr_lwpid); /* LWP */
1424 1431 if (Pflg) {
1425 1432 if (psinfo->pr_lwp.pr_bindpro == PBIND_NONE) /* PSR */
1426 1433 (void) printf(" -");
1427 1434 else
1428 1435 (void) printf(" %3d", psinfo->pr_lwp.pr_bindpro);
1429 1436 }
1430 1437 if (Lflg && fflg) /* NLWP */
1431 1438 (void) printf(" %5d", psinfo->pr_nlwp + psinfo->pr_nzomb);
1432 1439 if (cflg) {
1433 1440 if (zombie_lwp) /* CLS */
1434 1441 (void) printf(" ");
1435 1442 else
1436 1443 (void) printf(" %4s", psinfo->pr_lwp.pr_clname);
1437 1444 (void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */
1438 1445 } else if (lflg || fflg) {
1439 1446 (void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */
1440 1447 if (lflg) { /* PRI NI */
1441 1448 /*
1442 1449 * Print priorities the old way (lower numbers
1443 1450 * mean higher priority) and print nice value
1444 1451 * for time sharing procs.
1445 1452 */
1446 1453 (void) printf(" %3d", psinfo->pr_lwp.pr_oldpri);
1447 1454 if (psinfo->pr_lwp.pr_oldpri != 0)
1448 1455 (void) printf(" %2d", psinfo->pr_lwp.pr_nice);
1449 1456 else
1450 1457 (void) printf(" %2.2s",
1451 1458 psinfo->pr_lwp.pr_clname);
1452 1459 }
1453 1460 }
1454 1461 if (lflg) {
1455 1462 if (yflg) {
1456 1463 if (psinfo->pr_flag & SSYS) /* RSS */
1457 1464 (void) printf(" 0");
1458 1465 else if (psinfo->pr_rssize)
1459 1466 (void) printf(" %5lu",
1460 1467 (ulong_t)psinfo->pr_rssize);
1461 1468 else
1462 1469 (void) printf(" ?");
1463 1470 if (psinfo->pr_flag & SSYS) /* SZ */
1464 1471 (void) printf(" 0");
1465 1472 else if (psinfo->pr_size)
1466 1473 (void) printf(" %6lu",
1467 1474 (ulong_t)psinfo->pr_size);
1468 1475 else
1469 1476 (void) printf(" ?");
1470 1477 } else {
1471 1478 #ifndef _LP64
1472 1479 if (psinfo->pr_addr) /* ADDR */
1473 1480 (void) printf(" %8lx",
1474 1481 (ulong_t)psinfo->pr_addr);
1475 1482 else
1476 1483 #endif
1477 1484 (void) printf(" ?");
1478 1485 if (psinfo->pr_flag & SSYS) /* SZ */
1479 1486 (void) printf(" 0");
1480 1487 else if (psinfo->pr_size)
1481 1488 (void) printf(" %6lu",
1482 1489 (ulong_t)psinfo->pr_size / kbytes_per_page);
1483 1490 else
1484 1491 (void) printf(" ?");
1485 1492 }
1486 1493 if (psinfo->pr_lwp.pr_sname != 'S') /* WCHAN */
1487 1494 (void) printf(" ");
1488 1495 #ifndef _LP64
1489 1496 else if (psinfo->pr_lwp.pr_wchan)
1490 1497 (void) printf(" %8lx",
1491 1498 (ulong_t)psinfo->pr_lwp.pr_wchan);
1492 1499 #endif
1493 1500 else
1494 1501 (void) printf(" ?");
1495 1502 }
1496 1503 if (fflg) { /* STIME */
1497 1504 int width = fname[F_STIME].width;
1498 1505 if (Lflg)
1499 1506 prtime(psinfo->pr_lwp.pr_start, width + 1, 1);
1500 1507 else
1501 1508 prtime(psinfo->pr_start, width + 1, 1);
1502 1509 }
1503 1510
1504 1511 if (Hflg) {
1505 1512 /* Display home lgroup */
1506 1513 (void) printf(" %4d", (int)psinfo->pr_lwp.pr_lgrp);
1507 1514 }
1508 1515
1509 1516 (void) printf(" %-8.14s", ttyp); /* TTY */
1510 1517 if (Lflg) {
1511 1518 tm = psinfo->pr_lwp.pr_time.tv_sec;
1512 1519 if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)
1513 1520 tm++;
1514 1521 } else {
1515 1522 tm = psinfo->pr_time.tv_sec;
1516 1523 if (psinfo->pr_time.tv_nsec > 500000000)
1517 1524 tm++;
1518 1525 }
1519 1526 (void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* [L]TIME */
1520 1527
1521 1528 if (zombie_lwp) {
1522 1529 (void) printf(" <defunct>\n");
1523 1530 return;
1524 1531 }
1525 1532
1526 1533 if (!fflg) { /* CMD */
1527 1534 wcnt = namencnt(psinfo->pr_fname, 16, 8);
1528 1535 (void) printf(" %.*s\n", wcnt, psinfo->pr_fname);
1529 1536 return;
1530 1537 }
1531 1538
1532 1539
1533 1540 /*
1534 1541 * PRARGSZ == length of cmd arg string.
1535 1542 */
1536 1543 psinfo->pr_psargs[PRARGSZ-1] = '\0';
1537 1544 bytesleft = PRARGSZ;
1538 1545 for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {
1539 1546 length = mbtowc(&wchar, cp, MB_LEN_MAX);
1540 1547 if (length == 0)
1541 1548 break;
1542 1549 if (length < 0 || !iswprint(wchar)) {
1543 1550 if (length < 0)
1544 1551 length = 1;
1545 1552 if (bytesleft <= length) {
1546 1553 *cp = '\0';
1547 1554 break;
1548 1555 }
1549 1556 /* omit the unprintable character */
1550 1557 (void) memmove(cp, cp+length, bytesleft-length);
1551 1558 length = 0;
1552 1559 }
1553 1560 bytesleft -= length;
1554 1561 }
1555 1562 wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, lflg ? 35 : PRARGSZ);
1556 1563 (void) printf(" %.*s\n", wcnt, psinfo->pr_psargs);
1557 1564 }
1558 1565
1559 1566 /*
1560 1567 * Print percent from 16-bit binary fraction [0 .. 1]
1561 1568 * Round up .01 to .1 to indicate some small percentage (the 0x7000 below).
1562 1569 */
1563 1570 static void
1564 1571 prtpct(ushort_t pct, int width)
1565 1572 {
1566 1573 uint_t value = pct; /* need 32 bits to compute with */
1567 1574
1568 1575 value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */
1569 1576 if (value >= 1000)
1570 1577 value = 999;
1571 1578 if ((width -= 2) < 2)
1572 1579 width = 2;
1573 1580 (void) printf("%*u.%u", width, value / 10, value % 10);
1574 1581 }
1575 1582
1576 1583 static void
1577 1584 print_time(time_t tim, int width)
1578 1585 {
1579 1586 char buf[30];
1580 1587 time_t seconds;
1581 1588 time_t minutes;
1582 1589 time_t hours;
1583 1590 time_t days;
1584 1591
1585 1592 if (tim < 0) {
1586 1593 (void) printf("%*s", width, "-");
1587 1594 return;
1588 1595 }
1589 1596
1590 1597 seconds = tim % 60;
1591 1598 tim /= 60;
1592 1599 minutes = tim % 60;
1593 1600 tim /= 60;
1594 1601 hours = tim % 24;
1595 1602 days = tim / 24;
1596 1603
1597 1604 if (days > 0) {
1598 1605 (void) snprintf(buf, sizeof (buf), "%ld-%2.2ld:%2.2ld:%2.2ld",
1599 1606 days, hours, minutes, seconds);
1600 1607 } else if (hours > 0) {
1601 1608 (void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld:%2.2ld",
1602 1609 hours, minutes, seconds);
1603 1610 } else {
1604 1611 (void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld",
1605 1612 minutes, seconds);
1606 1613 }
1607 1614
1608 1615 (void) printf("%*s", width, buf);
1609 1616 }
1610 1617
1611 1618 static void
1612 1619 print_field(psinfo_t *psinfo, struct field *f, const char *ttyp)
1613 1620 {
1614 1621 int width = f->width;
1615 1622 struct passwd *pwd;
1616 1623 struct group *grp;
1617 1624 time_t cputime;
1618 1625 int bytesleft;
1619 1626 int wcnt;
1620 1627 wchar_t wchar;
1621 1628 char *cp;
1622 1629 int length;
1623 1630 ulong_t mask;
1624 1631 char c, *csave;
1625 1632 int zombie_lwp;
1626 1633
1627 1634 zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z');
1628 1635
1629 1636 switch (f->fname) {
1630 1637 case F_RUSER:
1631 1638 if ((pwd = getpwuid(psinfo->pr_uid)) != NULL)
1632 1639 (void) printf("%*s", width, pwd->pw_name);
1633 1640 else
1634 1641 (void) printf("%*u", width, psinfo->pr_uid);
1635 1642 break;
1636 1643 case F_USER:
1637 1644 if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
1638 1645 (void) printf("%*s", width, pwd->pw_name);
1639 1646 else
1640 1647 (void) printf("%*u", width, psinfo->pr_euid);
1641 1648 break;
1642 1649 case F_RGROUP:
1643 1650 if ((grp = getgrgid(psinfo->pr_gid)) != NULL)
1644 1651 (void) printf("%*s", width, grp->gr_name);
1645 1652 else
1646 1653 (void) printf("%*u", width, psinfo->pr_gid);
1647 1654 break;
1648 1655 case F_GROUP:
1649 1656 if ((grp = getgrgid(psinfo->pr_egid)) != NULL)
1650 1657 (void) printf("%*s", width, grp->gr_name);
1651 1658 else
1652 1659 (void) printf("%*u", width, psinfo->pr_egid);
1653 1660 break;
1654 1661 case F_RUID:
1655 1662 (void) printf("%*u", width, psinfo->pr_uid);
1656 1663 break;
1657 1664 case F_UID:
1658 1665 (void) printf("%*u", width, psinfo->pr_euid);
1659 1666 break;
1660 1667 case F_RGID:
1661 1668 (void) printf("%*u", width, psinfo->pr_gid);
1662 1669 break;
1663 1670 case F_GID:
1664 1671 (void) printf("%*u", width, psinfo->pr_egid);
1665 1672 break;
1666 1673 case F_PID:
1667 1674 (void) printf("%*d", width, (int)psinfo->pr_pid);
1668 1675 break;
1669 1676 case F_PPID:
1670 1677 (void) printf("%*d", width, (int)psinfo->pr_ppid);
1671 1678 break;
1672 1679 case F_PGID:
1673 1680 (void) printf("%*d", width, (int)psinfo->pr_pgid);
1674 1681 break;
1675 1682 case F_SID:
1676 1683 (void) printf("%*d", width, (int)psinfo->pr_sid);
1677 1684 break;
1678 1685 case F_PSR:
1679 1686 if (zombie_lwp || psinfo->pr_lwp.pr_bindpro == PBIND_NONE)
1680 1687 (void) printf("%*s", width, "-");
1681 1688 else
1682 1689 (void) printf("%*d", width, psinfo->pr_lwp.pr_bindpro);
1683 1690 break;
1684 1691 case F_LWP:
1685 1692 (void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lwpid);
1686 1693 break;
1687 1694 case F_NLWP:
1688 1695 (void) printf("%*d", width, psinfo->pr_nlwp + psinfo->pr_nzomb);
1689 1696 break;
1690 1697 case F_OPRI:
1691 1698 if (zombie_lwp)
1692 1699 (void) printf("%*s", width, "-");
1693 1700 else
1694 1701 (void) printf("%*d", width, psinfo->pr_lwp.pr_oldpri);
1695 1702 break;
1696 1703 case F_PRI:
1697 1704 if (zombie_lwp)
1698 1705 (void) printf("%*s", width, "-");
1699 1706 else
1700 1707 (void) printf("%*d", width, psinfo->pr_lwp.pr_pri);
1701 1708 break;
1702 1709 case F_F:
1703 1710 mask = 0xffffffffUL;
1704 1711 if (width < 8)
1705 1712 mask >>= (8 - width) * 4;
1706 1713 (void) printf("%*lx", width, psinfo->pr_flag & mask);
1707 1714 break;
1708 1715 case F_S:
1709 1716 (void) printf("%*c", width, psinfo->pr_lwp.pr_sname);
1710 1717 break;
1711 1718 case F_C:
1712 1719 if (zombie_lwp)
1713 1720 (void) printf("%*s", width, "-");
1714 1721 else
1715 1722 (void) printf("%*d", width, psinfo->pr_lwp.pr_cpu);
1716 1723 break;
1717 1724 case F_PCPU:
1718 1725 if (zombie_lwp)
1719 1726 (void) printf("%*s", width, "-");
1720 1727 else if (Lflg)
1721 1728 prtpct(psinfo->pr_lwp.pr_pctcpu, width);
1722 1729 else
1723 1730 prtpct(psinfo->pr_pctcpu, width);
1724 1731 break;
1725 1732 case F_PMEM:
1726 1733 prtpct(psinfo->pr_pctmem, width);
1727 1734 break;
1728 1735 case F_OSZ:
1729 1736 (void) printf("%*lu", width,
1730 1737 (ulong_t)psinfo->pr_size / kbytes_per_page);
1731 1738 break;
1732 1739 case F_VSZ:
1733 1740 (void) printf("%*lu", width, (ulong_t)psinfo->pr_size);
1734 1741 break;
1735 1742 case F_RSS:
1736 1743 (void) printf("%*lu", width, (ulong_t)psinfo->pr_rssize);
1737 1744 break;
1738 1745 case F_NICE:
1739 1746 /* if pr_oldpri is zero, then this class has no nice */
1740 1747 if (zombie_lwp)
1741 1748 (void) printf("%*s", width, "-");
1742 1749 else if (psinfo->pr_lwp.pr_oldpri != 0)
1743 1750 (void) printf("%*d", width, psinfo->pr_lwp.pr_nice);
1744 1751 else
1745 1752 (void) printf("%*.*s", width, width,
1746 1753 psinfo->pr_lwp.pr_clname);
1747 1754 break;
1748 1755 case F_CLASS:
1749 1756 if (zombie_lwp)
1750 1757 (void) printf("%*s", width, "-");
1751 1758 else
1752 1759 (void) printf("%*.*s", width, width,
1753 1760 psinfo->pr_lwp.pr_clname);
1754 1761 break;
1755 1762 case F_STIME:
1756 1763 if (Lflg)
1757 1764 prtime(psinfo->pr_lwp.pr_start, width, 0);
1758 1765 else
1759 1766 prtime(psinfo->pr_start, width, 0);
1760 1767 break;
1761 1768 case F_ETIME:
1762 1769 if (Lflg)
1763 1770 print_time(delta_secs(&psinfo->pr_lwp.pr_start),
1764 1771 width);
1765 1772 else
1766 1773 print_time(delta_secs(&psinfo->pr_start), width);
1767 1774 break;
1768 1775 case F_TIME:
1769 1776 if (Lflg) {
1770 1777 cputime = psinfo->pr_lwp.pr_time.tv_sec;
1771 1778 if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)
1772 1779 cputime++;
1773 1780 } else {
1774 1781 cputime = psinfo->pr_time.tv_sec;
1775 1782 if (psinfo->pr_time.tv_nsec > 500000000)
1776 1783 cputime++;
1777 1784 }
1778 1785 print_time(cputime, width);
1779 1786 break;
1780 1787 case F_TTY:
1781 1788 (void) printf("%-*s", width, ttyp);
1782 1789 break;
1783 1790 case F_ADDR:
1784 1791 if (zombie_lwp)
1785 1792 (void) printf("%*s", width, "-");
1786 1793 else if (Lflg)
1787 1794 (void) printf("%*lx", width,
1788 1795 (long)psinfo->pr_lwp.pr_addr);
1789 1796 else
1790 1797 (void) printf("%*lx", width, (long)psinfo->pr_addr);
1791 1798 break;
1792 1799 case F_WCHAN:
1793 1800 if (!zombie_lwp && psinfo->pr_lwp.pr_wchan)
1794 1801 (void) printf("%*lx", width,
1795 1802 (long)psinfo->pr_lwp.pr_wchan);
1796 1803 else
1797 1804 (void) printf("%*.*s", width, width, "-");
1798 1805 break;
1799 1806 case F_FNAME:
1800 1807 /*
1801 1808 * Print full width unless this is the last output format.
1802 1809 */
1803 1810 if (zombie_lwp) {
1804 1811 if (f->next != NULL)
1805 1812 (void) printf("%-*s", width, "<defunct>");
1806 1813 else
1807 1814 (void) printf("%s", "<defunct>");
1808 1815 break;
1809 1816 }
1810 1817 wcnt = namencnt(psinfo->pr_fname, 16, width);
1811 1818 if (f->next != NULL)
1812 1819 (void) printf("%-*.*s", width, wcnt, psinfo->pr_fname);
1813 1820 else
1814 1821 (void) printf("%-.*s", wcnt, psinfo->pr_fname);
1815 1822 break;
1816 1823 case F_COMM:
1817 1824 if (zombie_lwp) {
1818 1825 if (f->next != NULL)
1819 1826 (void) printf("%-*s", width, "<defunct>");
1820 1827 else
1821 1828 (void) printf("%s", "<defunct>");
1822 1829 break;
1823 1830 }
1824 1831 csave = strpbrk(psinfo->pr_psargs, " \t\r\v\f\n");
1825 1832 if (csave) {
1826 1833 c = *csave;
1827 1834 *csave = '\0';
1828 1835 }
1829 1836 /* FALLTHROUGH */
1830 1837 case F_ARGS:
1831 1838 /*
1832 1839 * PRARGSZ == length of cmd arg string.
1833 1840 */
1834 1841 if (zombie_lwp) {
1835 1842 (void) printf("%-*s", width, "<defunct>");
1836 1843 break;
1837 1844 }
1838 1845 psinfo->pr_psargs[PRARGSZ-1] = '\0';
1839 1846 bytesleft = PRARGSZ;
1840 1847 for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {
1841 1848 length = mbtowc(&wchar, cp, MB_LEN_MAX);
1842 1849 if (length == 0)
1843 1850 break;
1844 1851 if (length < 0 || !iswprint(wchar)) {
1845 1852 if (length < 0)
1846 1853 length = 1;
1847 1854 if (bytesleft <= length) {
1848 1855 *cp = '\0';
1849 1856 break;
1850 1857 }
1851 1858 /* omit the unprintable character */
1852 1859 (void) memmove(cp, cp+length, bytesleft-length);
1853 1860 length = 0;
1854 1861 }
1855 1862 bytesleft -= length;
1856 1863 }
1857 1864 wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, width);
1858 1865 /*
1859 1866 * Print full width unless this is the last format.
1860 1867 */
1861 1868 if (f->next != NULL)
1862 1869 (void) printf("%-*.*s", width, wcnt,
1863 1870 psinfo->pr_psargs);
1864 1871 else
1865 1872 (void) printf("%-.*s", wcnt,
1866 1873 psinfo->pr_psargs);
1867 1874 if (f->fname == F_COMM && csave)
1868 1875 *csave = c;
1869 1876 break;
1870 1877 case F_TASKID:
1871 1878 (void) printf("%*d", width, (int)psinfo->pr_taskid);
1872 1879 break;
1873 1880 case F_PROJID:
1874 1881 (void) printf("%*d", width, (int)psinfo->pr_projid);
1875 1882 break;
1876 1883 case F_PROJECT:
1877 1884 {
1878 1885 struct project cproj;
1879 1886 char proj_buf[PROJECT_BUFSZ];
1880 1887
1881 1888 if ((getprojbyid(psinfo->pr_projid, &cproj,
1882 1889 (void *)&proj_buf, PROJECT_BUFSZ)) == NULL)
1883 1890 (void) printf("%*d", width,
1884 1891 (int)psinfo->pr_projid);
1885 1892 else
1886 1893 (void) printf("%*s", width,
1887 1894 (cproj.pj_name != NULL) ?
1888 1895 cproj.pj_name : "---");
1889 1896 }
1890 1897 break;
1891 1898 case F_PSET:
1892 1899 if (zombie_lwp || psinfo->pr_lwp.pr_bindpset == PS_NONE)
1893 1900 (void) printf("%*s", width, "-");
1894 1901 else
1895 1902 (void) printf("%*d", width, psinfo->pr_lwp.pr_bindpset);
1896 1903 break;
1897 1904 case F_ZONEID:
1898 1905 (void) printf("%*d", width, (int)psinfo->pr_zoneid);
1899 1906 break;
1900 1907 case F_ZONE:
1901 1908 {
1902 1909 char zonename[ZONENAME_MAX];
1903 1910
1904 1911 if (getzonenamebyid(psinfo->pr_zoneid, zonename,
1905 1912 sizeof (zonename)) < 0) {
1906 1913 (void) printf("%*d", width,
1907 1914 ((int)psinfo->pr_zoneid));
1908 1915 } else {
1909 1916 (void) printf("%*s", width, zonename);
1910 1917 }
1911 1918 }
1912 1919 break;
1913 1920 case F_CTID:
1914 1921 if (psinfo->pr_contract == -1)
1915 1922 (void) printf("%*s", width, "-");
1916 1923 else
1917 1924 (void) printf("%*ld", width, (long)psinfo->pr_contract);
1918 1925 break;
1919 1926 case F_LGRP:
1920 1927 /* Display home lgroup */
1921 1928 (void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lgrp);
1922 1929 break;
1923 1930
1924 1931 case F_DMODEL:
1925 1932 (void) printf("%*s", width,
1926 1933 psinfo->pr_dmodel == PR_MODEL_LP64 ? "_LP64" : "_ILP32");
1927 1934 break;
1928 1935 }
1929 1936 }
1930 1937
1931 1938 static void
1932 1939 print_zombie_field(psinfo_t *psinfo, struct field *f, const char *ttyp)
1933 1940 {
1934 1941 int wcnt;
1935 1942 int width = f->width;
1936 1943
1937 1944 switch (f->fname) {
1938 1945 case F_FNAME:
1939 1946 case F_COMM:
1940 1947 case F_ARGS:
1941 1948 /*
1942 1949 * Print full width unless this is the last output format.
1943 1950 */
1944 1951 wcnt = min(width, sizeof ("<defunct>"));
1945 1952 if (f->next != NULL)
1946 1953 (void) printf("%-*.*s", width, wcnt, "<defunct>");
1947 1954 else
1948 1955 (void) printf("%-.*s", wcnt, "<defunct>");
1949 1956 break;
1950 1957
1951 1958 case F_PSR:
1952 1959 case F_PCPU:
1953 1960 case F_PMEM:
1954 1961 case F_NICE:
1955 1962 case F_CLASS:
1956 1963 case F_STIME:
1957 1964 case F_ETIME:
1958 1965 case F_WCHAN:
1959 1966 case F_PSET:
1960 1967 (void) printf("%*s", width, "-");
1961 1968 break;
1962 1969
1963 1970 case F_OPRI:
1964 1971 case F_PRI:
1965 1972 case F_OSZ:
1966 1973 case F_VSZ:
1967 1974 case F_RSS:
1968 1975 (void) printf("%*d", width, 0);
1969 1976 break;
1970 1977
1971 1978 default:
1972 1979 print_field(psinfo, f, ttyp);
1973 1980 break;
1974 1981 }
1975 1982 }
1976 1983
1977 1984 static void
1978 1985 pr_fields(psinfo_t *psinfo, const char *ttyp,
1979 1986 void (*print_fld)(psinfo_t *, struct field *, const char *))
1980 1987 {
1981 1988 struct field *f;
1982 1989
1983 1990 for (f = fields; f != NULL; f = f->next) {
1984 1991 print_fld(psinfo, f, ttyp);
1985 1992 if (f->next != NULL)
1986 1993 (void) printf(" ");
1987 1994 }
1988 1995 (void) printf("\n");
1989 1996 }
1990 1997
1991 1998 /*
1992 1999 * Returns 1 if arg is found in array arr, of length num; 0 otherwise.
1993 2000 */
1994 2001 static int
1995 2002 search(pid_t *arr, int number, pid_t arg)
1996 2003 {
1997 2004 int i;
1998 2005
1999 2006 for (i = 0; i < number; i++)
2000 2007 if (arg == arr[i])
2001 2008 return (1);
2002 2009 return (0);
2003 2010 }
2004 2011
2005 2012 /*
2006 2013 * Add an entry (user, group) to the specified table.
2007 2014 */
2008 2015 static void
2009 2016 add_ugentry(struct ughead *tbl, char *name)
2010 2017 {
2011 2018 struct ugdata *entp;
2012 2019
2013 2020 if (tbl->size == tbl->nent) { /* reallocate the table entries */
2014 2021 if ((tbl->size *= 2) == 0)
2015 2022 tbl->size = 32; /* first time */
2016 2023 tbl->ent = Realloc(tbl->ent, tbl->size*sizeof (struct ugdata));
2017 2024 }
2018 2025 entp = &tbl->ent[tbl->nent++];
2019 2026 entp->id = 0;
2020 2027 (void) strncpy(entp->name, name, MAXUGNAME);
2021 2028 entp->name[MAXUGNAME] = '\0';
2022 2029 }
2023 2030
2024 2031 static int
2025 2032 uconv(struct ughead *uhead)
2026 2033 {
2027 2034 struct ugdata *utbl = uhead->ent;
2028 2035 int n = uhead->nent;
2029 2036 struct passwd *pwd;
2030 2037 int i;
2031 2038 int fnd = 0;
2032 2039 uid_t uid;
2033 2040
2034 2041 /*
2035 2042 * Ask the name service for names.
2036 2043 */
2037 2044 for (i = 0; i < n; i++) {
2038 2045 /*
2039 2046 * If name is numeric, ask for numeric id
2040 2047 */
2041 2048 if (str2uid(utbl[i].name, &uid, 0, MAXEPHUID) == 0)
2042 2049 pwd = getpwuid(uid);
2043 2050 else
2044 2051 pwd = getpwnam(utbl[i].name);
2045 2052
2046 2053 /*
2047 2054 * If found, enter found index into tbl array.
2048 2055 */
2049 2056 if (pwd == NULL) {
2050 2057 (void) fprintf(stderr,
2051 2058 gettext("ps: unknown user %s\n"), utbl[i].name);
2052 2059 continue;
2053 2060 }
2054 2061
2055 2062 utbl[fnd].id = pwd->pw_uid;
2056 2063 (void) strncpy(utbl[fnd].name, pwd->pw_name, MAXUGNAME);
2057 2064 fnd++;
2058 2065 }
2059 2066
2060 2067 uhead->nent = fnd; /* in case it changed */
2061 2068 return (n - fnd);
2062 2069 }
2063 2070
2064 2071 static int
2065 2072 gconv(struct ughead *ghead)
2066 2073 {
2067 2074 struct ugdata *gtbl = ghead->ent;
2068 2075 int n = ghead->nent;
2069 2076 struct group *grp;
2070 2077 gid_t gid;
2071 2078 int i;
2072 2079 int fnd = 0;
2073 2080
2074 2081 /*
2075 2082 * Ask the name service for names.
2076 2083 */
2077 2084 for (i = 0; i < n; i++) {
2078 2085 /*
2079 2086 * If name is numeric, ask for numeric id
2080 2087 */
2081 2088 if (str2uid(gtbl[i].name, (uid_t *)&gid, 0, MAXEPHUID) == 0)
2082 2089 grp = getgrgid(gid);
2083 2090 else
2084 2091 grp = getgrnam(gtbl[i].name);
2085 2092 /*
2086 2093 * If found, enter found index into tbl array.
2087 2094 */
2088 2095 if (grp == NULL) {
2089 2096 (void) fprintf(stderr,
2090 2097 gettext("ps: unknown group %s\n"), gtbl[i].name);
2091 2098 continue;
2092 2099 }
2093 2100
2094 2101 gtbl[fnd].id = grp->gr_gid;
2095 2102 (void) strncpy(gtbl[fnd].name, grp->gr_name, MAXUGNAME);
2096 2103 fnd++;
2097 2104 }
2098 2105
2099 2106 ghead->nent = fnd; /* in case it changed */
2100 2107 return (n - fnd);
2101 2108 }
2102 2109
2103 2110 /*
2104 2111 * Return 1 if puid is in table, otherwise 0.
2105 2112 */
2106 2113 static int
2107 2114 ugfind(id_t id, struct ughead *ughead)
2108 2115 {
2109 2116 struct ugdata *utbl = ughead->ent;
2110 2117 int n = ughead->nent;
2111 2118 int i;
2112 2119
2113 2120 for (i = 0; i < n; i++)
2114 2121 if (utbl[i].id == id)
2115 2122 return (1);
2116 2123 return (0);
2117 2124 }
2118 2125
2119 2126 /*
2120 2127 * Print starting time of process unless process started more than 24 hours
2121 2128 * ago, in which case the date is printed. The date is printed in the form
2122 2129 * "MMM dd" if old format, else the blank is replaced with an '_' so
2123 2130 * it appears as a single word (for parseability).
2124 2131 */
2125 2132 static void
2126 2133 prtime(timestruc_t st, int width, int old)
2127 2134 {
2128 2135 char sttim[26];
2129 2136 time_t starttime;
2130 2137
2131 2138 starttime = st.tv_sec;
2132 2139 if (st.tv_nsec > 500000000)
2133 2140 starttime++;
2134 2141 if ((now.tv_sec - starttime) >= 24*60*60) {
2135 2142 (void) strftime(sttim, sizeof (sttim), old?
2136 2143 /*
2137 2144 * TRANSLATION_NOTE
2138 2145 * This time format is used by STIME field when -f option
2139 2146 * is specified. Used for processes that begun more than
2140 2147 * 24 hours.
2141 2148 */
2142 2149 dcgettext(NULL, "%b %d", LC_TIME) :
2143 2150 /*
2144 2151 * TRANSLATION_NOTE
2145 2152 * This time format is used by STIME field when -o option
2146 2153 * is specified. Used for processes that begun more than
2147 2154 * 24 hours.
2148 2155 */
2149 2156 dcgettext(NULL, "%b_%d", LC_TIME), localtime(&starttime));
2150 2157 } else {
2151 2158 /*
2152 2159 * TRANSLATION_NOTE
2153 2160 * This time format is used by STIME field when -f or -o option
2154 2161 * is specified. Used for processes that begun less than
2155 2162 * 24 hours.
2156 2163 */
2157 2164 (void) strftime(sttim, sizeof (sttim),
2158 2165 dcgettext(NULL, "%H:%M:%S", LC_TIME),
2159 2166 localtime(&starttime));
2160 2167 }
2161 2168 (void) printf("%*.*s", width, width, sttim);
2162 2169 }
2163 2170
2164 2171 static void
2165 2172 przom(psinfo_t *psinfo)
2166 2173 {
2167 2174 long tm;
2168 2175 struct passwd *pwd;
2169 2176 char zonename[ZONENAME_MAX];
2170 2177
2171 2178 /*
2172 2179 * All fields before 'PID' are printed with a trailing space as a
2173 2180 * spearator, rather than keeping track of which column is first. All
2174 2181 * other fields are printed with a leading space.
2175 2182 */
2176 2183 if (lflg) { /* F S */
2177 2184 if (!yflg)
2178 2185 (void) printf("%2x ", psinfo->pr_flag & 0377); /* F */
2179 2186 (void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */
2180 2187 }
2181 2188 if (Zflg) {
2182 2189 if (getzonenamebyid(psinfo->pr_zoneid, zonename,
2183 2190 sizeof (zonename)) < 0) {
2184 2191 (void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));
2185 2192 } else {
2186 2193 (void) printf("%8.8s ", zonename);
2187 2194 }
2188 2195 }
2189 2196 if (Hflg) {
2190 2197 /* Display home lgroup */
2191 2198 (void) printf(" %6d", (int)psinfo->pr_lwp.pr_lgrp); /* LGRP */
2192 2199 }
2193 2200 if (fflg) {
2194 2201 if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
2195 2202 (void) printf("%8.8s ", pwd->pw_name);
2196 2203 else
2197 2204 (void) printf(" %7.7u ", psinfo->pr_euid);
2198 2205 } else if (lflg)
2199 2206 (void) printf("%6u ", psinfo->pr_euid);
2200 2207
2201 2208 (void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */
2202 2209 if (lflg || fflg)
2203 2210 (void) printf(" %*d", pidwidth,
2204 2211 (int)psinfo->pr_ppid); /* PPID */
2205 2212
2206 2213 if (jflg) {
2207 2214 (void) printf(" %*d", pidwidth,
2208 2215 (int)psinfo->pr_pgid); /* PGID */
2209 2216 (void) printf(" %*d", pidwidth,
2210 2217 (int)psinfo->pr_sid); /* SID */
2211 2218 }
2212 2219
2213 2220 if (Lflg)
2214 2221 (void) printf(" %5d", 0); /* LWP */
2215 2222 if (Pflg)
2216 2223 (void) printf(" -"); /* PSR */
2217 2224 if (Lflg && fflg)
2218 2225 (void) printf(" %5d", 0); /* NLWP */
2219 2226
2220 2227 if (cflg) {
2221 2228 (void) printf(" %4s", "-"); /* zombies have no class */
2222 2229 (void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */
2223 2230 } else if (lflg || fflg) {
2224 2231 (void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */
2225 2232 if (lflg)
2226 2233 (void) printf(" %3d %2s",
2227 2234 psinfo->pr_lwp.pr_oldpri, "-"); /* PRI NI */
2228 2235 }
2229 2236 if (lflg) {
2230 2237 if (yflg) /* RSS SZ WCHAN */
2231 2238 (void) printf(" %5d %6d %8s", 0, 0, "-");
2232 2239 else /* ADDR SZ WCHAN */
2233 2240 (void) printf(" %8s %6d %8s", "-", 0, "-");
2234 2241 }
2235 2242 if (fflg) {
2236 2243 int width = fname[F_STIME].width;
2237 2244 (void) printf(" %*.*s", width, width, "-"); /* STIME */
2238 2245 }
2239 2246 (void) printf(" %-8.14s", "?"); /* TTY */
2240 2247
2241 2248 tm = psinfo->pr_time.tv_sec;
2242 2249 if (psinfo->pr_time.tv_nsec > 500000000)
2243 2250 tm++;
2244 2251 (void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* TIME */
2245 2252 (void) printf(" <defunct>\n");
2246 2253 }
2247 2254
2248 2255 /*
2249 2256 * Function to compute the number of printable bytes in a multibyte
2250 2257 * command string ("internationalization").
2251 2258 */
2252 2259 static int
2253 2260 namencnt(char *cmd, int csisize, int scrsize)
2254 2261 {
2255 2262 int csiwcnt = 0, scrwcnt = 0;
2256 2263 int ncsisz, nscrsz;
2257 2264 wchar_t wchar;
2258 2265 int len;
2259 2266
2260 2267 while (*cmd != '\0') {
2261 2268 if ((len = csisize - csiwcnt) > (int)MB_CUR_MAX)
2262 2269 len = MB_CUR_MAX;
2263 2270 if ((ncsisz = mbtowc(&wchar, cmd, len)) < 0)
2264 2271 return (8); /* default to use for illegal chars */
2265 2272 if ((nscrsz = wcwidth(wchar)) <= 0)
2266 2273 return (8);
2267 2274 if (csiwcnt + ncsisz > csisize || scrwcnt + nscrsz > scrsize)
2268 2275 break;
2269 2276 csiwcnt += ncsisz;
2270 2277 scrwcnt += nscrsz;
2271 2278 cmd += ncsisz;
2272 2279 }
2273 2280 return (csiwcnt);
2274 2281 }
2275 2282
2276 2283 static char *
2277 2284 err_string(int err)
2278 2285 {
2279 2286 static char buf[32];
2280 2287 char *str = strerror(err);
2281 2288
2282 2289 if (str == NULL)
2283 2290 (void) snprintf(str = buf, sizeof (buf), "Errno #%d", err);
2284 2291
2285 2292 return (str);
2286 2293 }
2287 2294
2288 2295 /* If allocation fails, die */
2289 2296 static void *
2290 2297 Realloc(void *ptr, size_t size)
2291 2298 {
2292 2299 ptr = realloc(ptr, size);
2293 2300 if (ptr == NULL) {
2294 2301 (void) fprintf(stderr, gettext("ps: no memory\n"));
2295 2302 exit(1);
2296 2303 }
2297 2304 return (ptr);
2298 2305 }
2299 2306
2300 2307 static time_t
2301 2308 delta_secs(const timestruc_t *start)
2302 2309 {
2303 2310 time_t seconds = now.tv_sec - start->tv_sec;
2304 2311 long nanosecs = now.tv_usec * 1000 - start->tv_nsec;
2305 2312
2306 2313 if (nanosecs >= (NANOSEC / 2))
2307 2314 seconds++;
2308 2315 else if (nanosecs < -(NANOSEC / 2))
2309 2316 seconds--;
2310 2317
2311 2318 return (seconds);
2312 2319 }
2313 2320
2314 2321 /*
2315 2322 * Returns the following:
2316 2323 *
2317 2324 * 0 No error
2318 2325 * EINVAL Invalid number
2319 2326 * ERANGE Value exceeds (min, max) range
2320 2327 */
2321 2328 static int
2322 2329 str2id(const char *p, pid_t *val, long min, long max)
2323 2330 {
2324 2331 char *q;
2325 2332 long number;
2326 2333 int error;
2327 2334
2328 2335 errno = 0;
2329 2336 number = strtol(p, &q, 10);
2330 2337
2331 2338 if (errno != 0 || q == p || *q != '\0') {
2332 2339 if ((error = errno) == 0) {
2333 2340 /*
2334 2341 * strtol() can fail without setting errno, or it can
2335 2342 * set it to EINVAL or ERANGE. In the case errno is
2336 2343 * still zero, return EINVAL.
2337 2344 */
2338 2345 error = EINVAL;
2339 2346 }
2340 2347 } else if (number < min || number > max) {
2341 2348 error = ERANGE;
2342 2349 } else {
2343 2350 error = 0;
2344 2351 }
2345 2352
2346 2353 *val = number;
2347 2354
2348 2355 return (error);
2349 2356 }
2350 2357
2351 2358 /*
2352 2359 * Returns the following:
2353 2360 *
2354 2361 * 0 No error
2355 2362 * EINVAL Invalid number
2356 2363 * ERANGE Value exceeds (min, max) range
2357 2364 */
2358 2365 static int
2359 2366 str2uid(const char *p, uid_t *val, unsigned long min, unsigned long max)
2360 2367 {
2361 2368 char *q;
2362 2369 unsigned long number;
2363 2370 int error;
2364 2371
2365 2372 errno = 0;
2366 2373 number = strtoul(p, &q, 10);
2367 2374
2368 2375 if (errno != 0 || q == p || *q != '\0') {
2369 2376 if ((error = errno) == 0) {
2370 2377 /*
2371 2378 * strtoul() can fail without setting errno, or it can
2372 2379 * set it to EINVAL or ERANGE. In the case errno is
2373 2380 * still zero, return EINVAL.
2374 2381 */
2375 2382 error = EINVAL;
2376 2383 }
2377 2384 } else if (number < min || number > max) {
2378 2385 error = ERANGE;
2379 2386 } else {
2380 2387 error = 0;
2381 2388 }
2382 2389
2383 2390 *val = number;
2384 2391
2385 2392 return (error);
2386 2393 }
2387 2394
2388 2395 static int
2389 2396 pidcmp(const void *p1, const void *p2)
2390 2397 {
2391 2398 pid_t i = *((pid_t *)p1);
2392 2399 pid_t j = *((pid_t *)p2);
2393 2400
2394 2401 return (i - j);
2395 2402 }
|
↓ open down ↓ |
2306 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX