emo/procps
1
0
Fork 0
Code Issues Pull Requests Packages Releases Activity
procps/top.c
csmall 11c1eba093 Added jims top and moved old files
2002-05-30 03:44:46 +00:00

2540 lines
79 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* top.c - Source file: show Linux processes */
/*
* Copyright (c) 2002 - James C. Warner, <warnerjc@worldnet.att.net>
* All rights reserved.
* This file may be used subject to the terms and conditions of the
* GNU Library General Public License Version 2, or any later version
* at your option, as published by the Free Software Foundation.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*/
#include <asm/param.h>
#include <sys/ioctl.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <ctype.h>
#include <curses.h>
#include <errno.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <term.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>
#include <values.h>
/*
I am listing precisely why each header is needed because of the
construction of libproc -- separate header files may not always be
available and function names are not normalized. We have avoided
some library routine(s) as overkill and have subsumed some others.
*/
/* need: 1 define + dev_to_tty */
#include "proc/devname.h"
/* need: (ksym.c) open_psdb_message, wchan, close_psdb (redhat only) */
#include "proc/procps.h"
/* need: 2 types + openproc, readproc, closeproc */
#include "proc/readproc.h"
#ifdef UGH_ITS_4_RH
/* need: get_signal2 */
#include "proc/signals.h"
#else
/* need: signal_name_to_number */
#include "proc/sig.h"
#endif
/* need: status */
#include "proc/status.h"
/* need: meminfo stuff */
#include "proc/sysinfo.h"
/* need: procps_version */
#include "proc/version.h"
/* need: sprint_uptime */
#include "proc/whattime.h"
#include "top.h"
/*###### Miscellaneous global stuff ####################################*/
/* The original and new terminal attributes */
static struct termios Savedtty,
Rawtty;
static int Ttychanged = 0;
/* Program names used in error messages and 'rc' file names */
static char *Myname,
*Myrealname;
/* The Name of the config file(s), dynamically constructed */
static char RCfile [OURPATHSZ],
RCfile_Sys [SMLBUFSIZ];
/* The run-time acquired page size */
static int Page_size;
/* SMP and Irix/Solaris mode support */
static int Cpu_tot,
*Cpu_map;
/* Specific process id monitoring support */
static pid_t Monpids [MONPIDMAX] = { 0 };
static int Monpidsidx = 0;
/* A postponed error message */
static char Msg_delayed [SMLBUFSIZ];
static int Msg_awaiting = 0;
/* Configurable Display support ##################################*/
static unsigned PFlags [PFLAGSSIZ];
static char CurFields [PFLAGSSIZ],
ColHeadings [SMLBUFSIZ],
ColUsername [USRNAMSIZ];
static int NumFields;
/* Current window size.
note: Max_tasks is the specified number of processes to display
(zero for infinite), and Max_lines is the actual number
which, in turn, depends on screen size and summary info. */
static int Screen_cols, Screen_rows,
Max_lines, Max_tasks;
/* Number of lines needed to display the summary information
which is never less than 2 since it also must accomodate the
message line + column headings -- set soley by mkheadings! */
static int HSum_lines;
/* Maximum length to display of a process' command name/line
(excluding padding due to terminfo strings) */
static int Max_cmd;
/* Controls how long we sleep between screen updates.
Accurate to microseconds (when not in 'Batch' mode). */
static float Delay_time = DEF_DELAY;
/* Special flags dealing with the kernel symbol table */
static int No_ksyms = -1, /* set to '0' if ksym avail, '1' otherwise */
PSDBopen = 0; /* set to '1' if psdb opened (now postponed) */
/* The Mode flags.
Except for Batch and Loops, all of them are preserved in the
rc file. Thus, once personalized it stays personalized!
note: the 'letter' shown is the On condition, some default to Off */
static int Batch = 0, /* batch mode, collect no input, dumb output */
Loops = -1, /* number of iterations, -1 loops forever */
Secure_mode = 0, /* set if some functionality restricted */
Irix_mode = 1, /* 'I' - Irix vs. Solaris view (SMP-only) */
Sort_normal = 1, /* 'R' - reversed column sort order */
HSum_loadav = 1, /* 'l' - display load avg and uptime summary */
HSum_states = 1, /* 't' - display task/cpu(s) states summary */
HSum_memory = 1, /* 'm' - display memory summary */
Show_ctimes = 1, /* 'S' - show times as cumulative */
Show_cmdlin = 0, /* 'c' - show cmdline vs. name */
Show_idleps = 1, /* 'i' - show idle processes (all processes) */
Show_hicols = 0, /* 'x' - show sort column highlighted */
Show_hirows = 1, /* 'y' - show running task(s) highlighted */
Show_colors = 0, /* 'z' - show in color (vs. mono) */
Show_hibold = 1, /* 'b' - rows and/or col bold (vs. reverse) */
Show_cpusum = 1; /* '1' - show combined cpu stats (vs. each) */
/* Current current sort type (this too is preserved in the rc file)
* and handler -- goodbye libproc mult_lvl_cmp, etc. overkill. */
static int Sort_type = -1;
static QSORT_t Sort_func = NULL;
/* These are our gosh darn 'Fields' !
They MUST be kept in sync with pflags !! */
static FTAB_t Fieldstab[] = {
/* head fmts width scale sort desc
----------- ------- ------ ------ ------ ---------------------- */
{ " PID ", "%5d ", -1, -1, S_PID, "Process Id" },
{ " PPID ", "%5d ", -1, -1, -1, "Parent Process Pid" },
{ " UID ", "%4d ", -1, -1, -1, "User Id" },
{ "USER ", "%-8.8s ", -1, -1, S_USR, "User Name" },
{ "GROUP ", "%-8.8s ", -1, -1, -1, "Group Name" },
{ "TTY ", "%-8.8s ", 8, -1, S_TTY, "Controlling Tty" },
{ " PR ", "%3ld ", -1, -1, -1, "Priority" },
{ " NI ", "%3ld ", -1, -1, -1, "Nice value" },
{ "#C ", "%2d ", -1, -1, -1, "Last used cpu (SMP)" },
{ "%CPU ", "%#4.1f ", -1, -1, S_CPU, "CPU usage" },
{ " TIME ", "%6.6s ", 6, -1, S_TME, "CPU Time" },
{ " TIME+ ", "%9.9s ", 9, -1, S_TME, "CPU Time, hundredths" },
{ "%MEM ", "%#4.1f ", -1, -1, S_MEM, "Memory usage (RES)" },
{ " VIRT ", "%5.5s ", 5, SK_Kb, -1, "Virtual Image (kb)" },
{ "SWAP ", "%4.4s ", 4, SK_Kb, -1, "Swapped size (kb)" },
{ " RES ", "%4.4s ", 4, SK_Kb, S_MEM, "Resident size (kb)" },
{ "CODE ", "%4.4s ", 4, SK_Kb, -1, "Code size (kb)" },
{ "DATA ", "%4.4s ", 4, SK_Kb, -1, "Data+Stack size (kb)" },
{ " SHR ", "%4.4s ", 4, SK_Kb, -1, "Shared Mem size (kb)" },
{ "nFLT ", "%4.4s ", 4, SK_no, -1, "Page Fault count" },
{ "nDRT ", "%4.4s ", 4, SK_no, -1, "Dirty Pages count" },
{ "STA ", "%3.3s ", -1, -1, -1, "Process Status" },
/** next entry's special: '.head' will be formatted using table entry's own
'.fmts' plus runtime supplied conversion args! */
{ "Command ", "%-*.*s ", -1, -1, S_CMD, "Command line/name" },
{ "WCHAN ", "%-9.9s ", -1, -1, -1, "Sleeping in Function" },
/** next entry's special: the 0's will be replaced with '.'! */
#ifdef UPCASE_HEXES
{ "Flags ", "%08lX ", -1, -1, -1, "Task Flags <sched.h>" }
#else
{ "Flags ", "%08lx ", -1, -1, -1, "Task Flags <sched.h>" }
#endif
};
/* Miscellaneous Color stuff #####################################*/
/* Our three basic colors --
they can be manipulated by the 'tweak_colors' routine */
static int Base_color = BASEcolor,
Msgs_color = MSGScolor,
Head_color = HEADcolor;
/* Some cap's stuff to reduce runtime calls --
to accomodate 'Batch' mode, they begin life as empty strings */
static char Cap_bold [CAPBUFSIZ] = "",
Cap_clr_eol [CAPBUFSIZ] = "",
Cap_clr_eos [CAPBUFSIZ] = "",
Cap_clr_scr [CAPBUFSIZ] = "",
Cap_curs_norm [CAPBUFSIZ] = "",
Cap_curs_huge [CAPBUFSIZ] = "",
Cap_home [CAPBUFSIZ] = "",
Cap_norm [CAPBUFSIZ] = "",
Cap_reverse [CAPBUFSIZ] = "",
Caps_off [CAPBUFSIZ] = "";
static char Sum_color [CLRBUFSIZ] = "",
Msg_color [CLRBUFSIZ] = "",
Pmt_color [CLRBUFSIZ] = "",
Hdr_color [CLRBUFSIZ] = "",
Row_color_norm [CLRBUFSIZ] = "",
Row_color_high [CLRBUFSIZ] = "";
static int Cap_can_goto = 0,
Len_row_high = 0,
Len_row_norm = 0;
/* Development/debug stuff #######################################*/
#ifdef TRAK_MAXCAPS
static int Max_pads = 0, Min_pads = MAXINT,
Max_rbuf = 0, Min_rbuf = MAXINT;
#endif
#ifdef TRAK_MAXBUFS
BUF2INT(fmtmk, buf)
BUF2INT(show_special, tmp)
BUF2INT(ask_str, buf)
BUF2INT(scale_num, buf)
BUF2INT(scale_tics, buf)
BUF2INT(std_err, buf)
BUF2INT(frame_states, tmp)
BUF2INT(mkcol, tmp)
BUF2INT(show_a_task, cbuf)
BUF2INT(show_a_task, rbuf)
BUF2INT(rcfiles_read, fbuf)
BUF2INT(rcfiles_read, RCfile)
BUF2INT(rcfiles_read, RCfile_Sys)
BUF2INT(do_key, ColUsername)
BUF2INT(mkheadings, CurFields)
BUF2INT(mkheadings, ColHeadings)
BUF2INT(main, not_really_tmp)
#endif
/*###### Sort callbacks ################################################*/
static int sort_cmd (proc_t **P, proc_t **Q)
{
/* if a process doesn't have a cmdline, we'll consider it a kernel thread
-- since show_a_task gives such tasks special treatment, we must too */
if (Show_cmdlin && ((*P)->cmdline || (*Q)->cmdline)) {
if (!(*P)->cmdline) return SORT_lt;
if (!(*Q)->cmdline) return SORT_gt;
if ( 0 > strncmp((*P)->cmdline[0], (*Q)->cmdline[0], (unsigned)Max_cmd) )
return SORT_lt;
if ( 0 < strncmp((*P)->cmdline[0], (*Q)->cmdline[0], (unsigned)Max_cmd) )
return SORT_gt;
} else {
/* this part also handles the compare if both are kernel threads */
if ( 0 > strcmp((*P)->cmd, (*Q)->cmd) ) return SORT_lt;
if ( 0 < strcmp((*P)->cmd, (*Q)->cmd) ) return SORT_gt;
}
return 0;
}
static int sort_cpu (proc_t **P, proc_t **Q)
{
if ( (*P)->pcpu < (*Q)->pcpu ) return SORT_lt;
if ( (*P)->pcpu > (*Q)->pcpu ) return SORT_gt;
return 0;
}
static int sort_mem (proc_t **P, proc_t **Q)
{
if ( (*P)->resident < (*Q)->resident ) return SORT_lt;
if ( (*P)->resident > (*Q)->resident ) return SORT_gt;
/* still equal? we'll try to fix that... */
if ( (*P)->size < (*Q)->size ) return SORT_lt;
if ( (*P)->size > (*Q)->size ) return SORT_gt;
return 0;
}
static int sort_pid (proc_t **P, proc_t **Q)
{
if ( (*P)->pid < (*Q)->pid ) return SORT_lt;
if ( (*P)->pid > (*Q)->pid ) return SORT_gt;
return 0;
}
static int sort_tme (proc_t **P, proc_t **Q)
{
if (Show_ctimes) {
if ( ((*P)->cutime + (*P)->cstime + (*P)->utime + (*P)->stime)
< ((*Q)->cutime + (*Q)->cstime + (*Q)->utime + (*Q)->stime) )
return SORT_lt;
if ( ((*P)->cutime + (*P)->cstime + (*P)->utime + (*P)->stime)
> ((*Q)->cutime + (*Q)->cstime + (*Q)->utime + (*Q)->stime) )
return SORT_gt;
} else {
if ( ((*P)->utime + (*P)->stime) < ((*Q)->utime + (*Q)->stime))
return SORT_lt;
if ( ((*P)->utime + (*P)->stime) > ((*Q)->utime + (*Q)->stime))
return SORT_gt;
}
return 0;
}
static int sort_tty (proc_t **P, proc_t **Q)
{
if ( (*P)->tty < (*Q)->tty ) return SORT_lt;
if ( (*P)->tty > (*Q)->tty ) return SORT_gt;
/* still equal? we'll try to fix that... */
return sort_pid(P, Q);
}
static int sort_usr (proc_t **P, proc_t **Q)
{
if ( 0 > strcmp((*P)->euser, (*Q)->euser) ) return SORT_lt;
if ( 0 < strcmp((*P)->euser, (*Q)->euser) ) return SORT_gt;
/* still equal? we'll try to fix that... */
return sort_pid(P, Q);
}
/*###### Tiny useful routine(s) ########################################*/
/*
* This routine isolates ALL user input and ensures that we
* wont be mixing I/O from stdio and low-level read() requests */
static int chin (int ech, char *buf, unsigned cnt)
{
int rc;
fflush(stdout);
if (!ech)
rc = read(STDIN_FILENO, buf, cnt);
else {
tcsetattr(STDIN_FILENO, TCSAFLUSH, &Savedtty);
rc = read(STDIN_FILENO, buf, cnt);
tcsetattr(STDIN_FILENO, TCSAFLUSH, &Rawtty);
}
/* may be the beginning of a lengthy escape sequence */
tcflush(STDIN_FILENO, TCIFLUSH);
return rc; /* note: we do NOT produce a vaid 'string' */
}
/*
* This routine simply formats whatever the caller wants and
* returns a pointer to the resulting 'const char' string... */
static const char *fmtmk (const char *fmts, ...)
{
static char buf[BIGBUFSIZ]; /* with help stuff, our buffer */
va_list va; /* requirements exceed 1k */
va_start(va, fmts);
vsprintf(buf, fmts, va);
va_end(va);
#ifdef TRAK_MAXBUFS
MAXBUFS(fmtmk, buf);
#endif
return (const char *)buf;
}
/*
* What need be said... */
static char *strim (int sp, char *str)
{
const char *ws = "\b\f\n\r\t\v";
char *p;
/* this guy was originally designed just to trim the rc file lines and
any 'open_psdb_message' result which arrived with an inappropriate
newline (thanks to 'sysmap_mmap') -- but when tabs (^I) were found
in some proc cmdlines, a choice was offered twix space or null... */
if (sp)
while ((p = strpbrk(str, ws))) *p = ' ';
else
if ((p = strpbrk(str, ws))) *p = 0;
return str;
}
/*
* This guy just facilitates Batch and protects against dumb ttys. */
static char *tg2 (int x, int y)
{
return Cap_can_goto ? tgoto(cursor_address, x, y) : (char *)"\n";
}
/*###### Misc Color/Highlighting support ###############################*/
/*
* Make the appropriate caps/color strings and set some
* lengths which are used to distinguish twix the displayed
* columns and an actual printf row!
* note: we avoid the use of background color so as to maximize
* compatibility with the user's xterm settings */
static void capsmk (void)
{
/* macro to test if a basic (non-color) capability is valid
thanks: Floyd Davidson <floyd@ptialaska.net> */
#define tIF(s) s ? s : ""
static int capsdone = 0;
/* just a precaution for the future, we aren't called now... */
if (Batch) return;
/* these are the unchangeable puppies, so we only do 'em once */
if (!capsdone) {
strcpy(Cap_bold, tIF(enter_bold_mode));
strcpy(Cap_clr_eol, tIF(clr_eol));
strcpy(Cap_clr_eos, tIF(clr_eos));
strcpy(Cap_clr_scr, tIF(clear_screen));
strcpy(Cap_curs_huge, tIF(cursor_visible));
strcpy(Cap_curs_norm, tIF(cursor_normal));
strcpy(Cap_home, tIF(cursor_home));
strcpy(Cap_norm, tIF(exit_attribute_mode));
strcpy(Cap_reverse, tIF(enter_reverse_mode));
sprintf(Caps_off, "%s%s", Cap_norm, tIF(orig_pair));
if (tgoto(cursor_address, 1, 1)) Cap_can_goto = 1;
capsdone = 1;
}
/* now do the changeable guys... */
if (Show_colors && max_colors > 0) {
strcpy(Sum_color, tparm(set_a_foreground, Base_color));
sprintf(Msg_color, "%s%s"
, tparm(set_a_foreground, Msgs_color), Cap_reverse);
sprintf(Pmt_color, "%s%s"
, tparm(set_a_foreground, Msgs_color), Cap_bold);
sprintf(Hdr_color, "%s%s"
, tparm(set_a_foreground, Head_color), Cap_reverse);
sprintf(Row_color_norm, "%s%s"
, Caps_off, tparm(set_a_foreground, Base_color));
} else {
Sum_color[0] = '\0';
strcpy(Msg_color, Cap_reverse);
strcpy(Pmt_color, Cap_bold);
strcpy(Hdr_color, Cap_reverse);
strcpy(Row_color_norm, Cap_norm);
}
sprintf(Row_color_high, "%s%s"
, Row_color_norm, Show_hibold ? Cap_bold : Cap_reverse);
Len_row_norm = strlen(Row_color_norm);
Len_row_high = strlen(Row_color_high);
#undef tIF
}
/*
* Show an error, but not right now.
* Due to the postponed opening of ksym, using open_psdb_message,
* if P_WCHAN had been selected and the program is restarted, the
* message would otherwise be displayed prematurely */
static void msg_save (const char *fmts, ...)
{
char tmp[SMLBUFSIZ];
va_list va;
va_start(va, fmts);
vsprintf(tmp, fmts, va);
va_end(va);
/* we'll add some extra attention grabbers to whatever this is */
sprintf(Msg_delayed, "\a*** %s ***", strim(0, tmp));
Msg_awaiting = 1;
}
/*
* Show an error message (caller may include a '\a' for sound) */
static void show_msg (const char *str)
{
printf("%s%s %s %s%s"
, tg2(0, MSG_line)
, Msg_color
, str
, Caps_off
, Cap_clr_eol);
fflush(stdout);
sleep(MSG_SLEEP);
Msg_awaiting = 0;
}
/*
* Show an input prompt + larger cursor */
static void show_pmt (const char *str)
{
printf("%s%s%s: %s%s"
, tg2(0, MSG_line)
, Pmt_color
, str
, Cap_curs_huge
, Caps_off);
fflush(stdout);
}
/*
* Show lines with specially formatted elements, but only output
* what will fit within the current screen width.
* Our special formatting consists of:
* "some text <_delimiter_> some more text <_delimiter_>...\n"
* Where <_delimiter_> is a single byte in the range of:
* \01 through \07 (more properly \0001 - \0007)
* and is used to select an 'attribute' from a capabilities table
* which is then applied to the *preceding* substring.
*
* Once recognized, the delimiter is replaced with a null character
* and viola, we've got a substring ready to output! Strings or
* substrings without delimiters will receive the Cap_norm attribute.
*
* Caution:
* This routine treats all non-delimiter bytes as displayable
* data subject to our screen width marching orders. If callers
* embed non-display data like tabs or terminfo strings in our
* glob, a line will truncate incorrectly at best. Worse case
* would be truncation of an embedded tty escape sequence.
*
* Tabs must always be avoided or our efforts are wasted and
* lines will wrap. To lessen but not eliminate the risk of
* terminfo string truncation, such non-display stuff should
* be placed at the beginning of a "short" line. */
static void show_special (const char *glob)
{
static char *captab[] = { /* Cap's/Delim's */
Cap_norm, Cap_norm, Cap_bold, /* \00, \01, \02 */
Sum_color, /* \03 */
Msg_color, Pmt_color, /* \04, \05 */
Hdr_color, /* \06 */
Row_color_high }; /* \07 */
char tmp[BIGBUFSIZ], *cap, *lin_end, *sub_beg, *sub_end;
int room;
/* handle multiple lines passed in a bunch */
while ((lin_end = strchr(glob, '\n'))) {
/* create a local copy we can extend and otherwise abuse */
memcpy(tmp, glob, (unsigned)(lin_end - glob));
#ifdef TRAK_MAXBUFS
MAXBUFS(show_special, tmp);
#endif
/* zero terminate this part and prepare to parse substrings */
tmp[lin_end - glob] = '\0';
room = Screen_cols;
sub_beg = sub_end = tmp;
while (*sub_beg) {
switch (*sub_end) {
case '\00' : /* no end delim, captab makes normal */
*(sub_end + 1) = '\0'; /* extend str end, then fall through */
case '\01' ... '\07' :
cap = captab[(int)*sub_end];
*sub_end = '\0';
printf("%s%.*s%s", cap, room, sub_beg, Caps_off);
room -= (sub_end - sub_beg);
sub_beg = ++sub_end;
break;
default : /* nothin' special, just text */
++sub_end;
}
if (0 >= room) break; /* skip substrings that won't fit */
} /* end: while 'subtrings' */
printf("%s\n", Cap_clr_eol); /* emulate truncated newline */
glob = ++lin_end; /* point to next line (maybe) */
} /* end: while 'lines' */
/* if there's anything left in the glob (by virtue of no trailing '\n'),
it probably means caller wants to retain cursor position on this final
line -- ok then, we'll just do our 'fit-to-screen' thingy... */
if (strlen(glob)) printf("%.*s", Screen_cols, glob);
fflush(stdout);
}
/*
* Change colors used in display */
static void tweak_colors (void)
{
#define kbdABORT 'q'
#define kbdAPPLY '\n'
int clrssav = Show_colors, boldsav = Show_hibold,
basesav = Base_color, msgssav = Msgs_color, headsav = Head_color;
int clr = Base_color, *pclr = &Base_color;
char ch, tgt = 'B';
if (0 >= max_colors) {
show_msg("\aNo colors to map!");
return;
}
if (!Show_colors) {
Show_colors = 1;
capsmk();
}
printf("%s%s", Cap_clr_scr, Cap_curs_huge);
do {
/* this string is well above ISO C89's minimum requirements! */
show_special(fmtmk(COLOR_sample
, Cap_home, Myname, procps_version, tgt, clr));
chin(0, &ch, 1);
switch (ch) {
case 'B' :
pclr = &Base_color;
clr = *pclr;
tgt = ch;
break;
case 'M' :
pclr = &Msgs_color;
clr = *pclr;
tgt = ch;
break;
case 'H' :
pclr = &Head_color;
clr = *pclr;
tgt = ch;
break;
case '0' ... '7' :
clr = ch - '0';
break;
case 'b' :
Show_hibold = !Show_hibold;
break;
case 'z' :
Show_colors = !Show_colors;
break;
}
*pclr = clr;
capsmk();
} while (kbdAPPLY != ch && kbdABORT != ch);
if (kbdABORT == ch) {
Show_colors = clrssav; Show_hibold = boldsav;
Base_color = basesav; Msgs_color = msgssav; Head_color = headsav;
capsmk();
}
putp(Cap_curs_norm);
#undef kbdABORT
#undef kbdAPPLY
}
/*###### Small utility routines ########################################*/
/*
* Get a string from the user */
static char *ask_str (const char *prompt)
{
static char buf[GETBUFSIZ];
show_pmt(prompt);
memset(buf, '\0', sizeof(buf));
chin(1, buf, sizeof(buf) - 1);
putp(Cap_curs_norm);
#ifdef TRAK_MAXBUFS
MAXBUFS(ask_str, buf);
#endif
return strim(0, buf);
}
/*
* Get a float from the user */
static float get_float (const char *prompt)
{
char *line;
float f;
if (!(*(line = ask_str(prompt)))) return -1;
/* note: we're not allowing negative floats */
if (strcspn(line, ".1234567890")) {
show_msg("\aNot valid");
return -1;
}
sscanf(line, "%f", &f);
return f;
}
/*
* Get an integer from the user */
static int get_int (const char *prompt)
{
char *line;
int n;
if (!(*(line = ask_str(prompt)))) return -1;
/* note: we've got to allow negative ints (renice) */
if (strcspn(line, "-1234567890")) {
show_msg("\aNot valid");
return -1;
}
sscanf(line, "%d", &n);
return n;
}
/*
* Set the number of fields/columns to display.
* Create the field/column headings and set maximum cmdline length.
* Establish the heading/summary lines currently in use.
* Adjust the number of tasks to display. */
static void mkheadings (void)
{
const char *h;
int i, needpsdb = 0;
/* build our PFlags array and establish a tentative NumFields */
for (i = 0, NumFields = 0; i < (int)strlen(CurFields); i++) {
if (isupper(CurFields[i]))
PFlags[NumFields++] = CurFields[i] - 'A';
}
/* build a preliminary ColHeadings not to exceed screen width */
ColHeadings[0] = '\0';
for (i = 0; i < NumFields; i++) {
h = Fieldstab[PFlags[i]].head;
/* oops, won't fit -- we're outta here... */
if (Screen_cols < (int)(strlen(ColHeadings) + strlen(h))) break;
strcat(ColHeadings, h);
}
/* establish the final NumFields and prepare to grow the command
column heading via Max_cmd -- it may be a fib if P_CMD wasn't
encountered, but that's ok because it won't be displayed anyway */
NumFields = i;
Max_cmd = Screen_cols
- (strlen(ColHeadings) - strlen(Fieldstab[P_CMD].head)) - 1;
/* now we can build the true run-time ColHeadings and format the
command column heading if P_CMD is really being displayed */
ColHeadings[0] = '\0';
for (i = 0; i < NumFields; i++) {
/* are we gonna' need the kernel symbol table? */
if (P_WCHAN == PFlags[i]) needpsdb = 1;
h = Fieldstab[PFlags[i]].head;
if (P_CMD == PFlags[i])
strcat(ColHeadings, fmtmk(Fieldstab[P_CMD].fmts, Max_cmd, Max_cmd, h));
else
strcat(ColHeadings, h);
}
/* set the number of heading lines and calc display height */
HSum_lines = SUMMINLINS;
if (HSum_loadav) HSum_lines += 1;
if (HSum_states) {
if (Show_cpusum) HSum_lines += 2;
/* no tellin' how darn many cpus they might have -- if they exceed
screen height, they'll have to suffer scroll...
(Max_lines may go negative, which is as good as 0) */
else HSum_lines += Cpu_tot + 1;
}
if (HSum_memory) HSum_lines += 2;
Max_lines = Screen_rows - HSum_lines;
if (Max_tasks && Max_tasks < Max_lines)
Max_lines = Max_tasks;
/* do we (still) need the kernel symbol table? */
if (needpsdb) {
if (-1 == No_ksyms) {
No_ksyms = 0;
if (open_psdb_message(NULL, msg_save))
/* why so counter-intuitive, couldn't open_psdb_message
mirror sysmap_mmap -- that func does all the work anyway? */
No_ksyms = 1;
else
PSDBopen = 1;
}
}
#ifdef UGH_ITS_4_RH
else if (PSDBopen) {
close_psdb();
PSDBopen = 0;
No_ksyms = -1;
}
#endif
#ifdef TRAK_MAXBUFS
MAXBUFS(mkheadings, CurFields);
MAXBUFS(mkheadings, ColHeadings);
#endif
}
/*
* Do some scaling stuff.
* We'll interpret 'num' as one of the following types and
* try to format it to fit 'width'.
* SK_no (0) it's a byte count
* SK_Kb (1) it's kilobytes
* SK_Mb (2) it's megabytes
* SK_Gb (3) it's gigabytes */
static char *scale_num (unsigned num, const unsigned width, const unsigned type)
{
/* kilobytes, megabytes, gigabytes, too-big-for-int-bytes */
static double scale[] = { 1024, 1024*1024, 1024*1024*1024, 0 };
/* kilo, mega, giga, none */
#ifdef UPCASE_SCALE
static char nextup[] = { 'K', 'M', 'G', 0 };
#else
static char nextup[] = { 'k', 'm', 'g', 0 };
#endif
static char buf[TNYBUFSIZ];
double *dp;
char *up;
/* try an unscaled version first... */
sprintf(buf, "%d", num);
#ifdef TRAK_MAXBUFS
MAXBUFS(scale_num, buf);
#endif
if (strlen(buf) <= width)
return buf;
/* now try successively higher types until it fits */
for (up = nextup + type, dp = scale; *dp; ++dp, ++up) {
/* the most accurate version */
sprintf(buf, "%.1f%c", num / *dp, *up);
if (strlen(buf) <= width)
return buf;
/* the integer version */
sprintf(buf, "%d%c", (int)(num / *dp), *up);
if (strlen(buf) <= width)
return buf;
}
/* well shoot, this outta' fit... */
return (char *)"?";
}
/*
* Do some scaling stuff.
* Format 'tics' to fit 'width' */
static char *scale_tics (TICS_t tics, const unsigned width)
{
static struct {
unsigned div;
const char *fmt;
} ttab[] = {
/* minutes hours days weeks */
#ifdef UPCASE_SCALE
{ 60, "%uM" }, { 60, "%uH" }, { 24, "%uD" }, { 7, "%uW" }
#else
{ 60, "%um" }, { 60, "%uh" }, { 24, "%ud" }, { 7, "%uw" }
#endif
};
static char buf[TNYBUFSIZ];
unsigned i, t;
/* try successively higher units until it fits */
t = tics / Hertz;
sprintf(buf, "%d:%02d.%02d" /* minutes:seconds.tenths */
, t/60, t%60, (int)((tics*100)/Hertz)%100);
#ifdef TRAK_MAXBUFS
MAXBUFS(scale_tics, buf);
#endif
if (strlen(buf) <= width)
return buf;
sprintf(buf, "%d:%02d", t/60, t%60); /* minutes:seconds */
if (strlen(buf) <= width)
return buf;
/* try successively: minutes; hours; days; weeks */
for (i = 0; i < MAXtbl(ttab); i++) {
t /= ttab[i].div;
sprintf(buf, ttab[i].fmt, t);
if (strlen(buf) <= width)
return buf;
};
/* well shoot, this outta' fit... */
return (char *)"?";
}
/*
* Calculate and return the elapsed time since the last update
* which is then used in % CPU calc's. */
static float time_elapsed (void)
{
static struct timeval oldtimev;
struct timeval timev;
struct timezone timez;
float et;
gettimeofday(&timev, &timez);
et = (timev.tv_sec - oldtimev.tv_sec)
+ (float)(timev.tv_usec - oldtimev.tv_usec) / 1000000.0;
oldtimev.tv_sec = timev.tv_sec;
oldtimev.tv_usec = timev.tv_usec;
return et;
}
/*###### Exit and Signal handled routines ##############################*/
/*
* The usual program end --
* called only by functions in this section. */
static void bye_bye (int eno, const char *str)
{
#ifdef UGH_ITS_4_RH
if (PSDBopen)
close_psdb();
#endif
if (!Batch)
tcsetattr(STDIN_FILENO, TCSAFLUSH, &Savedtty);
printf("%s%s\n", tg2(0, Screen_rows), Cap_curs_norm);
if (str) {
if (eno) perror(str);
else fputs(str, stderr);
}
#ifdef TRAK_MAXCAPS
fprintf(stderr,
"\nTRAK_MAXCAPS report:"
"\n\tBasic lengths:"
"\n\t Cap_home = %d, Cap_bold = %d, Cap_norm = %d, Cap_reverse = %d"
"\n\t Cap_clr_eol = %d, Cap_clr_eos = %d, Cap_clr_scr = %d"
"\n\t Cap_curs_norm = %d, Cap_curs_huge = %d"
"\n\t Caps_off = %d"
"\n\tColor lengths:"
"\n\t Sum_color = %d, Msg_color = %d, Pmt_color = %d, Hdr_color = %d"
"\n\t Row_color_norm = %d, Len_row_norm = '%d'"
"\n\t Row_color_high = %d, Len_row_high = '%d'"
"\n\tMax_pads = %d, Min_pads = %d"
"\n\tMax_rbuf = %d, Min_rbuf = %d"
"\n"
, strlen(Cap_home), strlen(Cap_bold), strlen(Cap_norm), strlen(Cap_reverse)
, strlen(Cap_clr_eol), strlen(Cap_clr_eos), strlen(Cap_clr_scr)
, strlen(Cap_curs_norm), strlen(Cap_curs_huge)
, strlen(Caps_off)
, strlen(Sum_color), strlen(Msg_color), strlen(Pmt_color), strlen(Hdr_color)
, strlen(Row_color_norm), Len_row_norm
, strlen(Row_color_high), Len_row_high
, Max_pads, Min_pads
, Max_rbuf, Min_rbuf);
#endif
#ifdef TRAK_MAXBUFS
fprintf(stderr,
"\nTRAK_MAXBUFS report:"
"\n\tused size\tfunction, buffer"
"\n\t---- ----\t-----------------------"
ARPTBUF(fmtmk, buf)
ARPTBUF(show_special, tmp)
ARPTBUF(ask_str, buf)
ARPTBUF(scale_num, buf)
ARPTBUF(scale_tics, buf)
ARPTBUF(std_err, buf)
ARPTBUF(frame_states, tmp)
ARPTBUF(mkcol, tmp)
ARPTBUF(show_a_task, cbuf)
ARPTBUF(show_a_task, rbuf)
ARPTBUF(rcfiles_read, fbuf)
ARPTBUF(rcfiles_read, RCfile)
ARPTBUF(rcfiles_read, RCfile_Sys)
ARPTBUF(do_key, ColUsername)
ARPTBUF(mkheadings, CurFields)
ARPTBUF(mkheadings, ColHeadings)
ARPTBUF(main, not_really_tmp)
"\n"
, AUSEBUF(fmtmk, buf), ASIZBUF(fmtmk, buf)
, AUSEBUF(show_special, tmp), ASIZBUF(show_special, tmp)
, AUSEBUF(ask_str, buf), ASIZBUF(ask_str, buf)
, AUSEBUF(scale_num, buf), ASIZBUF(scale_num, buf)
, AUSEBUF(scale_tics, buf), ASIZBUF(scale_tics, buf)
, AUSEBUF(std_err, buf), ASIZBUF(std_err, buf)
, AUSEBUF(frame_states, tmp), ASIZBUF(frame_states, tmp)
, AUSEBUF(mkcol, tmp), ASIZBUF(mkcol, tmp)
, AUSEBUF(show_a_task, cbuf), ASIZBUF(show_a_task, cbuf)
, AUSEBUF(show_a_task, rbuf), ASIZBUF(show_a_task, rbuf)
, AUSEBUF(rcfiles_read, fbuf), ASIZBUF(rcfiles_read, fbuf)
, AUSEBUF(rcfiles_read, RCfile) , ASIZBUF(rcfiles_read, RCfile)
, AUSEBUF(rcfiles_read, RCfile_Sys) , ASIZBUF(rcfiles_read, RCfile_Sys)
, AUSEBUF(do_key, ColUsername), ASIZBUF(do_key, ColUsername)
, AUSEBUF(mkheadings, CurFields), ASIZBUF(mkheadings, CurFields)
, AUSEBUF(mkheadings, ColHeadings), ASIZBUF(mkheadings, ColHeadings)
, AUSEBUF(main, not_really_tmp), ASIZBUF(main, not_really_tmp));
#endif
#if defined(TRAK_MAXCAPS) || defined(TRAK_MAXBUFS)
fprintf(stderr,
"\nbye_bye's Summary report:"
"\n\tprogram names:"
"\n\t Myrealname = %s, Myname = %s"
"\n\tterminal = '%s'"
"\n\t device = %s, ncurses = v%s"
"\n\t max_colors = %d, max_pairs = %d"
"\n\t Cap_can_goto = %s"
"\n\tScreen_cols = %d, Screen_rows = %d"
"\n\tNumFields = %d, HSum_lines = %d"
"\n\tMax_lines = %d, Max_cmd = %d, Max_tasks = %d"
"\n\tPage_size = %d"
"\n"
, Myrealname, Myname
#ifdef PRETENDNOCAP
, "dumb"
#else
, termname()
#endif
, ttyname(STDOUT_FILENO), NCURSES_VERSION
, max_colors, max_pairs
, Cap_can_goto ? "yes" : "No!"
, Screen_cols, Screen_rows
, NumFields, HSum_lines
, Max_lines, Max_cmd, Max_tasks
, Page_size);
#endif
if (str && !eno) eno = 1;
exit(eno);
}
/*
* Standard error handler to normalize the look of all err o/p */
static void std_err (const char *str)
{
static char buf[SMLBUFSIZ];
fflush(stdout);
/* we'll use our own buffer so callers can still use fmtmk() */
sprintf(buf, "\t%s: %s\n", Myname, str);
#ifdef TRAK_MAXBUFS
MAXBUFS(std_err, buf);
#endif
if (!Ttychanged) {
fprintf(stderr, buf);
exit(1);
}
/* not to worry, he'll change our exit code to 1 due to 'buf' */
bye_bye(0, buf);
}
/*
* Normal end of execution.
* catches:
* SIGALRM, SIGHUP, SIGINT, SIGPIPE, SIGQUIT and SIGTERM */
static void stop (int dont_care_sig)
{
bye_bye(0, NULL);
}
/*
* Suspend ourself.
* catches:
* SIGTSTP, SIGTTIN and SIGTTOU */
static void suspend (int dont_care_sig)
{
/* reset terminal */
tcsetattr(STDIN_FILENO, TCSAFLUSH, &Savedtty);
printf("%s%s", tg2(0, Screen_rows), Cap_curs_norm);
fflush(stdout);
raise(SIGSTOP);
/* later, after SIGCONT... */
if (!Batch)
tcsetattr(STDIN_FILENO, TCSAFLUSH, &Rawtty);
}
/*
* Set the screen dimensions and call the real workhorse.
* catches:
* SIGWINCH and SIGCONT */
static void window_resize (int dont_care_sig)
{
struct winsize w;
Screen_cols = columns;
Screen_rows = lines;
if (-1 != (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w))) {
Screen_cols = w.ws_col;
Screen_rows = w.ws_row;
}
/* he'll calculate header size, length of command field, etc ... */
mkheadings();
}
/*###### Startup routines ##############################################*/
/*
* Parse command line arguments
* (and force ol' main into a much needed diet)
* Note: it's assumed that the rc file(s) have already been read
* and our job is to see if any of those options are to be
* overridden -- we'll force some on and negate others in our
* best effort to honor the user's wishes... */
static void parse_argvs (char **argv)
{
/* difference(s) from traditional top:
-q (zero delay time) eliminated as redundant, use -d0
-p (pid monitoring) allows comma delimited list
no deprecated/illegal use of 'goto' with 'breakargv:'
bunched args are actually handled properly and none are ignored
(we tolerate No whitespace and No switches -- maybe too tolerant) */
const char *usage = " -hv | -bcisS -d delay -n iterations -p pid [,pid ...]\n";
float tmp_delay = MAXFLOAT;
char *p;
++argv;
while (*argv) {
char *cp = *(argv++);
while (*cp) {
switch (*cp) {
case '\0':
case '-':
break;
case 'b':
Batch = 1;
break;
case 'c':
Show_cmdlin = !Show_cmdlin;
break;
case 'd':
if (cp[1]) ++cp;
else if (*argv) cp = *argv++;
else std_err("-d requires argument");
/* a negative delay will be dealt with shortly... */
if (1 != sscanf(cp, "%f", &tmp_delay))
std_err(fmtmk("bad delay '%s'", cp));
break;
case 'h': case 'H':
case 'v': case 'V':
std_err(fmtmk("\t%s\nusage:\t%s%s"
, procps_version, Myname, usage));
case 'i':
Show_idleps = !Show_idleps;
break;
case 'n':
if (cp[1]) cp++;
else if (*argv) cp = *argv++;
else std_err("-n requires argument");
if (1 != sscanf(cp, "%d", &Loops) || 0 > Loops)
std_err(fmtmk("bad iterations arg '%s'", cp));
break;
case 'p':
if (cp[1]) cp++;
else if (*argv) cp = *argv++;
else std_err("-p requires argument");
do {
if (Monpidsidx >= MONPIDMAX)
std_err(fmtmk("pid limit (%d) exceeded", MONPIDMAX));
if (1 != sscanf(cp, "%d", &Monpids[Monpidsidx])
|| 0 > Monpids[Monpidsidx])
std_err(fmtmk("bad pid '%s'", cp));
if (!Monpids[Monpidsidx])
Monpids[Monpidsidx] = getpid();
Monpidsidx++;
if (!(p = strchr(cp, ',')))
break;
cp = ++p;
} while (*cp);
break;
case 's':
Secure_mode = 1;
break;
case 'S':
Show_ctimes = !Show_ctimes;
break;
default :
std_err(fmtmk("unknown argument '%c'\nusage:\t%s%s"
, *cp, Myname, usage));
} /* end: switch */
/* advance cp and jump over any numerical args used above */
cp += strspn(++cp, "-.1234567890 ");
} /* end: while *cp */
} /* end: while *argv */
/* fixup delay time, maybe... */
if (MAXFLOAT != tmp_delay) {
if (Secure_mode || 0 > tmp_delay)
msg_save("Delay time Not changed");
else
Delay_time = tmp_delay;
}
/* set the default sort type, maybe... */
if (-1 == Sort_type || Monpidsidx) {
Sort_type = S_PID;
Sort_func = (QSORT_t)sort_pid;
}
}
/*
* Parse the options string as read from line two of the "local"
* configuration file. */
static void parse_rc (char *opts)
{
unsigned i;
for (i = 0; i < strlen(opts); i++) {
switch (opts[i]) {
case 'b':
Show_hibold = 1;
break;
case 'c':
Show_cmdlin = 1;
break;
case 'C':
Sort_type = S_CMD;
Sort_func = (QSORT_t)sort_cmd;
break;
case 'E':
Sort_type = S_USR;
Sort_func = (QSORT_t)sort_usr;
break;
case 'i':
Show_idleps = 1;
break;
case 'I':
Irix_mode = 1;
break;
case 'l':
HSum_loadav = 1;
break;
case 'm':
HSum_memory = 1;
break;
case 'M':
Sort_type = S_MEM;
Sort_func = (QSORT_t)sort_mem;
break;
case 'P':
Sort_type = S_PID;
Sort_func = (QSORT_t)sort_pid;
break;
case 'R':
Sort_normal = 1;
break;
case 'S':
Show_ctimes = 1;
break;
case 't':
HSum_states = 1;
break;
case 'T':
Sort_type = S_TME;
Sort_func = (QSORT_t)sort_tme;
break;
case 'U':
Sort_type = S_CPU;
Sort_func = (QSORT_t)sort_cpu;
break;
case 'x':
Show_hicols = 1;
break;
case 'y':
Show_hirows = 1;
break;
case 'Y':
Sort_type = S_TTY;
Sort_func = (QSORT_t)sort_tty;
break;
case 'z':
Show_colors = 1;
break;
case '1':
Show_cpusum = 1;
break;
case ' ' : /* these serve as rc file comments */
case '\t': /* and will be treated as 'eol' */
case '\n':
return;
default :
std_err(fmtmk("bad config option - '%c'", opts[i]));
}
}
}
/*
* Build the two RC file names then try to read 'em.
*
* '/etc/RCfile_Sys' contains two lines consisting of the secure mode
* switch and an update interval. It's presence limits what ordinary
* users are allowed to do.
*
* '$HOME/RCfile' contains five lines.
* line 1: specifies the fields that are to be displayed
* and their order. Uppercase letters == displayed,
* lowercase letters == not shown.
* line 2: specifies miscellaneous display options and
* toggles along with the prefered sort order.
* line 3: specifies maximum processes, 0 == unlimited.
* line 4: specifies the update interval. If run in secure
* mode, this value will be ignored except for root.
* line 5: specifies the 3 basic color values. */
static void rcfiles_read (void)
{
char fbuf[RCFBUFSIZ];
FILE *fp;
strcpy(RCfile_Sys, fmtmk("/etc/%src", Myrealname));
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, RCfile_Sys);
#endif
if (getenv("HOME"))
strcpy(RCfile, fmtmk("%s%c", getenv("HOME"), '/'));
strcat(RCfile, fmtmk(".%src", Myname));
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, RCfile);
#endif
fp = fopen(RCfile_Sys, "r");
if (fp) {
fbuf[0] = '\0';
fgets(fbuf, sizeof(fbuf), fp); /* sys rc file, line #1 */
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, fbuf);
#endif
if (strchr(fbuf, 's')) Secure_mode = 1;
fbuf[0] = '\0';
fgets(fbuf, sizeof(fbuf), fp); /* sys rc file, line #2 */
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, fbuf);
#endif
fclose(fp);
sscanf(fbuf, "%f", &Delay_time);
}
fp = fopen(RCfile, "r");
if (fp) {
fbuf[0] = '\0';
if (fgets(fbuf, sizeof(fbuf), fp)) { /* rc file, line #1 */
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, fbuf);
#endif
strcpy(CurFields, strim(0, fbuf));
/* Now that we've found an rc file, we'll honor those
preferences by first turning off everything... */
Irix_mode = 0;
HSum_states = HSum_memory = HSum_loadav = Show_cpusum = 0;
Show_cmdlin = Show_ctimes = Show_idleps = Sort_normal = 0;
Show_colors = Show_hicols = Show_hirows = Show_hibold = 0;
fbuf[0] = '\0';
fgets(fbuf, sizeof(fbuf), fp); /* rc file, line #2 */
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, fbuf);
#endif
/* we could subsume this next guy since we're the only caller
-- but we're both too fat already... */
parse_rc(strim(0, fbuf));
fbuf[0] = '\0';
fgets(fbuf, sizeof(fbuf), fp); /* rc file, line #3 */
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, fbuf);
#endif
sscanf(fbuf, "%d", &Max_tasks);
fbuf[0] = '\0';
fgets(fbuf, sizeof(fbuf), fp); /* rc file, line #4 */
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, fbuf);
#endif
if (!Secure_mode || !getuid())
sscanf(fbuf, "%f", &Delay_time);
fbuf[0] = '\0';
fgets(fbuf, sizeof(fbuf), fp); /* rc file, line #5 */
#ifdef TRAK_MAXBUFS
MAXBUFS(rcfiles_read, fbuf);
#endif
sscanf(fbuf, "%d,%d,%d", &Base_color, &Msgs_color, &Head_color);
}
fclose(fp);
}
/* protect against meddling leading to a possible fault --
shorter would kinda' work, longer ain't healthy for us! */
if (strlen(CurFields) != strlen(DEF_FIELDS))
strcpy(CurFields, DEF_FIELDS);
/* lastly, establish the true runtime secure mode */
Secure_mode = getuid() ? Secure_mode : 0;
}
/*
* Set up the terminal attributes */
static void terminal_set (void)
{
struct termios newtty;
/* first the ncurses part... */
#ifdef PRETENDNOCAP
setupterm((char *)"dumb", STDOUT_FILENO, NULL);
#else
setupterm(NULL, STDOUT_FILENO, NULL);
#endif
/* now our part... */
if (!Batch) {
if (-1 == tcgetattr(STDIN_FILENO, &Savedtty))
std_err("tcgetattr() failed");
capsmk();
newtty = Savedtty;
newtty.c_lflag &= ~ICANON;
newtty.c_lflag &= ~ECHO;
newtty.c_cc[VMIN] = 1;
newtty.c_cc[VTIME] = 0;
Ttychanged = 1;
if (-1 == tcsetattr(STDIN_FILENO, TCSAFLUSH, &newtty)) {
putp(Cap_clr_scr);
std_err(fmtmk("Failed tty set: %s", strerror(errno)));
}
tcgetattr(STDIN_FILENO, &Rawtty);
putp(Cap_clr_scr);
fflush(stdout);
}
}
/*###### Field Selection/Ordering routines #############################*/
/*
* Display the current fields and their order.
* Upper case indicates a displayed field, display order is
* according to the order of the letters.
*
* A short description of each field is shown as well and is
* marked by a leading asterisk (*) if currently displayed.
*
* After all fields have been displayed, some extra explanatory
* text is then output */
static void display_fields (void)
{
const char *p, *x;
int i, cmax = Screen_cols / 2, rmax = Screen_rows - 3;
/* we're relying on our callers to first clear the screen --
thus 'fields_toggle' can avoid screen flicker since he's
too lazy to handle his own asterisk (*) logic */
putp(Cap_bold);
for (i = 0; i < MAXtbl(Fieldstab); ++i) {
/* advance past any leading spaces */
for (p = Fieldstab[i].head; ' ' == *p; ++p)
;
printf("%s%c %c: %-10s = %s"
, tg2((i / rmax) * cmax, (i % rmax) + 3)
, strchr(CurFields, i + 'A') ? '*' : ' '
, i + 'A'
, p
, Fieldstab[i].desc);
}
putp(Row_color_norm);
x = FIELDS_xtra;
while ((p = strchr(x, '\n'))) {
++i;
printf("%s%.*s"
, tg2((i / rmax) * cmax, (i % rmax) + 3)
, p - x, x);
x = ++p;
}
putp(Caps_off);
}
/*
* Change order of displayed fields. */
static void fields_reorder (void)
{
static char prompt[] =
"Upper case characters move field left, lower case right";
char c, *p;
int i;
printf("%s%s", Cap_clr_scr, Cap_curs_huge);
display_fields();
do {
show_special(fmtmk(FIELDS_current
, Cap_home, Myname, CurFields, prompt));
chin(0, &c, 1);
i = toupper(c) - 'A';
if (i < 0 || i >= MAXtbl(Fieldstab))
break;
if (((p = strchr(CurFields, i + 'A')))
|| ((p = strchr(CurFields, i + 'a')))) {
if (isupper(c)) p--;
if (('\0' != p[1]) && (p >= CurFields)) {
c = p[0];
p[0] = p[1];
p[1] = c;
}
}
} while (1);
putp(Cap_curs_norm);
mkheadings();
}
/*
* Toggle displayed fields. */
static void fields_toggle (void)
{
static char prompt[] =
"Toggle fields with a-x, type any other key to return";
char c, *p;
int i;
printf("%s%s", Cap_clr_scr, Cap_curs_huge);
do {
display_fields();
show_special(fmtmk(FIELDS_current
, Cap_home, Myname, CurFields, prompt));
chin(0, &c, 1);
i = toupper(c) - 'A';
if (i < 0 || i >= MAXtbl(Fieldstab))
break;
if ((p = strchr(CurFields, i + 'A')))
*p = i + 'a';
else if ((p = strchr(CurFields, i + 'a')))
*p = i + 'A';
} while (1);
putp(Cap_curs_norm);
mkheadings();
}
/*###### Library Alternatives ##########################################*/
/*
* Handle our own memory stuff without the risk of leaving the
* user's terminal in an ugly state should things go sour. */
static const char *alloc_msg = "Failed memory allocate (%d bytes)";
static void *alloc_c (unsigned numb)
{
void * p;
if (!numb) ++numb;
if (!(p = calloc(1, numb)))
std_err(fmtmk(alloc_msg, numb));
return p;
}
static void *alloc_r (void *q, unsigned numb)
{
void *p;
if (!numb) ++numb;
if (!(p = realloc(q, numb)))
std_err(fmtmk(alloc_msg, numb));
return p;
}
/*
* This guy is modeled on libproc's readproctab function except
* we reuse and extend any prior proc_t's. He's been customized
* for our specific needs and to avoid the use of <stdarg.h> */
static proc_t **readprocs (proc_t **tbl)
{
#define PTRsz sizeof(proc_t *) /* eyeball candy */
#define ENTsz sizeof(proc_t)
static int flags = PROC_FILLMEM | PROC_FILLCMD | PROC_FILLUSR
| PROC_FILLSTATUS | PROC_FILLSTAT;
static unsigned savmax = 0; /* first time, bypass: (i) */
proc_t *ptsk = (proc_t *)-1; /* first time, force: (ii) */
unsigned curmax = 0; /* every time */
PROCTAB* PT;
if (Monpidsidx) {
PT = openproc(flags | PROC_PID, Monpids);
/* work around a previous bug in openproc (now corrected) */
PT->procfs = NULL;
} else
PT = openproc(flags);
/* i) Allocated Chunks: *Existing* table; refresh + reuse */
while (curmax < savmax) {
if (tbl[curmax]->cmdline) {
free(*tbl[curmax]->cmdline);
tbl[curmax]->cmdline = NULL;
}
if (!(ptsk = readproc(PT, tbl[curmax]))) break;
++curmax;
}
/* ii) Unallocated Chunks: *New* or *Existing* table; extend + fill */
while (ptsk) {
/* realloc as we go, keeping 'tbl' ahead of 'currmax++' */
tbl = alloc_r(tbl, (curmax + 1) * PTRsz);
/* here, readproc will allocate the underlying proc_t stg */
if ((ptsk = readproc(PT, NULL)))
tbl[curmax++] = ptsk;
}
closeproc(PT);
/* iii) Chunkless: make 'eot' entry, after possible extension */
if (curmax >= savmax) {
tbl = alloc_r(tbl, (curmax + 1) * PTRsz);
/* here, we must allocate the underlying proc_t stg ourselves */
tbl[curmax] = alloc_c(ENTsz);
savmax = curmax + 1;
}
/* this frame's end, but not necessarily end of allocated space */
tbl[curmax]->pid = -1;
return tbl;
#undef PTRsz
#undef ENTsz
}
/*###### Main screen routines ##########################################*/
/*
* Process keyboard input during the main loop plus the three
* special immediate keys used with help processing.
* (thus making us only slightly recursive) */
static void do_key (unsigned c)
{
#define kbdCTRL_L 12
/* standardized 'secure mode' errors */
const char *smerror = "\aCan't %s in secure mode";
switch (c) {
case 'b':
if (!Show_hicols && !Show_hirows)
show_msg("\aNothing to highlight!");
else {
Show_hibold = !Show_hibold;
}
capsmk();
break;
case 'c':
Show_cmdlin = !Show_cmdlin;
break;
case 'C':
Sort_type = S_CMD;
Sort_func = (QSORT_t)sort_cmd;
break;
case 'E':
Sort_type = S_USR;
Sort_func = (QSORT_t)sort_usr;
break;
case 'f':
case 'F':
fields_toggle();
break;
case 'i':
Show_idleps = !Show_idleps;
break;
case 'I':
if (Cpu_tot > 1) {
Irix_mode = !Irix_mode;
show_msg(fmtmk("Irix mode %s", Irix_mode ? "On" : "Off"));
} else
show_msg("\aIrix mode requires SMP!");
break;
case 'k':
if (Secure_mode) {
show_msg(fmtmk(smerror, "kill"));
} else {
int sig, pid = get_int("PID to kill");
if (-1 != pid) {
#ifdef UGH_ITS_4_RH
sig = get_signal2(
#else
sig = signal_name_to_number(
#endif
ask_str(fmtmk("Kill PID %d with signal [%i]"
, pid, DEF_SIGNAL)));
if (-1 == sig) sig = DEF_SIGNAL;
if (sig && kill(pid, sig))
show_msg(fmtmk("\aKill of PID '%d' with '%d' failed: %s"
, pid, sig, strerror(errno)));
}
}
break;
case 'l':
HSum_loadav = !HSum_loadav;
mkheadings();
break;
case 'm':
HSum_memory = !HSum_memory;
mkheadings();
break;
case 'M':
Sort_type = S_MEM;
Sort_func = (QSORT_t)sort_mem;
break;
case 'n':
case '#':
{ int num;
if (-1 != (num = get_int("Processes to display (0 = unlimited)"))) {
Max_tasks = num;
window_resize(0);
}
}
break;
case 'o':
case 'O':
fields_reorder();
break;
case 'P':
Sort_type = S_PID;
Sort_func = (QSORT_t)sort_pid;
break;
case 'q':
stop(0);
case 'r':
if (Secure_mode)
show_msg(fmtmk(smerror, "renice"));
else {
int pid, val;
pid = get_int("PID to renice");
if (-1 == pid) break;
val = get_int(fmtmk("Renice PID %d to value", pid));
if (setpriority(PRIO_PROCESS, (unsigned)pid, val))
show_msg(fmtmk("\aRenice of PID %d to %d failed: %s"
, pid, val, strerror(errno)));
}
break;
case 'R':
Sort_normal = !Sort_normal;
break;
case 's':
case 'd':
if (Secure_mode)
show_msg(fmtmk(smerror, "change delay"));
else {
float tmp =
get_float(fmtmk("Change delay from %.1f to", Delay_time));
if (tmp > -1) Delay_time = tmp;
}
break;
case 'S':
Show_ctimes = !Show_ctimes;
show_msg(fmtmk("Cumulative time %s", Show_ctimes ? "On" : "Off"));
break;
case 't':
HSum_states = !HSum_states;
mkheadings();
break;
case 'T':
Sort_type = S_TME;
Sort_func = (QSORT_t)sort_tme;
break;
case 'u':
strcpy(ColUsername, ask_str("Which User (Blank for All)"));
#ifdef TRAK_MAXBUFS
MAXBUFS(do_key, ColUsername);
#endif
break;
case 'U':
Sort_type = S_CPU;
Sort_func = (QSORT_t)sort_cpu;
break;
case 'W':
{ FILE *fp = fopen(RCfile, "w");
if (fp) {
fprintf(fp, "%s\t\t# Fields displayed and ordering\n"
, CurFields);
fprintf(fp, "%s%s%s%s%s%s%s%s%s%s%s%s%s%c"
"\t\t\t\t# Misc options (spelled poorly)\n"
, Show_cmdlin ? "c" : "", Sort_normal ? "R" : ""
, HSum_loadav ? "l" : "", Show_hirows ? "y" : ""
, HSum_memory ? "m" : "", Show_hicols ? "x" : ""
, Show_idleps ? "i" : "", Show_ctimes ? "S" : ""
, Irix_mode ? "I" : "", HSum_states ? "t" : ""
, Show_hibold ? "b" : "", Show_colors ? "z" : ""
, Show_cpusum ? "1" : "", Sort_type);
fprintf(fp, "%d\t\t\t\t\t# Number of tasks shown\n"
, Max_tasks);
fprintf(fp, "%.1f\t\t\t\t\t# Delay between updates\n"
, Delay_time);
fprintf(fp, "%u,%u,%u\t\t\t\t\t# Base, Msgs & Head colors\n"
, Base_color, Msgs_color, Head_color);
fclose(fp);
show_msg(fmtmk("Wrote configuration to '%s'", RCfile));
} else
show_msg(fmtmk("\aFailed '%s' open: %s", RCfile, strerror(errno)));
}
break;
case 'x':
Show_hicols = !Show_hicols;
capsmk();
break;
case 'y':
Show_hirows = !Show_hirows;
capsmk();
break;
case 'Y':
Sort_type = S_TTY;
Sort_func = (QSORT_t)sort_tty;
break;
case 'z':
Show_colors = !Show_colors;
capsmk();
break;
case 'Z':
tweak_colors();
break;
case '?':
case 'h':
{ char ch;
printf("%s%s", Cap_clr_scr, Cap_curs_huge);
/* this string is well above ISO C89's minimum requirements! */
show_special(fmtmk(HELP_data
, Myname, procps_version
, Secure_mode ? "On" : "Off", Show_ctimes ? "On" : "Off", Delay_time
, Secure_mode ? "" : HELP_unsecured));
chin(0, &ch, 1);
putp(Cap_curs_norm);
/* our help screen currently provides for three 'immediate' keys,
two of which conflict with the main process display keys */
switch (ch) {
case 'j' :
strcpy(CurFields, JOB_FIELDS);
ch = 'T'; /* force sort on time */
break;
case 'm' :
strcpy(CurFields, MEM_FIELDS);
ch = 'M'; /* force sort on %mem/res */
break;
case 'u' :
strcpy(CurFields, USR_FIELDS);
ch = 'E'; /* force sort on user */
break;
default :
ch = 0;
}
if (ch) {
/* besides resetting the sort environment with the call to us
below, the 'Show_' manipulations will provide our most subtle
hint as to what the user has just wrought */
Show_hibold = Show_hicols = Sort_normal = 1;
capsmk();
mkheadings();
do_key((unsigned)ch);
}
}
break;
case ' ':
case kbdCTRL_L:
putp(Cap_clr_scr);
break;
case '1':
Show_cpusum = !Show_cpusum;
mkheadings();
break;
case '\n': /* just ignore it */
break;
default:
show_msg("\aUnknown command -- try 'h' for help");
}
#undef kbdCTRL_L
#undef smERROR
}
#ifdef UGH_ITS_4_RH
/*
* Obtain memory information and display it.
* Return the total memory available as a page count which is
* then used in % memory calc's. */
static unsigned frame_memory (void)
{
/* don't be mislead by the proc/sysinfo subscripts, they're just poorly
chosen names for enumerations apparently designed to make source
lines as imbalanced and as long as possible */
unsigned long long **memarray;
if (!(memarray = meminfo()))
std_err("Failed /proc/meminfo read");
if (HSum_memory) {
show_special(fmtmk(MEMORY_line1
, BYTES_2K(memarray[meminfo_main][meminfo_total])
, BYTES_2K(memarray[meminfo_main][meminfo_used])
, BYTES_2K(memarray[meminfo_main][meminfo_free])
, BYTES_2K(memarray[meminfo_main][meminfo_buffers])));
show_special(fmtmk(MEMORY_line2
, BYTES_2K(memarray[meminfo_swap][meminfo_total])
, BYTES_2K(memarray[meminfo_swap][meminfo_used])
, BYTES_2K(memarray[meminfo_swap][meminfo_free])
, BYTES_2K(memarray[meminfo_total][meminfo_cached])));
}
return PAGE_CNT(memarray[meminfo_main][meminfo_total]);
}
#else
/*
* Obtain memory information and display it. */
static void frame_memory (void)
{
meminfo();
if (HSum_memory) {
show_special(fmtmk(MEMORY_line1
, kb_main_total
, kb_main_used
, kb_main_free
, kb_main_buffers));
show_special(fmtmk(MEMORY_line2
, kb_swap_total
, kb_swap_used
, kb_swap_free
, kb_main_cached));
}
}
#endif /* end: UGH_ITS_4_RH */
/*
* State display *Helper* function to calc and display the state
* percentages for a single cpu. In this way, we can support
* the following environments without the usual code bloat.
* 1 - single cpu machines
* 2 - modest smp boxes with room for each cpu's percentages
* 3 - massive smp guys leaving little or no room for process
* display and thus requiring the Show_cpusum toggle */
static void frame_smp (FILE *fp, const char *fmt, CPUS_t *cpu, const char *pfx)
{
/* we'll trim to zero if we get negative time ticks,
which has happened with some SMP kernels (pre-2.4?) */
#define TRIMz(x) ((tz = (long)x) < 0 ? 0 : tz)
TICS_t u_tics, s_tics, n_tics, i_tics;
long u_frme, s_frme, n_frme, i_frme, tot_frme, tz;
if (4 != fscanf(fp, fmt, &u_tics, &n_tics, &s_tics, &i_tics))
std_err("Failed /proc/stat read");
u_frme = TRIMz(u_tics - cpu->u);
s_frme = TRIMz(s_tics - cpu->s);
n_frme = TRIMz(n_tics - cpu->n);
i_frme = TRIMz(i_tics - cpu->i);
tot_frme = u_frme + s_frme + n_frme + i_frme;
if (1 > tot_frme) tot_frme = 1;
/* display some kinda' cpu state percentages
(who or what is explained by the passed prefix) */
show_special(fmtmk(STATES_line2
, pfx
, (float)u_frme * 100 / tot_frme
, (float)s_frme * 100 / tot_frme
, (float)n_frme * 100 / tot_frme
, (float)i_frme * 100 / tot_frme));
/* remember for next time around */
cpu->u = u_tics;
cpu->s = s_tics;
cpu->n = n_tics;
cpu->i = i_tics;
#undef TRIMz
}
/*
* Calc the number of tasks in each state (run, sleep, etc)
* Calc percent cpu usage for each task (pcpu)
* Calc the cpu(s) percent in each state (user, system, nice, idle) */
static void frame_states (proc_t **p, int show)
{
static HIST_t *hist_sav = NULL;
static unsigned hist_siz;
static int hist_tot, showsav;
static CPUS_t *smpcpu;
HIST_t *hist_new;
unsigned total, running, sleeping, stopped, zombie;
float etime;
int i;
if (!hist_sav) {
hist_tot = 0;
/* room for 512 HIST_t's (if Page_size == 4k) */
hist_siz = (Page_size / sizeof(HIST_t));
hist_sav = alloc_c(hist_siz);
/* note: we allocate one more CPUS_t than Cpu_tot so that the last
slot can hold tics representing the /proc/stat cpu summary
(first line read) -- that slot supports Show_cpusum */
smpcpu = alloc_c((1 + Cpu_tot) * sizeof(CPUS_t));
showsav = Show_cpusum;
}
hist_new = alloc_c(hist_siz);
total = running = sleeping = stopped = zombie = 0;
etime = time_elapsed();
/* make a pass through the data to get stats */
while (-1 != p[total]->pid) {
TICS_t tics;
proc_t *this = p[total];
switch (this->state) {
case 'S':
case 'D':
sleeping++;
break;
case 'T':
stopped++;
break;
case 'Z':
zombie++;
break;
case 'R':
running++;
break;
}
if (total * sizeof(HIST_t) >= hist_siz) {
hist_siz += (Page_size / sizeof(HIST_t));
hist_sav = alloc_r(hist_sav, hist_siz);
hist_new = alloc_r(hist_new, hist_siz);
}
/* calculate time in this process; the sum of user time (utime)
+ system time (stime) -- but PLEASE dont waste time and effort
calculating and saving data that goes unused, like the old top! */
hist_new[total].pid = this->pid;
hist_new[total].tics = tics = (this->utime + this->stime);
/* find matching entry from previous pass and make ticks elapsed */
for (i = 0; i < hist_tot; i++) {
if (this->pid == hist_sav[i].pid) {
tics -= hist_sav[i].tics;
break;
}
}
/* finally calculate an integer version of %cpu for this task
and plug it into the unfilled slot in proc_t */
this->pcpu = (tics * 1000 / Hertz) / etime;
if (this->pcpu > 999) this->pcpu = 999;
/* if in Solaris mode, adjust cpu percentage not only for the cpu
the process is running on, but for all cpus together */
if (!Irix_mode) this->pcpu /= Cpu_tot;
total++;
} /* end: while 'p[total]->pid' */
if (show) {
FILE *fp;
/* whoa, we've changed modes -- gotta' clean old histories */
if (Show_cpusum != showsav) {
/* fresh start for the last slot in the history area */
if (Show_cpusum) memset(&smpcpu[Cpu_tot], '\0', sizeof(CPUS_t));
/* fresh start for the true smpcpu history area */
else memset(smpcpu, '\0', Cpu_tot * sizeof(CPUS_t));
showsav = Show_cpusum;
}
/* display Task states */
show_special(fmtmk(STATES_line1
, total, running, sleeping, stopped, zombie));
/* now arrange to calculate and display states for all Cpu's */
if (!(fp = fopen("/proc/stat", "r")))
std_err(fmtmk("Failed /proc/stat open: %s", strerror(errno)));
if (Show_cpusum)
/* retrieve and display just the 1st /proc/stat line */
frame_smp(fp, CPU_FMTS_JUST1, &smpcpu[Cpu_tot], "Cpu(s) state:");
else {
char tmp[SMLBUFSIZ];
/* skip the 1st line, which reflects total cpu states */
if (!fgets(tmp, sizeof(tmp), fp))
std_err("Failed /proc/stat read");
#ifdef TRAK_MAXBUFS
MAXBUFS(frame_states, tmp);
#endif
/* now do each cpu's states separately */
for (i = 0; i < Cpu_tot; i++) {
sprintf(tmp, "%-6scpu%-2d:" /* [ cpu states as ] */
, i ? " " : "State" /* 'State cpu0 : ... ' */
, Irix_mode ? i : Cpu_map[i]); /* ' cpu1 : ... ' */
frame_smp(fp, CPU_FMTS_MULTI, &smpcpu[i], tmp);
}
}
fclose(fp);
} /* end: if 'show' */
/* save this frame's information */
hist_tot = total;
memcpy(hist_sav, hist_new, hist_siz);
free(hist_new);
/* finally, sort the processes on whatever... */
qsort(p, total, sizeof(proc_t *), (QSORT_t)Sort_func);
}
/*
* Task display *Helper* function to handle highlighted
* column transitions. */
static void mkcol (unsigned idx, int sta, int *pad, char *buf, ...)
{
char tmp[COLBUFSIZ];
va_list va;
va_start(va, buf);
if (!Show_hicols || Sort_type != Fieldstab[idx].sort) {
vsprintf(buf, Fieldstab[idx].fmts, va);
} else {
vsprintf(tmp, Fieldstab[idx].fmts, va);
sprintf(buf, "%s%s", Row_color_high, tmp);
*pad += Len_row_high;
if (!Show_hirows || 'R' != sta) {
strcat(buf, Row_color_norm);
*pad += Len_row_norm;
}
}
va_end(va);
#ifdef TRAK_MAXBUFS
MAXBUFS(mkcol, tmp);
#endif
}
/*
* Displays information for a single task. */
#ifdef UGH_ITS_4_RH
static void show_a_task (proc_t *task, unsigned mempgs)
#else
static void show_a_task (proc_t *task)
#endif
{
/* the following macro is used for those columns that are NOT sortable
so as to avoid the function call overhead since mkcol cannot be made
inline -- if additional sort columns are added, change the appropriate
switch label's usage to lower case and thus invoke the real function */
#define MKCOL(idx,sta,pad,buf,arg) \
sprintf(buf, Fieldstab[idx].fmts, arg)
char rbuf[ROWBUFSIZ];
int i, x, pad;
pad = 0;
rbuf[0] = '\0';
for (i = 0; i < NumFields; i++) {
char cbuf[COLBUFSIZ];
unsigned f, s, w;
cbuf[0] = '\0';
f = PFlags[i];
s = Fieldstab[f].scale;
w = Fieldstab[f].width;
switch (f) {
case P_CMD:
{ char *cmdptr, cmdnam[ROWBUFSIZ];
if (Show_cmdlin) {
cmdnam[0] = '\0';
if (task->cmdline) {
x = 0;
do {
/* whoa, during a kernel build, parts of the make
process will create cmdlines in excess of 3000 bytes
but *without* the typical intervening nulls */
strcat(cmdnam
, fmtmk("%.*s ", Max_cmd, task->cmdline[x++]));
/* whoa, gnome's xscreensaver had a ^I in his cmdline
creating a line wrap when the window was maximized &
the tab came into view -- that in turn, whacked
our heading lines so we'll strim those !#@*#!... */
strim(1, cmdnam);
/* enough, don't ya think? */
if (Max_cmd < (int)strlen(cmdnam))
break;
} while (task->cmdline[x]);
} else {
/* if this process really doesn't have a cmdline, we'll
consider it a kernel thread and display it uniquely
[ we need sort_cmd's complicity in this plot ] */
strcpy(cmdnam, fmtmk("( %s )", task->cmd));
}
cmdptr = cmdnam;
} else
cmdptr = task->cmd;
/* hurry up, before cmdptr goes out of scope... */
mkcol(f, task->state, &pad, cbuf, Max_cmd, Max_cmd, cmdptr);
}
break;
case P_CODE:
MKCOL(f, task->state, &pad, cbuf
, scale_num(PAGES_2K(task->trs), w, s));
break;
case P_CPU:
mkcol(f, task->state, &pad, cbuf, (float)task->pcpu / 10);
break;
case P_DATA:
MKCOL(f, task->state, &pad, cbuf
, scale_num(PAGES_2K(task->drs), w, s));
break;
case P_DIRTY:
MKCOL(f, task->state, &pad, cbuf
, scale_num((unsigned)task->dt, w, s));
break;
case P_FAULT:
MKCOL(f, task->state, &pad, cbuf
, scale_num(task->maj_flt, w, s));
break;
case P_FLAGS:
MKCOL(f, task->state, &pad, cbuf, task->flags);
for (x = 0; x < (int)strlen(cbuf); x++)
if ('0' == cbuf[x]) cbuf[x] = '.';
break;
case P_GROUP:
MKCOL(f, task->state, &pad, cbuf, task->egroup);
break;
case P_MEM:
mkcol(f, task->state, &pad, cbuf
#ifdef UGH_ITS_4_RH
, (float)task->resident * 100 / mempgs);
#else
, (float)PAGES_2K(task->resident) * 100 / kb_main_total);
#endif
break;
case P_NCPU:
#ifdef UGH_ITS_4_RH
MKCOL(f, task->state, &pad, cbuf, task->lproc);
#else
MKCOL(f, task->state, &pad, cbuf, task->processor);
#endif
break;
case P_NI:
MKCOL(f, task->state, &pad, cbuf, task->nice);
break;
case P_PID:
mkcol(f, task->state, &pad, cbuf, task->pid);
break;
case P_PPID:
MKCOL(f, task->state, &pad, cbuf, task->ppid);
break;
case P_PR:
MKCOL(f, task->state, &pad, cbuf, task->priority);
break;
case P_RES:
/* 'rss' vs 'resident' (which includes IO memory) ?
-- we'll ensure that VIRT = SWAP + RES */
mkcol(f, task->state, &pad, cbuf
, scale_num(PAGES_2K(task->resident), w, s));
break;
case P_SHR:
MKCOL(f, task->state, &pad, cbuf
, scale_num(PAGES_2K(task->share), w, s));
break;
case P_STA:
MKCOL(f, task->state, &pad, cbuf, status(task));
break;
case P_SWAP:
MKCOL(f, task->state, &pad, cbuf
, scale_num(PAGES_2K(task->size - task->resident), w, s));
break;
case P_TIME:
case P_TIME2:
{ TICS_t t;
t = task->utime + task->stime;
if (Show_ctimes)
t += (task->cutime + task->cstime);
mkcol(f, task->state, &pad, cbuf, scale_tics(t, w));
}
break;
case P_TTY:
{ char tmp[TNYBUFSIZ];
dev_to_tty(tmp, Fieldstab[f].width
, task->tty, task->pid, ABBREV_DEV);
mkcol(f, task->state, &pad, cbuf, tmp);
}
break;
case P_UID:
MKCOL(f, task->state, &pad, cbuf, task->euid);
break;
case P_USER:
mkcol(f, task->state, &pad, cbuf, task->euser);
break;
case P_VIRT:
MKCOL(f, task->state, &pad, cbuf
, scale_num(PAGES_2K(task->size), w, s));
break;
case P_WCHAN:
if (No_ksyms)
#ifdef UPCASE_HEXES
MKCOL(f, task->state, &pad, cbuf
, fmtmk("x%08lX", (long)task->wchan));
#else
MKCOL(f, task->state, &pad, cbuf
, fmtmk("x%08lx", (long)task->wchan));
#endif
else
MKCOL(f, task->state, &pad, cbuf, wchan(task->wchan));
break;
} /* end: switch 'PFlags[i]' */
#ifdef TRAK_MAXBUFS
MAXBUFS(show_a_task, cbuf);
#endif
strcat(rbuf, cbuf);
} /* end: for 'NumFields' */
#ifdef TRAK_MAXBUFS
MAXBUFS(show_a_task, rbuf);
#endif
/* This row buffer could be stuffed with parameterized strings.
We are thus advised to always use tputs/putp, but it works just
fine with good ol' printf... */
printf("\n%s%.*s%s%s"
, (Show_hirows && 'R' == task->state) ? Row_color_high : Row_color_norm
, Screen_cols + pad
, rbuf
, Caps_off
, Cap_clr_eol);
#ifdef TRAK_MAXCAPS
if (pad > Max_pads) Max_pads = pad;
if (pad < Min_pads) Min_pads = pad;
/* now that we have TRAK_MAXBUFS, the next two duplicate some effort */
if ((int)strlen(rbuf) > Max_rbuf) Max_rbuf = (int)strlen(rbuf);
if ((int)strlen(rbuf) < Min_rbuf) Min_rbuf = (int)strlen(rbuf);
#endif
#undef MKCOL
}
/*
* Read all process info and display it. */
static void show_everything (void)
{
static proc_t **p_table = NULL;
int ntask, nline;
#ifdef UGH_ITS_4_RH
unsigned mempgs;
#endif
if (!p_table) {
p_table = readprocs(p_table);
frame_states(p_table, 0);
sleep(1);
} else
putp(Batch ? "\n" : Cap_home);
/*
** Display Load averages */
if (HSum_loadav)
show_special(fmtmk(LOADAV_line, Myname, sprint_uptime()));
/*
** Display System stats (also calc 'pcpu' and sort p_table) */
p_table = readprocs(p_table);
frame_states(p_table, HSum_states);
/*
** Display Memory and Swap space usage */
#ifdef UGH_ITS_4_RH
mempgs = frame_memory();
#else
frame_memory();
#endif
/*
** Display Headings for columns */
printf("%s%s%s%s%s"
, tg2(0, MSG_line + 1)
, Hdr_color
, ColHeadings
, Caps_off
, Cap_clr_eol);
/* Finally! Loop through to find each task, and display it ...
... lather, rinse, repeat */
ntask = nline = 0;
while (-1 != p_table[ntask]->pid && nline < Max_lines) {
if ((Show_idleps
|| ('S' != p_table[ntask]->state && 'Z' != p_table[ntask]->state))
&& ((!ColUsername[0])
|| (!strcmp(ColUsername, p_table[ntask]->euser)) ) ) {
/*
** Display a process Row */
#ifdef UGH_ITS_4_RH
show_a_task(p_table[ntask], mempgs);
#else
show_a_task(p_table[ntask]);
#endif
if (!Batch) ++nline;
}
++ntask;
}
printf("%s%s%s", Cap_clr_eos, tg2(0, MSG_line), Cap_clr_eol);
fflush(stdout);
}
/*###### Entry point ###################################################*/
int main (int dont_care_argc, char **argv)
{
char not_really_tmp[OURPATHSZ];
int i;
/* setup our program name(s)... */
Myname = strrchr(argv[0], '/');
if (Myname) ++Myname; else Myname = argv[0];
Myrealname = Myname;
memset(not_really_tmp, '\0', sizeof(not_really_tmp));
/* proper permissions should deny symlinks to /usr/bin for ordinary
users, but root may have employed them -- Myrealname will be used
in constructing the global rc filename ... */
if (-1 != readlink(argv[0], not_really_tmp, sizeof(not_really_tmp) - 1)) {
Myrealname = strrchr(not_really_tmp, '/');
if (Myrealname) ++Myrealname; else Myrealname = not_really_tmp;
#ifdef TRAK_MAXBUFS
MAXBUFS(main, not_really_tmp);
#endif
}
/* setup some important system stuff... */
Page_size = getpagesize();
Cpu_tot = sysconf(_SC_NPROCESSORS_ONLN);
if (1 > Cpu_tot) Cpu_tot = 1;
Cpu_map = alloc_r(NULL, sizeof(int) * Cpu_tot);
for (i = 0; i < Cpu_tot; i++)
Cpu_map[i] = i;
rcfiles_read();
parse_argvs(argv);
terminal_set();
window_resize(0);
/* set up signal handlers */
signal(SIGALRM, stop);
signal(SIGHUP, stop);
signal(SIGINT, stop);
signal(SIGPIPE, stop);
signal(SIGQUIT, stop);
signal(SIGTERM, stop);
signal(SIGTSTP, suspend);
signal(SIGTTIN, suspend);
signal(SIGTTOU, suspend);
signal(SIGCONT, window_resize);
signal(SIGWINCH, window_resize);
/* loop, collecting process info and sleeping */
do {
struct timeval tv;
fd_set fs;
char c;
show_everything();
if (Msg_awaiting) show_msg(Msg_delayed);
if (0 < Loops) --Loops;
if (!Loops) stop(0);
if (Batch)
sleep((unsigned)Delay_time);
else {
/* Linux reports time not slept, so we must reinit every time */
tv.tv_sec = Delay_time;
tv.tv_usec = (Delay_time - (int)Delay_time) * 1000000;
FD_ZERO(&fs);
FD_SET(STDIN_FILENO, &fs);
if (0 < select(STDIN_FILENO+1, &fs, NULL, NULL, &tv)
&& 0 < chin(0, &c, 1))
do_key((unsigned)c);
}
} while (1);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink