diff options
Diffstat (limited to 'top.c')
| -rw-r--r-- | top.c | 1698 |
1 files changed, 828 insertions, 870 deletions
@@ -1,1022 +1,980 @@ -char *copyright = - "Copyright (c) 1984 through 1996, William LeFebvre"; - -/* - * Top users/processes display for Unix - * Version 3 - * - * This program may be freely redistributed, - * but this entire comment MUST remain intact. - * - * Copyright (c) 1984, 1989, William LeFebvre, Rice University - * Copyright (c) 1989 - 1994, William LeFebvre, Northwestern University - * Copyright (c) 1994, 1995, William LeFebvre, Argonne National Laboratory - * Copyright (c) 1996, William LeFebvre, Group sys Consulting - */ - /* - * See the file "Changes" for information on version-to-version changes. + * Copyright (c) 1984 through 2008, William LeFebvre + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of William LeFebvre nor the names of other + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * This file contains "main" and other high-level routines. - */ +char *copyright = + "Copyright (c) 1984 through 2008, William LeFebvre"; /* - * The following preprocessor variables, when defined, are used to - * distinguish between different Unix implementations: - * - * SIGHOLD - use SVR4 sighold function when defined - * SIGRELSE - use SVR4 sigrelse function when defined - * FD_SET - macros FD_SET and FD_ZERO are used when defined + * Changes to other files that we can do at the same time: + * screen.c:init_termcap: get rid of the "interactive" argument and have it + * pass back something meaningful (such as success/failure/error). */ #include "os.h" #include <signal.h> #include <setjmp.h> #include <ctype.h> -#include <sys/time.h> +#include <sys/types.h> +#include <sys/uio.h> +#include <unistd.h> + +#ifdef HAVE_SYS_UTSNAME_H +#include <sys/utsname.h> +#endif + +#ifdef HAVE_GETOPT_H +#include <getopt.h> +#endif + +/* definitions */ +#ifndef STDIN_FILENO +#define STDIN_FILENO 0 +#endif + +/* determine which type of signal functions to use */ +/* cant have sigaction without sigprocmask */ +#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGPROCMASK) +#undef HAVE_SIGACTION +#endif +/* always use sigaction when it is available */ +#ifdef HAVE_SIGACTION +#undef HAVE_SIGHOLD +#else +/* use sighold/sigrelse, otherwise use old fashioned BSD signals */ +#if !defined(HAVE_SIGHOLD) || !defined(HAVE_SIGRELSE) +#define BSD_SIGNALS +#endif +#endif + +/* if FD_SET and friends aren't present, then fake something up */ +#ifndef FD_SET +typedef int fd_set; +#define FD_ZERO(x) (*(x) = 0) +#define FD_SET(f, x) (*(x) = 1<<f) +#endif /* includes specific to top */ -#include "display.h" /* interface to display package */ -#include "screen.h" /* interface to screen package */ + #include "top.h" -#include "top.local.h" -#include "boolean.h" #include "machine.h" +#include "globalstate.h" +#include "commands.h" +#include "display.h" +#include "screen.h" +#include "boolean.h" +#include "username.h" #include "utils.h" +#include "version.h" +#ifdef ENABLE_COLOR +#include "color.h" +#endif -/* Size of the stdio buffer given to stdout */ -#define Buffersize 2048 - -/* The buffer that stdio will use */ -char stdoutbuf[Buffersize]; - -/* build Signal masks */ -#define Smask(s) (1 << ((s) - 1)) +/* definitions */ +#define BUFFERSIZE 4096 +#define JMP_RESUME 1 +#define JMP_RESIZE 2 -/* for getopt: */ +/* externs for getopt: */ extern int optind; extern char *optarg; -/* imported from screen.c */ -extern int overstrike; +/* statics */ +static char stdoutbuf[BUFFERSIZE]; +static jmp_buf jmp_int; -/* signal handling routines */ -sigret_t leave(); -sigret_t onalrm(); -sigret_t tstop(); -#ifdef SIGWINCH -sigret_t winch(); -#endif +/* globals */ +char *myname = "top"; -/* internal routines */ -void quit(); +void +quit(int status) -/* values which need to be accessed by signal handlers */ -static int max_topn; /* maximum displayable processes */ +{ + screen_end(); + chdir("/tmp"); + exit(status); + /* NOTREACHED */ +} -/* miscellaneous things */ -char *myname = "top"; -jmp_buf jmp_int; +/* + * signal handlers + */ -/* routines that don't return int */ +void +set_signal(int sig, RETSIGTYPE (*handler)(int)) -char *username(); -char *ctime(); -char *kill_procs(); -char *renice_procs(); +{ +#ifdef HAVE_SIGACTION + struct sigaction action; -#ifdef ORDER -extern int (*proc_compares[])(); + action.sa_handler = handler; + action.sa_flags = 0; + (void) sigaction(sig, &action, NULL); #else -extern int proc_compare(); -#endif -time_t time(); - -caddr_t get_process_info(); - -/* different routines for displaying the user's identification */ -/* (values assigned to get_userid) */ -char *username(); -char *itoa7(); - -/* display routines that need to be predeclared */ -int i_loadave(); -int u_loadave(); -int i_procstates(); -int u_procstates(); -int i_cpustates(); -int u_cpustates(); -int i_memory(); -int u_memory(); -int i_message(); -int u_message(); -int i_header(); -int u_header(); -int i_process(); -int u_process(); - -/* pointers to display routines */ -int (*d_loadave)() = i_loadave; -int (*d_procstates)() = i_procstates; -int (*d_cpustates)() = i_cpustates; -int (*d_memory)() = i_memory; -int (*d_message)() = i_message; -int (*d_header)() = i_header; -int (*d_process)() = i_process; - - -main(argc, argv) - -int argc; -char *argv[]; + (void) signal(sig, handler); +#endif +} + +void +release_signal(int sig) { - register int i; - register int active_procs; - register int change; +#ifdef HAVE_SIGACTION + sigset_t set; + sigemptyset(&set); + sigaddset(&set, sig); + sigprocmask(SIG_UNBLOCK, &set, NULL); +#endif - struct system_info system_info; - struct statics statics; - caddr_t processes; +#ifdef HAVE_SIGHOLD + sigrelse(sig); +#endif - static char tempbuf1[50]; - static char tempbuf2[50]; - int old_sigmask; /* only used for BSD-style signals */ - int topn = Default_TOPN; - int delay = Default_DELAY; - int displays = 0; /* indicates unspecified */ - time_t curr_time; - char *(*get_userid)() = username; - char *uname_field = "USERNAME"; - char *header_text; - char *env_top; - char **preset_argv; - int preset_argc = 0; - char **av; - int ac; - char dostates = No; - char do_unames = Yes; - char interactive = Maybe; - char warnings = 0; -#if Default_TOPN == Infinity - char topn_specified = No; -#endif - char ch; - char *iptr; - char no_command = 1; - struct timeval timeout; - struct process_select ps; -#ifdef ORDER - char *order_name = NULL; - int order_index = 0; +#ifdef BSD_SIGNALS + (void) sigsetmask(sigblock(0) & ~(sigmask(sig))); #endif -#ifndef FD_SET - /* FD_SET and friends are not present: fake it */ - typedef int fd_set; -#define FD_ZERO(x) (*(x) = 0) -#define FD_SET(f, x) (*(x) = 1<<f) +} + +RETSIGTYPE +sig_leave(int i) /* exit under normal conditions -- INT handler */ + +{ + screen_end(); + exit(EX_OK); +} + +RETSIGTYPE +sig_tstop(int i) /* SIGTSTP handler */ + +{ + /* move to the lower left */ + screen_end(); + fflush(stdout); + + /* default the signal handler action */ + set_signal(SIGTSTP, SIG_DFL); + + /* unblock the TSTP signal */ + release_signal(SIGTSTP); + + /* send ourselves a TSTP to stop the process */ + (void) kill(0, SIGTSTP); + + /* reset the signal handler */ + set_signal(SIGTSTP, sig_tstop); + + /* reinit screen */ + screen_reinit(); + + /* jump back to a known place in the main loop */ + longjmp(jmp_int, JMP_RESUME); + + /* NOTREACHED */ +} + +#ifdef SIGWINCH +RETSIGTYPE +sig_winch(int i) /* SIGWINCH handler */ + +{ + /* reascertain the screen dimensions */ + screen_getsize(); + + /* jump back to a known place in the main loop */ + longjmp(jmp_int, JMP_RESIZE); +} #endif - fd_set readfds; -#ifdef ORDER - static char command_chars[] = "\f qh?en#sdkriIuo"; -#else - static char command_chars[] = "\f qh?en#sdkriIu"; -#endif -/* these defines enumerate the "strchr"s of the commands in command_chars */ -#define CMD_redraw 0 -#define CMD_update 1 -#define CMD_quit 2 -#define CMD_help1 3 -#define CMD_help2 4 -#define CMD_OSLIMIT 4 /* terminals with OS can only handle commands */ -#define CMD_errors 5 /* less than or equal to CMD_OSLIMIT */ -#define CMD_number1 6 -#define CMD_number2 7 -#define CMD_delay 8 -#define CMD_displays 9 -#define CMD_kill 10 -#define CMD_renice 11 -#define CMD_idletog 12 -#define CMD_idletog2 13 -#define CMD_user 14 -#ifdef ORDER -#define CMD_order 15 -#endif - - /* set the buffer for stdout */ -#ifdef DEBUG - extern FILE *debug; - debug = fopen("debug.run", "w"); - setbuffer(stdout, NULL, 0); -#else - setbuffer(stdout, stdoutbuf, Buffersize); +#ifdef HAVE_SIGACTION +static sigset_t signalset; #endif - /* get our name */ - if (argc > 0) - { - if ((myname = strrchr(argv[0], '/')) == 0) - { - myname = argv[0]; - } - else - { - myname++; - } - } +void * +hold_signals() + +{ +#ifdef HAVE_SIGACTION + sigemptyset(&signalset); + sigaddset(&signalset, SIGINT); + sigaddset(&signalset, SIGQUIT); + sigaddset(&signalset, SIGTSTP); +#ifdef SIGWINCH + sigaddset(&signalset, SIGWINCH); +#endif + sigprocmask(SIG_BLOCK, &signalset, NULL); + return (void *)(&signalset); +#endif - /* initialize some selection options */ - ps.idle = Yes; - ps.system = No; - ps.uid = -1; - ps.command = NULL; +#ifdef HAVE_SIGHOLD + sighold(SIGINT); + sighold(SIGQUIT); + sighold(SIGTSTP); +#ifdef SIGWINCH + sighold(SIGWINCH); + return NULL; +#endif +#endif - /* get preset options from the environment */ - if ((env_top = getenv("TOP")) != NULL) - { - av = preset_argv = argparse(env_top, &preset_argc); - ac = preset_argc; +#ifdef BSD_SIGNALS + int mask; +#ifdef SIGWINCH + mask = sigblock(sigmask(SIGINT) | sigmask(SIGQUIT) | + sigmask(SIGTSTP) | sigmask(SIGWINCH)); +#else + mask = sigblock(sigmask(SIGINT) | sigmask(SIGQUIT) | sigmask(SIGTSTP)); + return (void *)mask; +#endif +#endif - /* set the dummy argument to an explanatory message, in case - getopt encounters a bad argument */ - preset_argv[0] = "while processing environment"; - } +} - /* process options */ - do { - /* if we're done doing the presets, then process the real arguments */ - if (preset_argc == 0) - { - ac = argc; - av = argv; +void +set_signals() - /* this should keep getopt happy... */ - optind = 1; - } +{ + (void) set_signal(SIGINT, sig_leave); + (void) set_signal(SIGQUIT, sig_leave); + (void) set_signal(SIGTSTP, sig_tstop); +#ifdef SIGWINCH + (void) set_signal(SIGWINCH, sig_winch); +#endif +} - while ((i = getopt(ac, av, "SIbinquvs:d:U:o:")) != EOF) - { - switch(i) - { - case 'v': /* show version number */ - fprintf(stderr, "%s: version %s\n", - myname, version_string()); - exit(1); - break; +void +release_signals(void *parm) - case 'u': /* toggle uid/username display */ - do_unames = !do_unames; - break; +{ +#ifdef HAVE_SIGACTION + sigprocmask(SIG_UNBLOCK, (sigset_t *)parm, NULL); +#endif - case 'U': /* display only username's processes */ - if ((ps.uid = userid(optarg)) == -1) - { - fprintf(stderr, "%s: unknown user\n", optarg); - exit(1); - } - break; +#ifdef HAVE_SIGHOLD + sigrelse(SIGINT); + sigrelse(SIGQUIT); + sigrelse(SIGTSTP); +#ifdef SIGWINCH + sigrelse(SIGWINCH); +#endif +#endif - case 'S': /* show system processes */ - ps.system = !ps.system; - break; +#ifdef BSD_SIGNALS + (void) sigsetmask((int)parm); +#endif +} - case 'I': /* show idle processes */ - ps.idle = !ps.idle; - break; +/* + * void do_arguments(globalstate *gstate, int ac, char **av) + * + * Arguments processing. gstate points to the global state, + * ac and av are the arguments to process. This can be called + * multiple times with different sets of arguments. + */ - case 'i': /* go interactive regardless */ - interactive = Yes; - break; +#ifdef HAVE_GETOPT_LONG +static struct option longopts[] = { + { "color", no_argument, NULL, 'C' }, + { "debug", no_argument, NULL, 'D' }, + { "system-procs", no_argument, NULL, 'S' }, + { "idle-procs", no_argument, NULL, 'I' }, + { "tag-names", no_argument, NULL, 'T' }, + { "all", no_argument, NULL, 'a' }, + { "batch", no_argument, NULL, 'b' }, + { "full-commands", no_argument, NULL, 'c' }, + { "interactive", no_argument, NULL, 'i' }, + { "quick", no_argument, NULL, 'q' }, + { "threads", no_argument, NULL, 't' }, + { "uids", no_argument, NULL, 'u' }, + { "version", no_argument, NULL, 'v' }, + { "delay", required_argument, NULL, 's' }, + { "displays", required_argument, NULL, 'd' }, + { "user", required_argument, NULL, 'U' }, + { "sort-order", required_argument, NULL, 'o' }, + { "display-mode", required_argument, NULL, 'm' }, + { NULL, 0, NULL, 0 }, +}; +#endif - case 'n': /* batch, or non-interactive */ - case 'b': - interactive = No; - break; - case 'd': /* number of displays to show */ - if ((i = atoiwi(optarg)) == Invalid || i == 0) - { - fprintf(stderr, - "%s: warning: display count should be positive -- option ignored\n", - myname); - warnings++; - } - else - { - displays = i; - } - break; +void +do_arguments(globalstate *gstate, int ac, char **av) - case 's': - if ((delay = atoi(optarg)) < 0 || (delay == 0 && getuid() != 0)) - { - fprintf(stderr, - "%s: warning: seconds delay should be positive -- using default\n", - myname); - delay = Default_DELAY; - warnings++; - } - break; +{ + int i; - case 'q': /* be quick about it */ - /* only allow this if user is really root */ - if (getuid() == 0) - { - /* be very un-nice! */ - (void) nice(-20); - } - else - { - fprintf(stderr, - "%s: warning: `-q' option can only be used by root\n", - myname); - warnings++; - } - break; + /* this appears to keep getopt happy */ + optind = 1; - case 'o': /* select sort order */ -#ifdef ORDER - order_name = optarg; +#ifdef HAVE_GETOPT_LONG + while ((i = getopt_long(ac, av, "CDSITabcinqtuvs:d:U:o:m:", longopts, NULL)) != -1) #else - fprintf(stderr, - "%s: this platform does not support arbitrary ordering. Sorry.\n", - myname); - warnings++; + while ((i = getopt(ac, av, "CDSITabcinqtuvs:d:U:o:m:")) != EOF) +#endif + { + switch(i) + { +#ifdef ENABLE_COLOR + case 'C': + gstate->use_color = !gstate->use_color; + break; #endif - break; - default: - fprintf(stderr, "\ -Top version %s\n\ -Usage: %s [-ISbinqu] [-d x] [-s x] [-o field] [-U username] [number]\n", - version_string(), myname); - exit(1); + case 'D': + debug_set(1); + break; + + case 'v': + fprintf(stderr, "%s: version %s\n", myname, version_string()); + exit(EX_OK); + break; + + case 'b': + case 'n': + gstate->interactive = No; + break; + + case 'a': + gstate->displays = Infinity; + gstate->topn = Infinity; + break; + + case 'i': + gstate->interactive = Yes; + break; + + case 'o': + gstate->order_name = optarg; + break; + + case 'd': + i = atoiwi(optarg); + if (i == Invalid || i == 0) + { + message_error(" Bad display count"); } - } + else + { + gstate->displays = i; + } + break; - /* get count of top processes to display (if any) */ - if (optind < ac) - { - if ((topn = atoiwi(av[optind])) == Invalid) + case 's': + i = atoi(optarg); + if (i < 0 || (i == 0 && getuid() != 0)) { - fprintf(stderr, - "%s: warning: process display count should be non-negative -- using default\n", - myname); - warnings++; + message_error(" Bad seconds delay"); } -#if Default_TOPN == Infinity - else + else { - topn_specified = Yes; + gstate->delay = i; } -#endif - } + break; - /* tricky: remember old value of preset_argc & set preset_argc = 0 */ - i = preset_argc; - preset_argc = 0; + case 'u': + gstate->show_usernames = !gstate->show_usernames; + break; - /* repeat only if we really did the preset arguments */ - } while (i != 0); + case 'U': + i = userid(optarg); + if (i == -1) + { + message_error(" Unknown user '%s'", optarg); + } + else + { + gstate->pselect.uid = i; + } + break; - /* set constants for username/uid display correctly */ - if (!do_unames) - { - uname_field = " UID "; - get_userid = itoa7; - } + case 'm': + i = atoi(optarg); + gstate->pselect.mode = i; + break; - /* initialize the kernel memory interface */ - if (machine_init(&statics) == -1) - { - exit(1); - } + case 'S': + gstate->pselect.system = !gstate->pselect.system; + break; -#ifdef ORDER - /* determine sorting order index, if necessary */ - if (order_name != NULL) - { - if ((order_index = string_index(order_name, statics.order_names)) == -1) - { - char **pp; + case 'I': + gstate->pselect.idle = !gstate->pselect.idle; + break; - fprintf(stderr, "%s: '%s' is not a recognized sorting order.\n", - myname, order_name); - fprintf(stderr, "\tTry one of these:"); - pp = statics.order_names; - while (*pp != NULL) +#ifdef ENABLE_COLOR + case 'T': + gstate->show_tags = 1; + break; +#endif + + case 'c': + gstate->pselect.fullcmd = !gstate->pselect.fullcmd; + break; + + case 't': + gstate->pselect.threads = !gstate->pselect.threads; + break; + + case 'q': /* be quick about it */ + /* only allow this if user is really root */ + if (getuid() == 0) + { + /* be very un-nice! */ + (void) nice(-20); + } + else { - fprintf(stderr, " %s", *pp++); + message_error(" Option -q can only be used by root"); } - fputc('\n', stderr); - exit(1); + break; + + default: + fprintf(stderr, "\ +Top version %s\n\ +Usage: %s [-ISTabcinqu] [-d x] [-s x] [-o field] [-U username] [number]\n", + version_string(), myname); + exit(EX_USAGE); } } -#endif -#ifdef no_initialization_needed - /* initialize the hashing stuff */ - if (do_unames) + /* get count of top processes to display */ + if (optind < ac && *av[optind]) { - init_hash(); + if ((i = atoiwi(av[optind])) == Invalid) + { + message_error(" Process count not a number"); + } + else + { + gstate->topn = i; + } } -#endif +} - /* initialize termcap */ - init_termcap(interactive); +void +do_display(globalstate *gstate) - /* get the string to use for the process area header */ - header_text = format_header(uname_field); +{ + int active_procs; + int i; + time_t curr_time; + caddr_t processes; + struct system_info system_info; + char *hdr; - /* initialize display interface */ - if ((max_topn = display_init(&statics)) == -1) - { - fprintf(stderr, "%s: can't allocate sufficient memory\n", myname); - exit(4); - } - - /* print warning if user requested more processes than we can display */ - if (topn > max_topn) - { - fprintf(stderr, - "%s: warning: this terminal can only display %d processes.\n", - myname, max_topn); - warnings++; - } + /* get the time */ + time_mark(&(gstate->now)); + curr_time = (time_t)(gstate->now.tv_sec); - /* adjust for topn == Infinity */ - if (topn == Infinity) - { - /* - * For smart terminals, infinity really means everything that can - * be displayed, or Largest. - * On dumb terminals, infinity means every process in the system! - * We only really want to do that if it was explicitly specified. - * This is always the case when "Default_TOPN != Infinity". But if - * topn wasn't explicitly specified and we are on a dumb terminal - * and the default is Infinity, then (and only then) we use - * "Nominal_TOPN" instead. - */ -#if Default_TOPN == Infinity - topn = smart_terminal ? Largest : - (topn_specified ? Largest : Nominal_TOPN); -#else - topn = Largest; -#endif - } + /* get the current stats */ + get_system_info(&system_info); - /* set header display accordingly */ - display_header(topn > 0); + /* get the current processes */ + processes = get_process_info(&system_info, &(gstate->pselect), gstate->order_index); - /* determine interactive state */ - if (interactive == Maybe) + /* determine number of processes to actually display */ + if (gstate->topn > 0) { - interactive = smart_terminal; + /* this number will be the smallest of: active processes, + number user requested, number current screen accomodates */ + active_procs = system_info.P_ACTIVE; + if (active_procs > gstate->topn) + { + active_procs = gstate->topn; + } + if (active_procs > gstate->max_topn) + { + active_procs = gstate->max_topn; + } } - - /* if # of displays not specified, fill it in */ - if (displays == 0) + else { - displays = smart_terminal ? Infinity : 1; + /* dont show any */ + active_procs = 0; } - /* hold interrupt signals while setting up the screen and the handlers */ -#ifdef SIGHOLD - sighold(SIGINT); - sighold(SIGQUIT); - sighold(SIGTSTP); -#else - old_sigmask = sigblock(Smask(SIGINT) | Smask(SIGQUIT) | Smask(SIGTSTP)); -#endif - init_screen(); - (void) signal(SIGINT, leave); - (void) signal(SIGQUIT, leave); - (void) signal(SIGTSTP, tstop); -#ifdef SIGWINCH - (void) signal(SIGWINCH, winch); -#endif -#ifdef SIGRELSE - sigrelse(SIGINT); - sigrelse(SIGQUIT); - sigrelse(SIGTSTP); +#ifdef HAVE_FORMAT_PROCESS_HEADER + /* get the process header to use */ + hdr = format_process_header(&(gstate->pselect), processes, active_procs); #else - (void) sigsetmask(old_sigmask); + hdr = gstate->header_text; #endif - if (warnings) - { - fputs("....", stderr); - fflush(stderr); /* why must I do this? */ - sleep((unsigned)(3 * warnings)); - fputc('\n', stderr); - } - - /* setup the jump buffer for stops */ - if (setjmp(jmp_int) != 0) - { - /* control ends up here after an interrupt */ - reset_display(); - } - - /* - * main loop -- repeat while display count is positive or while it - * indicates infinity (by being -1) - */ - while ((displays == -1) || (displays-- > 0)) + /* full screen or update? */ + if (gstate->fulldraw) { - /* get the current stats */ - get_system_info(&system_info); - - /* get the current set of processes */ - processes = - get_process_info(&system_info, - &ps, -#ifdef ORDER - proc_compares[order_index]); -#else - proc_compare); -#endif - - /* display the load averages */ - (*d_loadave)(system_info.last_pid, - system_info.load_avg); - - /* display the current time */ - /* this method of getting the time SHOULD be fairly portable */ - time(&curr_time); + display_clear(); + i_loadave(system_info.last_pid, system_info.load_avg); + i_uptime(&(gstate->statics->boottime), &curr_time); i_timeofday(&curr_time); - - /* display process state breakdown */ - (*d_procstates)(system_info.p_total, - system_info.procstates); - - /* display the cpu state percentage breakdown */ - if (dostates) /* but not the first time */ + i_procstates(system_info.p_total, system_info.procstates, gstate->pselect.threads); + if (gstate->show_cpustates) { - (*d_cpustates)(system_info.cpustates); + i_cpustates(system_info.cpustates); } else { - /* we'll do it next time */ if (smart_terminal) { z_cpustates(); } - else - { - putchar('\n'); - } - dostates = Yes; + gstate->show_cpustates = Yes; + } + i_kernel(system_info.kernel); + i_memory(system_info.memory); + i_swap(system_info.swap); + i_message(&(gstate->now)); + i_header(hdr); + for (i = 0; i < active_procs; i++) + { + i_process(i, format_next_process(processes, gstate->get_userid)); } + i_endscreen(); + if (gstate->smart_terminal) + { + gstate->fulldraw = No; + } + } + else + { + u_loadave(system_info.last_pid, system_info.load_avg); + u_uptime(&(gstate->statics->boottime), &curr_time); + i_timeofday(&curr_time); + u_procstates(system_info.p_total, system_info.procstates, gstate->pselect.threads); + u_cpustates(system_info.cpustates); + u_kernel(system_info.kernel); + u_memory(system_info.memory); + u_swap(system_info.swap); + u_message(&(gstate->now)); + u_header(hdr); + for (i = 0; i < active_procs; i++) + { + u_process(i, format_next_process(processes, gstate->get_userid)); + } + u_endscreen(); + } +} - /* display memory stats */ - (*d_memory)(system_info.memory); +#ifdef DEBUG +void +timeval_xdprint(char *s, struct timeval tv) + +{ + xdprintf("%s %d.%06d\n", s, tv.tv_sec, tv.tv_usec); +} +#endif + +void +do_wait(globalstate *gstate) + +{ + struct timeval wait; + + wait.tv_sec = gstate->delay; + wait.tv_usec = 0; + select(0, NULL, NULL, NULL, &wait); +} + +void +do_command(globalstate *gstate) + +{ + int status; + struct timeval wait = {0, 0}; + struct timeval now; + fd_set readfds; + unsigned char ch; - /* handle message area */ - (*d_message)(); + /* calculate new refresh time */ + gstate->refresh = gstate->now; + gstate->refresh.tv_sec += gstate->delay; + time_get(&now); - /* update the header area */ - (*d_header)(header_text); - - if (topn > 0) + /* loop waiting for time to expire */ + do { + /* calculate time to wait */ + if (gstate->delay > 0) { - /* determine number of processes to actually display */ - /* this number will be the smallest of: active processes, - number user requested, number current screen accomodates */ - active_procs = system_info.P_ACTIVE; - if (active_procs > topn) + wait = gstate->refresh; + wait.tv_usec -= now.tv_usec; + if (wait.tv_usec < 0) { - active_procs = topn; + wait.tv_usec += 1000000; + wait.tv_sec--; } - if (active_procs > max_topn) + wait.tv_sec -= now.tv_sec; + } + + /* set up arguments for select on stdin (0) */ + FD_ZERO(&readfds); + FD_SET(STDIN_FILENO, &readfds); + + /* wait for something to read or time out */ + if (select(32, &readfds, NULL, NULL, &wait) > 0) + { + /* read it */ + if (read(STDIN_FILENO, &ch, 1) != 1) { - active_procs = max_topn; + /* read error */ + message_error(" Read error on stdin"); + quit(EX_DATAERR); + /*NOTREACHED*/ } - /* now show the top "n" processes. */ - for (i = 0; i < active_procs; i++) + /* mark pending messages as old */ + message_mark(); + + /* dispatch */ + status = command_process(gstate, (int)ch); + switch(status) { - (*d_process)(i, format_next_process(processes, get_userid)); + case CMD_ERROR: + quit(EX_SOFTWARE); + /*NOTREACHED*/ + + case CMD_REFRESH: + return; + + case CMD_UNKNOWN: + message_error(" Unknown command"); + break; + + case CMD_NA: + message_error(" Command not available"); } } - else - { - i = 0; - } - /* do end-screen processing */ - u_endscreen(i); + /* get new time */ + time_get(&now); + } while (timercmp(&now, &(gstate->refresh), < )); +} + +void +do_minidisplay(globalstate *gstate) - /* now, flush the output buffer */ - if (fflush(stdout) != 0) +{ + int real_delay; + struct system_info si; + + /* save the real delay and substitute 1 second */ + real_delay = gstate->delay; + gstate->delay = 1; + + /* wait 1 second for a command */ + time_mark(&(gstate->now)); + do_command(gstate); + + /* do a mini update that only updates the cpustates */ + get_system_info(&si); + u_cpustates(si.cpustates); + + /* restore the delay time */ + gstate->delay = real_delay; + + /* done */ + i_endscreen(); +} + +int +main(int argc, char *argv[]) + +{ + char *env_top; + char **preset_argv; + int preset_argc = 0; + void *mask; + int need_mini = 1; + + struct statics statics; + globalstate *gstate; + + /* get our name */ + if (argc > 0) + { + if ((myname = strrchr(argv[0], '/')) == 0) { - new_message(MT_standout, " Write error on stdout"); - putchar('\r'); - quit(1); - /*NOTREACHED*/ + myname = argv[0]; + } + else + { + myname++; } + } - /* only do the rest if we have more displays to show */ - if (displays) + /* binary compatibility check */ +#ifdef HAVE_UNAME + { + struct utsname uts; + + if (uname(&uts) == 0) { - /* switch out for new display on smart terminals */ - if (smart_terminal) - { - if (overstrike) - { - reset_display(); - } - else - { - d_loadave = u_loadave; - d_procstates = u_procstates; - d_cpustates = u_cpustates; - d_memory = u_memory; - d_message = u_message; - d_header = u_header; - d_process = u_process; - } - } - - no_command = Yes; - if (!interactive) - { - /* set up alarm */ - (void) signal(SIGALRM, onalrm); - (void) alarm((unsigned)delay); - - /* wait for the rest of it .... */ - pause(); - } - else while (no_command) + if (strcmp(uts.machine, UNAME_HARDWARE) != 0) { - /* assume valid command unless told otherwise */ - no_command = No; - - /* set up arguments for select with timeout */ - FD_ZERO(&readfds); - FD_SET(0, &readfds); /* for standard input */ - timeout.tv_sec = delay; - timeout.tv_usec = 0; - - /* wait for either input or the end of the delay period */ - if (select(32, &readfds, (fd_set *)NULL, (fd_set *)NULL, &timeout) > 0) - { - int newval; - char *errmsg; - - /* something to read -- clear the message area first */ - clear_message(); - - /* now read it and convert to command strchr */ - /* (use "change" as a temporary to hold strchr) */ - if (read(0, &ch, 1) != 1) - { - /* read error: either 0 or -1 */ - new_message(MT_standout, " Read error on stdin"); - putchar('\r'); - quit(1); - /*NOTREACHED*/ - } - if ((iptr = strchr(command_chars, ch)) == NULL) - { - /* illegal command */ - new_message(MT_standout, " Command not understood"); - putchar('\r'); - no_command = Yes; - } - else - { - change = iptr - command_chars; - if (overstrike && change > CMD_OSLIMIT) - { - /* error */ - new_message(MT_standout, - " Command cannot be handled by this terminal"); - putchar('\r'); - no_command = Yes; - } - else switch(change) - { - case CMD_redraw: /* redraw screen */ - reset_display(); - break; - - case CMD_update: /* merely update display */ - /* is the load average high? */ - if (system_info.load_avg[0] > LoadMax) - { - /* yes, go home for visual feedback */ - go_home(); - fflush(stdout); - } - break; - - case CMD_quit: /* quit */ - quit(0); - /*NOTREACHED*/ - break; - - case CMD_help1: /* help */ - case CMD_help2: - reset_display(); - clear(); - show_help(); - standout("Hit any key to continue: "); - fflush(stdout); - (void) read(0, &ch, 1); - break; - - case CMD_errors: /* show errors */ - if (error_count() == 0) - { - new_message(MT_standout, - " Currently no errors to report."); - putchar('\r'); - no_command = Yes; - } - else - { - reset_display(); - clear(); - show_errors(); - standout("Hit any key to continue: "); - fflush(stdout); - (void) read(0, &ch, 1); - } - break; - - case CMD_number1: /* new number */ - case CMD_number2: - new_message(MT_standout, - "Number of processes to show: "); - newval = readline(tempbuf1, 8, Yes); - if (newval > -1) - { - if (newval > max_topn) - { - new_message(MT_standout | MT_delayed, - " This terminal can only display %d processes.", - max_topn); - putchar('\r'); - } - - if (newval == 0) - { - /* inhibit the header */ - display_header(No); - } - else if (newval > topn && topn == 0) - { - /* redraw the header */ - display_header(Yes); - d_header = i_header; - } - topn = newval; - } - break; - - case CMD_delay: /* new seconds delay */ - new_message(MT_standout, "Seconds to delay: "); - if ((i = readline(tempbuf1, 8, Yes)) > -1) - { - if ((delay = i) == 0 && getuid() != 0) - { - delay = 1; - } - } - clear_message(); - break; - - case CMD_displays: /* change display count */ - new_message(MT_standout, - "Displays to show (currently %s): ", - displays == -1 ? "infinite" : - itoa(displays)); - if ((i = readline(tempbuf1, 10, Yes)) > 0) - { - displays = i; - } - else if (i == 0) - { - quit(0); - } - clear_message(); - break; - - case CMD_kill: /* kill program */ - new_message(0, "kill "); - if (readline(tempbuf2, sizeof(tempbuf2), No) > 0) - { - if ((errmsg = kill_procs(tempbuf2)) != NULL) - { - new_message(MT_standout, errmsg); - putchar('\r'); - no_command = Yes; - } - } - else - { - clear_message(); - } - break; - - case CMD_renice: /* renice program */ - new_message(0, "renice "); - if (readline(tempbuf2, sizeof(tempbuf2), No) > 0) - { - if ((errmsg = renice_procs(tempbuf2)) != NULL) - { - new_message(MT_standout, errmsg); - putchar('\r'); - no_command = Yes; - } - } - else - { - clear_message(); - } - break; - - case CMD_idletog: - case CMD_idletog2: - ps.idle = !ps.idle; - new_message(MT_standout | MT_delayed, - " %sisplaying idle processes.", - ps.idle ? "D" : "Not d"); - putchar('\r'); - break; - - case CMD_user: - new_message(MT_standout, - "Username to show: "); - if (readline(tempbuf2, sizeof(tempbuf2), No) > 0) - { - if (tempbuf2[0] == '+' && - tempbuf2[1] == '\0') - { - ps.uid = -1; - } - else if ((i = userid(tempbuf2)) == -1) - { - new_message(MT_standout, - " %s: unknown user", tempbuf2); - no_command = Yes; - } - else - { - ps.uid = i; - } - putchar('\r'); - } - else - { - clear_message(); - } - break; - -#ifdef ORDER - case CMD_order: - new_message(MT_standout, - "Order to sort: "); - if (readline(tempbuf2, sizeof(tempbuf2), No) > 0) - { - if ((i = string_index(tempbuf2, statics.order_names)) == -1) - { - new_message(MT_standout, - " %s: unrecognized sorting order", tempbuf2); - no_command = Yes; - } - else - { - order_index = i; - } - putchar('\r'); - } - else - { - clear_message(); - } - break; -#endif - - default: - new_message(MT_standout, " BAD CASE IN SWITCH!"); - putchar('\r'); - } - } - - /* flush out stuff that may have been written */ - fflush(stdout); - } + fprintf(stderr, "%s: incompatible hardware platform\n", + myname); + exit(EX_UNAVAILABLE); } } } +#endif -#ifdef DEBUG - fclose(debug); + /* initialization */ + gstate = (globalstate *)calloc(1, sizeof(globalstate)); + gstate->statics = &statics; + time_mark(NULL); + + /* preset defaults for various options */ + gstate->show_usernames = Yes; + gstate->topn = DEFAULT_TOPN; + gstate->delay = DEFAULT_DELAY; + gstate->fulldraw = Yes; + gstate->use_color = Yes; + gstate->interactive = Maybe; + + /* preset defaults for process selection */ + gstate->pselect.idle = Yes; + gstate->pselect.system = No; + gstate->pselect.fullcmd = No; + gstate->pselect.command = NULL; + gstate->pselect.uid = -1; + gstate->pselect.mode = 0; + + /* use a large buffer for stdout */ +#ifdef HAVE_SETVBUF + setvbuf(stdout, stdoutbuf, _IOFBF, BUFFERSIZE); +#else +#ifdef HAVE_SETBUFFER + setbuffer(stdout, stdoutbuf, BUFFERSIZE); +#endif #endif - quit(0); - /*NOTREACHED*/ -} -/* - * reset_display() - reset all the display routine pointers so that entire - * screen will get redrawn. - */ + /* get preset options from the environment */ + if ((env_top = getenv("TOP")) != NULL) + { + preset_argv = argparse(env_top, &preset_argc); + preset_argv[0] = myname; + do_arguments(gstate, preset_argc, preset_argv); + } -reset_display() + /* process arguments */ + do_arguments(gstate, argc, argv); -{ - d_loadave = i_loadave; - d_procstates = i_procstates; - d_cpustates = i_cpustates; - d_memory = i_memory; - d_message = i_message; - d_header = i_header; - d_process = i_process; -} +#ifdef ENABLE_COLOR + /* If colour has been turned on read in the settings. */ + env_top = getenv("TOPCOLOURS"); + if (!env_top) + { + env_top = getenv("TOPCOLORS"); + } + /* must do something about error messages */ + color_env_parse(env_top); + color_activate(gstate->use_color); +#endif -/* - * signal handlers - */ + /* in order to support forward compatability, we have to ensure that + the entire statics structure is set to a known value before we call + machine_init. This way fields that a module does not know about + will retain their default values */ + memzero((void *)&statics, sizeof(statics)); + statics.boottime = -1; -sigret_t leave() /* exit under normal conditions -- INT handler */ + /* call the platform-specific init */ + if (machine_init(&statics) == -1) + { + exit(EX_SOFTWARE); + } -{ - end_screen(); - exit(0); -} + /* create a helper list of sort order names */ + gstate->order_namelist = string_list(statics.order_names); -sigret_t tstop(i) /* SIGTSTP handler */ + /* look up chosen sorting order */ + if (gstate->order_name != NULL) + { + int i; -int i; + if (statics.order_names == NULL) + { + message_error(" This platform does not support arbitrary ordering"); + } + else if ((i = string_index(gstate->order_name, + statics.order_names)) == -1) + { + message_error(" Sort order `%s' not recognized", gstate->order_name); + message_error(" Recognized sort orders: %s", gstate->order_namelist); + } + else + { + gstate->order_index = i; + } + } -{ - /* move to the lower left */ - end_screen(); - fflush(stdout); + /* initialize extensions */ + init_username(); - /* default the signal handler action */ - (void) signal(SIGTSTP, SIG_DFL); + /* initialize termcap */ + gstate->smart_terminal = screen_readtermcap(gstate->interactive); - /* unblock the signal and send ourselves one */ -#ifdef SIGRELSE - sigrelse(SIGTSTP); -#else - (void) sigsetmask(sigblock(0) & ~(1 << (SIGTSTP - 1))); -#endif - (void) kill(0, SIGTSTP); + /* determine interactive state */ + if (gstate->interactive == Maybe) + { + gstate->interactive = smart_terminal; + } - /* reset the signal handler */ - (void) signal(SIGTSTP, tstop); + /* if displays were not specified, choose an appropriate default */ + if (gstate->displays == 0) + { + gstate->displays = gstate->smart_terminal ? Infinity: 1; + } - /* reinit screen */ - reinit_screen(); + /* we don't need a mini display when delay is less than 2 + seconds or when we are not on a smart terminal */ + if (gstate->delay <= 1 || !smart_terminal) + { + need_mini = 0; + } - /* jump to appropriate place */ - longjmp(jmp_int, 1); +#ifndef HAVE_FORMAT_PROCESS_HEADER + /* set constants for username/uid display */ + if (gstate->show_usernames) + { + gstate->header_text = format_header("USERNAME"); + gstate->get_userid = username; + } + else + { + gstate->header_text = format_header(" UID "); + gstate->get_userid = itoa7; + } +#endif + gstate->pselect.usernames = gstate->show_usernames; - /*NOTREACHED*/ -} + /* initialize display */ + if ((gstate->max_topn = display_init(&statics)) == -1) + { + fprintf(stderr, "%s: can't allocate sufficient memory\n", myname); + exit(EX_OSERR); + } -#ifdef SIGWINCH -sigret_t winch(i) /* SIGWINCH handler */ + /* check for infinity and for overflowed screen */ + if (gstate->topn == Infinity) + { + gstate->topn = INT_MAX; + } + else if (gstate->topn > gstate->max_topn) + { + message_error(" This terminal can only display %d processes", + gstate->max_topn); + } -int i; +#ifdef ENABLE_COLOR + /* producing a list of color tags is easy */ + if (gstate->show_tags) + { + color_dump(stdout); + exit(EX_OK); + } +#endif -{ - /* reascertain the screen dimensions */ - get_screensize(); + /* hold all signals while we initialize the screen */ + mask = hold_signals(); + screen_init(); - /* tell display to resize */ - max_topn = display_resize(); + /* set the signal handlers */ + set_signals(); - /* reset the signal handler */ - (void) signal(SIGWINCH, winch); + /* longjmp re-entry point */ + /* set the jump buffer for long jumps out of signal handlers */ + if (setjmp(jmp_int) != 0) + { + /* this is where we end up after processing sigwinch or sigtstp */ - /* jump to appropriate place */ - longjmp(jmp_int, 1); -} -#endif + /* tell display to resize its buffers, and get the new length */ + if ((gstate->max_topn = display_resize()) == -1) + { + /* thats bad */ + quit(EX_OSERR); + /*NOTREACHED*/ + } -void quit(status) /* exit under duress */ + /* set up for a full redraw, and get the current line count */ + gstate->fulldraw = Yes; -int status; + /* safe to release the signals now */ + release_signals(mask); + } + else + { + /* release the signals */ + release_signals(mask); -{ - end_screen(); - exit(status); - /*NOTREACHED*/ -} + /* some systems require a warmup */ + /* always do a warmup for batch mode */ + if (gstate->interactive == 0 || statics.flags.warmup) + { + struct system_info system_info; + struct timeval timeout; + + time_mark(&(gstate->now)); + get_system_info(&system_info); + (void)get_process_info(&system_info, &gstate->pselect, 0); + timeout.tv_sec = 1; + timeout.tv_usec = 0; + select(0, NULL, NULL, NULL, &timeout); + + /* if we've warmed up, then we can show good states too */ + gstate->show_cpustates = Yes; + need_mini = 0; + } + } -sigret_t onalrm() /* SIGALRM handler */ + /* main loop */ + while ((gstate->displays == -1) || (--gstate->displays > 0)) + { + do_display(gstate); + if (gstate->interactive) + { + if (need_mini) + { + do_minidisplay(gstate); + need_mini = 0; + } + do_command(gstate); + } + else + { + do_wait(gstate); + } + } -{ - /* this is only used in batch mode to break out of the pause() */ - /* return; */ -} + /* do one last display */ + do_display(gstate); + quit(EX_OK); + /* NOTREACHED */ + return 1; /* Keep compiler quiet. */ +} |