top - Import DragonFly specific patches for 3.8beta1.
[dragonfly.git] / contrib / top / top.c
CommitLineData
63d92323
JL
1/*
2 * Copyright (c) 1984 through 2008, William LeFebvre
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * * Redistributions in binary form must reproduce the above
12 * copyright notice, this list of conditions and the following disclaimer
13 * in the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * * Neither the name of William LeFebvre nor the names of other
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33char *copyright =
34 "Copyright (c) 1984 through 2008, William LeFebvre";
35
36/*
37 * Changes to other files that we can do at the same time:
38 * screen.c:init_termcap: get rid of the "interactive" argument and have it
39 * pass back something meaningful (such as success/failure/error).
40 */
41
42#include "os.h"
43#include <signal.h>
44#include <setjmp.h>
45#include <ctype.h>
46#include <sys/types.h>
47#include <sys/uio.h>
48#include <unistd.h>
49
50#ifdef HAVE_SYS_UTSNAME_H
51#include <sys/utsname.h>
52#endif
53
54#ifdef HAVE_GETOPT_H
55#include <getopt.h>
56#endif
57
58/* definitions */
59#ifndef STDIN_FILENO
60#define STDIN_FILENO 0
61#endif
62
63/* determine which type of signal functions to use */
64/* cant have sigaction without sigprocmask */
65#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGPROCMASK)
66#undef HAVE_SIGACTION
67#endif
68/* always use sigaction when it is available */
69#ifdef HAVE_SIGACTION
70#undef HAVE_SIGHOLD
71#else
72/* use sighold/sigrelse, otherwise use old fashioned BSD signals */
73#if !defined(HAVE_SIGHOLD) || !defined(HAVE_SIGRELSE)
74#define BSD_SIGNALS
75#endif
76#endif
77
78/* if FD_SET and friends aren't present, then fake something up */
79#ifndef FD_SET
80typedef int fd_set;
81#define FD_ZERO(x) (*(x) = 0)
82#define FD_SET(f, x) (*(x) = 1<<f)
83#endif
84
85/* includes specific to top */
86
87#include "top.h"
88#include "machine.h"
89#include "globalstate.h"
90#include "commands.h"
91#include "display.h"
92#include "screen.h"
93#include "boolean.h"
94#include "username.h"
95#include "utils.h"
96#include "version.h"
97#ifdef ENABLE_COLOR
98#include "color.h"
99#endif
100
101/* definitions */
102#define BUFFERSIZE 4096
103#define JMP_RESUME 1
104#define JMP_RESIZE 2
105
106/* externs for getopt: */
107extern int optind;
108extern char *optarg;
109
110/* statics */
111static char stdoutbuf[BUFFERSIZE];
112static jmp_buf jmp_int;
113
114/* globals */
115char *myname = "top";
116
117void
118quit(int status)
119
120{
121 screen_end();
122 chdir("/tmp");
123 exit(status);
124 /* NOTREACHED */
125}
126
127/*
128 * signal handlers
129 */
130
131void
132set_signal(int sig, RETSIGTYPE (*handler)(int))
133
134{
135#ifdef HAVE_SIGACTION
136 struct sigaction action;
137
138 action.sa_handler = handler;
139 action.sa_flags = 0;
140 (void) sigaction(sig, &action, NULL);
141#else
142 (void) signal(sig, handler);
143#endif
144}
145
146void
147release_signal(int sig)
148
149{
150#ifdef HAVE_SIGACTION
151 sigset_t set;
152 sigemptyset(&set);
153 sigaddset(&set, sig);
154 sigprocmask(SIG_UNBLOCK, &set, NULL);
155#endif
156
157#ifdef HAVE_SIGHOLD
158 sigrelse(sig);
159#endif
160
161#ifdef BSD_SIGNALS
162 (void) sigsetmask(sigblock(0) & ~(sigmask(sig)));
163#endif
164}
165
166RETSIGTYPE
167sig_leave(int i) /* exit under normal conditions -- INT handler */
168
169{
170 screen_end();
171 exit(EX_OK);
172}
173
174RETSIGTYPE
175sig_tstop(int i) /* SIGTSTP handler */
176
177{
178 /* move to the lower left */
179 screen_end();
180 fflush(stdout);
181
182 /* default the signal handler action */
183 set_signal(SIGTSTP, SIG_DFL);
184
185 /* unblock the TSTP signal */
186 release_signal(SIGTSTP);
187
188 /* send ourselves a TSTP to stop the process */
189 (void) kill(0, SIGTSTP);
190
191 /* reset the signal handler */
192 set_signal(SIGTSTP, sig_tstop);
193
194 /* reinit screen */
195 screen_reinit();
196
197 /* jump back to a known place in the main loop */
198 longjmp(jmp_int, JMP_RESUME);
199
200 /* NOTREACHED */
201}
202
203#ifdef SIGWINCH
204RETSIGTYPE
205sig_winch(int i) /* SIGWINCH handler */
206
207{
208 /* reascertain the screen dimensions */
209 screen_getsize();
210
211 /* jump back to a known place in the main loop */
212 longjmp(jmp_int, JMP_RESIZE);
213}
214#endif
215
216#ifdef HAVE_SIGACTION
217static sigset_t signalset;
218#endif
219
220void *
221hold_signals()
222
223{
224#ifdef HAVE_SIGACTION
225 sigemptyset(&signalset);
226 sigaddset(&signalset, SIGINT);
227 sigaddset(&signalset, SIGQUIT);
228 sigaddset(&signalset, SIGTSTP);
229#ifdef SIGWINCH
230 sigaddset(&signalset, SIGWINCH);
231#endif
232 sigprocmask(SIG_BLOCK, &signalset, NULL);
233 return (void *)(&signalset);
234#endif
235
236#ifdef HAVE_SIGHOLD
237 sighold(SIGINT);
238 sighold(SIGQUIT);
239 sighold(SIGTSTP);
240#ifdef SIGWINCH
241 sighold(SIGWINCH);
242 return NULL;
243#endif
244#endif
245
246#ifdef BSD_SIGNALS
247 int mask;
248#ifdef SIGWINCH
249 mask = sigblock(sigmask(SIGINT) | sigmask(SIGQUIT) |
250 sigmask(SIGTSTP) | sigmask(SIGWINCH));
251#else
252 mask = sigblock(sigmask(SIGINT) | sigmask(SIGQUIT) | sigmask(SIGTSTP));
253 return (void *)mask;
254#endif
255#endif
256
257}
258
259void
260set_signals()
261
262{
263 (void) set_signal(SIGINT, sig_leave);
264 (void) set_signal(SIGQUIT, sig_leave);
265 (void) set_signal(SIGTSTP, sig_tstop);
266#ifdef SIGWINCH
267 (void) set_signal(SIGWINCH, sig_winch);
268#endif
269}
270
271void
272release_signals(void *parm)
273
274{
275#ifdef HAVE_SIGACTION
276 sigprocmask(SIG_UNBLOCK, (sigset_t *)parm, NULL);
277#endif
278
279#ifdef HAVE_SIGHOLD
280 sigrelse(SIGINT);
281 sigrelse(SIGQUIT);
282 sigrelse(SIGTSTP);
283#ifdef SIGWINCH
284 sigrelse(SIGWINCH);
285#endif
286#endif
287
288#ifdef BSD_SIGNALS
289 (void) sigsetmask((int)parm);
290#endif
291}
292
293/*
294 * void do_arguments(globalstate *gstate, int ac, char **av)
295 *
296 * Arguments processing. gstate points to the global state,
297 * ac and av are the arguments to process. This can be called
298 * multiple times with different sets of arguments.
299 */
300
301#ifdef HAVE_GETOPT_LONG
302static struct option longopts[] = {
303 { "color", no_argument, NULL, 'C' },
304 { "debug", no_argument, NULL, 'D' },
305 { "system-procs", no_argument, NULL, 'S' },
306 { "idle-procs", no_argument, NULL, 'I' },
307 { "tag-names", no_argument, NULL, 'T' },
308 { "all", no_argument, NULL, 'a' },
309 { "batch", no_argument, NULL, 'b' },
310 { "full-commands", no_argument, NULL, 'c' },
311 { "interactive", no_argument, NULL, 'i' },
312 { "quick", no_argument, NULL, 'q' },
313 { "threads", no_argument, NULL, 't' },
314 { "uids", no_argument, NULL, 'u' },
315 { "version", no_argument, NULL, 'v' },
316 { "delay", required_argument, NULL, 's' },
317 { "displays", required_argument, NULL, 'd' },
318 { "user", required_argument, NULL, 'U' },
319 { "sort-order", required_argument, NULL, 'o' },
320 { "display-mode", required_argument, NULL, 'm' },
321 { NULL, 0, NULL, 0 },
322};
323#endif
324
325
326void
327do_arguments(globalstate *gstate, int ac, char **av)
328
329{
330 int i;
331
332 /* this appears to keep getopt happy */
333 optind = 1;
334
335#ifdef HAVE_GETOPT_LONG
7af1b2bc 336 while ((i = getopt_long(ac, av, "CDSIMTabcinqtuvs:d:U:o:m:", longopts, NULL)) != -1)
63d92323 337#else
7af1b2bc 338 while ((i = getopt(ac, av, "CDSIMTabcinqtuvs:d:U:o:m:")) != EOF)
63d92323
JL
339#endif
340 {
341 switch(i)
342 {
343#ifdef ENABLE_COLOR
344 case 'C':
345 gstate->use_color = !gstate->use_color;
346 break;
347#endif
348
349 case 'D':
350 debug_set(1);
351 break;
352
353 case 'v':
354 fprintf(stderr, "%s: version %s\n", myname, version_string());
355 exit(EX_OK);
356 break;
357
358 case 'b':
359 case 'n':
360 gstate->interactive = No;
361 break;
362
363 case 'a':
364 gstate->displays = Infinity;
365 gstate->topn = Infinity;
366 break;
367
368 case 'i':
369 gstate->interactive = Yes;
370 break;
371
372 case 'o':
373 gstate->order_name = optarg;
374 break;
375
376 case 'd':
377 i = atoiwi(optarg);
378 if (i == Invalid || i == 0)
379 {
380 message_error(" Bad display count");
381 }
382 else
383 {
384 gstate->displays = i;
385 }
386 break;
387
388 case 's':
389 i = atoi(optarg);
390 if (i < 0 || (i == 0 && getuid() != 0))
391 {
392 message_error(" Bad seconds delay");
393 }
394 else
395 {
396 gstate->delay = i;
397 }
398 break;
399
400 case 'u':
401 gstate->show_usernames = !gstate->show_usernames;
402 break;
403
404 case 'U':
405 i = userid(optarg);
406 if (i == -1)
407 {
408 message_error(" Unknown user '%s'", optarg);
409 }
410 else
411 {
412 gstate->pselect.uid = i;
413 }
414 break;
415
416 case 'm':
417 i = atoi(optarg);
418 gstate->pselect.mode = i;
419 break;
420
421 case 'S':
422 gstate->pselect.system = !gstate->pselect.system;
423 break;
424
425 case 'I':
426 gstate->pselect.idle = !gstate->pselect.idle;
427 break;
428
7af1b2bc
JL
429 case 'M':
430 enable_ncpus = 1;
431 break;
432
433
63d92323
JL
434#ifdef ENABLE_COLOR
435 case 'T':
436 gstate->show_tags = 1;
437 break;
438#endif
439
440 case 'c':
441 gstate->pselect.fullcmd = !gstate->pselect.fullcmd;
442 break;
443
444 case 't':
445 gstate->pselect.threads = !gstate->pselect.threads;
446 break;
447
448 case 'q': /* be quick about it */
449 /* only allow this if user is really root */
450 if (getuid() == 0)
451 {
452 /* be very un-nice! */
453 (void) nice(-20);
454 }
455 else
456 {
457 message_error(" Option -q can only be used by root");
458 }
459 break;
460
461 default:
462 fprintf(stderr, "\
463Top version %s\n\
464Usage: %s [-ISTabcinqu] [-d x] [-s x] [-o field] [-U username] [number]\n",
465 version_string(), myname);
466 exit(EX_USAGE);
467 }
468 }
469
470 /* get count of top processes to display */
471 if (optind < ac && *av[optind])
472 {
473 if ((i = atoiwi(av[optind])) == Invalid)
474 {
475 message_error(" Process count not a number");
476 }
477 else
478 {
479 gstate->topn = i;
480 }
481 }
482}
483
484void
485do_display(globalstate *gstate)
486
487{
488 int active_procs;
489 int i;
490 time_t curr_time;
491 caddr_t processes;
492 struct system_info system_info;
493 char *hdr;
494
495 /* get the time */
496 time_mark(&(gstate->now));
497 curr_time = (time_t)(gstate->now.tv_sec);
498
499 /* get the current stats */
500 get_system_info(&system_info);
501
502 /* get the current processes */
503 processes = get_process_info(&system_info, &(gstate->pselect), gstate->order_index);
504
505 /* determine number of processes to actually display */
506 if (gstate->topn > 0)
507 {
508 /* this number will be the smallest of: active processes,
509 number user requested, number current screen accomodates */
510 active_procs = system_info.P_ACTIVE;
511 if (active_procs > gstate->topn)
512 {
513 active_procs = gstate->topn;
514 }
515 if (active_procs > gstate->max_topn)
516 {
517 active_procs = gstate->max_topn;
518 }
519 }
520 else
521 {
522 /* dont show any */
523 active_procs = 0;
524 }
525
526#ifdef HAVE_FORMAT_PROCESS_HEADER
527 /* get the process header to use */
528 hdr = format_process_header(&(gstate->pselect), processes, active_procs);
529#else
530 hdr = gstate->header_text;
531#endif
532
533 /* full screen or update? */
534 if (gstate->fulldraw)
535 {
536 display_clear();
537 i_loadave(system_info.last_pid, system_info.load_avg);
538 i_uptime(&(gstate->statics->boottime), &curr_time);
539 i_timeofday(&curr_time);
540 i_procstates(system_info.p_total, system_info.procstates, gstate->pselect.threads);
541 if (gstate->show_cpustates)
542 {
543 i_cpustates(system_info.cpustates);
544 }
545 else
546 {
547 if (smart_terminal)
548 {
549 z_cpustates();
550 }
551 gstate->show_cpustates = Yes;
552 }
553 i_kernel(system_info.kernel);
554 i_memory(system_info.memory);
555 i_swap(system_info.swap);
556 i_message(&(gstate->now));
557 i_header(hdr);
558 for (i = 0; i < active_procs; i++)
559 {
560 i_process(i, format_next_process(processes, gstate->get_userid));
561 }
562 i_endscreen();
563 if (gstate->smart_terminal)
564 {
565 gstate->fulldraw = No;
566 }
567 }
568 else
569 {
570 u_loadave(system_info.last_pid, system_info.load_avg);
571 u_uptime(&(gstate->statics->boottime), &curr_time);
572 i_timeofday(&curr_time);
573 u_procstates(system_info.p_total, system_info.procstates, gstate->pselect.threads);
574 u_cpustates(system_info.cpustates);
575 u_kernel(system_info.kernel);
576 u_memory(system_info.memory);
577 u_swap(system_info.swap);
578 u_message(&(gstate->now));
579 u_header(hdr);
580 for (i = 0; i < active_procs; i++)
581 {
582 u_process(i, format_next_process(processes, gstate->get_userid));
583 }
584 u_endscreen();
585 }
586}
587
588#ifdef DEBUG
589void
590timeval_xdprint(char *s, struct timeval tv)
591
592{
593 xdprintf("%s %d.%06d\n", s, tv.tv_sec, tv.tv_usec);
594}
595#endif
596
597void
598do_wait(globalstate *gstate)
599
600{
601 struct timeval wait;
602
603 wait.tv_sec = gstate->delay;
604 wait.tv_usec = 0;
605 select(0, NULL, NULL, NULL, &wait);
606}
607
608void
609do_command(globalstate *gstate)
610
611{
612 int status;
613 struct timeval wait = {0, 0};
614 struct timeval now;
615 fd_set readfds;
616 unsigned char ch;
617
618 /* calculate new refresh time */
619 gstate->refresh = gstate->now;
620 gstate->refresh.tv_sec += gstate->delay;
621 time_get(&now);
622
623 /* loop waiting for time to expire */
624 do {
625 /* calculate time to wait */
626 if (gstate->delay > 0)
627 {
628 wait = gstate->refresh;
629 wait.tv_usec -= now.tv_usec;
630 if (wait.tv_usec < 0)
631 {
632 wait.tv_usec += 1000000;
633 wait.tv_sec--;
634 }
635 wait.tv_sec -= now.tv_sec;
636 }
637
638 /* set up arguments for select on stdin (0) */
639 FD_ZERO(&readfds);
640 FD_SET(STDIN_FILENO, &readfds);
641
642 /* wait for something to read or time out */
643 if (select(32, &readfds, NULL, NULL, &wait) > 0)
644 {
645 /* read it */
646 if (read(STDIN_FILENO, &ch, 1) != 1)
647 {
648 /* read error */
649 message_error(" Read error on stdin");
650 quit(EX_DATAERR);
651 /*NOTREACHED*/
652 }
653
654 /* mark pending messages as old */
655 message_mark();
656
657 /* dispatch */
658 status = command_process(gstate, (int)ch);
659 switch(status)
660 {
661 case CMD_ERROR:
662 quit(EX_SOFTWARE);
663 /*NOTREACHED*/
664
665 case CMD_REFRESH:
666 return;
667
668 case CMD_UNKNOWN:
669 message_error(" Unknown command");
670 break;
671
672 case CMD_NA:
673 message_error(" Command not available");
674 }
675 }
676
677 /* get new time */
678 time_get(&now);
679 } while (timercmp(&now, &(gstate->refresh), < ));
680}
681
682void
683do_minidisplay(globalstate *gstate)
684
685{
686 int real_delay;
687 struct system_info si;
688
689 /* save the real delay and substitute 1 second */
690 real_delay = gstate->delay;
691 gstate->delay = 1;
692
693 /* wait 1 second for a command */
694 time_mark(&(gstate->now));
695 do_command(gstate);
696
697 /* do a mini update that only updates the cpustates */
698 get_system_info(&si);
699 u_cpustates(si.cpustates);
700
701 /* restore the delay time */
702 gstate->delay = real_delay;
703
704 /* done */
705 i_endscreen();
706}
707
708int
709main(int argc, char *argv[])
710
711{
712 char *env_top;
713 char **preset_argv;
714 int preset_argc = 0;
715 void *mask;
716 int need_mini = 1;
717
718 struct statics statics;
719 globalstate *gstate;
720
721 /* get our name */
722 if (argc > 0)
723 {
724 if ((myname = strrchr(argv[0], '/')) == 0)
725 {
726 myname = argv[0];
727 }
728 else
729 {
730 myname++;
731 }
732 }
733
734 /* binary compatibility check */
735#ifdef HAVE_UNAME
736 {
737 struct utsname uts;
738
739 if (uname(&uts) == 0)
740 {
741 if (strcmp(uts.machine, UNAME_HARDWARE) != 0)
742 {
743 fprintf(stderr, "%s: incompatible hardware platform\n",
744 myname);
745 exit(EX_UNAVAILABLE);
746 }
747 }
748 }
749#endif
750
751 /* initialization */
752 gstate = (globalstate *)calloc(1, sizeof(globalstate));
753 gstate->statics = &statics;
754 time_mark(NULL);
755
756 /* preset defaults for various options */
757 gstate->show_usernames = Yes;
758 gstate->topn = DEFAULT_TOPN;
759 gstate->delay = DEFAULT_DELAY;
760 gstate->fulldraw = Yes;
761 gstate->use_color = Yes;
762 gstate->interactive = Maybe;
763
764 /* preset defaults for process selection */
765 gstate->pselect.idle = Yes;
766 gstate->pselect.system = No;
767 gstate->pselect.fullcmd = No;
768 gstate->pselect.command = NULL;
769 gstate->pselect.uid = -1;
770 gstate->pselect.mode = 0;
771
772 /* use a large buffer for stdout */
773#ifdef HAVE_SETVBUF
774 setvbuf(stdout, stdoutbuf, _IOFBF, BUFFERSIZE);
775#else
776#ifdef HAVE_SETBUFFER
777 setbuffer(stdout, stdoutbuf, BUFFERSIZE);
778#endif
779#endif
780
781 /* get preset options from the environment */
782 if ((env_top = getenv("TOP")) != NULL)
783 {
784 preset_argv = argparse(env_top, &preset_argc);
785 preset_argv[0] = myname;
786 do_arguments(gstate, preset_argc, preset_argv);
787 }
788
789 /* process arguments */
790 do_arguments(gstate, argc, argv);
791
792#ifdef ENABLE_COLOR
793 /* If colour has been turned on read in the settings. */
794 env_top = getenv("TOPCOLOURS");
795 if (!env_top)
796 {
797 env_top = getenv("TOPCOLORS");
798 }
799 /* must do something about error messages */
800 color_env_parse(env_top);
801 color_activate(gstate->use_color);
802#endif
803
804 /* in order to support forward compatability, we have to ensure that
805 the entire statics structure is set to a known value before we call
806 machine_init. This way fields that a module does not know about
807 will retain their default values */
808 memzero((void *)&statics, sizeof(statics));
809 statics.boottime = -1;
810
811 /* call the platform-specific init */
812 if (machine_init(&statics) == -1)
813 {
814 exit(EX_SOFTWARE);
815 }
816
817 /* create a helper list of sort order names */
818 gstate->order_namelist = string_list(statics.order_names);
819
820 /* look up chosen sorting order */
821 if (gstate->order_name != NULL)
822 {
823 int i;
824
825 if (statics.order_names == NULL)
826 {
827 message_error(" This platform does not support arbitrary ordering");
828 }
829 else if ((i = string_index(gstate->order_name,
830 statics.order_names)) == -1)
831 {
832 message_error(" Sort order `%s' not recognized", gstate->order_name);
833 message_error(" Recognized sort orders: %s", gstate->order_namelist);
834 }
835 else
836 {
837 gstate->order_index = i;
838 }
839 }
840
841 /* initialize extensions */
842 init_username();
843
844 /* initialize termcap */
845 gstate->smart_terminal = screen_readtermcap(gstate->interactive);
846
847 /* determine interactive state */
848 if (gstate->interactive == Maybe)
849 {
850 gstate->interactive = smart_terminal;
851 }
852
853 /* if displays were not specified, choose an appropriate default */
854 if (gstate->displays == 0)
855 {
856 gstate->displays = gstate->smart_terminal ? Infinity: 1;
857 }
858
859 /* we don't need a mini display when delay is less than 2
860 seconds or when we are not on a smart terminal */
861 if (gstate->delay <= 1 || !smart_terminal)
862 {
863 need_mini = 0;
864 }
865
866#ifndef HAVE_FORMAT_PROCESS_HEADER
867 /* set constants for username/uid display */
868 if (gstate->show_usernames)
869 {
870 gstate->header_text = format_header("USERNAME");
871 gstate->get_userid = username;
872 }
873 else
874 {
875 gstate->header_text = format_header(" UID ");
876 gstate->get_userid = itoa7;
877 }
878#endif
879 gstate->pselect.usernames = gstate->show_usernames;
880
881 /* initialize display */
882 if ((gstate->max_topn = display_init(&statics)) == -1)
883 {
884 fprintf(stderr, "%s: can't allocate sufficient memory\n", myname);
885 exit(EX_OSERR);
886 }
887
888 /* check for infinity and for overflowed screen */
889 if (gstate->topn == Infinity)
890 {
891 gstate->topn = INT_MAX;
892 }
893 else if (gstate->topn > gstate->max_topn)
894 {
895 message_error(" This terminal can only display %d processes",
896 gstate->max_topn);
897 }
898
899#ifdef ENABLE_COLOR
900 /* producing a list of color tags is easy */
901 if (gstate->show_tags)
902 {
903 color_dump(stdout);
904 exit(EX_OK);
905 }
906#endif
907
908 /* hold all signals while we initialize the screen */
909 mask = hold_signals();
910 screen_init();
911
912 /* set the signal handlers */
913 set_signals();
914
915 /* longjmp re-entry point */
916 /* set the jump buffer for long jumps out of signal handlers */
917 if (setjmp(jmp_int) != 0)
918 {
919 /* this is where we end up after processing sigwinch or sigtstp */
920
921 /* tell display to resize its buffers, and get the new length */
922 if ((gstate->max_topn = display_resize()) == -1)
923 {
924 /* thats bad */
925 quit(EX_OSERR);
926 /*NOTREACHED*/
927 }
928
929 /* set up for a full redraw, and get the current line count */
930 gstate->fulldraw = Yes;
931
932 /* safe to release the signals now */
933 release_signals(mask);
934 }
935 else
936 {
937 /* release the signals */
938 release_signals(mask);
939
940 /* some systems require a warmup */
941 /* always do a warmup for batch mode */
942 if (gstate->interactive == 0 || statics.flags.warmup)
943 {
944 struct system_info system_info;
945 struct timeval timeout;
946
947 time_mark(&(gstate->now));
948 get_system_info(&system_info);
949 (void)get_process_info(&system_info, &gstate->pselect, 0);
950 timeout.tv_sec = 1;
951 timeout.tv_usec = 0;
952 select(0, NULL, NULL, NULL, &timeout);
953
954 /* if we've warmed up, then we can show good states too */
955 gstate->show_cpustates = Yes;
956 need_mini = 0;
957 }
958 }
959
960 /* main loop */
961 while ((gstate->displays == -1) || (--gstate->displays > 0))
962 {
963 do_display(gstate);
964 if (gstate->interactive)
965 {
966 if (need_mini)
967 {
968 do_minidisplay(gstate);
969 need_mini = 0;
970 }
971 do_command(gstate);
972 }
973 else
974 {
975 do_wait(gstate);
976 }
977 }
978
979 /* do one last display */
980 do_display(gstate);
981
982 quit(EX_OK);
983 /* NOTREACHED */
984 return 1; /* Keep compiler quiet. */
985}