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.
1388 1395 */
1389 1396 if (lflg) {
|
↓ open down ↓ |
319 lines elided |
↑ open up ↑ |
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 - (void) printf("%8.8s ", zonename);
1407 + if (strlen(zonename) > 8)
1408 + (void) printf("%7.7s%c ", zonename, '*');
1409 + else
1410 + (void) printf("%8.8s ", zonename);
1401 1411 }
1402 1412 }
1403 1413
1404 1414 if (fflg) { /* UID */
1405 - if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
1406 - (void) printf("%8.8s ", pwd->pw_name);
1407 - else
1415 + if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) {
1416 + if (strlen(pwd->pw_name) > 8)
1417 + (void) printf("%7.7s%c ", pwd->pw_name, '*');
1418 + else
1419 + (void) printf("%8.8s ", pwd->pw_name);
1420 + } else {
1408 1421 (void) printf(" %7.7u ", psinfo->pr_euid);
1422 + }
1409 1423 } else if (lflg) {
1410 1424 (void) printf("%6u ", psinfo->pr_euid);
1411 1425 }
1412 1426 (void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */
1413 1427 if (lflg || fflg)
1414 1428 (void) printf(" %*d", pidwidth,
1415 1429 (int)psinfo->pr_ppid); /* PPID */
1416 1430 if (jflg) {
1417 1431 (void) printf(" %*d", pidwidth,
1418 1432 (int)psinfo->pr_pgid); /* PGID */
1419 1433 (void) printf(" %*d", pidwidth,
1420 1434 (int)psinfo->pr_sid); /* SID */
1421 1435 }
1422 1436 if (Lflg)
1423 1437 (void) printf(" %5d", (int)psinfo->pr_lwp.pr_lwpid); /* LWP */
1424 1438 if (Pflg) {
1425 1439 if (psinfo->pr_lwp.pr_bindpro == PBIND_NONE) /* PSR */
1426 1440 (void) printf(" -");
1427 1441 else
1428 1442 (void) printf(" %3d", psinfo->pr_lwp.pr_bindpro);
1429 1443 }
1430 1444 if (Lflg && fflg) /* NLWP */
1431 1445 (void) printf(" %5d", psinfo->pr_nlwp + psinfo->pr_nzomb);
1432 1446 if (cflg) {
1433 1447 if (zombie_lwp) /* CLS */
1434 1448 (void) printf(" ");
1435 1449 else
1436 1450 (void) printf(" %4s", psinfo->pr_lwp.pr_clname);
1437 1451 (void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */
1438 1452 } else if (lflg || fflg) {
1439 1453 (void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */
1440 1454 if (lflg) { /* PRI NI */
1441 1455 /*
1442 1456 * Print priorities the old way (lower numbers
1443 1457 * mean higher priority) and print nice value
1444 1458 * for time sharing procs.
1445 1459 */
1446 1460 (void) printf(" %3d", psinfo->pr_lwp.pr_oldpri);
1447 1461 if (psinfo->pr_lwp.pr_oldpri != 0)
1448 1462 (void) printf(" %2d", psinfo->pr_lwp.pr_nice);
1449 1463 else
1450 1464 (void) printf(" %2.2s",
1451 1465 psinfo->pr_lwp.pr_clname);
1452 1466 }
1453 1467 }
1454 1468 if (lflg) {
1455 1469 if (yflg) {
1456 1470 if (psinfo->pr_flag & SSYS) /* RSS */
1457 1471 (void) printf(" 0");
1458 1472 else if (psinfo->pr_rssize)
1459 1473 (void) printf(" %5lu",
1460 1474 (ulong_t)psinfo->pr_rssize);
1461 1475 else
1462 1476 (void) printf(" ?");
1463 1477 if (psinfo->pr_flag & SSYS) /* SZ */
1464 1478 (void) printf(" 0");
1465 1479 else if (psinfo->pr_size)
1466 1480 (void) printf(" %6lu",
1467 1481 (ulong_t)psinfo->pr_size);
1468 1482 else
1469 1483 (void) printf(" ?");
1470 1484 } else {
1471 1485 #ifndef _LP64
1472 1486 if (psinfo->pr_addr) /* ADDR */
1473 1487 (void) printf(" %8lx",
1474 1488 (ulong_t)psinfo->pr_addr);
1475 1489 else
1476 1490 #endif
1477 1491 (void) printf(" ?");
1478 1492 if (psinfo->pr_flag & SSYS) /* SZ */
1479 1493 (void) printf(" 0");
1480 1494 else if (psinfo->pr_size)
1481 1495 (void) printf(" %6lu",
1482 1496 (ulong_t)psinfo->pr_size / kbytes_per_page);
1483 1497 else
1484 1498 (void) printf(" ?");
1485 1499 }
1486 1500 if (psinfo->pr_lwp.pr_sname != 'S') /* WCHAN */
1487 1501 (void) printf(" ");
1488 1502 #ifndef _LP64
1489 1503 else if (psinfo->pr_lwp.pr_wchan)
1490 1504 (void) printf(" %8lx",
1491 1505 (ulong_t)psinfo->pr_lwp.pr_wchan);
1492 1506 #endif
1493 1507 else
1494 1508 (void) printf(" ?");
1495 1509 }
1496 1510 if (fflg) { /* STIME */
1497 1511 int width = fname[F_STIME].width;
1498 1512 if (Lflg)
1499 1513 prtime(psinfo->pr_lwp.pr_start, width + 1, 1);
1500 1514 else
1501 1515 prtime(psinfo->pr_start, width + 1, 1);
1502 1516 }
1503 1517
1504 1518 if (Hflg) {
1505 1519 /* Display home lgroup */
1506 1520 (void) printf(" %4d", (int)psinfo->pr_lwp.pr_lgrp);
1507 1521 }
1508 1522
1509 1523 (void) printf(" %-8.14s", ttyp); /* TTY */
1510 1524 if (Lflg) {
1511 1525 tm = psinfo->pr_lwp.pr_time.tv_sec;
1512 1526 if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)
1513 1527 tm++;
1514 1528 } else {
1515 1529 tm = psinfo->pr_time.tv_sec;
1516 1530 if (psinfo->pr_time.tv_nsec > 500000000)
1517 1531 tm++;
1518 1532 }
1519 1533 (void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* [L]TIME */
1520 1534
1521 1535 if (zombie_lwp) {
1522 1536 (void) printf(" <defunct>\n");
1523 1537 return;
1524 1538 }
1525 1539
1526 1540 if (!fflg) { /* CMD */
1527 1541 wcnt = namencnt(psinfo->pr_fname, 16, 8);
1528 1542 (void) printf(" %.*s\n", wcnt, psinfo->pr_fname);
1529 1543 return;
1530 1544 }
1531 1545
1532 1546
1533 1547 /*
1534 1548 * PRARGSZ == length of cmd arg string.
1535 1549 */
1536 1550 psinfo->pr_psargs[PRARGSZ-1] = '\0';
1537 1551 bytesleft = PRARGSZ;
1538 1552 for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {
1539 1553 length = mbtowc(&wchar, cp, MB_LEN_MAX);
1540 1554 if (length == 0)
1541 1555 break;
1542 1556 if (length < 0 || !iswprint(wchar)) {
1543 1557 if (length < 0)
1544 1558 length = 1;
1545 1559 if (bytesleft <= length) {
1546 1560 *cp = '\0';
1547 1561 break;
1548 1562 }
1549 1563 /* omit the unprintable character */
1550 1564 (void) memmove(cp, cp+length, bytesleft-length);
1551 1565 length = 0;
1552 1566 }
1553 1567 bytesleft -= length;
1554 1568 }
1555 1569 wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, lflg ? 35 : PRARGSZ);
1556 1570 (void) printf(" %.*s\n", wcnt, psinfo->pr_psargs);
1557 1571 }
1558 1572
1559 1573 /*
1560 1574 * Print percent from 16-bit binary fraction [0 .. 1]
1561 1575 * Round up .01 to .1 to indicate some small percentage (the 0x7000 below).
1562 1576 */
1563 1577 static void
1564 1578 prtpct(ushort_t pct, int width)
1565 1579 {
1566 1580 uint_t value = pct; /* need 32 bits to compute with */
1567 1581
1568 1582 value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */
1569 1583 if (value >= 1000)
1570 1584 value = 999;
1571 1585 if ((width -= 2) < 2)
1572 1586 width = 2;
1573 1587 (void) printf("%*u.%u", width, value / 10, value % 10);
1574 1588 }
1575 1589
1576 1590 static void
1577 1591 print_time(time_t tim, int width)
1578 1592 {
1579 1593 char buf[30];
1580 1594 time_t seconds;
1581 1595 time_t minutes;
1582 1596 time_t hours;
1583 1597 time_t days;
1584 1598
1585 1599 if (tim < 0) {
1586 1600 (void) printf("%*s", width, "-");
1587 1601 return;
1588 1602 }
1589 1603
1590 1604 seconds = tim % 60;
1591 1605 tim /= 60;
1592 1606 minutes = tim % 60;
1593 1607 tim /= 60;
1594 1608 hours = tim % 24;
1595 1609 days = tim / 24;
1596 1610
1597 1611 if (days > 0) {
1598 1612 (void) snprintf(buf, sizeof (buf), "%ld-%2.2ld:%2.2ld:%2.2ld",
1599 1613 days, hours, minutes, seconds);
1600 1614 } else if (hours > 0) {
1601 1615 (void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld:%2.2ld",
1602 1616 hours, minutes, seconds);
1603 1617 } else {
1604 1618 (void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld",
1605 1619 minutes, seconds);
1606 1620 }
1607 1621
1608 1622 (void) printf("%*s", width, buf);
1609 1623 }
1610 1624
1611 1625 static void
1612 1626 print_field(psinfo_t *psinfo, struct field *f, const char *ttyp)
1613 1627 {
1614 1628 int width = f->width;
1615 1629 struct passwd *pwd;
1616 1630 struct group *grp;
1617 1631 time_t cputime;
1618 1632 int bytesleft;
1619 1633 int wcnt;
1620 1634 wchar_t wchar;
|
↓ open down ↓ |
202 lines elided |
↑ open up ↑ |
1621 1635 char *cp;
1622 1636 int length;
1623 1637 ulong_t mask;
1624 1638 char c, *csave;
1625 1639 int zombie_lwp;
1626 1640
1627 1641 zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z');
1628 1642
1629 1643 switch (f->fname) {
1630 1644 case F_RUSER:
1631 - if ((pwd = getpwuid(psinfo->pr_uid)) != NULL)
1632 - (void) printf("%*s", width, pwd->pw_name);
1633 - else
1645 + if ((pwd = getpwuid(psinfo->pr_uid)) != NULL) {
1646 + if (Wflg && strlen(pwd->pw_name) > width)
1647 + (void) printf("%.*s%c", width - 1,
1648 + pwd->pw_name, '*');
1649 + else
1650 + (void) printf("%*s", width, pwd->pw_name);
1651 + } else {
1634 1652 (void) printf("%*u", width, psinfo->pr_uid);
1653 + }
1635 1654 break;
1636 1655 case F_USER:
1637 - if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
1638 - (void) printf("%*s", width, pwd->pw_name);
1639 - else
1656 + if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) {
1657 + if (Wflg && strlen(pwd->pw_name) > width)
1658 + (void) printf("%.*s%c", width - 1,
1659 + pwd->pw_name, '*');
1660 + else
1661 + (void) printf("%*s", width, pwd->pw_name);
1662 + } else {
1640 1663 (void) printf("%*u", width, psinfo->pr_euid);
1664 + }
1641 1665 break;
1642 1666 case F_RGROUP:
1643 1667 if ((grp = getgrgid(psinfo->pr_gid)) != NULL)
1644 1668 (void) printf("%*s", width, grp->gr_name);
1645 1669 else
1646 1670 (void) printf("%*u", width, psinfo->pr_gid);
1647 1671 break;
1648 1672 case F_GROUP:
1649 1673 if ((grp = getgrgid(psinfo->pr_egid)) != NULL)
1650 1674 (void) printf("%*s", width, grp->gr_name);
1651 1675 else
1652 1676 (void) printf("%*u", width, psinfo->pr_egid);
1653 1677 break;
1654 1678 case F_RUID:
1655 1679 (void) printf("%*u", width, psinfo->pr_uid);
1656 1680 break;
1657 1681 case F_UID:
1658 1682 (void) printf("%*u", width, psinfo->pr_euid);
1659 1683 break;
1660 1684 case F_RGID:
1661 1685 (void) printf("%*u", width, psinfo->pr_gid);
1662 1686 break;
1663 1687 case F_GID:
1664 1688 (void) printf("%*u", width, psinfo->pr_egid);
1665 1689 break;
1666 1690 case F_PID:
1667 1691 (void) printf("%*d", width, (int)psinfo->pr_pid);
1668 1692 break;
1669 1693 case F_PPID:
1670 1694 (void) printf("%*d", width, (int)psinfo->pr_ppid);
1671 1695 break;
1672 1696 case F_PGID:
1673 1697 (void) printf("%*d", width, (int)psinfo->pr_pgid);
1674 1698 break;
1675 1699 case F_SID:
1676 1700 (void) printf("%*d", width, (int)psinfo->pr_sid);
1677 1701 break;
1678 1702 case F_PSR:
1679 1703 if (zombie_lwp || psinfo->pr_lwp.pr_bindpro == PBIND_NONE)
1680 1704 (void) printf("%*s", width, "-");
1681 1705 else
1682 1706 (void) printf("%*d", width, psinfo->pr_lwp.pr_bindpro);
1683 1707 break;
1684 1708 case F_LWP:
1685 1709 (void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lwpid);
1686 1710 break;
1687 1711 case F_NLWP:
1688 1712 (void) printf("%*d", width, psinfo->pr_nlwp + psinfo->pr_nzomb);
1689 1713 break;
1690 1714 case F_OPRI:
1691 1715 if (zombie_lwp)
1692 1716 (void) printf("%*s", width, "-");
1693 1717 else
1694 1718 (void) printf("%*d", width, psinfo->pr_lwp.pr_oldpri);
1695 1719 break;
1696 1720 case F_PRI:
1697 1721 if (zombie_lwp)
1698 1722 (void) printf("%*s", width, "-");
1699 1723 else
1700 1724 (void) printf("%*d", width, psinfo->pr_lwp.pr_pri);
1701 1725 break;
1702 1726 case F_F:
1703 1727 mask = 0xffffffffUL;
1704 1728 if (width < 8)
1705 1729 mask >>= (8 - width) * 4;
1706 1730 (void) printf("%*lx", width, psinfo->pr_flag & mask);
1707 1731 break;
1708 1732 case F_S:
1709 1733 (void) printf("%*c", width, psinfo->pr_lwp.pr_sname);
1710 1734 break;
1711 1735 case F_C:
1712 1736 if (zombie_lwp)
1713 1737 (void) printf("%*s", width, "-");
1714 1738 else
1715 1739 (void) printf("%*d", width, psinfo->pr_lwp.pr_cpu);
1716 1740 break;
1717 1741 case F_PCPU:
1718 1742 if (zombie_lwp)
1719 1743 (void) printf("%*s", width, "-");
1720 1744 else if (Lflg)
1721 1745 prtpct(psinfo->pr_lwp.pr_pctcpu, width);
1722 1746 else
1723 1747 prtpct(psinfo->pr_pctcpu, width);
1724 1748 break;
1725 1749 case F_PMEM:
1726 1750 prtpct(psinfo->pr_pctmem, width);
1727 1751 break;
1728 1752 case F_OSZ:
1729 1753 (void) printf("%*lu", width,
1730 1754 (ulong_t)psinfo->pr_size / kbytes_per_page);
1731 1755 break;
1732 1756 case F_VSZ:
1733 1757 (void) printf("%*lu", width, (ulong_t)psinfo->pr_size);
1734 1758 break;
1735 1759 case F_RSS:
1736 1760 (void) printf("%*lu", width, (ulong_t)psinfo->pr_rssize);
1737 1761 break;
1738 1762 case F_NICE:
1739 1763 /* if pr_oldpri is zero, then this class has no nice */
1740 1764 if (zombie_lwp)
1741 1765 (void) printf("%*s", width, "-");
1742 1766 else if (psinfo->pr_lwp.pr_oldpri != 0)
1743 1767 (void) printf("%*d", width, psinfo->pr_lwp.pr_nice);
1744 1768 else
1745 1769 (void) printf("%*.*s", width, width,
1746 1770 psinfo->pr_lwp.pr_clname);
1747 1771 break;
1748 1772 case F_CLASS:
1749 1773 if (zombie_lwp)
1750 1774 (void) printf("%*s", width, "-");
1751 1775 else
1752 1776 (void) printf("%*.*s", width, width,
1753 1777 psinfo->pr_lwp.pr_clname);
1754 1778 break;
1755 1779 case F_STIME:
1756 1780 if (Lflg)
1757 1781 prtime(psinfo->pr_lwp.pr_start, width, 0);
1758 1782 else
1759 1783 prtime(psinfo->pr_start, width, 0);
1760 1784 break;
1761 1785 case F_ETIME:
1762 1786 if (Lflg)
1763 1787 print_time(delta_secs(&psinfo->pr_lwp.pr_start),
1764 1788 width);
1765 1789 else
1766 1790 print_time(delta_secs(&psinfo->pr_start), width);
1767 1791 break;
1768 1792 case F_TIME:
1769 1793 if (Lflg) {
1770 1794 cputime = psinfo->pr_lwp.pr_time.tv_sec;
1771 1795 if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)
1772 1796 cputime++;
1773 1797 } else {
1774 1798 cputime = psinfo->pr_time.tv_sec;
1775 1799 if (psinfo->pr_time.tv_nsec > 500000000)
1776 1800 cputime++;
1777 1801 }
1778 1802 print_time(cputime, width);
1779 1803 break;
1780 1804 case F_TTY:
1781 1805 (void) printf("%-*s", width, ttyp);
1782 1806 break;
1783 1807 case F_ADDR:
1784 1808 if (zombie_lwp)
1785 1809 (void) printf("%*s", width, "-");
1786 1810 else if (Lflg)
1787 1811 (void) printf("%*lx", width,
1788 1812 (long)psinfo->pr_lwp.pr_addr);
1789 1813 else
1790 1814 (void) printf("%*lx", width, (long)psinfo->pr_addr);
1791 1815 break;
1792 1816 case F_WCHAN:
1793 1817 if (!zombie_lwp && psinfo->pr_lwp.pr_wchan)
1794 1818 (void) printf("%*lx", width,
1795 1819 (long)psinfo->pr_lwp.pr_wchan);
1796 1820 else
1797 1821 (void) printf("%*.*s", width, width, "-");
1798 1822 break;
1799 1823 case F_FNAME:
1800 1824 /*
1801 1825 * Print full width unless this is the last output format.
1802 1826 */
1803 1827 if (zombie_lwp) {
1804 1828 if (f->next != NULL)
1805 1829 (void) printf("%-*s", width, "<defunct>");
1806 1830 else
1807 1831 (void) printf("%s", "<defunct>");
1808 1832 break;
1809 1833 }
1810 1834 wcnt = namencnt(psinfo->pr_fname, 16, width);
1811 1835 if (f->next != NULL)
1812 1836 (void) printf("%-*.*s", width, wcnt, psinfo->pr_fname);
1813 1837 else
1814 1838 (void) printf("%-.*s", wcnt, psinfo->pr_fname);
1815 1839 break;
1816 1840 case F_COMM:
1817 1841 if (zombie_lwp) {
1818 1842 if (f->next != NULL)
1819 1843 (void) printf("%-*s", width, "<defunct>");
1820 1844 else
1821 1845 (void) printf("%s", "<defunct>");
1822 1846 break;
1823 1847 }
1824 1848 csave = strpbrk(psinfo->pr_psargs, " \t\r\v\f\n");
1825 1849 if (csave) {
1826 1850 c = *csave;
1827 1851 *csave = '\0';
1828 1852 }
1829 1853 /* FALLTHROUGH */
1830 1854 case F_ARGS:
1831 1855 /*
1832 1856 * PRARGSZ == length of cmd arg string.
1833 1857 */
1834 1858 if (zombie_lwp) {
1835 1859 (void) printf("%-*s", width, "<defunct>");
1836 1860 break;
1837 1861 }
1838 1862 psinfo->pr_psargs[PRARGSZ-1] = '\0';
1839 1863 bytesleft = PRARGSZ;
1840 1864 for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {
1841 1865 length = mbtowc(&wchar, cp, MB_LEN_MAX);
1842 1866 if (length == 0)
1843 1867 break;
1844 1868 if (length < 0 || !iswprint(wchar)) {
1845 1869 if (length < 0)
1846 1870 length = 1;
1847 1871 if (bytesleft <= length) {
1848 1872 *cp = '\0';
1849 1873 break;
1850 1874 }
1851 1875 /* omit the unprintable character */
1852 1876 (void) memmove(cp, cp+length, bytesleft-length);
1853 1877 length = 0;
1854 1878 }
1855 1879 bytesleft -= length;
1856 1880 }
1857 1881 wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, width);
1858 1882 /*
1859 1883 * Print full width unless this is the last format.
1860 1884 */
1861 1885 if (f->next != NULL)
1862 1886 (void) printf("%-*.*s", width, wcnt,
1863 1887 psinfo->pr_psargs);
1864 1888 else
1865 1889 (void) printf("%-.*s", wcnt,
1866 1890 psinfo->pr_psargs);
1867 1891 if (f->fname == F_COMM && csave)
1868 1892 *csave = c;
1869 1893 break;
1870 1894 case F_TASKID:
1871 1895 (void) printf("%*d", width, (int)psinfo->pr_taskid);
|
↓ open down ↓ |
221 lines elided |
↑ open up ↑ |
1872 1896 break;
1873 1897 case F_PROJID:
1874 1898 (void) printf("%*d", width, (int)psinfo->pr_projid);
1875 1899 break;
1876 1900 case F_PROJECT:
1877 1901 {
1878 1902 struct project cproj;
1879 1903 char proj_buf[PROJECT_BUFSZ];
1880 1904
1881 1905 if ((getprojbyid(psinfo->pr_projid, &cproj,
1882 - (void *)&proj_buf, PROJECT_BUFSZ)) == NULL)
1906 + (void *)&proj_buf, PROJECT_BUFSZ)) == NULL) {
1883 1907 (void) printf("%*d", width,
1884 1908 (int)psinfo->pr_projid);
1885 - else
1886 - (void) printf("%*s", width,
1887 - (cproj.pj_name != NULL) ?
1888 - cproj.pj_name : "---");
1909 + } else {
1910 + if (Wflg && cproj.pj_name != NULL &&
1911 + strlen(cproj.pj_name) > width)
1912 + (void) printf("%.*s%c", width - 1,
1913 + cproj.pj_name, '*');
1914 + else
1915 + (void) printf("%*s", width,
1916 + (cproj.pj_name != NULL) ?
1917 + cproj.pj_name : "---");
1918 + }
1889 1919 }
1890 1920 break;
1891 1921 case F_PSET:
1892 1922 if (zombie_lwp || psinfo->pr_lwp.pr_bindpset == PS_NONE)
1893 1923 (void) printf("%*s", width, "-");
1894 1924 else
1895 1925 (void) printf("%*d", width, psinfo->pr_lwp.pr_bindpset);
1896 1926 break;
1897 1927 case F_ZONEID:
1898 1928 (void) printf("%*d", width, (int)psinfo->pr_zoneid);
1899 1929 break;
1900 1930 case F_ZONE:
1901 1931 {
1902 1932 char zonename[ZONENAME_MAX];
1903 1933
1904 1934 if (getzonenamebyid(psinfo->pr_zoneid, zonename,
1905 1935 sizeof (zonename)) < 0) {
1906 1936 (void) printf("%*d", width,
1907 1937 ((int)psinfo->pr_zoneid));
1908 1938 } else {
1909 - (void) printf("%*s", width, zonename);
1939 + if (Wflg && strlen(zonename) > width)
1940 + (void) printf("%.*s%c", width - 1,
1941 + zonename, '*');
1942 + else
1943 + (void) printf("%*s", width, zonename);
1910 1944 }
1911 1945 }
1912 1946 break;
1913 1947 case F_CTID:
1914 1948 if (psinfo->pr_contract == -1)
1915 1949 (void) printf("%*s", width, "-");
1916 1950 else
1917 1951 (void) printf("%*ld", width, (long)psinfo->pr_contract);
1918 1952 break;
1919 1953 case F_LGRP:
1920 1954 /* Display home lgroup */
1921 1955 (void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lgrp);
1922 1956 break;
1923 1957
1924 1958 case F_DMODEL:
1925 1959 (void) printf("%*s", width,
1926 1960 psinfo->pr_dmodel == PR_MODEL_LP64 ? "_LP64" : "_ILP32");
1927 1961 break;
1928 1962 }
1929 1963 }
1930 1964
1931 1965 static void
1932 1966 print_zombie_field(psinfo_t *psinfo, struct field *f, const char *ttyp)
1933 1967 {
1934 1968 int wcnt;
1935 1969 int width = f->width;
1936 1970
1937 1971 switch (f->fname) {
1938 1972 case F_FNAME:
1939 1973 case F_COMM:
1940 1974 case F_ARGS:
1941 1975 /*
1942 1976 * Print full width unless this is the last output format.
1943 1977 */
1944 1978 wcnt = min(width, sizeof ("<defunct>"));
1945 1979 if (f->next != NULL)
1946 1980 (void) printf("%-*.*s", width, wcnt, "<defunct>");
1947 1981 else
1948 1982 (void) printf("%-.*s", wcnt, "<defunct>");
1949 1983 break;
1950 1984
1951 1985 case F_PSR:
1952 1986 case F_PCPU:
1953 1987 case F_PMEM:
1954 1988 case F_NICE:
1955 1989 case F_CLASS:
1956 1990 case F_STIME:
1957 1991 case F_ETIME:
1958 1992 case F_WCHAN:
1959 1993 case F_PSET:
1960 1994 (void) printf("%*s", width, "-");
1961 1995 break;
1962 1996
1963 1997 case F_OPRI:
1964 1998 case F_PRI:
1965 1999 case F_OSZ:
1966 2000 case F_VSZ:
1967 2001 case F_RSS:
1968 2002 (void) printf("%*d", width, 0);
1969 2003 break;
1970 2004
1971 2005 default:
1972 2006 print_field(psinfo, f, ttyp);
1973 2007 break;
1974 2008 }
1975 2009 }
1976 2010
1977 2011 static void
1978 2012 pr_fields(psinfo_t *psinfo, const char *ttyp,
1979 2013 void (*print_fld)(psinfo_t *, struct field *, const char *))
1980 2014 {
1981 2015 struct field *f;
1982 2016
1983 2017 for (f = fields; f != NULL; f = f->next) {
1984 2018 print_fld(psinfo, f, ttyp);
1985 2019 if (f->next != NULL)
1986 2020 (void) printf(" ");
1987 2021 }
1988 2022 (void) printf("\n");
1989 2023 }
1990 2024
1991 2025 /*
1992 2026 * Returns 1 if arg is found in array arr, of length num; 0 otherwise.
1993 2027 */
1994 2028 static int
1995 2029 search(pid_t *arr, int number, pid_t arg)
1996 2030 {
1997 2031 int i;
1998 2032
1999 2033 for (i = 0; i < number; i++)
2000 2034 if (arg == arr[i])
2001 2035 return (1);
2002 2036 return (0);
2003 2037 }
2004 2038
2005 2039 /*
2006 2040 * Add an entry (user, group) to the specified table.
2007 2041 */
2008 2042 static void
2009 2043 add_ugentry(struct ughead *tbl, char *name)
2010 2044 {
2011 2045 struct ugdata *entp;
2012 2046
2013 2047 if (tbl->size == tbl->nent) { /* reallocate the table entries */
2014 2048 if ((tbl->size *= 2) == 0)
2015 2049 tbl->size = 32; /* first time */
2016 2050 tbl->ent = Realloc(tbl->ent, tbl->size*sizeof (struct ugdata));
2017 2051 }
2018 2052 entp = &tbl->ent[tbl->nent++];
2019 2053 entp->id = 0;
2020 2054 (void) strncpy(entp->name, name, MAXUGNAME);
2021 2055 entp->name[MAXUGNAME] = '\0';
2022 2056 }
2023 2057
2024 2058 static int
2025 2059 uconv(struct ughead *uhead)
2026 2060 {
2027 2061 struct ugdata *utbl = uhead->ent;
2028 2062 int n = uhead->nent;
2029 2063 struct passwd *pwd;
2030 2064 int i;
2031 2065 int fnd = 0;
2032 2066 uid_t uid;
2033 2067
2034 2068 /*
2035 2069 * Ask the name service for names.
2036 2070 */
2037 2071 for (i = 0; i < n; i++) {
2038 2072 /*
2039 2073 * If name is numeric, ask for numeric id
2040 2074 */
2041 2075 if (str2uid(utbl[i].name, &uid, 0, MAXEPHUID) == 0)
2042 2076 pwd = getpwuid(uid);
2043 2077 else
2044 2078 pwd = getpwnam(utbl[i].name);
2045 2079
2046 2080 /*
2047 2081 * If found, enter found index into tbl array.
2048 2082 */
2049 2083 if (pwd == NULL) {
2050 2084 (void) fprintf(stderr,
2051 2085 gettext("ps: unknown user %s\n"), utbl[i].name);
2052 2086 continue;
2053 2087 }
2054 2088
2055 2089 utbl[fnd].id = pwd->pw_uid;
2056 2090 (void) strncpy(utbl[fnd].name, pwd->pw_name, MAXUGNAME);
2057 2091 fnd++;
2058 2092 }
2059 2093
2060 2094 uhead->nent = fnd; /* in case it changed */
2061 2095 return (n - fnd);
2062 2096 }
2063 2097
2064 2098 static int
2065 2099 gconv(struct ughead *ghead)
2066 2100 {
2067 2101 struct ugdata *gtbl = ghead->ent;
2068 2102 int n = ghead->nent;
2069 2103 struct group *grp;
2070 2104 gid_t gid;
2071 2105 int i;
2072 2106 int fnd = 0;
2073 2107
2074 2108 /*
2075 2109 * Ask the name service for names.
2076 2110 */
2077 2111 for (i = 0; i < n; i++) {
2078 2112 /*
2079 2113 * If name is numeric, ask for numeric id
2080 2114 */
2081 2115 if (str2uid(gtbl[i].name, (uid_t *)&gid, 0, MAXEPHUID) == 0)
2082 2116 grp = getgrgid(gid);
2083 2117 else
2084 2118 grp = getgrnam(gtbl[i].name);
2085 2119 /*
2086 2120 * If found, enter found index into tbl array.
2087 2121 */
2088 2122 if (grp == NULL) {
2089 2123 (void) fprintf(stderr,
2090 2124 gettext("ps: unknown group %s\n"), gtbl[i].name);
2091 2125 continue;
2092 2126 }
2093 2127
2094 2128 gtbl[fnd].id = grp->gr_gid;
2095 2129 (void) strncpy(gtbl[fnd].name, grp->gr_name, MAXUGNAME);
2096 2130 fnd++;
2097 2131 }
2098 2132
2099 2133 ghead->nent = fnd; /* in case it changed */
2100 2134 return (n - fnd);
2101 2135 }
2102 2136
2103 2137 /*
2104 2138 * Return 1 if puid is in table, otherwise 0.
2105 2139 */
2106 2140 static int
2107 2141 ugfind(id_t id, struct ughead *ughead)
2108 2142 {
2109 2143 struct ugdata *utbl = ughead->ent;
2110 2144 int n = ughead->nent;
2111 2145 int i;
2112 2146
2113 2147 for (i = 0; i < n; i++)
2114 2148 if (utbl[i].id == id)
2115 2149 return (1);
2116 2150 return (0);
2117 2151 }
2118 2152
2119 2153 /*
2120 2154 * Print starting time of process unless process started more than 24 hours
2121 2155 * ago, in which case the date is printed. The date is printed in the form
2122 2156 * "MMM dd" if old format, else the blank is replaced with an '_' so
2123 2157 * it appears as a single word (for parseability).
2124 2158 */
2125 2159 static void
2126 2160 prtime(timestruc_t st, int width, int old)
2127 2161 {
2128 2162 char sttim[26];
2129 2163 time_t starttime;
2130 2164
2131 2165 starttime = st.tv_sec;
2132 2166 if (st.tv_nsec > 500000000)
2133 2167 starttime++;
2134 2168 if ((now.tv_sec - starttime) >= 24*60*60) {
2135 2169 (void) strftime(sttim, sizeof (sttim), old?
2136 2170 /*
2137 2171 * TRANSLATION_NOTE
2138 2172 * This time format is used by STIME field when -f option
2139 2173 * is specified. Used for processes that begun more than
2140 2174 * 24 hours.
2141 2175 */
2142 2176 dcgettext(NULL, "%b %d", LC_TIME) :
2143 2177 /*
2144 2178 * TRANSLATION_NOTE
2145 2179 * This time format is used by STIME field when -o option
2146 2180 * is specified. Used for processes that begun more than
2147 2181 * 24 hours.
2148 2182 */
2149 2183 dcgettext(NULL, "%b_%d", LC_TIME), localtime(&starttime));
2150 2184 } else {
2151 2185 /*
2152 2186 * TRANSLATION_NOTE
2153 2187 * This time format is used by STIME field when -f or -o option
2154 2188 * is specified. Used for processes that begun less than
2155 2189 * 24 hours.
2156 2190 */
2157 2191 (void) strftime(sttim, sizeof (sttim),
2158 2192 dcgettext(NULL, "%H:%M:%S", LC_TIME),
2159 2193 localtime(&starttime));
2160 2194 }
2161 2195 (void) printf("%*.*s", width, width, sttim);
2162 2196 }
2163 2197
2164 2198 static void
2165 2199 przom(psinfo_t *psinfo)
2166 2200 {
2167 2201 long tm;
2168 2202 struct passwd *pwd;
2169 2203 char zonename[ZONENAME_MAX];
2170 2204
2171 2205 /*
2172 2206 * All fields before 'PID' are printed with a trailing space as a
2173 2207 * spearator, rather than keeping track of which column is first. All
2174 2208 * other fields are printed with a leading space.
2175 2209 */
|
↓ open down ↓ |
256 lines elided |
↑ open up ↑ |
2176 2210 if (lflg) { /* F S */
2177 2211 if (!yflg)
2178 2212 (void) printf("%2x ", psinfo->pr_flag & 0377); /* F */
2179 2213 (void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */
2180 2214 }
2181 2215 if (Zflg) {
2182 2216 if (getzonenamebyid(psinfo->pr_zoneid, zonename,
2183 2217 sizeof (zonename)) < 0) {
2184 2218 (void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));
2185 2219 } else {
2186 - (void) printf("%8.8s ", zonename);
2220 + if (strlen(zonename) > 8)
2221 + (void) printf("%7.7s%c ", zonename, '*');
2222 + else
2223 + (void) printf("%8.8s ", zonename);
2187 2224 }
2188 2225 }
2189 2226 if (Hflg) {
2190 2227 /* Display home lgroup */
2191 2228 (void) printf(" %6d", (int)psinfo->pr_lwp.pr_lgrp); /* LGRP */
2192 2229 }
2193 2230 if (fflg) {
2194 - if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)
2195 - (void) printf("%8.8s ", pwd->pw_name);
2196 - else
2231 + if ((pwd = getpwuid(psinfo->pr_euid)) != NULL) {
2232 + if (strlen(pwd->pw_name) > 8)
2233 + (void) printf("%7.7s%c ", pwd->pw_name, '*');
2234 + else
2235 + (void) printf("%8.8s ", pwd->pw_name);
2236 + } else {
2197 2237 (void) printf(" %7.7u ", psinfo->pr_euid);
2238 + }
2198 2239 } else if (lflg)
2199 2240 (void) printf("%6u ", psinfo->pr_euid);
2200 2241
2201 2242 (void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */
2202 2243 if (lflg || fflg)
2203 2244 (void) printf(" %*d", pidwidth,
2204 2245 (int)psinfo->pr_ppid); /* PPID */
2205 2246
2206 2247 if (jflg) {
2207 2248 (void) printf(" %*d", pidwidth,
2208 2249 (int)psinfo->pr_pgid); /* PGID */
2209 2250 (void) printf(" %*d", pidwidth,
2210 2251 (int)psinfo->pr_sid); /* SID */
2211 2252 }
2212 2253
2213 2254 if (Lflg)
2214 2255 (void) printf(" %5d", 0); /* LWP */
2215 2256 if (Pflg)
2216 2257 (void) printf(" -"); /* PSR */
2217 2258 if (Lflg && fflg)
2218 2259 (void) printf(" %5d", 0); /* NLWP */
2219 2260
2220 2261 if (cflg) {
2221 2262 (void) printf(" %4s", "-"); /* zombies have no class */
2222 2263 (void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */
2223 2264 } else if (lflg || fflg) {
2224 2265 (void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */
2225 2266 if (lflg)
2226 2267 (void) printf(" %3d %2s",
2227 2268 psinfo->pr_lwp.pr_oldpri, "-"); /* PRI NI */
2228 2269 }
2229 2270 if (lflg) {
2230 2271 if (yflg) /* RSS SZ WCHAN */
2231 2272 (void) printf(" %5d %6d %8s", 0, 0, "-");
2232 2273 else /* ADDR SZ WCHAN */
2233 2274 (void) printf(" %8s %6d %8s", "-", 0, "-");
2234 2275 }
2235 2276 if (fflg) {
2236 2277 int width = fname[F_STIME].width;
2237 2278 (void) printf(" %*.*s", width, width, "-"); /* STIME */
2238 2279 }
2239 2280 (void) printf(" %-8.14s", "?"); /* TTY */
2240 2281
2241 2282 tm = psinfo->pr_time.tv_sec;
2242 2283 if (psinfo->pr_time.tv_nsec > 500000000)
2243 2284 tm++;
2244 2285 (void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* TIME */
2245 2286 (void) printf(" <defunct>\n");
2246 2287 }
2247 2288
2248 2289 /*
2249 2290 * Function to compute the number of printable bytes in a multibyte
2250 2291 * command string ("internationalization").
2251 2292 */
2252 2293 static int
2253 2294 namencnt(char *cmd, int csisize, int scrsize)
2254 2295 {
2255 2296 int csiwcnt = 0, scrwcnt = 0;
2256 2297 int ncsisz, nscrsz;
2257 2298 wchar_t wchar;
2258 2299 int len;
2259 2300
2260 2301 while (*cmd != '\0') {
2261 2302 if ((len = csisize - csiwcnt) > (int)MB_CUR_MAX)
2262 2303 len = MB_CUR_MAX;
2263 2304 if ((ncsisz = mbtowc(&wchar, cmd, len)) < 0)
2264 2305 return (8); /* default to use for illegal chars */
2265 2306 if ((nscrsz = wcwidth(wchar)) <= 0)
2266 2307 return (8);
2267 2308 if (csiwcnt + ncsisz > csisize || scrwcnt + nscrsz > scrsize)
2268 2309 break;
2269 2310 csiwcnt += ncsisz;
2270 2311 scrwcnt += nscrsz;
2271 2312 cmd += ncsisz;
2272 2313 }
2273 2314 return (csiwcnt);
2274 2315 }
2275 2316
2276 2317 static char *
2277 2318 err_string(int err)
2278 2319 {
2279 2320 static char buf[32];
2280 2321 char *str = strerror(err);
2281 2322
2282 2323 if (str == NULL)
2283 2324 (void) snprintf(str = buf, sizeof (buf), "Errno #%d", err);
2284 2325
2285 2326 return (str);
2286 2327 }
2287 2328
2288 2329 /* If allocation fails, die */
2289 2330 static void *
2290 2331 Realloc(void *ptr, size_t size)
2291 2332 {
2292 2333 ptr = realloc(ptr, size);
2293 2334 if (ptr == NULL) {
2294 2335 (void) fprintf(stderr, gettext("ps: no memory\n"));
2295 2336 exit(1);
2296 2337 }
2297 2338 return (ptr);
2298 2339 }
2299 2340
2300 2341 static time_t
2301 2342 delta_secs(const timestruc_t *start)
2302 2343 {
2303 2344 time_t seconds = now.tv_sec - start->tv_sec;
2304 2345 long nanosecs = now.tv_usec * 1000 - start->tv_nsec;
2305 2346
2306 2347 if (nanosecs >= (NANOSEC / 2))
2307 2348 seconds++;
2308 2349 else if (nanosecs < -(NANOSEC / 2))
2309 2350 seconds--;
2310 2351
2311 2352 return (seconds);
2312 2353 }
2313 2354
2314 2355 /*
2315 2356 * Returns the following:
2316 2357 *
2317 2358 * 0 No error
2318 2359 * EINVAL Invalid number
2319 2360 * ERANGE Value exceeds (min, max) range
2320 2361 */
2321 2362 static int
2322 2363 str2id(const char *p, pid_t *val, long min, long max)
2323 2364 {
2324 2365 char *q;
2325 2366 long number;
2326 2367 int error;
2327 2368
2328 2369 errno = 0;
2329 2370 number = strtol(p, &q, 10);
2330 2371
2331 2372 if (errno != 0 || q == p || *q != '\0') {
2332 2373 if ((error = errno) == 0) {
2333 2374 /*
2334 2375 * strtol() can fail without setting errno, or it can
2335 2376 * set it to EINVAL or ERANGE. In the case errno is
2336 2377 * still zero, return EINVAL.
2337 2378 */
2338 2379 error = EINVAL;
2339 2380 }
2340 2381 } else if (number < min || number > max) {
2341 2382 error = ERANGE;
2342 2383 } else {
2343 2384 error = 0;
2344 2385 }
2345 2386
2346 2387 *val = number;
2347 2388
2348 2389 return (error);
2349 2390 }
2350 2391
2351 2392 /*
2352 2393 * Returns the following:
2353 2394 *
2354 2395 * 0 No error
2355 2396 * EINVAL Invalid number
2356 2397 * ERANGE Value exceeds (min, max) range
2357 2398 */
2358 2399 static int
2359 2400 str2uid(const char *p, uid_t *val, unsigned long min, unsigned long max)
2360 2401 {
2361 2402 char *q;
2362 2403 unsigned long number;
2363 2404 int error;
2364 2405
2365 2406 errno = 0;
2366 2407 number = strtoul(p, &q, 10);
2367 2408
2368 2409 if (errno != 0 || q == p || *q != '\0') {
2369 2410 if ((error = errno) == 0) {
2370 2411 /*
2371 2412 * strtoul() can fail without setting errno, or it can
2372 2413 * set it to EINVAL or ERANGE. In the case errno is
2373 2414 * still zero, return EINVAL.
2374 2415 */
2375 2416 error = EINVAL;
2376 2417 }
2377 2418 } else if (number < min || number > max) {
2378 2419 error = ERANGE;
2379 2420 } else {
2380 2421 error = 0;
2381 2422 }
2382 2423
2383 2424 *val = number;
2384 2425
2385 2426 return (error);
2386 2427 }
2387 2428
2388 2429 static int
2389 2430 pidcmp(const void *p1, const void *p2)
2390 2431 {
2391 2432 pid_t i = *((pid_t *)p1);
2392 2433 pid_t j = *((pid_t *)p2);
2393 2434
2394 2435 return (i - j);
2395 2436 }
|
↓ open down ↓ |
188 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX