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
79 -#define MAXUGNAME 10 /* max chars in a user/group name or printed u/g id */
81 +#define MAXUGNAME (LOGNAME_MAX+2) /* max chars in a user/group */
82 + /* name or printed u/g id */
80 83
81 84 /* Structure for storing user or group info */
82 85 struct ugdata {
83 86 id_t id; /* numeric user-id or group-id */
84 87 char name[MAXUGNAME+1]; /* user/group name, null terminated */
85 88 };
86 89
87 90 struct ughead {
88 91 size_t size; /* number of ugdata structs allocated */
89 92 size_t nent; /* number of active entries */
90 93 struct ugdata *ent; /* pointer to array of actual entries */
91 94 };
92 95
93 96 enum fname { /* enumeration of field names */
94 97 F_USER, /* effective user of the process */
95 98 F_RUSER, /* real user of the process */
96 99 F_GROUP, /* effective group of the process */
97 100 F_RGROUP, /* real group of the process */
98 101 F_UID, /* numeric effective uid of the process */
99 102 F_RUID, /* numeric real uid of the process */
100 103 F_GID, /* numeric effective gid of the process */
101 104 F_RGID, /* numeric real gid of the process */
102 105 F_PID, /* process id */
103 106 F_PPID, /* parent process id */
104 107 F_PGID, /* process group id */
105 108 F_SID, /* session id */
106 109 F_PSR, /* bound processor */
107 110 F_LWP, /* lwp-id */
108 111 F_NLWP, /* number of lwps */
109 112 F_OPRI, /* old priority (obsolete) */
110 113 F_PRI, /* new priority */
111 114 F_F, /* process flags */
112 115 F_S, /* letter indicating the state */
113 116 F_C, /* processor utilization (obsolete) */
114 117 F_PCPU, /* percent of recently used cpu time */
115 118 F_PMEM, /* percent of physical memory used (rss) */
116 119 F_OSZ, /* virtual size of the process in pages */
117 120 F_VSZ, /* virtual size of the process in kilobytes */
118 121 F_RSS, /* resident set size of the process in kilobytes */
119 122 F_NICE, /* "nice" value of the process */
120 123 F_CLASS, /* scheduler class */
121 124 F_STIME, /* start time of the process, hh:mm:ss or Month Day */
122 125 F_ETIME, /* elapsed time of the process, [[dd-]hh:]mm:ss */
123 126 F_TIME, /* cpu time of the process, [[dd-]hh:]mm:ss */
124 127 F_TTY, /* name of the controlling terminal */
125 128 F_ADDR, /* address of the process (obsolete) */
126 129 F_WCHAN, /* wait channel (sleep condition variable) */
127 130 F_FNAME, /* file name of command */
128 131 F_COMM, /* name of command (argv[0] value) */
129 132 F_ARGS, /* name of command plus all its arguments */
130 133 F_TASKID, /* task id */
131 134 F_PROJID, /* project id */
132 135 F_PROJECT, /* project name of the process */
133 136 F_PSET, /* bound processor set */
134 137 F_ZONE, /* zone name */
135 138 F_ZONEID, /* zone id */
136 139 F_CTID, /* process contract id */
137 140 F_LGRP, /* process home lgroup */
138 141 F_DMODEL /* process data model */
139 142 };
140 143
141 144 struct field {
142 145 struct field *next; /* linked list */
143 146 int fname; /* field index */
144 147 const char *header; /* header to use */
145 148 int width; /* width of field */
146 149 };
147 150
148 151 static struct field *fields = NULL; /* fields selected via -o */
149 152 static struct field *last_field = NULL;
150 153 static int do_header = 0;
151 154 static struct timeval now;
152 155
153 156 /* array of defined fields, in fname order */
154 157 struct def_field {
155 158 const char *fname;
156 159 const char *header;
157 160 int width;
158 161 int minwidth;
159 162 };
160 163
161 164 static struct def_field fname[] = {
162 165 /* fname header width minwidth */
163 166 { "user", "USER", 8, 8 },
164 167 { "ruser", "RUSER", 8, 8 },
165 168 { "group", "GROUP", 8, 8 },
166 169 { "rgroup", "RGROUP", 8, 8 },
167 170 { "uid", "UID", 5, 5 },
168 171 { "ruid", "RUID", 5, 5 },
169 172 { "gid", "GID", 5, 5 },
170 173 { "rgid", "RGID", 5, 5 },
171 174 { "pid", "PID", 5, 5 },
172 175 { "ppid", "PPID", 5, 5 },
173 176 { "pgid", "PGID", 5, 5 },
174 177 { "sid", "SID", 5, 5 },
175 178 { "psr", "PSR", 3, 2 },
176 179 { "lwp", "LWP", 6, 2 },
177 180 { "nlwp", "NLWP", 4, 2 },
178 181 { "opri", "PRI", 3, 2 },
179 182 { "pri", "PRI", 3, 2 },
180 183 { "f", "F", 2, 2 },
181 184 { "s", "S", 1, 1 },
182 185 { "c", "C", 2, 2 },
183 186 { "pcpu", "%CPU", 4, 4 },
184 187 { "pmem", "%MEM", 4, 4 },
185 188 { "osz", "SZ", 4, 4 },
186 189 { "vsz", "VSZ", 4, 4 },
187 190 { "rss", "RSS", 4, 4 },
188 191 { "nice", "NI", 2, 2 },
189 192 { "class", "CLS", 4, 2 },
190 193 { "stime", "STIME", 8, 8 },
191 194 { "etime", "ELAPSED", 11, 7 },
192 195 { "time", "TIME", 11, 5 },
193 196 { "tty", "TT", 7, 7 },
194 197 #ifdef _LP64
195 198 { "addr", "ADDR", 16, 8 },
196 199 { "wchan", "WCHAN", 16, 8 },
197 200 #else
198 201 { "addr", "ADDR", 8, 8 },
199 202 { "wchan", "WCHAN", 8, 8 },
200 203 #endif
201 204 { "fname", "COMMAND", 8, 8 },
202 205 { "comm", "COMMAND", 80, 8 },
203 206 { "args", "COMMAND", 80, 80 },
204 207 { "taskid", "TASKID", 5, 5 },
205 208 { "projid", "PROJID", 5, 5 },
206 209 { "project", "PROJECT", 8, 8 },
207 210 { "pset", "PSET", 3, 3 },
208 211 { "zone", "ZONE", 8, 8 },
209 212 { "zoneid", "ZONEID", 5, 5 },
210 213 { "ctid", "CTID", 5, 5 },
211 214 { "lgrp", "LGRP", 4, 2 },
212 215 { "dmodel", "DMODEL", 6, 6 },
213 216 };
214 217
215 218 #define NFIELDS (sizeof (fname) / sizeof (fname[0]))
216 219
|
↓ open down ↓ |
127 lines elided |
↑ open up ↑ |
217 220 static int retcode = 1;
218 221 static int lflg;
219 222 static int Aflg;
220 223 static int uflg;
221 224 static int Uflg;
222 225 static int Gflg;
223 226 static int aflg;
224 227 static int dflg;
225 228 static int Lflg;
226 229 static int Pflg;
230 +static int Wflg;
227 231 static int yflg;
228 232 static int pflg;
229 233 static int fflg;
230 234 static int cflg;
231 235 static int jflg;
232 236 static int gflg;
233 237 static int sflg;
234 238 static int tflg;
235 239 static int zflg;
236 240 static int Zflg;
237 241 static int hflg;
238 242 static int Hflg;
239 243 static uid_t tuid = (uid_t)-1;
240 244 static int errflg;
241 245
242 246 static int ndev; /* number of devices */
243 247 static int maxdev; /* number of devl structures allocated */
244 248
245 249 #define DNINCR 100
246 250 #define DNSIZE 14
247 251 static struct devl { /* device list */
248 252 char dname[DNSIZE]; /* device name */
249 253 dev_t ddev; /* device number */
250 254 } *devl;
251 255
252 256 static struct tty {
253 257 char *tname;
254 258 dev_t tdev;
255 259 } *tty = NULL; /* for t option */
256 260 static size_t ttysz = 0;
257 261 static int ntty = 0;
258 262
259 263 static pid_t *pid = NULL; /* for p option */
260 264 static size_t pidsz = 0;
261 265 static size_t npid = 0;
262 266
263 267 static int *lgrps = NULL; /* list of lgroup IDs for for h option */
264 268 static size_t lgrps_size = 0; /* size of the lgrps list */
265 269 static size_t nlgrps = 0; /* number elements in the list */
266 270
267 271 /* Maximum possible lgroup ID value */
268 272 #define MAX_LGRP_ID 256
269 273
270 274 static pid_t *grpid = NULL; /* for g option */
271 275 static size_t grpidsz = 0;
272 276 static int ngrpid = 0;
273 277
274 278 static pid_t *sessid = NULL; /* for s option */
275 279 static size_t sessidsz = 0;
276 280 static int nsessid = 0;
277 281
278 282 static zoneid_t *zoneid = NULL; /* for z option */
279 283 static size_t zoneidsz = 0;
280 284 static int nzoneid = 0;
281 285
282 286 static int kbytes_per_page;
283 287 static int pidwidth;
284 288
285 289 static char *procdir = "/proc"; /* standard /proc directory */
286 290
287 291 static struct ughead euid_tbl; /* table to store selected euid's */
288 292 static struct ughead ruid_tbl; /* table to store selected real uid's */
289 293 static struct ughead egid_tbl; /* table to store selected egid's */
290 294 static struct ughead rgid_tbl; /* table to store selected real gid's */
291 295 static prheader_t *lpsinfobuf; /* buffer to contain lpsinfo */
292 296 static size_t lpbufsize;
293 297
294 298 /*
295 299 * This constant defines the sentinal number of process IDs below which we
296 300 * only examine individual entries in /proc rather than scanning through
297 301 * /proc. This optimization is a huge win in the common case.
298 302 */
299 303 #define PTHRESHOLD 40
300 304
301 305 #define UCB_OPTS "-aceglnrtuvwxSU"
302 306
303 307 static void usage(void);
304 308 static char *getarg(char **);
305 309 static char *parse_format(char *);
306 310 static char *gettty(psinfo_t *);
307 311 static int prfind(int, psinfo_t *, char **);
308 312 static void prcom(psinfo_t *, char *);
309 313 static void prtpct(ushort_t, int);
310 314 static void print_time(time_t, int);
311 315 static void print_field(psinfo_t *, struct field *, const char *);
312 316 static void print_zombie_field(psinfo_t *, struct field *, const char *);
313 317 static void pr_fields(psinfo_t *, const char *,
314 318 void (*print_fld)(psinfo_t *, struct field *, const char *));
315 319 static int search(pid_t *, int, pid_t);
316 320 static void add_ugentry(struct ughead *, char *);
317 321 static int uconv(struct ughead *);
318 322 static int gconv(struct ughead *);
319 323 static int ugfind(id_t, struct ughead *);
320 324 static void prtime(timestruc_t, int, int);
321 325 static void przom(psinfo_t *);
322 326 static int namencnt(char *, int, int);
323 327 static char *err_string(int);
324 328 static int print_proc(char *pname);
325 329 static time_t delta_secs(const timestruc_t *);
326 330 static int str2id(const char *, pid_t *, long, long);
327 331 static int str2uid(const char *, uid_t *, unsigned long, unsigned long);
328 332 static void *Realloc(void *, size_t);
329 333 static int pidcmp(const void *p1, const void *p2);
330 334
331 335 extern int ucbmain(int, char **);
332 336 static int stdmain(int, char **);
333 337
334 338 int
335 339 main(int argc, char **argv)
336 340 {
337 341 const char *me;
338 342
339 343 /*
340 344 * The original two ps'es are linked in a single binary;
341 345 * their main()s are renamed to stdmain for /usr/bin/ps and
342 346 * ucbmain for /usr/ucb/ps.
343 347 * We try to figure out which instance of ps the user wants to run.
344 348 * Traditionally, the UCB variant doesn't require the flag argument
345 349 * start with a "-". If the first argument doesn't start with a
346 350 * "-", we call "ucbmain".
347 351 * If there's a first argument and it starts with a "-", we check
348 352 * whether any of the options isn't acceptable to "ucbmain"; in that
349 353 * case we run "stdmain".
350 354 * If we can't tell from the options which main to call, we check
351 355 * the binary we are running. We default to "stdmain" but
352 356 * any mention in the executable name of "ucb" causes us to call
353 357 * ucbmain.
354 358 */
355 359 if (argv[1] != NULL) {
356 360 if (argv[1][0] != '-')
357 361 return (ucbmain(argc, argv));
358 362 else if (argv[1][strspn(argv[1], UCB_OPTS)] != '\0')
359 363 return (stdmain(argc, argv));
360 364 }
361 365
362 366 me = getexecname();
363 367
364 368 if (me != NULL && strstr(me, "ucb") != NULL)
365 369 return (ucbmain(argc, argv));
366 370 else
367 371 return (stdmain(argc, argv));
368 372 }
369 373
370 374 static int
371 375 stdmain(int argc, char **argv)
372 376 {
373 377 char *p;
374 378 char *p1;
375 379 char *parg;
376 380 int c;
377 381 int i;
378 382 int pgerrflg = 0; /* err flg: non-numeric arg w/p & g options */
379 383 size_t size, len;
380 384 DIR *dirp;
381 385 struct dirent *dentp;
382 386 pid_t maxpid;
383 387 pid_t id;
384 388 int ret;
385 389 char loc_stime_str[32];
386 390
387 391 (void) setlocale(LC_ALL, "");
388 392 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
389 393 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
390 394 #endif
391 395 (void) textdomain(TEXT_DOMAIN);
392 396
393 397 (void) memset(&euid_tbl, 0, sizeof (euid_tbl));
394 398 (void) memset(&ruid_tbl, 0, sizeof (ruid_tbl));
395 399 (void) memset(&egid_tbl, 0, sizeof (egid_tbl));
396 400 (void) memset(&rgid_tbl, 0, sizeof (rgid_tbl));
397 401
398 402 kbytes_per_page = sysconf(_SC_PAGESIZE) / 1024;
399 403
400 404 (void) gettimeofday(&now, NULL);
401 405
402 406 /*
403 407 * calculate width of pid fields based on configured MAXPID
404 408 * (must be at least 5 to retain output format compatibility)
405 409 */
406 410 id = maxpid = (pid_t)sysconf(_SC_MAXPID);
407 411 pidwidth = 1;
408 412 while ((id /= 10) > 0)
409 413 ++pidwidth;
410 414 pidwidth = pidwidth < 5 ? 5 : pidwidth;
411 415
412 416 fname[F_PID].width = fname[F_PPID].width = pidwidth;
413 417 fname[F_PGID].width = fname[F_SID].width = pidwidth;
414 418
415 419 /*
416 420 * TRANSLATION_NOTE
|
↓ open down ↓ |
180 lines elided |
↑ open up ↑ |
417 421 * Specify the printf format with width and precision for
418 422 * the STIME field.
419 423 */
420 424 len = snprintf(loc_stime_str, sizeof (loc_stime_str),
421 425 dcgettext(NULL, "%8.8s", LC_TIME), "STIME");
422 426 if (len >= sizeof (loc_stime_str))
423 427 len = sizeof (loc_stime_str) - 1;
424 428
425 429 fname[F_STIME].width = fname[F_STIME].minwidth = len;
426 430
427 - while ((c = getopt(argc, argv, "jlfceAadLPyZHh:t:p:g:u:U:G:n:s:o:z:"))
431 + while ((c = getopt(argc, argv, "jlfceAadLPWyZHh:t:p:g:u:U:G:n:s:o:z:"))
428 432 != EOF)
429 433 switch (c) {
430 434 case 'H': /* Show home lgroups */
431 435 Hflg++;
432 436 break;
433 437 case 'h':
434 438 /*
435 439 * Show processes/threads with given home lgroups
436 440 */
437 441 hflg++;
438 442 p1 = optarg;
439 443 do {
440 444 int id;
441 445
442 446 /*
443 447 * Get all IDs in the list, verify for
444 448 * correctness and place in lgrps array.
445 449 */
446 450 parg = getarg(&p1);
447 451 /* Convert string to integer */
448 452 ret = str2id(parg, (pid_t *)&id, 0,
449 453 MAX_LGRP_ID);
450 454 /* Complain if ID didn't parse correctly */
451 455 if (ret != 0) {
452 456 pgerrflg++;
453 457 (void) fprintf(stderr,
454 458 gettext("ps: %s "), parg);
455 459 if (ret == EINVAL)
456 460 (void) fprintf(stderr,
457 461 gettext("is an invalid "
458 462 "non-numeric argument"));
459 463 else
460 464 (void) fprintf(stderr,
461 465 gettext("exceeds valid "
462 466 "range"));
463 467 (void) fprintf(stderr,
464 468 gettext(" for -h option\n"));
465 469 continue;
466 470 }
467 471
468 472 /* Extend lgrps array if needed */
469 473 if (nlgrps == lgrps_size) {
470 474 /* Double the size of the lgrps array */
471 475 if (lgrps_size == 0)
472 476 lgrps_size = SIZ;
473 477 lgrps_size *= 2;
474 478 lgrps = Realloc(lgrps,
475 479 lgrps_size * sizeof (int));
476 480 }
477 481 /* place the id in the lgrps table */
478 482 lgrps[nlgrps++] = id;
479 483 } while (*p1);
480 484 break;
481 485 case 'l': /* long listing */
482 486 lflg++;
483 487 break;
484 488 case 'f': /* full listing */
485 489 fflg++;
486 490 break;
487 491 case 'j':
488 492 jflg++;
489 493 break;
490 494 case 'c':
491 495 /*
492 496 * Format output to reflect scheduler changes:
493 497 * high numbers for high priorities and don't
494 498 * print nice or p_cpu values. 'c' option only
495 499 * effective when used with 'l' or 'f' options.
496 500 */
497 501 cflg++;
498 502 break;
499 503 case 'A': /* list every process */
500 504 case 'e': /* (obsolete) list every process */
501 505 Aflg++;
502 506 tflg = Gflg = Uflg = uflg = pflg = gflg = sflg = 0;
503 507 zflg = hflg = 0;
504 508 break;
505 509 case 'a':
506 510 /*
507 511 * Same as 'e' except no session group leaders
508 512 * and no non-terminal processes.
509 513 */
510 514 aflg++;
|
↓ open down ↓ |
73 lines elided |
↑ open up ↑ |
511 515 break;
512 516 case 'd': /* same as e except no session leaders */
513 517 dflg++;
514 518 break;
515 519 case 'L': /* show lwps */
516 520 Lflg++;
517 521 break;
518 522 case 'P': /* show bound processor */
519 523 Pflg++;
520 524 break;
525 + case 'W': /* truncate long names */
526 + Wflg++;
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
|
↓ open down ↓ |
519 lines elided |
↑ open up ↑ |
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 - "ps [ -aAdefHlcjLPyZ ] [ -o format ] [ -t termlist ]";
1067 + "ps [ -aAdefHlcjLPWyZ ] [ -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.
|
↓ open down ↓ |
317 lines elided |
↑ open up ↑ |
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 - (void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));
1405 + if (snprintf(NULL, 0, "%d",
1406 + ((int)psinfo->pr_zoneid)) > 7)
1407 + (void) printf(" %6.6d%c ",
1408 + ((int)psinfo->pr_zoneid), '*');
1409 + else
1410 + (void) printf(" %7.7d ",
1411 + ((int)psinfo->pr_zoneid));
1399 1412 } else {
1400 - (void) printf("%8.8s ", zonename);
1413 + if (strlen(zonename) > 8)
1414 + (void) printf("%7.7s%c ", zonename, '*');
1415 + else
1416 + (void) printf("%8.8s ", zonename);
1401 1417 }
1402 1418 }
1403 1419
1404 1420 if (fflg) { /* UID */
1405 - if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
1406 - (void) printf("%8.8s ", pwd->pw_name);
1407 - else
1408 - (void) printf(" %7.7u ", psinfo->pr_euid);
1421 + if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) {
1422 + if (strlen(pwd->pw_name) > 8)
1423 + (void) printf("%7.7s%c ", pwd->pw_name, '*');
1424 + else
1425 + (void) printf("%8.8s ", pwd->pw_name);
1426 + } else {
1427 + if (snprintf(NULL, 0, "%u",
1428 + ((int)psinfo->pr_euid)) > 7)
1429 + (void) printf(" %6.6u%c ", psinfo->pr_euid,
1430 + '*');
1431 + else
1432 + (void) printf(" %7.7u ", psinfo->pr_euid);
1433 + }
1409 1434 } else if (lflg) {
1410 - (void) printf("%6u ", psinfo->pr_euid);
1435 + if (snprintf(NULL, 0, "%u", ((int)psinfo->pr_euid)) > 6)
1436 + (void) printf("%5.5u%c ", psinfo->pr_euid, '*');
1437 + else
1438 + (void) printf("%6u ", psinfo->pr_euid);
1411 1439 }
1412 1440 (void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */
1413 1441 if (lflg || fflg)
1414 1442 (void) printf(" %*d", pidwidth,
1415 1443 (int)psinfo->pr_ppid); /* PPID */
1416 1444 if (jflg) {
1417 1445 (void) printf(" %*d", pidwidth,
1418 1446 (int)psinfo->pr_pgid); /* PGID */
1419 1447 (void) printf(" %*d", pidwidth,
1420 1448 (int)psinfo->pr_sid); /* SID */
1421 1449 }
1422 1450 if (Lflg)
1423 1451 (void) printf(" %5d", (int)psinfo->pr_lwp.pr_lwpid); /* LWP */
1424 1452 if (Pflg) {
1425 1453 if (psinfo->pr_lwp.pr_bindpro == PBIND_NONE) /* PSR */
1426 1454 (void) printf(" -");
1427 1455 else
1428 1456 (void) printf(" %3d", psinfo->pr_lwp.pr_bindpro);
1429 1457 }
1430 1458 if (Lflg && fflg) /* NLWP */
1431 1459 (void) printf(" %5d", psinfo->pr_nlwp + psinfo->pr_nzomb);
1432 1460 if (cflg) {
1433 1461 if (zombie_lwp) /* CLS */
1434 1462 (void) printf(" ");
1435 1463 else
1436 1464 (void) printf(" %4s", psinfo->pr_lwp.pr_clname);
1437 1465 (void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */
1438 1466 } else if (lflg || fflg) {
1439 1467 (void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */
1440 1468 if (lflg) { /* PRI NI */
1441 1469 /*
1442 1470 * Print priorities the old way (lower numbers
1443 1471 * mean higher priority) and print nice value
1444 1472 * for time sharing procs.
1445 1473 */
1446 1474 (void) printf(" %3d", psinfo->pr_lwp.pr_oldpri);
1447 1475 if (psinfo->pr_lwp.pr_oldpri != 0)
1448 1476 (void) printf(" %2d", psinfo->pr_lwp.pr_nice);
1449 1477 else
1450 1478 (void) printf(" %2.2s",
1451 1479 psinfo->pr_lwp.pr_clname);
1452 1480 }
1453 1481 }
1454 1482 if (lflg) {
1455 1483 if (yflg) {
1456 1484 if (psinfo->pr_flag & SSYS) /* RSS */
1457 1485 (void) printf(" 0");
1458 1486 else if (psinfo->pr_rssize)
1459 1487 (void) printf(" %5lu",
1460 1488 (ulong_t)psinfo->pr_rssize);
1461 1489 else
1462 1490 (void) printf(" ?");
1463 1491 if (psinfo->pr_flag & SSYS) /* SZ */
1464 1492 (void) printf(" 0");
1465 1493 else if (psinfo->pr_size)
1466 1494 (void) printf(" %6lu",
1467 1495 (ulong_t)psinfo->pr_size);
1468 1496 else
1469 1497 (void) printf(" ?");
1470 1498 } else {
1471 1499 #ifndef _LP64
1472 1500 if (psinfo->pr_addr) /* ADDR */
1473 1501 (void) printf(" %8lx",
1474 1502 (ulong_t)psinfo->pr_addr);
1475 1503 else
1476 1504 #endif
1477 1505 (void) printf(" ?");
1478 1506 if (psinfo->pr_flag & SSYS) /* SZ */
1479 1507 (void) printf(" 0");
1480 1508 else if (psinfo->pr_size)
1481 1509 (void) printf(" %6lu",
1482 1510 (ulong_t)psinfo->pr_size / kbytes_per_page);
1483 1511 else
1484 1512 (void) printf(" ?");
1485 1513 }
1486 1514 if (psinfo->pr_lwp.pr_sname != 'S') /* WCHAN */
1487 1515 (void) printf(" ");
1488 1516 #ifndef _LP64
1489 1517 else if (psinfo->pr_lwp.pr_wchan)
1490 1518 (void) printf(" %8lx",
1491 1519 (ulong_t)psinfo->pr_lwp.pr_wchan);
1492 1520 #endif
1493 1521 else
1494 1522 (void) printf(" ?");
1495 1523 }
1496 1524 if (fflg) { /* STIME */
1497 1525 int width = fname[F_STIME].width;
1498 1526 if (Lflg)
1499 1527 prtime(psinfo->pr_lwp.pr_start, width + 1, 1);
1500 1528 else
1501 1529 prtime(psinfo->pr_start, width + 1, 1);
1502 1530 }
1503 1531
1504 1532 if (Hflg) {
1505 1533 /* Display home lgroup */
1506 1534 (void) printf(" %4d", (int)psinfo->pr_lwp.pr_lgrp);
1507 1535 }
1508 1536
1509 1537 (void) printf(" %-8.14s", ttyp); /* TTY */
1510 1538 if (Lflg) {
1511 1539 tm = psinfo->pr_lwp.pr_time.tv_sec;
1512 1540 if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)
1513 1541 tm++;
1514 1542 } else {
1515 1543 tm = psinfo->pr_time.tv_sec;
1516 1544 if (psinfo->pr_time.tv_nsec > 500000000)
1517 1545 tm++;
1518 1546 }
1519 1547 (void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* [L]TIME */
1520 1548
1521 1549 if (zombie_lwp) {
1522 1550 (void) printf(" <defunct>\n");
1523 1551 return;
1524 1552 }
1525 1553
1526 1554 if (!fflg) { /* CMD */
1527 1555 wcnt = namencnt(psinfo->pr_fname, 16, 8);
1528 1556 (void) printf(" %.*s\n", wcnt, psinfo->pr_fname);
1529 1557 return;
1530 1558 }
1531 1559
1532 1560
1533 1561 /*
1534 1562 * PRARGSZ == length of cmd arg string.
1535 1563 */
1536 1564 psinfo->pr_psargs[PRARGSZ-1] = '\0';
1537 1565 bytesleft = PRARGSZ;
1538 1566 for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {
1539 1567 length = mbtowc(&wchar, cp, MB_LEN_MAX);
1540 1568 if (length == 0)
1541 1569 break;
1542 1570 if (length < 0 || !iswprint(wchar)) {
1543 1571 if (length < 0)
1544 1572 length = 1;
1545 1573 if (bytesleft <= length) {
1546 1574 *cp = '\0';
1547 1575 break;
1548 1576 }
1549 1577 /* omit the unprintable character */
1550 1578 (void) memmove(cp, cp+length, bytesleft-length);
1551 1579 length = 0;
1552 1580 }
1553 1581 bytesleft -= length;
1554 1582 }
1555 1583 wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, lflg ? 35 : PRARGSZ);
1556 1584 (void) printf(" %.*s\n", wcnt, psinfo->pr_psargs);
1557 1585 }
1558 1586
1559 1587 /*
1560 1588 * Print percent from 16-bit binary fraction [0 .. 1]
1561 1589 * Round up .01 to .1 to indicate some small percentage (the 0x7000 below).
1562 1590 */
1563 1591 static void
1564 1592 prtpct(ushort_t pct, int width)
1565 1593 {
1566 1594 uint_t value = pct; /* need 32 bits to compute with */
1567 1595
1568 1596 value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */
1569 1597 if (value >= 1000)
1570 1598 value = 999;
1571 1599 if ((width -= 2) < 2)
1572 1600 width = 2;
1573 1601 (void) printf("%*u.%u", width, value / 10, value % 10);
1574 1602 }
1575 1603
1576 1604 static void
1577 1605 print_time(time_t tim, int width)
1578 1606 {
1579 1607 char buf[30];
1580 1608 time_t seconds;
1581 1609 time_t minutes;
1582 1610 time_t hours;
1583 1611 time_t days;
1584 1612
1585 1613 if (tim < 0) {
1586 1614 (void) printf("%*s", width, "-");
1587 1615 return;
1588 1616 }
1589 1617
1590 1618 seconds = tim % 60;
1591 1619 tim /= 60;
1592 1620 minutes = tim % 60;
1593 1621 tim /= 60;
1594 1622 hours = tim % 24;
1595 1623 days = tim / 24;
1596 1624
1597 1625 if (days > 0) {
1598 1626 (void) snprintf(buf, sizeof (buf), "%ld-%2.2ld:%2.2ld:%2.2ld",
1599 1627 days, hours, minutes, seconds);
1600 1628 } else if (hours > 0) {
1601 1629 (void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld:%2.2ld",
1602 1630 hours, minutes, seconds);
1603 1631 } else {
1604 1632 (void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld",
1605 1633 minutes, seconds);
1606 1634 }
1607 1635
1608 1636 (void) printf("%*s", width, buf);
1609 1637 }
1610 1638
1611 1639 static void
1612 1640 print_field(psinfo_t *psinfo, struct field *f, const char *ttyp)
1613 1641 {
1614 1642 int width = f->width;
1615 1643 struct passwd *pwd;
1616 1644 struct group *grp;
1617 1645 time_t cputime;
1618 1646 int bytesleft;
1619 1647 int wcnt;
1620 1648 wchar_t wchar;
|
↓ open down ↓ |
200 lines elided |
↑ open up ↑ |
1621 1649 char *cp;
1622 1650 int length;
1623 1651 ulong_t mask;
1624 1652 char c, *csave;
1625 1653 int zombie_lwp;
1626 1654
1627 1655 zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z');
1628 1656
1629 1657 switch (f->fname) {
1630 1658 case F_RUSER:
1631 - if ((pwd = getpwuid(psinfo->pr_uid)) != NULL)
1632 - (void) printf("%*s", width, pwd->pw_name);
1633 - else
1634 - (void) printf("%*u", width, psinfo->pr_uid);
1659 + if ((pwd = getpwuid(psinfo->pr_uid)) != NULL) {
1660 + if (Wflg && strlen(pwd->pw_name) > width)
1661 + (void) printf("%.*s%c", width - 1,
1662 + pwd->pw_name, '*');
1663 + else
1664 + (void) printf("%*s", width, pwd->pw_name);
1665 + } else {
1666 + if (Wflg && snprintf(NULL, 0, "%u",
1667 + ((int)psinfo->pr_uid)) > width)
1668 +
1669 + (void) printf("%*u%c", width - 1,
1670 + psinfo->pr_uid, '*');
1671 + else
1672 + (void) printf("%*u", width, psinfo->pr_uid);
1673 + }
1635 1674 break;
1636 1675 case F_USER:
1637 - if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
1638 - (void) printf("%*s", width, pwd->pw_name);
1639 - else
1640 - (void) printf("%*u", width, psinfo->pr_euid);
1676 + if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) {
1677 + if (Wflg && strlen(pwd->pw_name) > width)
1678 + (void) printf("%.*s%c", width - 1,
1679 + pwd->pw_name, '*');
1680 + else
1681 + (void) printf("%*s", width, pwd->pw_name);
1682 + } else {
1683 + if (Wflg && snprintf(NULL, 0, "%u",
1684 + ((int)psinfo->pr_euid)) > width)
1685 +
1686 + (void) printf("%*u%c", width - 1,
1687 + psinfo->pr_euid, '*');
1688 + else
1689 + (void) printf("%*u", width, psinfo->pr_euid);
1690 + }
1641 1691 break;
1642 1692 case F_RGROUP:
1643 1693 if ((grp = getgrgid(psinfo->pr_gid)) != NULL)
1644 1694 (void) printf("%*s", width, grp->gr_name);
1645 1695 else
1646 1696 (void) printf("%*u", width, psinfo->pr_gid);
1647 1697 break;
1648 1698 case F_GROUP:
1649 1699 if ((grp = getgrgid(psinfo->pr_egid)) != NULL)
1650 1700 (void) printf("%*s", width, grp->gr_name);
1651 1701 else
1652 1702 (void) printf("%*u", width, psinfo->pr_egid);
1653 1703 break;
1654 1704 case F_RUID:
1655 1705 (void) printf("%*u", width, psinfo->pr_uid);
1656 1706 break;
1657 1707 case F_UID:
1658 1708 (void) printf("%*u", width, psinfo->pr_euid);
1659 1709 break;
1660 1710 case F_RGID:
1661 1711 (void) printf("%*u", width, psinfo->pr_gid);
1662 1712 break;
1663 1713 case F_GID:
1664 1714 (void) printf("%*u", width, psinfo->pr_egid);
1665 1715 break;
1666 1716 case F_PID:
1667 1717 (void) printf("%*d", width, (int)psinfo->pr_pid);
1668 1718 break;
1669 1719 case F_PPID:
1670 1720 (void) printf("%*d", width, (int)psinfo->pr_ppid);
1671 1721 break;
1672 1722 case F_PGID:
1673 1723 (void) printf("%*d", width, (int)psinfo->pr_pgid);
1674 1724 break;
1675 1725 case F_SID:
1676 1726 (void) printf("%*d", width, (int)psinfo->pr_sid);
1677 1727 break;
1678 1728 case F_PSR:
1679 1729 if (zombie_lwp || psinfo->pr_lwp.pr_bindpro == PBIND_NONE)
1680 1730 (void) printf("%*s", width, "-");
1681 1731 else
1682 1732 (void) printf("%*d", width, psinfo->pr_lwp.pr_bindpro);
1683 1733 break;
1684 1734 case F_LWP:
1685 1735 (void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lwpid);
1686 1736 break;
1687 1737 case F_NLWP:
1688 1738 (void) printf("%*d", width, psinfo->pr_nlwp + psinfo->pr_nzomb);
1689 1739 break;
1690 1740 case F_OPRI:
1691 1741 if (zombie_lwp)
1692 1742 (void) printf("%*s", width, "-");
1693 1743 else
1694 1744 (void) printf("%*d", width, psinfo->pr_lwp.pr_oldpri);
1695 1745 break;
1696 1746 case F_PRI:
1697 1747 if (zombie_lwp)
1698 1748 (void) printf("%*s", width, "-");
1699 1749 else
1700 1750 (void) printf("%*d", width, psinfo->pr_lwp.pr_pri);
1701 1751 break;
1702 1752 case F_F:
1703 1753 mask = 0xffffffffUL;
1704 1754 if (width < 8)
1705 1755 mask >>= (8 - width) * 4;
1706 1756 (void) printf("%*lx", width, psinfo->pr_flag & mask);
1707 1757 break;
1708 1758 case F_S:
1709 1759 (void) printf("%*c", width, psinfo->pr_lwp.pr_sname);
1710 1760 break;
1711 1761 case F_C:
1712 1762 if (zombie_lwp)
1713 1763 (void) printf("%*s", width, "-");
1714 1764 else
1715 1765 (void) printf("%*d", width, psinfo->pr_lwp.pr_cpu);
1716 1766 break;
1717 1767 case F_PCPU:
1718 1768 if (zombie_lwp)
1719 1769 (void) printf("%*s", width, "-");
1720 1770 else if (Lflg)
1721 1771 prtpct(psinfo->pr_lwp.pr_pctcpu, width);
1722 1772 else
1723 1773 prtpct(psinfo->pr_pctcpu, width);
1724 1774 break;
1725 1775 case F_PMEM:
1726 1776 prtpct(psinfo->pr_pctmem, width);
1727 1777 break;
1728 1778 case F_OSZ:
1729 1779 (void) printf("%*lu", width,
1730 1780 (ulong_t)psinfo->pr_size / kbytes_per_page);
1731 1781 break;
1732 1782 case F_VSZ:
1733 1783 (void) printf("%*lu", width, (ulong_t)psinfo->pr_size);
1734 1784 break;
1735 1785 case F_RSS:
1736 1786 (void) printf("%*lu", width, (ulong_t)psinfo->pr_rssize);
1737 1787 break;
1738 1788 case F_NICE:
1739 1789 /* if pr_oldpri is zero, then this class has no nice */
1740 1790 if (zombie_lwp)
1741 1791 (void) printf("%*s", width, "-");
1742 1792 else if (psinfo->pr_lwp.pr_oldpri != 0)
1743 1793 (void) printf("%*d", width, psinfo->pr_lwp.pr_nice);
1744 1794 else
1745 1795 (void) printf("%*.*s", width, width,
1746 1796 psinfo->pr_lwp.pr_clname);
1747 1797 break;
1748 1798 case F_CLASS:
1749 1799 if (zombie_lwp)
1750 1800 (void) printf("%*s", width, "-");
1751 1801 else
1752 1802 (void) printf("%*.*s", width, width,
1753 1803 psinfo->pr_lwp.pr_clname);
1754 1804 break;
1755 1805 case F_STIME:
1756 1806 if (Lflg)
1757 1807 prtime(psinfo->pr_lwp.pr_start, width, 0);
1758 1808 else
1759 1809 prtime(psinfo->pr_start, width, 0);
1760 1810 break;
1761 1811 case F_ETIME:
1762 1812 if (Lflg)
1763 1813 print_time(delta_secs(&psinfo->pr_lwp.pr_start),
1764 1814 width);
1765 1815 else
1766 1816 print_time(delta_secs(&psinfo->pr_start), width);
1767 1817 break;
1768 1818 case F_TIME:
1769 1819 if (Lflg) {
1770 1820 cputime = psinfo->pr_lwp.pr_time.tv_sec;
1771 1821 if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)
1772 1822 cputime++;
1773 1823 } else {
1774 1824 cputime = psinfo->pr_time.tv_sec;
1775 1825 if (psinfo->pr_time.tv_nsec > 500000000)
1776 1826 cputime++;
1777 1827 }
1778 1828 print_time(cputime, width);
1779 1829 break;
1780 1830 case F_TTY:
1781 1831 (void) printf("%-*s", width, ttyp);
1782 1832 break;
1783 1833 case F_ADDR:
1784 1834 if (zombie_lwp)
1785 1835 (void) printf("%*s", width, "-");
1786 1836 else if (Lflg)
1787 1837 (void) printf("%*lx", width,
1788 1838 (long)psinfo->pr_lwp.pr_addr);
1789 1839 else
1790 1840 (void) printf("%*lx", width, (long)psinfo->pr_addr);
1791 1841 break;
1792 1842 case F_WCHAN:
1793 1843 if (!zombie_lwp && psinfo->pr_lwp.pr_wchan)
1794 1844 (void) printf("%*lx", width,
1795 1845 (long)psinfo->pr_lwp.pr_wchan);
1796 1846 else
1797 1847 (void) printf("%*.*s", width, width, "-");
1798 1848 break;
1799 1849 case F_FNAME:
1800 1850 /*
1801 1851 * Print full width unless this is the last output format.
1802 1852 */
1803 1853 if (zombie_lwp) {
1804 1854 if (f->next != NULL)
1805 1855 (void) printf("%-*s", width, "<defunct>");
1806 1856 else
1807 1857 (void) printf("%s", "<defunct>");
1808 1858 break;
1809 1859 }
1810 1860 wcnt = namencnt(psinfo->pr_fname, 16, width);
1811 1861 if (f->next != NULL)
1812 1862 (void) printf("%-*.*s", width, wcnt, psinfo->pr_fname);
1813 1863 else
1814 1864 (void) printf("%-.*s", wcnt, psinfo->pr_fname);
1815 1865 break;
1816 1866 case F_COMM:
1817 1867 if (zombie_lwp) {
1818 1868 if (f->next != NULL)
1819 1869 (void) printf("%-*s", width, "<defunct>");
1820 1870 else
1821 1871 (void) printf("%s", "<defunct>");
1822 1872 break;
1823 1873 }
1824 1874 csave = strpbrk(psinfo->pr_psargs, " \t\r\v\f\n");
1825 1875 if (csave) {
1826 1876 c = *csave;
1827 1877 *csave = '\0';
1828 1878 }
1829 1879 /* FALLTHROUGH */
1830 1880 case F_ARGS:
1831 1881 /*
1832 1882 * PRARGSZ == length of cmd arg string.
1833 1883 */
1834 1884 if (zombie_lwp) {
1835 1885 (void) printf("%-*s", width, "<defunct>");
1836 1886 break;
1837 1887 }
1838 1888 psinfo->pr_psargs[PRARGSZ-1] = '\0';
1839 1889 bytesleft = PRARGSZ;
1840 1890 for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {
1841 1891 length = mbtowc(&wchar, cp, MB_LEN_MAX);
1842 1892 if (length == 0)
1843 1893 break;
1844 1894 if (length < 0 || !iswprint(wchar)) {
1845 1895 if (length < 0)
1846 1896 length = 1;
1847 1897 if (bytesleft <= length) {
1848 1898 *cp = '\0';
1849 1899 break;
1850 1900 }
1851 1901 /* omit the unprintable character */
1852 1902 (void) memmove(cp, cp+length, bytesleft-length);
1853 1903 length = 0;
1854 1904 }
1855 1905 bytesleft -= length;
1856 1906 }
1857 1907 wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, width);
1858 1908 /*
1859 1909 * Print full width unless this is the last format.
1860 1910 */
1861 1911 if (f->next != NULL)
1862 1912 (void) printf("%-*.*s", width, wcnt,
1863 1913 psinfo->pr_psargs);
1864 1914 else
1865 1915 (void) printf("%-.*s", wcnt,
1866 1916 psinfo->pr_psargs);
1867 1917 if (f->fname == F_COMM && csave)
1868 1918 *csave = c;
1869 1919 break;
1870 1920 case F_TASKID:
1871 1921 (void) printf("%*d", width, (int)psinfo->pr_taskid);
|
↓ open down ↓ |
221 lines elided |
↑ open up ↑ |
1872 1922 break;
1873 1923 case F_PROJID:
1874 1924 (void) printf("%*d", width, (int)psinfo->pr_projid);
1875 1925 break;
1876 1926 case F_PROJECT:
1877 1927 {
1878 1928 struct project cproj;
1879 1929 char proj_buf[PROJECT_BUFSZ];
1880 1930
1881 1931 if ((getprojbyid(psinfo->pr_projid, &cproj,
1882 - (void *)&proj_buf, PROJECT_BUFSZ)) == NULL)
1883 - (void) printf("%*d", width,
1884 - (int)psinfo->pr_projid);
1885 - else
1886 - (void) printf("%*s", width,
1887 - (cproj.pj_name != NULL) ?
1888 - cproj.pj_name : "---");
1932 + (void *)&proj_buf, PROJECT_BUFSZ)) == NULL) {
1933 + if (Wflg && snprintf(NULL, 0, "%d",
1934 + ((int)psinfo->pr_projid)) > width)
1935 + (void) printf("%.*d%c", width - 1,
1936 + ((int)psinfo->pr_projid), '*');
1937 + else
1938 + (void) printf("%*d", width,
1939 + (int)psinfo->pr_projid);
1940 + } else {
1941 + if (Wflg && cproj.pj_name != NULL &&
1942 + strlen(cproj.pj_name) > width)
1943 + (void) printf("%.*s%c", width - 1,
1944 + cproj.pj_name, '*');
1945 + else
1946 + (void) printf("%*s", width,
1947 + (cproj.pj_name != NULL) ?
1948 + cproj.pj_name : "---");
1949 + }
1889 1950 }
1890 1951 break;
1891 1952 case F_PSET:
1892 1953 if (zombie_lwp || psinfo->pr_lwp.pr_bindpset == PS_NONE)
1893 1954 (void) printf("%*s", width, "-");
1894 1955 else
1895 1956 (void) printf("%*d", width, psinfo->pr_lwp.pr_bindpset);
1896 1957 break;
1897 1958 case F_ZONEID:
1898 1959 (void) printf("%*d", width, (int)psinfo->pr_zoneid);
1899 1960 break;
1900 1961 case F_ZONE:
1901 1962 {
1902 1963 char zonename[ZONENAME_MAX];
1903 1964
1904 1965 if (getzonenamebyid(psinfo->pr_zoneid, zonename,
1905 1966 sizeof (zonename)) < 0) {
1906 - (void) printf("%*d", width,
1907 - ((int)psinfo->pr_zoneid));
1967 + if (Wflg && snprintf(NULL, 0, "%d",
1968 + ((int)psinfo->pr_zoneid)) > width)
1969 + (void) printf("%.*d%c", width - 1,
1970 + ((int)psinfo->pr_zoneid), '*');
1971 + else
1972 + (void) printf("%*d", width,
1973 + (int)psinfo->pr_zoneid);
1908 1974 } else {
1909 - (void) printf("%*s", width, zonename);
1975 + if (Wflg && strlen(zonename) > width)
1976 + (void) printf("%.*s%c", width - 1,
1977 + zonename, '*');
1978 + else
1979 + (void) printf("%*s", width, zonename);
1910 1980 }
1911 1981 }
1912 1982 break;
1913 1983 case F_CTID:
1914 1984 if (psinfo->pr_contract == -1)
1915 1985 (void) printf("%*s", width, "-");
1916 1986 else
1917 1987 (void) printf("%*ld", width, (long)psinfo->pr_contract);
1918 1988 break;
1919 1989 case F_LGRP:
1920 1990 /* Display home lgroup */
1921 1991 (void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lgrp);
1922 1992 break;
1923 1993
1924 1994 case F_DMODEL:
1925 1995 (void) printf("%*s", width,
1926 1996 psinfo->pr_dmodel == PR_MODEL_LP64 ? "_LP64" : "_ILP32");
1927 1997 break;
1928 1998 }
1929 1999 }
1930 2000
1931 2001 static void
1932 2002 print_zombie_field(psinfo_t *psinfo, struct field *f, const char *ttyp)
1933 2003 {
1934 2004 int wcnt;
1935 2005 int width = f->width;
1936 2006
1937 2007 switch (f->fname) {
1938 2008 case F_FNAME:
1939 2009 case F_COMM:
1940 2010 case F_ARGS:
1941 2011 /*
1942 2012 * Print full width unless this is the last output format.
1943 2013 */
1944 2014 wcnt = min(width, sizeof ("<defunct>"));
1945 2015 if (f->next != NULL)
1946 2016 (void) printf("%-*.*s", width, wcnt, "<defunct>");
1947 2017 else
1948 2018 (void) printf("%-.*s", wcnt, "<defunct>");
1949 2019 break;
1950 2020
1951 2021 case F_PSR:
1952 2022 case F_PCPU:
1953 2023 case F_PMEM:
1954 2024 case F_NICE:
1955 2025 case F_CLASS:
1956 2026 case F_STIME:
1957 2027 case F_ETIME:
1958 2028 case F_WCHAN:
1959 2029 case F_PSET:
1960 2030 (void) printf("%*s", width, "-");
1961 2031 break;
1962 2032
1963 2033 case F_OPRI:
1964 2034 case F_PRI:
1965 2035 case F_OSZ:
1966 2036 case F_VSZ:
1967 2037 case F_RSS:
1968 2038 (void) printf("%*d", width, 0);
1969 2039 break;
1970 2040
1971 2041 default:
1972 2042 print_field(psinfo, f, ttyp);
1973 2043 break;
1974 2044 }
1975 2045 }
1976 2046
1977 2047 static void
1978 2048 pr_fields(psinfo_t *psinfo, const char *ttyp,
1979 2049 void (*print_fld)(psinfo_t *, struct field *, const char *))
1980 2050 {
1981 2051 struct field *f;
1982 2052
1983 2053 for (f = fields; f != NULL; f = f->next) {
1984 2054 print_fld(psinfo, f, ttyp);
1985 2055 if (f->next != NULL)
1986 2056 (void) printf(" ");
1987 2057 }
1988 2058 (void) printf("\n");
1989 2059 }
1990 2060
1991 2061 /*
1992 2062 * Returns 1 if arg is found in array arr, of length num; 0 otherwise.
1993 2063 */
1994 2064 static int
1995 2065 search(pid_t *arr, int number, pid_t arg)
1996 2066 {
1997 2067 int i;
1998 2068
1999 2069 for (i = 0; i < number; i++)
2000 2070 if (arg == arr[i])
2001 2071 return (1);
2002 2072 return (0);
2003 2073 }
2004 2074
2005 2075 /*
2006 2076 * Add an entry (user, group) to the specified table.
2007 2077 */
2008 2078 static void
2009 2079 add_ugentry(struct ughead *tbl, char *name)
2010 2080 {
2011 2081 struct ugdata *entp;
2012 2082
2013 2083 if (tbl->size == tbl->nent) { /* reallocate the table entries */
2014 2084 if ((tbl->size *= 2) == 0)
2015 2085 tbl->size = 32; /* first time */
2016 2086 tbl->ent = Realloc(tbl->ent, tbl->size*sizeof (struct ugdata));
2017 2087 }
2018 2088 entp = &tbl->ent[tbl->nent++];
2019 2089 entp->id = 0;
2020 2090 (void) strncpy(entp->name, name, MAXUGNAME);
2021 2091 entp->name[MAXUGNAME] = '\0';
2022 2092 }
2023 2093
2024 2094 static int
2025 2095 uconv(struct ughead *uhead)
2026 2096 {
2027 2097 struct ugdata *utbl = uhead->ent;
2028 2098 int n = uhead->nent;
2029 2099 struct passwd *pwd;
2030 2100 int i;
2031 2101 int fnd = 0;
2032 2102 uid_t uid;
2033 2103
2034 2104 /*
2035 2105 * Ask the name service for names.
2036 2106 */
2037 2107 for (i = 0; i < n; i++) {
2038 2108 /*
2039 2109 * If name is numeric, ask for numeric id
2040 2110 */
2041 2111 if (str2uid(utbl[i].name, &uid, 0, MAXEPHUID) == 0)
2042 2112 pwd = getpwuid(uid);
2043 2113 else
2044 2114 pwd = getpwnam(utbl[i].name);
2045 2115
2046 2116 /*
2047 2117 * If found, enter found index into tbl array.
2048 2118 */
2049 2119 if (pwd == NULL) {
2050 2120 (void) fprintf(stderr,
2051 2121 gettext("ps: unknown user %s\n"), utbl[i].name);
2052 2122 continue;
2053 2123 }
2054 2124
2055 2125 utbl[fnd].id = pwd->pw_uid;
2056 2126 (void) strncpy(utbl[fnd].name, pwd->pw_name, MAXUGNAME);
2057 2127 fnd++;
2058 2128 }
2059 2129
2060 2130 uhead->nent = fnd; /* in case it changed */
2061 2131 return (n - fnd);
2062 2132 }
2063 2133
2064 2134 static int
2065 2135 gconv(struct ughead *ghead)
2066 2136 {
2067 2137 struct ugdata *gtbl = ghead->ent;
2068 2138 int n = ghead->nent;
2069 2139 struct group *grp;
2070 2140 gid_t gid;
2071 2141 int i;
2072 2142 int fnd = 0;
2073 2143
2074 2144 /*
2075 2145 * Ask the name service for names.
2076 2146 */
2077 2147 for (i = 0; i < n; i++) {
2078 2148 /*
2079 2149 * If name is numeric, ask for numeric id
2080 2150 */
2081 2151 if (str2uid(gtbl[i].name, (uid_t *)&gid, 0, MAXEPHUID) == 0)
2082 2152 grp = getgrgid(gid);
2083 2153 else
2084 2154 grp = getgrnam(gtbl[i].name);
2085 2155 /*
2086 2156 * If found, enter found index into tbl array.
2087 2157 */
2088 2158 if (grp == NULL) {
2089 2159 (void) fprintf(stderr,
2090 2160 gettext("ps: unknown group %s\n"), gtbl[i].name);
2091 2161 continue;
2092 2162 }
2093 2163
2094 2164 gtbl[fnd].id = grp->gr_gid;
2095 2165 (void) strncpy(gtbl[fnd].name, grp->gr_name, MAXUGNAME);
2096 2166 fnd++;
2097 2167 }
2098 2168
2099 2169 ghead->nent = fnd; /* in case it changed */
2100 2170 return (n - fnd);
2101 2171 }
2102 2172
2103 2173 /*
2104 2174 * Return 1 if puid is in table, otherwise 0.
2105 2175 */
2106 2176 static int
2107 2177 ugfind(id_t id, struct ughead *ughead)
2108 2178 {
2109 2179 struct ugdata *utbl = ughead->ent;
2110 2180 int n = ughead->nent;
2111 2181 int i;
2112 2182
2113 2183 for (i = 0; i < n; i++)
2114 2184 if (utbl[i].id == id)
2115 2185 return (1);
2116 2186 return (0);
2117 2187 }
2118 2188
2119 2189 /*
2120 2190 * Print starting time of process unless process started more than 24 hours
2121 2191 * ago, in which case the date is printed. The date is printed in the form
2122 2192 * "MMM dd" if old format, else the blank is replaced with an '_' so
2123 2193 * it appears as a single word (for parseability).
2124 2194 */
2125 2195 static void
2126 2196 prtime(timestruc_t st, int width, int old)
2127 2197 {
2128 2198 char sttim[26];
2129 2199 time_t starttime;
2130 2200
2131 2201 starttime = st.tv_sec;
2132 2202 if (st.tv_nsec > 500000000)
2133 2203 starttime++;
2134 2204 if ((now.tv_sec - starttime) >= 24*60*60) {
2135 2205 (void) strftime(sttim, sizeof (sttim), old?
2136 2206 /*
2137 2207 * TRANSLATION_NOTE
2138 2208 * This time format is used by STIME field when -f option
2139 2209 * is specified. Used for processes that begun more than
2140 2210 * 24 hours.
2141 2211 */
2142 2212 dcgettext(NULL, "%b %d", LC_TIME) :
2143 2213 /*
2144 2214 * TRANSLATION_NOTE
2145 2215 * This time format is used by STIME field when -o option
2146 2216 * is specified. Used for processes that begun more than
2147 2217 * 24 hours.
2148 2218 */
2149 2219 dcgettext(NULL, "%b_%d", LC_TIME), localtime(&starttime));
2150 2220 } else {
2151 2221 /*
2152 2222 * TRANSLATION_NOTE
2153 2223 * This time format is used by STIME field when -f or -o option
2154 2224 * is specified. Used for processes that begun less than
2155 2225 * 24 hours.
2156 2226 */
2157 2227 (void) strftime(sttim, sizeof (sttim),
2158 2228 dcgettext(NULL, "%H:%M:%S", LC_TIME),
2159 2229 localtime(&starttime));
2160 2230 }
2161 2231 (void) printf("%*.*s", width, width, sttim);
2162 2232 }
2163 2233
2164 2234 static void
2165 2235 przom(psinfo_t *psinfo)
2166 2236 {
2167 2237 long tm;
2168 2238 struct passwd *pwd;
2169 2239 char zonename[ZONENAME_MAX];
2170 2240
2171 2241 /*
2172 2242 * All fields before 'PID' are printed with a trailing space as a
2173 2243 * spearator, rather than keeping track of which column is first. All
|
↓ open down ↓ |
254 lines elided |
↑ open up ↑ |
2174 2244 * other fields are printed with a leading space.
2175 2245 */
2176 2246 if (lflg) { /* F S */
2177 2247 if (!yflg)
2178 2248 (void) printf("%2x ", psinfo->pr_flag & 0377); /* F */
2179 2249 (void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */
2180 2250 }
2181 2251 if (Zflg) {
2182 2252 if (getzonenamebyid(psinfo->pr_zoneid, zonename,
2183 2253 sizeof (zonename)) < 0) {
2184 - (void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));
2254 + if (snprintf(NULL, 0, "%d",
2255 + ((int)psinfo->pr_zoneid)) > 7)
2256 + (void) printf(" %6.6d%c ",
2257 + ((int)psinfo->pr_zoneid), '*');
2258 + else
2259 + (void) printf(" %7.7d ",
2260 + ((int)psinfo->pr_zoneid));
2185 2261 } else {
2186 - (void) printf("%8.8s ", zonename);
2262 + if (strlen(zonename) > 8)
2263 + (void) printf("%7.7s%c ", zonename, '*');
2264 + else
2265 + (void) printf("%8.8s ", zonename);
2187 2266 }
2188 2267 }
2189 2268 if (Hflg) {
2190 2269 /* Display home lgroup */
2191 2270 (void) printf(" %6d", (int)psinfo->pr_lwp.pr_lgrp); /* LGRP */
2192 2271 }
2193 2272 if (fflg) {
2194 - if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
2195 - (void) printf("%8.8s ", pwd->pw_name);
2273 + if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) {
2274 + if (strlen(pwd->pw_name) > 8)
2275 + (void) printf("%7.7s%c ", pwd->pw_name, '*');
2276 + else
2277 + (void) printf("%8.8s ", pwd->pw_name);
2278 + } else {
2279 + if (snprintf(NULL, 0, "%u",
2280 + ((int)psinfo->pr_euid)) > 7)
2281 + (void) printf(" %6.6u%c ", psinfo->pr_euid,
2282 + '*');
2283 + else
2284 + (void) printf(" %7.7u ", psinfo->pr_euid);
2285 + }
2286 + } else if (lflg) {
2287 + if (snprintf(NULL, 0, "%u", ((int)psinfo->pr_euid)) > 6)
2288 + (void) printf("%5.5u%c ", psinfo->pr_euid, '*');
2196 2289 else
2197 - (void) printf(" %7.7u ", psinfo->pr_euid);
2198 - } else if (lflg)
2199 - (void) printf("%6u ", psinfo->pr_euid);
2290 + (void) printf("%6u ", psinfo->pr_euid);
2291 + }
2200 2292
2201 2293 (void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */
2202 2294 if (lflg || fflg)
2203 2295 (void) printf(" %*d", pidwidth,
2204 2296 (int)psinfo->pr_ppid); /* PPID */
2205 2297
2206 2298 if (jflg) {
2207 2299 (void) printf(" %*d", pidwidth,
2208 2300 (int)psinfo->pr_pgid); /* PGID */
2209 2301 (void) printf(" %*d", pidwidth,
2210 2302 (int)psinfo->pr_sid); /* SID */
2211 2303 }
2212 2304
2213 2305 if (Lflg)
2214 2306 (void) printf(" %5d", 0); /* LWP */
2215 2307 if (Pflg)
2216 2308 (void) printf(" -"); /* PSR */
2217 2309 if (Lflg && fflg)
2218 2310 (void) printf(" %5d", 0); /* NLWP */
2219 2311
2220 2312 if (cflg) {
2221 2313 (void) printf(" %4s", "-"); /* zombies have no class */
2222 2314 (void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */
2223 2315 } else if (lflg || fflg) {
2224 2316 (void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */
2225 2317 if (lflg)
2226 2318 (void) printf(" %3d %2s",
2227 2319 psinfo->pr_lwp.pr_oldpri, "-"); /* PRI NI */
2228 2320 }
2229 2321 if (lflg) {
2230 2322 if (yflg) /* RSS SZ WCHAN */
2231 2323 (void) printf(" %5d %6d %8s", 0, 0, "-");
2232 2324 else /* ADDR SZ WCHAN */
2233 2325 (void) printf(" %8s %6d %8s", "-", 0, "-");
2234 2326 }
2235 2327 if (fflg) {
2236 2328 int width = fname[F_STIME].width;
2237 2329 (void) printf(" %*.*s", width, width, "-"); /* STIME */
2238 2330 }
2239 2331 (void) printf(" %-8.14s", "?"); /* TTY */
2240 2332
2241 2333 tm = psinfo->pr_time.tv_sec;
2242 2334 if (psinfo->pr_time.tv_nsec > 500000000)
2243 2335 tm++;
2244 2336 (void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* TIME */
2245 2337 (void) printf(" <defunct>\n");
2246 2338 }
2247 2339
2248 2340 /*
2249 2341 * Function to compute the number of printable bytes in a multibyte
2250 2342 * command string ("internationalization").
2251 2343 */
2252 2344 static int
2253 2345 namencnt(char *cmd, int csisize, int scrsize)
2254 2346 {
2255 2347 int csiwcnt = 0, scrwcnt = 0;
2256 2348 int ncsisz, nscrsz;
2257 2349 wchar_t wchar;
2258 2350 int len;
2259 2351
2260 2352 while (*cmd != '\0') {
2261 2353 if ((len = csisize - csiwcnt) > (int)MB_CUR_MAX)
2262 2354 len = MB_CUR_MAX;
2263 2355 if ((ncsisz = mbtowc(&wchar, cmd, len)) < 0)
2264 2356 return (8); /* default to use for illegal chars */
2265 2357 if ((nscrsz = wcwidth(wchar)) <= 0)
2266 2358 return (8);
2267 2359 if (csiwcnt + ncsisz > csisize || scrwcnt + nscrsz > scrsize)
2268 2360 break;
2269 2361 csiwcnt += ncsisz;
2270 2362 scrwcnt += nscrsz;
2271 2363 cmd += ncsisz;
2272 2364 }
2273 2365 return (csiwcnt);
2274 2366 }
2275 2367
2276 2368 static char *
2277 2369 err_string(int err)
2278 2370 {
2279 2371 static char buf[32];
2280 2372 char *str = strerror(err);
2281 2373
2282 2374 if (str == NULL)
2283 2375 (void) snprintf(str = buf, sizeof (buf), "Errno #%d", err);
2284 2376
2285 2377 return (str);
2286 2378 }
2287 2379
2288 2380 /* If allocation fails, die */
2289 2381 static void *
2290 2382 Realloc(void *ptr, size_t size)
2291 2383 {
2292 2384 ptr = realloc(ptr, size);
2293 2385 if (ptr == NULL) {
2294 2386 (void) fprintf(stderr, gettext("ps: no memory\n"));
2295 2387 exit(1);
2296 2388 }
2297 2389 return (ptr);
2298 2390 }
2299 2391
2300 2392 static time_t
2301 2393 delta_secs(const timestruc_t *start)
2302 2394 {
2303 2395 time_t seconds = now.tv_sec - start->tv_sec;
2304 2396 long nanosecs = now.tv_usec * 1000 - start->tv_nsec;
2305 2397
2306 2398 if (nanosecs >= (NANOSEC / 2))
2307 2399 seconds++;
2308 2400 else if (nanosecs < -(NANOSEC / 2))
2309 2401 seconds--;
2310 2402
2311 2403 return (seconds);
2312 2404 }
2313 2405
2314 2406 /*
2315 2407 * Returns the following:
2316 2408 *
2317 2409 * 0 No error
2318 2410 * EINVAL Invalid number
2319 2411 * ERANGE Value exceeds (min, max) range
2320 2412 */
2321 2413 static int
2322 2414 str2id(const char *p, pid_t *val, long min, long max)
2323 2415 {
2324 2416 char *q;
2325 2417 long number;
2326 2418 int error;
2327 2419
2328 2420 errno = 0;
2329 2421 number = strtol(p, &q, 10);
2330 2422
2331 2423 if (errno != 0 || q == p || *q != '\0') {
2332 2424 if ((error = errno) == 0) {
2333 2425 /*
2334 2426 * strtol() can fail without setting errno, or it can
2335 2427 * set it to EINVAL or ERANGE. In the case errno is
2336 2428 * still zero, return EINVAL.
2337 2429 */
2338 2430 error = EINVAL;
2339 2431 }
2340 2432 } else if (number < min || number > max) {
2341 2433 error = ERANGE;
2342 2434 } else {
2343 2435 error = 0;
2344 2436 }
2345 2437
2346 2438 *val = number;
2347 2439
2348 2440 return (error);
2349 2441 }
2350 2442
2351 2443 /*
2352 2444 * Returns the following:
2353 2445 *
2354 2446 * 0 No error
2355 2447 * EINVAL Invalid number
2356 2448 * ERANGE Value exceeds (min, max) range
2357 2449 */
2358 2450 static int
2359 2451 str2uid(const char *p, uid_t *val, unsigned long min, unsigned long max)
2360 2452 {
2361 2453 char *q;
2362 2454 unsigned long number;
2363 2455 int error;
2364 2456
2365 2457 errno = 0;
2366 2458 number = strtoul(p, &q, 10);
2367 2459
2368 2460 if (errno != 0 || q == p || *q != '\0') {
2369 2461 if ((error = errno) == 0) {
2370 2462 /*
2371 2463 * strtoul() can fail without setting errno, or it can
2372 2464 * set it to EINVAL or ERANGE. In the case errno is
2373 2465 * still zero, return EINVAL.
2374 2466 */
2375 2467 error = EINVAL;
2376 2468 }
2377 2469 } else if (number < min || number > max) {
2378 2470 error = ERANGE;
2379 2471 } else {
2380 2472 error = 0;
2381 2473 }
2382 2474
2383 2475 *val = number;
2384 2476
2385 2477 return (error);
2386 2478 }
2387 2479
2388 2480 static int
2389 2481 pidcmp(const void *p1, const void *p2)
2390 2482 {
2391 2483 pid_t i = *((pid_t *)p1);
2392 2484 pid_t j = *((pid_t *)p2);
2393 2485
2394 2486 return (i - j);
2395 2487 }
|
↓ open down ↓ |
186 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX