?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8158 Want named threads API
[unleashed.git] / usr / src / cmd / prstat / prstat.c
blob0ff4f51bcdad6b84e7e20933916b2cb0cd4a8160
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2013 Gary Mills
24 *
25 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
26 * Use is subject to license terms.
27 *
28 * Portions Copyright 2009 Chad Mynhier
29 * Copyright 2018 Joyent, Inc. All rights reserved.
30 */
31
32 #include <sys/types.h>
33 #include <sys/resource.h>
34 #include <sys/loadavg.h>
35 #include <sys/time.h>
36 #include <sys/pset.h>
37 #include <sys/vm_usage.h>
38 #include <zone.h>
39 #include <libzonecfg.h>
40
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <unistd.h>
44 #include <dirent.h>
45 #include <string.h>
46 #include <errno.h>
47 #include <poll.h>
48 #include <ctype.h>
49 #include <fcntl.h>
50 #include <limits.h>
51 #include <signal.h>
52 #include <time.h>
53 #include <project.h>
54
55 #include <langinfo.h>
56 #include <libintl.h>
57 #include <locale.h>
58
59 #include "prstat.h"
60 #include "prutil.h"
61 #include "prtable.h"
62 #include "prsort.h"
63 #include "prfile.h"
64
65 /*
66 * x86 <sys/regs.h> ERR conflicts with <curses.h> ERR. For the purposes
67 * of this file, we care about the curses.h ERR so include that last.
68 */
69
70 #if defined(ERR)
71 #undef ERR
72 #endif
73
74 #ifndef TEXT_DOMAIN /* should be defined by cc -D */
75 #define TEXT_DOMAIN "SYS_TEST" /* use this only if it wasn't */
76 #endif
77
78 #include <curses.h>
79 #include <term.h>
80
81 #define LOGIN_WIDTH 8
82 #define ZONE_WIDTH 28
83 #define PROJECT_WIDTH 28
84
85 #define PSINFO_HEADER_PROC \
86 " PID USERNAME SIZE RSS STATE PRI NICE TIME CPU PROCESS/NLWP "
87 #define PSINFO_HEADER_PROC_LGRP \
88 " PID USERNAME SIZE RSS STATE PRI NICE TIME CPU LGRP PROCESS/NLWP "
89 #define PSINFO_HEADER_LWP \
90 " PID USERNAME SIZE RSS STATE PRI NICE TIME CPU PROCESS/LWP "
91 #define PSINFO_HEADER_LWP_LGRP \
92 " PID USERNAME SIZE RSS STATE PRI NICE TIME CPU LGRP PROCESS/LWP "
93 #define USAGE_HEADER_PROC \
94 " PID USERNAME USR SYS TRP TFL DFL LCK SLP LAT VCX ICX SCL SIG PROCESS/NLWP "
95 #define USAGE_HEADER_LWP \
96 " PID USERNAME USR SYS TRP TFL DFL LCK SLP LAT VCX ICX SCL SIG PROCESS/LWP "
97 #define USER_HEADER_PROC \
98 " NPROC USERNAME SWAP RSS MEMORY TIME CPU "
99 #define USER_HEADER_LWP \
100 " NLWP USERNAME SWAP RSS MEMORY TIME CPU "
101 #define TASK_HEADER_PROC \
102 "TASKID NPROC SWAP RSS MEMORY TIME CPU PROJECT "
103 #define TASK_HEADER_LWP \
104 "TASKID NLWP SWAP RSS MEMORY TIME CPU PROJECT "
105 #define PROJECT_HEADER_PROC \
106 "PROJID NPROC SWAP RSS MEMORY TIME CPU PROJECT "
107 #define PROJECT_HEADER_LWP \
108 "PROJID NLWP SWAP RSS MEMORY TIME CPU PROJECT "
109 #define ZONE_HEADER_PROC \
110 "ZONEID NPROC SWAP RSS MEMORY TIME CPU ZONE "
111 #define ZONE_HEADER_LWP \
112 "ZONEID NLWP SWAP RSS MEMORY TIME CPU ZONE "
113 #define PSINFO_LINE \
114 "%6d %-8s %5s %5s %-6s %3s %3s %9s %3.3s%% %s"
115 #define PSINFO_LINE_LGRP \
116 "%6d %-8s %5s %5s %-6s %3s %3s %9s %3.3s%% %4d %s"
117 #define USAGE_LINE \
118 "%6d %-8s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s "\
119 "%3.3s %3.3s %s"
120 #define USER_LINE \
121 "%6d %-8s %5.5s %5.5s %3.3s%% %9s %3.3s%%"
122 #define TASK_LINE \
123 "%6d %8d %5s %5s %3.3s%% %9s %3.3s%% %28s"
124 #define PROJECT_LINE \
125 "%6d %8d %5s %5s %3.3s%% %9s %3.3s%% %28s"
126 #define ZONE_LINE \
127 "%6d %8d %5s %5s %3.3s%% %9s %3.3s%% %28s"
128
129 #define TOTAL_LINE \
130 "Total: %d processes, %d lwps, load averages: %3.2f, %3.2f, %3.2f"
131
132 /* global variables */
133
134 static char *t_ulon; /* termcap: start underline */
135 static char *t_uloff; /* termcap: end underline */
136 static char *t_up; /* termcap: cursor 1 line up */
137 static char *t_eol; /* termcap: clear end of line */
138 static char *t_smcup; /* termcap: cursor mvcap on */
139 static char *t_rmcup; /* termcap: cursor mvcap off */
140 static char *t_home; /* termcap: move cursor home */
141 static char *movecur = NULL; /* termcap: move up string */
142 static char *empty_string = "\0"; /* termcap: empty string */
143 static uint_t print_movecur = FALSE; /* print movecur or not */
144 static int is_curses_on = FALSE; /* current curses state */
145
146 static table_t pid_tbl = {0, 0, NULL}; /* selected processes */
147 static table_t cpu_tbl = {0, 0, NULL}; /* selected processors */
148 static table_t set_tbl = {0, 0, NULL}; /* selected processor sets */
149 static table_t prj_tbl = {0, 0, NULL}; /* selected projects */
150 static table_t tsk_tbl = {0, 0, NULL}; /* selected tasks */
151 static table_t lgr_tbl = {0, 0, NULL}; /* selected lgroups */
152 static zonetbl_t zone_tbl = {0, 0, NULL}; /* selected zones */
153 static uidtbl_t euid_tbl = {0, 0, NULL}; /* selected effective users */
154 static uidtbl_t ruid_tbl = {0, 0, NULL}; /* selected real users */
155
156 static uint_t total_procs; /* total number of procs */
157 static uint_t total_lwps; /* total number of lwps */
158 static float total_cpu; /* total cpu usage */
159 static float total_mem; /* total memory usage */
160
161 static list_t lwps; /* list of lwps/processes */
162 static list_t users; /* list of users */
163 static list_t tasks; /* list of tasks */
164 static list_t projects; /* list of projects */
165 static list_t zones; /* list of zones */
166 static list_t lgroups; /* list of lgroups */
167
168 static volatile uint_t sigwinch = 0;
169 static volatile uint_t sigtstp = 0;
170 static volatile uint_t sigterm = 0;
171
172 static long pagesize;
173
174 /* default settings */
175
176 optdesc_t opts = {
177 5, /* interval between updates, seconds */
178 15, /* number of lines in top part */
179 5, /* number of lines in bottom part */
180 -1, /* number of iterations; infinitely */
181 OPT_PSINFO | OPT_FULLSCREEN | OPT_USEHOME | OPT_TERMCAP,
182 -1 /* sort in decreasing order */
183 };
184
185 /*
186 * Print timestamp as decimal reprentation of time_t value (-d u was specified)
187 * or the standard date format (-d d was specified).
188 */
189 static void
190 print_timestamp(void)
191 {
192 time_t t = time(NULL);
193 static char *fmt = NULL;
194
195 /* We only need to retrieve this once per invocation */
196 if (fmt == NULL)
197 fmt = nl_langinfo(_DATE_FMT);
198
199 if (opts.o_outpmode & OPT_UDATE) {
200 (void) printf("%ld", t);
201 } else if (opts.o_outpmode & OPT_DDATE) {
202 char dstr[64];
203 int len;
204
205 len = strftime(dstr, sizeof (dstr), fmt, localtime(&t));
206 if (len > 0)
207 (void) printf("%s", dstr);
208 }
209 (void) putp(t_eol);
210 (void) putchar('\n');
211 }
212
213 static void
214 psetloadavg(long psetid, void *ptr)
215 {
216 double psetloadavg[3];
217 double *loadavg = ptr;
218
219 if (pset_getloadavg((psetid_t)psetid, psetloadavg, 3) != -1) {
220 *loadavg++ += psetloadavg[0];
221 *loadavg++ += psetloadavg[1];
222 *loadavg += psetloadavg[2];
223 }
224 }
225
226 /*
227 * Queries the memory virtual and rss size for each member of a list.
228 * This will override the values computed by /proc aggregation.
229 */
230 static void
231 list_getsize(list_t *list)
232 {
233 id_info_t *id;
234 vmusage_t *results, *next;
235 vmusage_t *match;
236 size_t nres = 0;
237 size_t i;
238 uint_t flags = 0;
239 int ret;
240 size_t physmem = sysconf(_SC_PHYS_PAGES) * pagesize;
241
242 /*
243 * Determine what swap/rss results to calculate. getvmusage() will
244 * prune results returned to non-global zones automatically, so
245 * there is no need to pass different flags when calling from a
246 * non-global zone.
247 *
248 * Currently list_getsize() is only called with a single flag. This
249 * is because -Z, -J, -T, and -a are mutually exclusive. Regardless
250 * of this, we handle multiple flags.
251 */
252 if (opts.o_outpmode & OPT_USERS) {
253 /*
254 * Gather rss for all users in all zones. Treat the same
255 * uid in different zones as the same user.
256 */
257 flags |= VMUSAGE_COL_RUSERS;
258
259 } else if (opts.o_outpmode & OPT_TASKS) {
260 /* Gather rss for all tasks in all zones */
261 flags |= VMUSAGE_ALL_TASKS;
262
263 } else if (opts.o_outpmode & OPT_PROJECTS) {
264 /*
265 * Gather rss for all projects in all zones. Treat the same
266 * projid in diffrent zones as the same project.
267 */
268 flags |= VMUSAGE_COL_PROJECTS;
269
270 } else if (opts.o_outpmode & OPT_ZONES) {
271 /* Gather rss for all zones */
272 flags |= VMUSAGE_ALL_ZONES;
273
274 } else {
275 Die(gettext(
276 "Cannot determine rss flags for output options %x\n"),
277 opts.o_outpmode);
278 }
279
280 /*
281 * getvmusage() returns an array of result structures. One for
282 * each zone, project, task, or user on the system, depending on
283 * flags.
284 *
285 * If getvmusage() fails, prstat will use the size already gathered
286 * from psinfo
287 */
288 if (getvmusage(flags, opts.o_interval, NULL, &nres) != 0)
289 return;
290
291 results = (vmusage_t *)Malloc(sizeof (vmusage_t) * nres);
292 for (;;) {
293 ret = getvmusage(flags, opts.o_interval, results, &nres);
294 if (ret == 0)
295 break;
296 if (errno == EOVERFLOW) {
297 results = (vmusage_t *)Realloc(results,
298 sizeof (vmusage_t) * nres);
299 continue;
300 }
301 /*
302 * Failure for some other reason. Prstat will use the size
303 * already gathered from psinfo.
304 */
305 free(results);
306 return;
307 }
308 for (id = list->l_head; id != NULL; id = id->id_next) {
309
310 match = NULL;
311 next = results;
312 for (i = 0; i < nres; i++, next++) {
313 switch (flags) {
314 case VMUSAGE_COL_RUSERS:
315 if (next->vmu_id == id->id_uid)
316 match = next;
317 break;
318 case VMUSAGE_ALL_TASKS:
319 if (next->vmu_id == id->id_taskid)
320 match = next;
321 break;
322 case VMUSAGE_COL_PROJECTS:
323 if (next->vmu_id == id->id_projid)
324 match = next;
325 break;
326 case VMUSAGE_ALL_ZONES:
327 if (next->vmu_id == id->id_zoneid)
328 match = next;
329 break;
330 default:
331 Die(gettext(
332 "Unknown vmusage flags %d\n"), flags);
333 }
334 }
335 if (match != NULL) {
336 id->id_size = match->vmu_swap_all / 1024;
337 id->id_rssize = match->vmu_rss_all / 1024;
338 id->id_pctmem = (100.0 * (float)match->vmu_rss_all) /
339 (float)physmem;
340 /* Output using data from getvmusage() */
341 id->id_sizematch = B_TRUE;
342 }
343 /*
344 * If no match is found, prstat will use the size already
345 * gathered from psinfo.
346 */
347 }
348 free(results);
349 }
350
351 /*
352 * A routine to display the contents of the list on the screen
353 */
354 static void
355 list_print(list_t *list)
356 {
357 lwp_info_t *lwp;
358 id_info_t *id;
359 char usr[4], sys[4], trp[4], tfl[4];
360 char dfl[4], lck[4], slp[4], lat[4];
361 char vcx[4], icx[4], scl[4], sig[4];
362 char psize[6], prssize[6], pmem[6], pcpu[6], ptime[12];
363 char pstate[7], pnice[4], ppri[4];
364 char pname[LOGNAME_MAX+1];
365 char name[PRFNSZ + THREAD_NAME_MAX + 2];
366 char projname[PROJNAME_MAX+1];
367 char zonename[ZONENAME_MAX+1];
368 float cpu, mem;
369 double loadavg[3] = {0, 0, 0};
370 int i, n;
371
372 if (list->l_size == 0)
373 return;
374
375 if (foreach_element(&set_tbl, &loadavg, psetloadavg) == 0) {
376 /*
377 * If processor sets aren't specified, we display system-wide
378 * load averages.
379 */
380 (void) getloadavg(loadavg, 3);
381 }
382
383 if (((opts.o_outpmode & OPT_UDATE) || (opts.o_outpmode & OPT_DDATE)) &&
384 ((list->l_type == LT_LWPS) || !(opts.o_outpmode & OPT_SPLIT)))
385 print_timestamp();
386 if (opts.o_outpmode & OPT_TTY)
387 (void) putchar('\r');
388 (void) putp(t_ulon);
389
390 n = opts.o_cols;
391 switch (list->l_type) {
392 case LT_PROJECTS:
393 if (opts.o_outpmode & OPT_LWPS)
394 n = printf(PROJECT_HEADER_LWP);
395 else
396 n = printf(PROJECT_HEADER_PROC);
397 break;
398 case LT_TASKS:
399 if (opts.o_outpmode & OPT_LWPS)
400 n = printf(TASK_HEADER_LWP);
401 else
402 n = printf(TASK_HEADER_PROC);
403 break;
404 case LT_ZONES:
405 if (opts.o_outpmode & OPT_LWPS)
406 n = printf(ZONE_HEADER_LWP);
407 else
408 n = printf(ZONE_HEADER_PROC);
409 break;
410 case LT_USERS:
411 if (opts.o_outpmode & OPT_LWPS)
412 n = printf(USER_HEADER_LWP);
413 else
414 n = printf(USER_HEADER_PROC);
415 break;
416 case LT_LWPS:
417 if (opts.o_outpmode & OPT_LWPS) {
418 if (opts.o_outpmode & OPT_PSINFO) {
419 if (opts.o_outpmode & OPT_LGRP)
420 n = printf(PSINFO_HEADER_LWP_LGRP);
421 else
422 n = printf(PSINFO_HEADER_LWP);
423 }
424 if (opts.o_outpmode & OPT_MSACCT)
425 n = printf(USAGE_HEADER_LWP);
426 } else {
427 if (opts.o_outpmode & OPT_PSINFO) {
428 if (opts.o_outpmode & OPT_LGRP)
429 n = printf(PSINFO_HEADER_PROC_LGRP);
430 else
431 n = printf(PSINFO_HEADER_PROC);
432 }
433 if (opts.o_outpmode & OPT_MSACCT)
434 n = printf(USAGE_HEADER_PROC);
435 }
436 break;
437 }
438
439 /* Pad out the header line so the underline spans the whole width */
440 if ((opts.o_outpmode & OPT_TERMCAP) && n < opts.o_cols)
441 (void) printf("%*s", (int)(opts.o_cols - n), "");
442
443 (void) putp(t_uloff);
444 (void) putp(t_eol);
445 (void) putchar('\n');
446
447 for (i = 0; i < list->l_used; i++) {
448 switch (list->l_type) {
449 case LT_PROJECTS:
450 case LT_TASKS:
451 case LT_USERS:
452 case LT_ZONES:
453 id = list->l_ptrs[i];
454 /*
455 * CPU usage and memory usage normalization
456 */
457 if (total_cpu >= 100)
458 cpu = (100 * id->id_pctcpu) / total_cpu;
459 else
460 cpu = id->id_pctcpu;
461 if (id->id_sizematch == B_FALSE && total_mem >= 100)
462 mem = (100 * id->id_pctmem) / total_mem;
463 else
464 mem = id->id_pctmem;
465 if (list->l_type == LT_USERS) {
466 pwd_getname(id->id_uid, pname, sizeof (pname),
467 opts.o_outpmode & OPT_NORESOLVE,
468 opts.o_outpmode & (OPT_TERMCAP|OPT_TRUNC),
469 LOGIN_WIDTH);
470 } else if (list->l_type == LT_ZONES) {
471 getzonename(id->id_zoneid, zonename,
472 sizeof (zonename),
473 opts.o_outpmode & (OPT_TERMCAP|OPT_TRUNC),
474 ZONE_WIDTH);
475 } else {
476 getprojname(id->id_projid, projname,
477 sizeof (projname),
478 opts.o_outpmode & OPT_NORESOLVE,
479 opts.o_outpmode & (OPT_TERMCAP|OPT_TRUNC),
480 PROJECT_WIDTH);
481 }
482 Format_size(psize, id->id_size, 6);
483 Format_size(prssize, id->id_rssize, 6);
484 Format_pct(pmem, mem, 4);
485 Format_pct(pcpu, cpu, 4);
486 Format_time(ptime, id->id_time, 10);
487 if (opts.o_outpmode & OPT_TTY)
488 (void) putchar('\r');
489 if (list->l_type == LT_PROJECTS)
490 (void) printf(PROJECT_LINE, (int)id->id_projid,
491 id->id_nproc, psize, prssize, pmem, ptime,
492 pcpu, projname);
493 else if (list->l_type == LT_TASKS)
494 (void) printf(TASK_LINE, (int)id->id_taskid,
495 id->id_nproc, psize, prssize, pmem, ptime,
496 pcpu, projname);
497 else if (list->l_type == LT_ZONES)
498 (void) printf(ZONE_LINE, (int)id->id_zoneid,
499 id->id_nproc, psize, prssize, pmem, ptime,
500 pcpu, zonename);
501 else
502 (void) printf(USER_LINE, id->id_nproc, pname,
503 psize, prssize, pmem, ptime, pcpu);
504 (void) putp(t_eol);
505 (void) putchar('\n');
506 break;
507 case LT_LWPS:
508 lwp = list->l_ptrs[i];
509
510 format_name(lwp, name, sizeof (name));
511
512 pwd_getname(lwp->li_info.pr_uid, pname, sizeof (pname),
513 opts.o_outpmode & OPT_NORESOLVE,
514 opts.o_outpmode & (OPT_TERMCAP|OPT_TRUNC),
515 LOGIN_WIDTH);
516
517 if (opts.o_outpmode & OPT_PSINFO) {
518 Format_size(psize, lwp->li_info.pr_size, 6);
519 Format_size(prssize, lwp->li_info.pr_rssize, 6);
520 Format_state(pstate,
521 lwp->li_info.pr_lwp.pr_sname,
522 lwp->li_info.pr_lwp.pr_onpro, 7);
523 if (strcmp(lwp->li_info.pr_lwp.pr_clname,
524 "RT") == 0 ||
525 strcmp(lwp->li_info.pr_lwp.pr_clname,
526 "SYS") == 0 ||
527 lwp->li_info.pr_lwp.pr_sname == 'Z')
528 (void) strcpy(pnice, " -");
529 else
530 Format_num(pnice,
531 lwp->li_info.pr_lwp.pr_nice - NZERO,
532 4);
533 Format_num(ppri, lwp->li_info.pr_lwp.pr_pri, 4);
534 Format_pct(pcpu,
535 FRC2PCT(lwp->li_info.pr_lwp.pr_pctcpu), 4);
536 if (opts.o_outpmode & OPT_LWPS)
537 Format_time(ptime,
538 lwp->li_info.pr_lwp.pr_time.tv_sec,
539 10);
540 else
541 Format_time(ptime,
542 lwp->li_info.pr_time.tv_sec, 10);
543 if (opts.o_outpmode & OPT_TTY)
544 (void) putchar('\r');
545 if (opts.o_outpmode & OPT_LGRP) {
546 (void) printf(PSINFO_LINE_LGRP,
547 (int)lwp->li_info.pr_pid, pname,
548 psize, prssize, pstate,
549 ppri, pnice, ptime, pcpu,
550 lwp->li_info.pr_lwp.pr_lgrp, name);
551 } else {
552 (void) printf(PSINFO_LINE,
553 (int)lwp->li_info.pr_pid, pname,
554 psize, prssize, pstate, ppri, pnice,
555 ptime, pcpu, name);
556 }
557 (void) putp(t_eol);
558 (void) putchar('\n');
559 }
560 if (opts.o_outpmode & OPT_MSACCT) {
561 Format_pct(usr, lwp->li_usr, 4);
562 Format_pct(sys, lwp->li_sys, 4);
563 Format_pct(slp, lwp->li_slp, 4);
564 Format_num(vcx, lwp->li_vcx, 4);
565 Format_num(icx, lwp->li_icx, 4);
566 Format_num(scl, lwp->li_scl, 4);
567 Format_num(sig, lwp->li_sig, 4);
568 Format_pct(trp, lwp->li_trp, 4);
569 Format_pct(tfl, lwp->li_tfl, 4);
570 Format_pct(dfl, lwp->li_dfl, 4);
571 Format_pct(lck, lwp->li_lck, 4);
572 Format_pct(lat, lwp->li_lat, 4);
573 if (opts.o_outpmode & OPT_TTY)
574 (void) putchar('\r');
575 (void) printf(USAGE_LINE,
576 (int)lwp->li_info.pr_pid, pname,
577 usr, sys, trp, tfl, dfl, lck,
578 slp, lat, vcx, icx, scl, sig,
579 name);
580 (void) putp(t_eol);
581 (void) putchar('\n');
582 }
583 break;
584 }
585 }
586
587 if (opts.o_outpmode & OPT_TTY)
588 (void) putchar('\r');
589 if (opts.o_outpmode & OPT_TERMCAP) {
590 switch (list->l_type) {
591 case LT_PROJECTS:
592 case LT_USERS:
593 case LT_TASKS:
594 case LT_ZONES:
595 while (i++ < opts.o_nbottom) {
596 (void) putp(t_eol);
597 (void) putchar('\n');
598 }
599 break;
600 case LT_LWPS:
601 while (i++ < opts.o_ntop) {
602 (void) putp(t_eol);
603 (void) putchar('\n');
604 }
605 }
606 }
607
608 if (opts.o_outpmode & OPT_TTY)
609 (void) putchar('\r');
610
611 if ((opts.o_outpmode & OPT_SPLIT) && list->l_type == LT_LWPS)
612 return;
613
614 (void) printf(TOTAL_LINE, total_procs, total_lwps,
615 loadavg[LOADAVG_1MIN], loadavg[LOADAVG_5MIN],
616 loadavg[LOADAVG_15MIN]);
617 (void) putp(t_eol);
618 (void) putchar('\n');
619 if (opts.o_outpmode & OPT_TTY)
620 (void) putchar('\r');
621 (void) putp(t_eol);
622 (void) fflush(stdout);
623 }
624
625 static lwp_info_t *
626 list_add_lwp(list_t *list, pid_t pid, id_t lwpid)
627 {
628 lwp_info_t *lwp;
629
630 if (list->l_head == NULL) {
631 list->l_head = list->l_tail = lwp = Zalloc(sizeof (lwp_info_t));
632 } else {
633 lwp = Zalloc(sizeof (lwp_info_t));
634 lwp->li_prev = list->l_tail;
635 ((lwp_info_t *)list->l_tail)->li_next = lwp;
636 list->l_tail = lwp;
637 }
638 lwp->li_info.pr_pid = pid;
639 lwp->li_info.pr_lwp.pr_lwpid = lwpid;
640 lwpid_add(lwp, pid, lwpid);
641 list->l_count++;
642 return (lwp);
643 }
644
645 static void
646 list_remove_lwp(list_t *list, lwp_info_t *lwp)
647 {
648 if (lwp->li_prev)
649 lwp->li_prev->li_next = lwp->li_next;
650 else
651 list->l_head = lwp->li_next; /* removing the head */
652 if (lwp->li_next)
653 lwp->li_next->li_prev = lwp->li_prev;
654 else
655 list->l_tail = lwp->li_prev; /* removing the tail */
656 lwpid_del(lwp->li_info.pr_pid, lwp->li_info.pr_lwp.pr_lwpid);
657 if (lwpid_pidcheck(lwp->li_info.pr_pid) == 0)
658 fds_rm(lwp->li_info.pr_pid);
659 list->l_count--;
660 free(lwp);
661 }
662
663 static void
664 list_clear(list_t *list)
665 {
666 if (list->l_type == LT_LWPS) {
667 lwp_info_t *lwp = list->l_tail;
668 lwp_info_t *lwp_tmp;
669
670 fd_closeall();
671 while (lwp) {
672 lwp_tmp = lwp;
673 lwp = lwp->li_prev;
674 list_remove_lwp(&lwps, lwp_tmp);
675 }
676 } else {
677 id_info_t *id = list->l_head;
678 id_info_t *nextid;
679
680 while (id) {
681 nextid = id->id_next;
682 free(id);
683 id = nextid;
684 }
685 list->l_count = 0;
686 list->l_head = list->l_tail = NULL;
687 }
688 }
689
690 static void
691 list_update(list_t *list, lwp_info_t *lwp)
692 {
693 id_info_t *id;
694
695 if (list->l_head == NULL) { /* first element */
696 list->l_head = list->l_tail = id = Zalloc(sizeof (id_info_t));
697 goto update;
698 }
699
700 for (id = list->l_head; id; id = id->id_next) {
701 if ((list->l_type == LT_USERS) &&
702 (id->id_uid != lwp->li_info.pr_uid))
703 continue;
704 if ((list->l_type == LT_TASKS) &&
705 (id->id_taskid != lwp->li_info.pr_taskid))
706 continue;
707 if ((list->l_type == LT_PROJECTS) &&
708 (id->id_projid != lwp->li_info.pr_projid))
709 continue;
710 if ((list->l_type == LT_ZONES) &&
711 (id->id_zoneid != lwp->li_info.pr_zoneid))
712 continue;
713 if ((list->l_type == LT_LGRPS) &&
714 (id->id_lgroup != lwp->li_info.pr_lwp.pr_lgrp))
715 continue;
716 id->id_nproc++;
717 id->id_taskid = lwp->li_info.pr_taskid;
718 id->id_projid = lwp->li_info.pr_projid;
719 id->id_zoneid = lwp->li_info.pr_zoneid;
720 id->id_lgroup = lwp->li_info.pr_lwp.pr_lgrp;
721
722 if (lwp->li_flags & LWP_REPRESENT) {
723 id->id_size += lwp->li_info.pr_size;
724 id->id_rssize += lwp->li_info.pr_rssize;
725 }
726 id->id_pctcpu += FRC2PCT(lwp->li_info.pr_lwp.pr_pctcpu);
727 if (opts.o_outpmode & OPT_LWPS)
728 id->id_time += TIME2SEC(lwp->li_info.pr_lwp.pr_time);
729 else
730 id->id_time += TIME2SEC(lwp->li_info.pr_time);
731 id->id_pctmem += FRC2PCT(lwp->li_info.pr_pctmem);
732 id->id_key += lwp->li_key;
733 total_cpu += FRC2PCT(lwp->li_info.pr_lwp.pr_pctcpu);
734 total_mem += FRC2PCT(lwp->li_info.pr_pctmem);
735 return;
736 }
737
738 id = list->l_tail;
739 id->id_next = Zalloc(sizeof (id_info_t));
740 id->id_next->id_prev = list->l_tail;
741 id->id_next->id_next = NULL;
742 list->l_tail = id->id_next;
743 id = list->l_tail;
744 update:
745 id->id_uid = lwp->li_info.pr_uid;
746 id->id_projid = lwp->li_info.pr_projid;
747 id->id_taskid = lwp->li_info.pr_taskid;
748 id->id_zoneid = lwp->li_info.pr_zoneid;
749 id->id_lgroup = lwp->li_info.pr_lwp.pr_lgrp;
750 id->id_nproc++;
751 id->id_sizematch = B_FALSE;
752 if (lwp->li_flags & LWP_REPRESENT) {
753 id->id_size = lwp->li_info.pr_size;
754 id->id_rssize = lwp->li_info.pr_rssize;
755 }
756 id->id_pctcpu = FRC2PCT(lwp->li_info.pr_lwp.pr_pctcpu);
757 if (opts.o_outpmode & OPT_LWPS)
758 id->id_time = TIME2SEC(lwp->li_info.pr_lwp.pr_time);
759 else
760 id->id_time = TIME2SEC(lwp->li_info.pr_time);
761 id->id_pctmem = FRC2PCT(lwp->li_info.pr_pctmem);
762 id->id_key = lwp->li_key;
763 total_cpu += id->id_pctcpu;
764 total_mem += id->id_pctmem;
765 list->l_count++;
766 }
767
768 static void
769 lwp_update(lwp_info_t *lwp, pid_t pid, id_t lwpid, struct prusage *usage)
770 {
771 float period;
772
773 if (!lwpid_is_active(pid, lwpid)) {
774 /*
775 * If we are reading cpu times for the first time then
776 * calculate average cpu times based on whole process
777 * execution time.
778 */
779 (void) memcpy(&lwp->li_usage, usage, sizeof (prusage_t));
780 period = TIME2NSEC(usage->pr_rtime);
781 period = period/(float)100;
782
783 if (period == 0) { /* zombie */
784 period = 1;
785 lwp->li_usr = 0;
786 lwp->li_sys = 0;
787 lwp->li_slp = 0;
788 } else {
789 lwp->li_usr = TIME2NSEC(usage->pr_utime)/period;
790 lwp->li_sys = TIME2NSEC(usage->pr_stime)/period;
791 lwp->li_slp = TIME2NSEC(usage->pr_slptime)/period;
792 }
793 lwp->li_trp = TIME2NSEC(usage->pr_ttime)/period;
794 lwp->li_tfl = TIME2NSEC(usage->pr_tftime)/period;
795 lwp->li_dfl = TIME2NSEC(usage->pr_dftime)/period;
796 lwp->li_lck = TIME2NSEC(usage->pr_ltime)/period;
797 lwp->li_lat = TIME2NSEC(usage->pr_wtime)/period;
798 period = (period / NANOSEC)*(float)100; /* now in seconds */
799 lwp->li_vcx = (ulong_t)
800 (opts.o_interval * (usage->pr_vctx/period));
801 lwp->li_icx = (ulong_t)
802 (opts.o_interval * (usage->pr_ictx/period));
803 lwp->li_scl = (ulong_t)
804 (opts.o_interval * (usage->pr_sysc/period));
805 lwp->li_sig = (ulong_t)
806 (opts.o_interval * (usage->pr_sigs/period));
807 (void) lwpid_set_active(pid, lwpid);
808 } else {
809 /*
810 * If this is not a first time we are reading a process's
811 * CPU times then recalculate CPU times based on fresh data
812 * obtained from procfs and previous CPU time usage values.
813 */
814 period = TIME2NSEC(usage->pr_rtime)-
815 TIME2NSEC(lwp->li_usage.pr_rtime);
816 period = period/(float)100;
817
818 if (period == 0) { /* zombie */
819 period = 1;
820 lwp->li_usr = 0;
821 lwp->li_sys = 0;
822 lwp->li_slp = 0;
823 } else {
824 lwp->li_usr = (TIME2NSEC(usage->pr_utime)-
825 TIME2NSEC(lwp->li_usage.pr_utime))/period;
826 lwp->li_sys = (TIME2NSEC(usage->pr_stime) -
827 TIME2NSEC(lwp->li_usage.pr_stime))/period;
828 lwp->li_slp = (TIME2NSEC(usage->pr_slptime) -
829 TIME2NSEC(lwp->li_usage.pr_slptime))/period;
830 }
831 lwp->li_trp = (TIME2NSEC(usage->pr_ttime) -
832 TIME2NSEC(lwp->li_usage.pr_ttime))/period;
833 lwp->li_tfl = (TIME2NSEC(usage->pr_tftime) -
834 TIME2NSEC(lwp->li_usage.pr_tftime))/period;
835 lwp->li_dfl = (TIME2NSEC(usage->pr_dftime) -
836 TIME2NSEC(lwp->li_usage.pr_dftime))/period;
837 lwp->li_lck = (TIME2NSEC(usage->pr_ltime) -
838 TIME2NSEC(lwp->li_usage.pr_ltime))/period;
839 lwp->li_lat = (TIME2NSEC(usage->pr_wtime) -
840 TIME2NSEC(lwp->li_usage.pr_wtime))/period;
841 lwp->li_vcx = usage->pr_vctx - lwp->li_usage.pr_vctx;
842 lwp->li_icx = usage->pr_ictx - lwp->li_usage.pr_ictx;
843 lwp->li_scl = usage->pr_sysc - lwp->li_usage.pr_sysc;
844 lwp->li_sig = usage->pr_sigs - lwp->li_usage.pr_sigs;
845 (void) memcpy(&lwp->li_usage, usage, sizeof (prusage_t));
846 }
847 }
848
849 static int
850 read_procfile(fd_t **fd, char *pidstr, char *file, void *buf, size_t bufsize)
851 {
852 char procfile[MAX_PROCFS_PATH];
853
854 (void) snprintf(procfile, MAX_PROCFS_PATH,
855 "/proc/%s/%s", pidstr, file);
856 if ((*fd = fd_open(procfile, O_RDONLY, *fd)) == NULL)
857 return (1);
858 if (pread(fd_getfd(*fd), buf, bufsize, 0) != bufsize) {
859 fd_close(*fd);
860 return (1);
861 }
862 return (0);
863 }
864
865 static void
866 add_proc(psinfo_t *psinfo)
867 {
868 lwp_info_t *lwp;
869 id_t lwpid;
870 pid_t pid = psinfo->pr_pid;
871
872 lwpid = psinfo->pr_lwp.pr_lwpid;
873 if ((lwp = lwpid_get(pid, lwpid)) == NULL)
874 lwp = list_add_lwp(&lwps, pid, lwpid);
875 lwp->li_flags |= LWP_ALIVE | LWP_REPRESENT;
876 (void) memcpy(&lwp->li_info, psinfo, sizeof (psinfo_t));
877 lwp->li_info.pr_lwp.pr_pctcpu = lwp->li_info.pr_pctcpu;
878 }
879
880 static void
881 get_lwpname(pid_t pid, id_t lwpid, char *buf, size_t bufsize)
882 {
883 char *path = NULL;
884 int fd;
885
886 buf[0] = '\0';
887
888 if (asprintf(&path, "/proc/%d/lwp/%d/lwpname",
889 (int)pid, (int)lwpid) == -1)
890 return;
891
892 if ((fd = open(path, O_RDONLY)) != -1) {
893 (void) read(fd, buf, bufsize);
894 buf[bufsize - 1] = '\0';
895 (void) close(fd);
896 }
897
898 free(path);
899 }
900
901 static void
902 add_lwp(psinfo_t *psinfo, lwpsinfo_t *lwpsinfo, int flags)
903 {
904 lwp_info_t *lwp;
905 pid_t pid = psinfo->pr_pid;
906 id_t lwpid = lwpsinfo->pr_lwpid;
907
908 if ((lwp = lwpid_get(pid, lwpid)) == NULL)
909 lwp = list_add_lwp(&lwps, pid, lwpid);
910 lwp->li_flags &= ~LWP_REPRESENT;
911 lwp->li_flags |= LWP_ALIVE;
912 lwp->li_flags |= flags;
913 (void) memcpy(&lwp->li_info, psinfo,
914 sizeof (psinfo_t) - sizeof (lwpsinfo_t));
915 (void) memcpy(&lwp->li_info.pr_lwp, lwpsinfo, sizeof (lwpsinfo_t));
916 get_lwpname(pid, lwpid, lwp->li_lwpname, sizeof (lwp->li_lwpname));
917 }
918
919 static void
920 prstat_scandir(DIR *procdir)
921 {
922 char *pidstr;
923 pid_t pid;
924 id_t lwpid;
925 size_t entsz;
926 long nlwps, nent, i;
927 char *buf, *ptr;
928
929 fds_t *fds;
930 lwp_info_t *lwp;
931 dirent_t *direntp;
932
933 prheader_t header;
934 psinfo_t psinfo;
935 prusage_t usage;
936 lwpsinfo_t *lwpsinfo;
937 prusage_t *lwpusage;
938
939 total_procs = 0;
940 total_lwps = 0;
941 total_cpu = 0;
942 total_mem = 0;
943
944 convert_zone(&zone_tbl);
945 for (rewinddir(procdir); (direntp = readdir(procdir)); ) {
946 pidstr = direntp->d_name;
947 if (pidstr[0] == '.') /* skip "." and ".." */
948 continue;
949 pid = atoi(pidstr);
950 if (pid == 0 || pid == 2 || pid == 3)
951 continue; /* skip sched, pageout and fsflush */
952 if (has_element(&pid_tbl, pid) == 0)
953 continue; /* check if we really want this pid */
954 fds = fds_get(pid); /* get ptr to file descriptors */
955
956 if (read_procfile(&fds->fds_psinfo, pidstr,
957 "psinfo", &psinfo, sizeof (psinfo_t)) != 0)
958 continue;
959 if (!has_uid(&ruid_tbl, psinfo.pr_uid) ||
960 !has_uid(&euid_tbl, psinfo.pr_euid) ||
961 !has_element(&prj_tbl, psinfo.pr_projid) ||
962 !has_element(&tsk_tbl, psinfo.pr_taskid) ||
963 !has_zone(&zone_tbl, psinfo.pr_zoneid)) {
964 fd_close(fds->fds_psinfo);
965 continue;
966 }
967 nlwps = psinfo.pr_nlwp + psinfo.pr_nzomb;
968
969 if (nlwps > 1 && (opts.o_outpmode & (OPT_LWPS | OPT_PSETS))) {
970 int rep_lwp = 0;
971
972 if (read_procfile(&fds->fds_lpsinfo, pidstr, "lpsinfo",
973 &header, sizeof (prheader_t)) != 0) {
974 fd_close(fds->fds_psinfo);
975 continue;
976 }
977
978 nent = header.pr_nent;
979 entsz = header.pr_entsize * nent;
980 ptr = buf = Malloc(entsz);
981 if (pread(fd_getfd(fds->fds_lpsinfo), buf,
982 entsz, sizeof (struct prheader)) != entsz) {
983 fd_close(fds->fds_lpsinfo);
984 fd_close(fds->fds_psinfo);
985 free(buf);
986 continue;
987 }
988
989 nlwps = 0;
990 for (i = 0; i < nent; i++, ptr += header.pr_entsize) {
991 /*LINTED ALIGNMENT*/
992 lwpsinfo = (lwpsinfo_t *)ptr;
993 if (!has_element(&cpu_tbl,
994 lwpsinfo->pr_onpro) ||
995 !has_element(&set_tbl,
996 lwpsinfo->pr_bindpset) ||
997 !has_element(&lgr_tbl, lwpsinfo->pr_lgrp))
998 continue;
999 nlwps++;
1000 if ((opts.o_outpmode & (OPT_PSETS | OPT_LWPS))
1001 == OPT_PSETS) {
1002 /*
1003 * If one of process's LWPs is bound
1004 * to a given processor set, report the
1005 * whole process. We may be doing this
1006 * a few times but we'll get an accurate
1007 * lwp count in return.
1008 */
1009 add_proc(&psinfo);
1010 } else {
1011 if (rep_lwp == 0) {
1012 rep_lwp = 1;
1013 add_lwp(&psinfo, lwpsinfo,
1014 LWP_REPRESENT);
1015 } else {
1016 add_lwp(&psinfo, lwpsinfo, 0);
1017 }
1018 }
1019 }
1020 free(buf);
1021 if (nlwps == 0) {
1022 fd_close(fds->fds_lpsinfo);
1023 fd_close(fds->fds_psinfo);
1024 continue;
1025 }
1026 } else {
1027 if (!has_element(&cpu_tbl, psinfo.pr_lwp.pr_onpro) ||
1028 !has_element(&set_tbl, psinfo.pr_lwp.pr_bindpset) ||
1029 !has_element(&lgr_tbl, psinfo.pr_lwp.pr_lgrp)) {
1030 fd_close(fds->fds_psinfo);
1031 continue;
1032 }
1033 add_proc(&psinfo);
1034 }
1035 if (!(opts.o_outpmode & OPT_MSACCT)) {
1036 total_procs++;
1037 total_lwps += nlwps;
1038 continue;
1039 }
1040 /*
1041 * Get more information about processes from /proc/pid/usage.
1042 * If process has more than one lwp, then we may have to
1043 * also look at the /proc/pid/lusage file.
1044 */
1045 if ((opts.o_outpmode & OPT_LWPS) && (nlwps > 1)) {
1046 if (read_procfile(&fds->fds_lusage, pidstr, "lusage",
1047 &header, sizeof (prheader_t)) != 0) {
1048 fd_close(fds->fds_lpsinfo);
1049 fd_close(fds->fds_psinfo);
1050 continue;
1051 }
1052 nent = header.pr_nent;
1053 entsz = header.pr_entsize * nent;
1054 buf = Malloc(entsz);
1055 if (pread(fd_getfd(fds->fds_lusage), buf,
1056 entsz, sizeof (struct prheader)) != entsz) {
1057 fd_close(fds->fds_lusage);
1058 fd_close(fds->fds_lpsinfo);
1059 fd_close(fds->fds_psinfo);
1060 free(buf);
1061 continue;
1062 }
1063 for (i = 1, ptr = buf + header.pr_entsize; i < nent;
1064 i++, ptr += header.pr_entsize) {
1065 /*LINTED ALIGNMENT*/
1066 lwpusage = (prusage_t *)ptr;
1067 lwpid = lwpusage->pr_lwpid;
1068 /*
1069 * New LWPs created after we read lpsinfo
1070 * will be ignored. Don't want to do
1071 * everything all over again.
1072 */
1073 if ((lwp = lwpid_get(pid, lwpid)) == NULL)
1074 continue;
1075 lwp_update(lwp, pid, lwpid, lwpusage);
1076 }
1077 free(buf);
1078 } else {
1079 if (read_procfile(&fds->fds_usage, pidstr, "usage",
1080 &usage, sizeof (prusage_t)) != 0) {
1081 fd_close(fds->fds_lpsinfo);
1082 fd_close(fds->fds_psinfo);
1083 continue;
1084 }
1085 lwpid = psinfo.pr_lwp.pr_lwpid;
1086 if ((lwp = lwpid_get(pid, lwpid)) == NULL)
1087 continue;
1088 lwp_update(lwp, pid, lwpid, &usage);
1089 }
1090 total_procs++;
1091 total_lwps += nlwps;
1092 }
1093 fd_update();
1094 }
1095
1096 /*
1097 * This procedure removes all dead lwps from the linked list of all lwps.
1098 * It also creates linked list of ids if necessary.
1099 */
1100 static void
1101 list_refresh(list_t *list)
1102 {
1103 lwp_info_t *lwp, *lwp_next;
1104
1105 if (!(list->l_type & LT_LWPS))
1106 return;
1107
1108 for (lwp = list->l_head; lwp != NULL; ) {
1109 if (lwp->li_flags & LWP_ALIVE) {
1110 /*
1111 * Process all live LWPs.
1112 * When we're done, mark them as dead.
1113 * They will be marked "alive" on the next
1114 * /proc scan if they still exist.
1115 */
1116 lwp->li_key = list_getkeyval(list, lwp);
1117 if (opts.o_outpmode & OPT_USERS)
1118 list_update(&users, lwp);
1119 if (opts.o_outpmode & OPT_TASKS)
1120 list_update(&tasks, lwp);
1121 if (opts.o_outpmode & OPT_PROJECTS)
1122 list_update(&projects, lwp);
1123 if (opts.o_outpmode & OPT_ZONES)
1124 list_update(&zones, lwp);
1125 if (opts.o_outpmode & OPT_LGRP)
1126 list_update(&lgroups, lwp);
1127 lwp->li_flags &= ~LWP_ALIVE;
1128 lwp = lwp->li_next;
1129
1130 } else {
1131 lwp_next = lwp->li_next;
1132 list_remove_lwp(&lwps, lwp);
1133 lwp = lwp_next;
1134 }
1135 }
1136 }
1137
1138 static void
1139 curses_on(void)
1140 {
1141 if ((opts.o_outpmode & OPT_TERMCAP) && (is_curses_on == FALSE)) {
1142 (void) initscr();
1143 (void) nonl();
1144 (void) putp(t_smcup);
1145 is_curses_on = TRUE;
1146 }
1147 }
1148
1149 static void
1150 curses_off(void)
1151 {
1152 if ((is_curses_on == TRUE) && (opts.o_outpmode & OPT_TERMCAP)) {
1153 (void) putp(t_rmcup);
1154 (void) endwin();
1155 is_curses_on = FALSE;
1156 }
1157 (void) fflush(stdout);
1158 }
1159
1160 static int
1161 nlines(int *linesp, int *colsp)
1162 {
1163 struct winsize ws;
1164 char *envp;
1165 int n;
1166
1167 *linesp = -1;
1168 *colsp = -1;
1169 if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) != -1) {
1170 if (ws.ws_row > 0)
1171 *linesp = ws.ws_row;
1172 if (ws.ws_col > 0)
1173 *colsp = ws.ws_col;
1174 if (ws.ws_row > 0 && ws.ws_col > 0)
1175 return (0);
1176 }
1177
1178 if ((envp = getenv("LINES")) != NULL) {
1179 if ((n = Atoi(envp)) > 0) {
1180 opts.o_outpmode &= ~OPT_USEHOME;
1181 *linesp = n;
1182 }
1183 }
1184 if ((envp = getenv("COLUMNS")) != NULL) {
1185 if ((n = Atoi(envp)) > 0) {
1186 *colsp = n;
1187 }
1188 }
1189
1190 return ((*linesp > 0 && *colsp > 0) ? 0 : -1);
1191 }
1192
1193 static void
1194 setmovecur(void)
1195 {
1196 int i, n;
1197 if ((opts.o_outpmode & OPT_FULLSCREEN) &&
1198 (opts.o_outpmode & OPT_USEHOME)) {
1199 movecur = t_home;
1200 return;
1201 }
1202 if (opts.o_outpmode & OPT_SPLIT) {
1203 if (opts.o_ntop == 0)
1204 n = opts.o_nbottom + 1;
1205 else
1206 n = opts.o_ntop + opts.o_nbottom + 2;
1207 } else {
1208 if (opts.o_outpmode & OPT_USERS)
1209 n = opts.o_nbottom + 1;
1210 else
1211 n = opts.o_ntop + 1;
1212 }
1213 if (((opts.o_outpmode & OPT_UDATE) || (opts.o_outpmode & OPT_DDATE)))
1214 n++;
1215
1216 if (movecur != NULL && movecur != empty_string && movecur != t_home)
1217 free(movecur);
1218 movecur = Zalloc(strlen(t_up) * (n + 5));
1219 for (i = 0; i <= n; i++)
1220 (void) strcat(movecur, t_up);
1221 }
1222
1223 static int
1224 setsize(void)
1225 {
1226 static int oldn = 0;
1227 int cols, n, ret;
1228
1229 if (opts.o_outpmode & OPT_FULLSCREEN) {
1230 ret = nlines(&n, &cols);
1231 if (ret != -1)
1232 opts.o_cols = cols;
1233 if (n == oldn)
1234 return (0);
1235 oldn = n;
1236 if (ret == -1) {
1237 opts.o_outpmode &= ~OPT_USEHOME;
1238 setmovecur(); /* set default window size */
1239 return (1);
1240 }
1241 n = n - 3; /* minus header, total and cursor lines */
1242 if ((opts.o_outpmode & OPT_UDATE) ||
1243 (opts.o_outpmode & OPT_DDATE))
1244 n--; /* minus timestamp */
1245 if (n < 1)
1246 Die(gettext("window is too small (try -n)\n"));
1247 if (opts.o_outpmode & OPT_SPLIT) {
1248 if (n < 8) {
1249 Die(gettext("window is too small (try -n)\n"));
1250 } else {
1251 opts.o_ntop = (n / 4) * 3;
1252 opts.o_nbottom = n - 1 - opts.o_ntop;
1253 }
1254 } else {
1255 if (opts.o_outpmode & OPT_USERS)
1256 opts.o_nbottom = n;
1257 else
1258 opts.o_ntop = n;
1259 }
1260 }
1261 setmovecur();
1262 return (1);
1263 }
1264
1265 static void
1266 ldtermcap()
1267 {
1268 int err;
1269 if (setupterm(NULL, STDIN_FILENO, &err) == ERR) {
1270 switch (err) {
1271 case 0:
1272 Warn(gettext("failed to load terminal info, "
1273 "defaulting to -c option\n"));
1274 break;
1275 case -1:
1276 Warn(gettext("terminfo database not found, "
1277 "defaulting to -c option\n"));
1278 break;
1279 default:
1280 Warn(gettext("failed to initialize terminal, "
1281 "defaulting to -c option\n"));
1282 }
1283 opts.o_outpmode &= ~OPT_TERMCAP;
1284 t_up = t_eol = t_smcup = t_rmcup = movecur = empty_string;
1285 t_ulon = t_uloff = empty_string;
1286 return;
1287 }
1288 t_ulon = tigetstr("smul");
1289 t_uloff = tigetstr("rmul");
1290 t_up = tigetstr("cuu1");
1291 t_eol = tigetstr("el");
1292 t_smcup = tigetstr("smcup");
1293 t_rmcup = tigetstr("rmcup");
1294 t_home = tigetstr("home");
1295 if ((t_up == (char *)-1) || (t_eol == (char *)-1) ||
1296 (t_smcup == (char *)-1) || (t_rmcup == (char *)-1)) {
1297 opts.o_outpmode &= ~OPT_TERMCAP;
1298 t_up = t_eol = t_smcup = t_rmcup = movecur = empty_string;
1299 return;
1300 }
1301 if (t_up == NULL || t_eol == NULL) {
1302 opts.o_outpmode &= ~OPT_TERMCAP;
1303 t_eol = t_up = movecur = empty_string;
1304 return;
1305 }
1306 if (t_ulon == (char *)-1 || t_uloff == (char *)-1 ||
1307 t_ulon == NULL || t_uloff == NULL) {
1308 t_ulon = t_uloff = empty_string; /* can live without it */
1309 }
1310 if (t_smcup == NULL || t_rmcup == NULL)
1311 t_smcup = t_rmcup = empty_string;
1312 if (t_home == (char *)-1 || t_home == NULL) {
1313 opts.o_outpmode &= ~OPT_USEHOME;
1314 t_home = empty_string;
1315 }
1316 }
1317
1318 static void
1319 sig_handler(int sig)
1320 {
1321 switch (sig) {
1322 case SIGTSTP: sigtstp = 1;
1323 break;
1324 case SIGWINCH: sigwinch = 1;
1325 break;
1326 case SIGINT:
1327 case SIGTERM: sigterm = 1;
1328 break;
1329 }
1330 }
1331
1332 static void
1333 set_signals()
1334 {
1335 (void) signal(SIGTSTP, sig_handler);
1336 (void) signal(SIGINT, sig_handler);
1337 (void) signal(SIGTERM, sig_handler);
1338 if (opts.o_outpmode & OPT_FULLSCREEN)
1339 (void) signal(SIGWINCH, sig_handler);
1340 }
1341
1342 static void
1343 fill_table(table_t *table, char *arg, char option)
1344 {
1345 char *p = strtok(arg, ", ");
1346
1347 if (p == NULL)
1348 Die(gettext("invalid argument for -%c\n"), option);
1349
1350 add_element(table, (long)Atoi(p));
1351 while (p = strtok(NULL, ", "))
1352 add_element(table, (long)Atoi(p));
1353 }
1354
1355 static void
1356 fill_prj_table(char *arg)
1357 {
1358 projid_t projid;
1359 char *p = strtok(arg, ", ");
1360
1361 if (p == NULL)
1362 Die(gettext("invalid argument for -j\n"));
1363
1364 if ((projid = getprojidbyname(p)) == -1)
1365 projid = Atoi(p);
1366 add_element(&prj_tbl, (long)projid);
1367
1368 while (p = strtok(NULL, ", ")) {
1369 if ((projid = getprojidbyname(p)) == -1)
1370 projid = Atoi(p);
1371 add_element(&prj_tbl, (long)projid);
1372 }
1373 }
1374
1375 static void
1376 fill_set_table(char *arg)
1377 {
1378 char *p = strtok(arg, ", ");
1379 psetid_t id;
1380
1381 if (p == NULL)
1382 Die(gettext("invalid argument for -C\n"));
1383
1384 if ((id = Atoi(p)) == 0)
1385 id = PS_NONE;
1386 add_element(&set_tbl, id);
1387 while (p = strtok(NULL, ", ")) {
1388 if ((id = Atoi(p)) == 0)
1389 id = PS_NONE;
1390 if (!has_element(&set_tbl, id))
1391 add_element(&set_tbl, id);
1392 }
1393 }
1394
1395 static void
1396 Exit()
1397 {
1398 curses_off();
1399 list_clear(&lwps);
1400 list_clear(&users);
1401 list_clear(&tasks);
1402 list_clear(&projects);
1403 list_clear(&zones);
1404 fd_exit();
1405 }
1406
1407
1408 int
1409 main(int argc, char **argv)
1410 {
1411 DIR *procdir;
1412 char *p;
1413 char *sortk = "cpu"; /* default sort key */
1414 int opt;
1415 int timeout;
1416 struct pollfd pollset;
1417 char key;
1418
1419 (void) setlocale(LC_ALL, "");
1420 (void) textdomain(TEXT_DOMAIN);
1421 Progname(argv[0]);
1422 lwpid_init();
1423 fd_init(Setrlimit());
1424
1425 pagesize = sysconf(_SC_PAGESIZE);
1426
1427 while ((opt = getopt(argc, argv,
1428 "vcd:HmarRLtu:U:n:p:C:P:h:s:S:j:k:TJWz:Z")) != (int)EOF) {
1429 switch (opt) {
1430 case 'r':
1431 opts.o_outpmode |= OPT_NORESOLVE;
1432 break;
1433 case 'R':
1434 opts.o_outpmode |= OPT_REALTIME;
1435 break;
1436 case 'c':
1437 opts.o_outpmode &= ~OPT_TERMCAP;
1438 opts.o_outpmode &= ~OPT_FULLSCREEN;
1439 break;
1440 case 'd':
1441 if (optarg) {
1442 if (*optarg == 'u')
1443 opts.o_outpmode |= OPT_UDATE;
1444 else if (*optarg == 'd')
1445 opts.o_outpmode |= OPT_DDATE;
1446 else
1447 Usage();
1448 } else {
1449 Usage();
1450 }
1451 break;
1452 case 'h':
1453 fill_table(&lgr_tbl, optarg, 'h');
1454 break;
1455 case 'H':
1456 opts.o_outpmode |= OPT_LGRP;
1457 break;
1458 case 'm':
1459 case 'v':
1460 opts.o_outpmode &= ~OPT_PSINFO;
1461 opts.o_outpmode |= OPT_MSACCT;
1462 break;
1463 case 't':
1464 opts.o_outpmode &= ~OPT_PSINFO;
1465 opts.o_outpmode |= OPT_USERS;
1466 break;
1467 case 'a':
1468 opts.o_outpmode |= OPT_SPLIT | OPT_USERS;
1469 break;
1470 case 'T':
1471 opts.o_outpmode |= OPT_SPLIT | OPT_TASKS;
1472 break;
1473 case 'J':
1474 opts.o_outpmode |= OPT_SPLIT | OPT_PROJECTS;
1475 break;
1476 case 'n':
1477 if ((p = strtok(optarg, ",")) == NULL)
1478 Die(gettext("invalid argument for -n\n"));
1479 opts.o_ntop = Atoi(p);
1480 if (p = strtok(NULL, ","))
1481 opts.o_nbottom = Atoi(p);
1482 else if (opts.o_ntop == 0)
1483 opts.o_nbottom = 5;
1484 opts.o_outpmode &= ~OPT_FULLSCREEN;
1485 break;
1486 case 's':
1487 opts.o_sortorder = -1;
1488 sortk = optarg;
1489 break;
1490 case 'S':
1491 opts.o_sortorder = 1;
1492 sortk = optarg;
1493 break;
1494 case 'u':
1495 if ((p = strtok(optarg, ", ")) == NULL)
1496 Die(gettext("invalid argument for -u\n"));
1497 add_uid(&euid_tbl, p);
1498 while (p = strtok(NULL, ", "))
1499 add_uid(&euid_tbl, p);
1500 break;
1501 case 'U':
1502 if ((p = strtok(optarg, ", ")) == NULL)
1503 Die(gettext("invalid argument for -U\n"));
1504 add_uid(&ruid_tbl, p);
1505 while (p = strtok(NULL, ", "))
1506 add_uid(&ruid_tbl, p);
1507 break;
1508 case 'p':
1509 fill_table(&pid_tbl, optarg, 'p');
1510 break;
1511 case 'C':
1512 fill_set_table(optarg);
1513 opts.o_outpmode |= OPT_PSETS;
1514 break;
1515 case 'P':
1516 fill_table(&cpu_tbl, optarg, 'P');
1517 break;
1518 case 'k':
1519 fill_table(&tsk_tbl, optarg, 'k');
1520 break;
1521 case 'j':
1522 fill_prj_table(optarg);
1523 break;
1524 case 'L':
1525 opts.o_outpmode |= OPT_LWPS;
1526 break;
1527 case 'W':
1528 opts.o_outpmode |= OPT_TRUNC;
1529 break;
1530 case 'z':
1531 if ((p = strtok(optarg, ", ")) == NULL)
1532 Die(gettext("invalid argument for -z\n"));
1533 add_zone(&zone_tbl, p);
1534 while (p = strtok(NULL, ", "))
1535 add_zone(&zone_tbl, p);
1536 break;
1537 case 'Z':
1538 opts.o_outpmode |= OPT_SPLIT | OPT_ZONES;
1539 break;
1540 default:
1541 Usage();
1542 }
1543 }
1544
1545 (void) atexit(Exit);
1546 if ((opts.o_outpmode & OPT_USERS) &&
1547 !(opts.o_outpmode & OPT_SPLIT))
1548 opts.o_nbottom = opts.o_ntop;
1549 if (!(opts.o_outpmode & OPT_SPLIT) && opts.o_ntop == 0)
1550 Die(gettext("invalid argument for -n\n"));
1551 if (opts.o_nbottom == 0)
1552 Die(gettext("invalid argument for -n\n"));
1553 if (!(opts.o_outpmode & OPT_SPLIT) && (opts.o_outpmode & OPT_USERS) &&
1554 ((opts.o_outpmode & (OPT_PSINFO | OPT_MSACCT))))
1555 Die(gettext("-t option cannot be used with -v or -m\n"));
1556
1557 if ((opts.o_outpmode & OPT_SPLIT) && (opts.o_outpmode & OPT_USERS) &&
1558 !((opts.o_outpmode & (OPT_PSINFO | OPT_MSACCT))))
1559 Die(gettext("-t option cannot be used with "
1560 "-a, -J, -T or -Z\n"));
1561
1562 if ((opts.o_outpmode & OPT_USERS) &&
1563 (opts.o_outpmode & (OPT_TASKS | OPT_PROJECTS | OPT_ZONES)))
1564 Die(gettext("-a option cannot be used with "
1565 "-t, -J, -T or -Z\n"));
1566
1567 if (((opts.o_outpmode & OPT_TASKS) &&
1568 (opts.o_outpmode & (OPT_PROJECTS|OPT_ZONES))) ||
1569 ((opts.o_outpmode & OPT_PROJECTS) &&
1570 (opts.o_outpmode & (OPT_TASKS|OPT_ZONES)))) {
1571 Die(gettext(
1572 "-J, -T and -Z options are mutually exclusive\n"));
1573 }
1574
1575 /*
1576 * There is not enough space to combine microstate information and
1577 * lgroup information and still fit in 80-column output.
1578 */
1579 if ((opts.o_outpmode & OPT_LGRP) && (opts.o_outpmode & OPT_MSACCT)) {
1580 Die(gettext("-H and -m options are mutually exclusive\n"));
1581 }
1582
1583 if (argc > optind)
1584 opts.o_interval = Atoi(argv[optind++]);
1585 if (argc > optind)
1586 opts.o_count = Atoi(argv[optind++]);
1587 if (opts.o_count == 0)
1588 Die(gettext("invalid counter value\n"));
1589 if (argc > optind)
1590 Usage();
1591 if (opts.o_outpmode & OPT_REALTIME)
1592 Priocntl("RT");
1593 if (isatty(STDOUT_FILENO) == 1 && isatty(STDIN_FILENO))
1594 opts.o_outpmode |= OPT_TTY; /* interactive */
1595 if (!(opts.o_outpmode & OPT_TTY)) {
1596 opts.o_outpmode &= ~OPT_TERMCAP; /* no termcap for pipes */
1597 opts.o_outpmode &= ~OPT_FULLSCREEN;
1598 }
1599 if (opts.o_outpmode & OPT_TERMCAP)
1600 ldtermcap(); /* can turn OPT_TERMCAP off */
1601 if (opts.o_outpmode & OPT_TERMCAP)
1602 (void) setsize();
1603 list_alloc(&lwps, opts.o_ntop);
1604 list_alloc(&users, opts.o_nbottom);
1605 list_alloc(&tasks, opts.o_nbottom);
1606 list_alloc(&projects, opts.o_nbottom);
1607 list_alloc(&zones, opts.o_nbottom);
1608 list_alloc(&lgroups, opts.o_nbottom);
1609 list_setkeyfunc(sortk, &opts, &lwps, LT_LWPS);
1610 list_setkeyfunc(NULL, &opts, &users, LT_USERS);
1611 list_setkeyfunc(NULL, &opts, &tasks, LT_TASKS);
1612 list_setkeyfunc(NULL, &opts, &projects, LT_PROJECTS);
1613 list_setkeyfunc(NULL, &opts, &zones, LT_ZONES);
1614 list_setkeyfunc(NULL, &opts, &lgroups, LT_LGRPS);
1615 if (opts.o_outpmode & OPT_TERMCAP)
1616 curses_on();
1617 if ((procdir = opendir("/proc")) == NULL)
1618 Die(gettext("cannot open /proc directory\n"));
1619 if (opts.o_outpmode & OPT_TTY) {
1620 (void) printf(gettext("Please wait...\r"));
1621 if (!(opts.o_outpmode & OPT_TERMCAP))
1622 (void) putchar('\n');
1623 (void) fflush(stdout);
1624 }
1625 set_signals();
1626 pollset.fd = STDIN_FILENO;
1627 pollset.events = POLLIN;
1628 timeout = opts.o_interval * MILLISEC;
1629
1630 /*
1631 * main program loop
1632 */
1633 do {
1634 if (sigterm == 1)
1635 break;
1636 if (sigtstp == 1) {
1637 curses_off();
1638 (void) signal(SIGTSTP, SIG_DFL);
1639 (void) kill(0, SIGTSTP);
1640 /*
1641 * prstat stops here until it receives SIGCONT signal.
1642 */
1643 sigtstp = 0;
1644 (void) signal(SIGTSTP, sig_handler);
1645 curses_on();
1646 print_movecur = FALSE;
1647 if (opts.o_outpmode & OPT_FULLSCREEN)
1648 sigwinch = 1;
1649 }
1650 if (sigwinch == 1) {
1651 if (setsize() == 1) {
1652 list_free(&lwps);
1653 list_free(&users);
1654 list_free(&tasks);
1655 list_free(&projects);
1656 list_free(&zones);
1657 list_alloc(&lwps, opts.o_ntop);
1658 list_alloc(&users, opts.o_nbottom);
1659 list_alloc(&tasks, opts.o_nbottom);
1660 list_alloc(&projects, opts.o_nbottom);
1661 list_alloc(&zones, opts.o_nbottom);
1662 }
1663 sigwinch = 0;
1664 (void) signal(SIGWINCH, sig_handler);
1665 }
1666 prstat_scandir(procdir);
1667 list_refresh(&lwps);
1668 if (print_movecur)
1669 (void) putp(movecur);
1670 print_movecur = TRUE;
1671 if ((opts.o_outpmode & OPT_PSINFO) ||
1672 (opts.o_outpmode & OPT_MSACCT)) {
1673 list_sort(&lwps);
1674 list_print(&lwps);
1675 }
1676 if (opts.o_outpmode & OPT_USERS) {
1677 list_getsize(&users);
1678 list_sort(&users);
1679 list_print(&users);
1680 list_clear(&users);
1681 }
1682 if (opts.o_outpmode & OPT_TASKS) {
1683 list_getsize(&tasks);
1684 list_sort(&tasks);
1685 list_print(&tasks);
1686 list_clear(&tasks);
1687 }
1688 if (opts.o_outpmode & OPT_PROJECTS) {
1689 list_getsize(&projects);
1690 list_sort(&projects);
1691 list_print(&projects);
1692 list_clear(&projects);
1693 }
1694 if (opts.o_outpmode & OPT_ZONES) {
1695 list_getsize(&zones);
1696 list_sort(&zones);
1697 list_print(&zones);
1698 list_clear(&zones);
1699 }
1700 if (opts.o_count == 1)
1701 break;
1702 /*
1703 * If poll() returns -1 and sets errno to EINTR here because
1704 * the process received a signal, it is Ok to abort this
1705 * timeout and loop around because we check the signals at the
1706 * top of the loop.
1707 */
1708 if (opts.o_outpmode & OPT_TTY) {
1709 if (poll(&pollset, (nfds_t)1, timeout) > 0) {
1710 if (read(STDIN_FILENO, &key, 1) == 1) {
1711 if (tolower(key) == 'q')
1712 break;
1713 }
1714 }
1715 } else {
1716 (void) sleep(opts.o_interval);
1717 }
1718 } while (opts.o_count == (-1) || --opts.o_count);
1719
1720 if (opts.o_outpmode & OPT_TTY)
1721 (void) putchar('\r');
1722 return (0);
1723 }
Unleashed OS