/*
* lmon.c -- Curses based Performance Monitor for Linux
* Developer: Nigel Griffiths.
*/
/*
* Use the following Makefile (for Linux on POWER)
CFLAGS=-g -D JFS -D GETUSER -Wall -D LARGEMEM -D POWER
LDFLAGS=-lcurses
nmon: lnmon.o
* end of Makefile
*/
/* #define POWER 1 */
/* #define KERNEL_2_6_18 1 */
/* This adds the following to the disk stats
pi_num_threads,
pi_rt_priority,
pi_policy,
pi_delayacct_blkio_ticks
*/
#define RAW(member) (long)((long)(p->cpuN[i].member) - (long)(q->cpuN[i].member))
#define RAWTOTAL(member) (long)((long)(p->cpu_total.member) - (long)(q->cpu_total.member))
#define VERSION "14g"
char version[] = VERSION;
static char *SccsId = "nmon " VERSION;
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <ncurses.h>
#include <signal.h>
#include <pwd.h>
#include <fcntl.h>
#include <math.h>
#include <time.h>
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/wait.h>
/* for Disk Busy rain style output covering 100's of diskss on one screen */
const char disk_busy_map_ch[] =
"_____.....----------++++++++++oooooooooo0000000000OOOOOOOOOO8888888888XXXXXXXXXX##########@@@@@@@@@@*";
/*"00000555551111111111222222222233333333334444444444555555555566666666667777777777888888888899999999991"*/
int extended_disk = 0; /* report additional data from /proc/diskstats to spreadsheet output */
#define FLIP(variable) if(variable) variable=0; else variable=1;
#ifdef MALLOC_DEBUG
#define MALLOC(argument) mymalloc(argument,__LINE__)
#define FREE(argument) myfree(argument,__LINE__)
#define REALLOC(argument1,argument2) myrealloc(argument1,argument2,__LINE__)
void *mymalloc(int size, int line)
{
void * ptr;
ptr= malloc(size);
fprintf(stderr,"0x%x = malloc(%d) at line=%d\n",ptr,size,line);
return ptr;
}
void myfree(void *ptr,int line)
{
fprintf(stderr,"free(0x%x) at line=%d\n",ptr,line);
free(ptr);
}
void *myrealloc(void *oldptr, int size, int line)
{
void * ptr;
ptr= realloc(oldptr,size);
fprintf(stderr,"0x%x = realloc(0x%x, %d) at line=%d\n",ptr,oldptr,size,line);
return ptr;
}
#else
#define MALLOC(argument) malloc(argument)
#define FREE(argument) free(argument)
#define REALLOC(argument1,argument2) realloc(argument1,argument2)
#endif /* MALLOC STUFF */
#define P_CPUINFO 0
#define P_STAT 1
#define P_VERSION 2
#define P_MEMINFO 3
#define P_UPTIME 4
#define P_LOADAVG 5
#define P_NFS 6
#define P_NFSD 7
#define P_VMSTAT 8 /* new in 13h */
#define P_NUMBER 9 /* one more than the max */
char *month[12] = { "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
"JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
/* Cut of everything after the first space in callback
* Delete any '&' just before the space
*/
char *check_call_string (char* callback, const char* name)
{
char * tmp_ptr = callback;
if (strlen(callback) > 256) {
fprintf(stderr,"ERROR nmon: ignoring %s - too long\n", name);
return (char *) NULL;
}
for( ; *tmp_ptr != '\0' && *tmp_ptr != ' ' && *tmp_ptr != '&'; ++tmp_ptr )
;
*tmp_ptr = '\0';
if( tmp_ptr == callback )
return (char *)NULL;
else
return callback;
}
/* Remove error output to this buffer and display it if NMONDEBUG=1 */
char errorstr[70];
int error_on = 0;
void error(char *err)
{
strncpy(errorstr,err,69);
}
/* Default size for smaller files */
#define PROC_MAXBUF (1024*4)
/* /proc/stat size for 50-ish bytes per CPU */
#define STAT_MAXBUF (1024*64)
/* /proc/cpuinfo can be 512 bytes per CPU and we allow 256 CPUs */
/* and 20 lines per CPU so boost the buffers for this one */
#define CPUINFO_MAXBUF (512*256)
#define PROC_MAXLINES (20*256*sizeof(char *))
int proc_cpu_done = 0; /* Flag if we have run function proc_cpu() already in this interval */
int reread =0;
struct {
FILE *fp;
char *filename;
int lines;
char *line[PROC_MAXLINES];
char *buf;
int read_this_interval; /* track updates for each update to stop double data collection */
} proc[P_NUMBER];
void proc_init()
{
int i;
/* Initialise the file pointers */
for(i=0;i<P_NUMBER;i++) {
proc[i].fp = 0;
proc[i].read_this_interval = 0;
if(i == P_CPUINFO)
proc[i].buf = (char *)malloc(CPUINFO_MAXBUF);
else if(i == P_STAT)
proc[i].buf = (char *)malloc(STAT_MAXBUF);
else
proc[i].buf = (char *)malloc(PROC_MAXBUF);
}
proc[P_CPUINFO].filename = "/proc/cpuinfo";
proc[P_STAT].filename = "/proc/stat";
proc[P_VERSION].filename = "/proc/version";
proc[P_MEMINFO].filename = "/proc/meminfo";
proc[P_UPTIME].filename = "/proc/uptime";
proc[P_LOADAVG].filename = "/proc/loadavg";
proc[P_NFS].filename = "/proc/net/rpc/nfs";
proc[P_NFSD].filename = "/proc/net/rpc/nfsd";
proc[P_VMSTAT].filename = "/proc/vmstat";
}
void proc_read(int num)
{
int i;
int size;
int found;
char buf[1024];
int bytes;
if(proc[num].read_this_interval == 1 )
return;
if(proc[num].fp == 0) {
if( (proc[num].fp = fopen(proc[num].filename,"r")) == NULL) {
sprintf(buf, "failed to open file %s", proc[num].filename);
error(buf);
proc[num].fp = 0;
return;
}
}
rewind(proc[num].fp);
/* We re-read P_STAT, now flag proc_cpu() that it has to re-process that data */
if( num == P_STAT)
proc_cpu_done = 0;
if(num == P_CPUINFO)
bytes = CPUINFO_MAXBUF -1;
else if(num == P_STAT)
bytes = STAT_MAXBUF -1;
else
bytes = PROC_MAXBUF -1;
size = fread(proc[num].buf, 1, bytes, proc[num].fp);
proc[num].buf[size]=0;
proc[num].lines=0;
proc[num].line[0]=&proc[num].buf[0];
if(num == P_VERSION) {
found=0;
for(i=0;i<size;i++) { /* remove some weird stuff found the hard way in various Linux versions and device drivers */
/* place ") (" on two lines */
if( found== 0 &&
proc[num].buf[i] == ')' &&
proc[num].buf[i+1] == ' ' &&
proc[num].buf[i+2] == '(' ) {
proc[num].buf[i+1] = '\n';
found=1;
} else {
/* place ") #" on two lines */
if( proc[num].buf[i] == ')' &&
proc[num].buf[i+1] == ' ' &&
proc[num].buf[i+2] == '#' ) {
proc[num].buf[i+1] = '\n';
}
/* place "#1" on two lines */
if(
proc[num].buf[i] == '#' &&
proc[num].buf[i+2] == '1' ) {
proc[num].buf[i] = '\n';
}
}
}
}
for(i=0;i<size;i++) {
/* replace Tab characters with space */
if(proc[num].buf[i] == '\t') {
proc[num].buf[i]= ' ';
}
else if(proc[num].buf[i] == '\n') {
/* replace newline characters with null */
proc[num].lines++;
proc[num].buf[i] = '\0';
proc[num].line[proc[num].lines] = &proc[num].buf[i+1];
}
if(proc[num].lines==PROC_MAXLINES-1)
break;
}
if(reread) {
fclose( proc[num].fp);
proc[num].fp = 0;
}
/* Set flag so we do not re-read the data even if called multiple times in same interval */
proc[num].read_this_interval = 1;
}
#include <dirent.h>
struct procsinfo {
int pi_pid;
char pi_comm[64];
char pi_state;
int pi_ppid;
int pi_pgrp;
int pi_session;
int pi_tty_nr;
int pi_tty_pgrp;
unsigned long pi_flags;
unsigned long pi_minflt;
unsigned long pi_cmin_flt;
unsigned long pi_majflt;
unsigned long pi_cmaj_flt;
unsigned long pi_utime;
unsigned long pi_stime;
long pi_cutime;
long pi_cstime;
long pi_pri;
long pi_nice;
#ifndef KERNEL_2_6_18
long junk /* removed */;
#else
long pi_num_threads;
#endif
long pi_it_real_value;
unsigned long pi_start_time;
unsigned long pi_vsize;
long pi_rss; /* - 3 */
unsigned long pi_rlim_cur;
unsigned long pi_start_code;
unsigned long pi_end_code;
unsigned long pi_start_stack;
unsigned long pi_esp;
unsigned long pi_eip;
/* The signal information here is obsolete. */
unsigned long pi_pending_signal;
unsigned long pi_blocked_sig;
unsigned long pi_sigign;
unsigned long pi_sigcatch;
unsigned long pi_wchan;
unsigned long pi_nswap;
unsigned long pi_cnswap;
int pi_exit_signal;
int pi_cpu;
#ifdef KERNEL_2_6_18
unsigned long pi_rt_priority;
unsigned long pi_policy;
unsigned long long pi_delayacct_blkio_ticks;
#endif
unsigned long statm_size; /* total program size */
unsigned long statm_resident; /* resident set size */
unsigned long statm_share; /* shared pages */
unsigned long statm_trs; /* text (code) */
unsigned long statm_drs; /* data/stack */
unsigned long statm_lrs; /* library */
unsigned long statm_dt; /* dirty pages */
};
#include <mntent.h>
#include <fstab.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#include <net/if.h>
int debug =0;
time_t timer; /* used to work out the hour/min/second */
/* Counts of resources */
int cpus = 1; /* number of CPUs in system (lets hope its more than zero!) */
int old_cpus = 1; /* Number of CPU seen in previuos interval */
int max_cpus = 1; /* highest number of CPUs in DLPAR */
int networks = 0; /* number of networks in system */
int partitions = 0; /* number of partitions in system */
int partitions_short = 0; /* partitions file data short form (i.e. data missing) */
int disks = 0; /* number of disks in system */
int seconds = -1; /* pause interval */
int maxloops = -1; /* stop after this number of updates */
char hostname[256];
char run_name[256];
int run_name_set = 0;
char fullhostname[256];
int loop;
#define DPL 150 /* Disks per line for file output to ensure it
does not overflow the spreadsheet input line max */
int disks_per_line = DPL;
#define NEWDISKGROUP(disk) ( (disk) % disks_per_line == 0)
/* Mode of output variables */
int show_aaa = 1;
int show_para = 1;
int show_headings= 1;
int show_cpu = 0;
int show_smp = 0;
int show_longterm= 0;
int show_disk = 0;
#define SHOW_DISK_NONE 0
#define SHOW_DISK_STATS 1
#define SHOW_DISK_GRAPH 2
int show_diskmap = 0;
int show_memory = 0;
int show_large = 0;
int show_kernel = 0;
int show_nfs = 0;
int show_net = 0;
int show_neterror= 0;
int show_partitions = 0;
int show_help = 0;
int show_top = 0;
int show_topmode = 1;
#define ARGS_NONE 0
#define ARGS_ONLY 1
int show_args = 0;
int show_all = 1; /* 1=all procs& disk 0=only if 1% or more busy */
int show_verbose = 0;
int show_jfs = 0;
int flash_on = 0;
int first_huge = 1;
long huge_peak = 0;
int welcome = 1;
int dotline = 0;
int show_rrd = 0;
int show_lpar = 0;
int show_vm = 0;
int show_dgroup = 0; /* disk groups */
int dgroup_loaded = 0; /* 0 = no, 1=needed, 2=loaded */
int show_raw = 0;
#define RRD if(show_rrd)
double ignore_procdisk_threshold = 0.1;
double ignore_io_threshold = 0.1;
/* Curses support */
#define CURSE if(cursed) /* Only use this for single line curses calls */
#define COLOUR if(colour) /* Only use this for single line colour curses calls */
int cursed = 1; /* 1 = using curses and
0 = loging output for a spreadsheet */
int colour = 1; /* 1 = using colour curses and
0 = using black and white curses (see -b flag) */
#define MVPRINTW(row,col,string) {move((row),(col)); \
attron(A_STANDOUT); \
printw(string); \
attroff(A_STANDOUT); }
FILE *fp; /* filepointer for spreadsheet output */
char *timestamp(int loop, time_t eon)
{
static char string[64];
if(show_rrd)
sprintf(string,"%ld",(long)eon);
else
sprintf(string,"T%04d",loop);
return string;
}
#define LOOP timestamp(loop,timer)
char *easy[5] = {"not found",0,0,0,0};
char *lsb_release[5] = {"not found",0,0,0,0};
void find_release()
{
FILE *pop;
int i;
char tmpstr[71];
pop = popen("cat /etc/*ease 2>/dev/null", "r");
if(pop != NULL) {
tmpstr[0]=0;
for(i=0;i<4;i++) {
if(fgets(tmpstr, 70, pop) == NULL)
break;
tmpstr[strlen(tmpstr)-1]=0; /* remove newline */
easy[i] = malloc(strlen(tmpstr)+1);
strcpy(easy[i],tmpstr);
}
pclose(pop);
}
pop = popen("/usr/bin/lsb_release -idrc 2>/dev/null", "r");
if(pop != NULL) {
tmpstr[0]=0;
for(i=0;i<4;i++) {
if(fgets(tmpstr, 70, pop) == NULL)
break;
tmpstr[strlen(tmpstr)-1]=0; /* remove newline */
lsb_release[i] = malloc(strlen(tmpstr)+1);
strcpy(lsb_release[i],tmpstr);
}
pclose(pop);
}
}
/* Full Args Mode stuff here */
#define ARGSMAX 1024*8
#define CMDLEN 4096
struct {
int pid;
char *args;
} arglist[ARGSMAX];
void args_output(int pid, int loop, char *progname)
{
FILE *pop;
int i,j,n;
char tmpstr[CMDLEN];
static int arg_first_time = 1;
if(pid == 0)
return; /* ignore init */
for(i=0;i<ARGSMAX-1;i++ ) { /* clear data out */
if(arglist[i].pid == pid){
return;
}
if(arglist[i].pid == 0) /* got to empty slot */
break;
}
sprintf(tmpstr,"ps -p %d -o args 2>/dev/null", pid);
pop = popen(tmpstr, "r");
if(pop == NULL) {
return;
} else {
if(fgets(tmpstr, CMDLEN, pop) == NULL) { /* throw away header */
pclose(pop);
return;
}
tmpstr[0]=0;
if(fgets(tmpstr, CMDLEN, pop) == NULL) {
pclose(pop);
return;
}
tmpstr[strlen(tmpstr)-1]=0;
if(tmpstr[strlen(tmpstr)-1]== ' ')
tmpstr[strlen(tmpstr)-1]=0;
arglist[i].pid = pid;
if(arg_first_time) {
fprintf(fp,"UARG,+Time,PID,ProgName,FullCommand\n");
arg_first_time = 0;
}
n=strlen(tmpstr);
for(i=0;i<n;i++) {
/*strip out stuff that confused Excel i.e. starting with maths symbol*/
if(tmpstr[i] == ',' &&
((tmpstr[i+1] == '-') || tmpstr[i+1] == '+') )
tmpstr[i+1] = '_';
/*strip out double spaces */
if(tmpstr[i] == ' ' && tmpstr[i+1] == ' ') {
for(j=0;j<n-i;j++)
tmpstr[i+j]=tmpstr[i+j+1];
i--; /* rescan to remove triple space etc */
}
}
fprintf(fp,"UARG,%s,%07d,%s,%s\n",LOOP,pid,progname,tmpstr);
pclose(pop);
return;
}
}
void args_load()
{
FILE *pop;
int i;
char tmpstr[CMDLEN];
for(i=0;i<ARGSMAX;i++ ) { /* clear data out */
if(arglist[i].pid == -1)
break;
if(arglist[i].pid != 0){
arglist[i].pid = -1;
free(arglist[i].args);
}
}
pop = popen("ps -eo pid,args 2>/dev/null", "r");
if(pop == NULL) {
return;
} else {
if(fgets(tmpstr, CMDLEN, pop) == NULL) { /* throw away header */
pclose(pop);
return;
}
for(i=0;i<ARGSMAX;i++ ) {
tmpstr[0]=0;
if(fgets(tmpstr, CMDLEN, pop) == NULL) {
pclose(pop);
return;
}
tmpstr[strlen(tmpstr)-1]=0;
if(tmpstr[strlen(tmpstr)-1]== ' ')
tmpstr[strlen(tmpstr)-1]=0;
arglist[i].pid = atoi(tmpstr);
arglist[i].args = malloc(strlen(tmpstr));
strcpy(arglist[i].args,&tmpstr[6]);
}
pclose(pop);
}
}
char *args_lookup(int pid, char *progname)
{
int i;
for(i=0;i<ARGSMAX;i++) {
if(arglist[i].pid == pid)
return arglist[i].args;
if(arglist[i].pid == -1)
return progname;
}
return progname;
}
/* end args mode stuff here */
void linux_bbbp(char *name, char *cmd, char *err)
{
int i;
int len;
#define STRLEN 4096
char str[STRLEN];
FILE * pop;
static int lineno = 0;
pop = popen(cmd, "r");
if (pop == NULL) {
fprintf(fp, "BBBP,%03d,%s failed to run %s\n", lineno++, cmd, err);
} else {
fprintf(fp, "BBBP,%03d,%s\n", lineno++, name);
for (i = 0; i < 2048 && (fgets(str, STRLEN, pop) != NULL); i++) { /* 2048=sanity check only */
len = strlen(str);
if(len>STRLEN) len=STRLEN;
if (str[len-1] == '\n') /*strip off the newline */
str[len-1] = 0;
/* fix lsconf style output so it does not confuse spread sheets */
if(str[0] == '+') str[0]='p';
if(str[0] == '*') str[0]='m';
if(str[0] == '-') str[0]='n';
if(str[0] == '/') str[0]='d';
if(str[0] == '=') str[0]='e';
fprintf(fp, "BBBP,%03d,%s,\"%s\"\n", lineno++, name, str);
}
pclose(pop);
}
}
#define WARNING "needs root permission or file not present"
/* Global name of programme for printing it */
char *progname;
/* Main data structure for collected stats.
* Two versions are previous and current data.
* Often its the difference that is printed.
* The pointers are swaped i.e. current becomes the previous
* and the previous over written rather than moving data around.
*/
struct cpu_stat {
long long user;
long long sys;
long long wait;
long long idle;
long long irq;
long long softirq;
long long steal;
long long nice;
long long intr;
long long ctxt;
long long btime;
long long procs;
long long running;
long long blocked;
float uptime;
float idletime;
float mins1;
float mins5;
float mins15;
};
#define ulong unsigned long
struct dsk_stat {
char dk_name[32];
int dk_major;
int dk_minor;
long dk_noinfo;
ulong dk_reads;
ulong dk_rmerge;
ulong dk_rmsec;
ulong dk_rkb;
ulong dk_writes;
ulong dk_wmerge;
ulong dk_wmsec;
ulong dk_wkb;
ulong dk_xfers;
ulong dk_bsize;
ulong dk_time;
ulong dk_inflight;
ulong dk_11;
ulong dk_partition;
ulong dk_blocks; /* in /proc/partitions only */
ulong dk_use;
ulong dk_aveq;
};
struct mem_stat {
long memtotal;
long memfree;
long memshared;
long buffers;
long cached;
long swapcached;
long active;
long inactive;
long hightotal;
long highfree;
long lowtotal;
long lowfree;
long swaptotal;
long swapfree;
#ifdef LARGEMEM
long dirty;
long writeback;
long mapped;
long slab;
long committed_as;
long pagetables;
long hugetotal;
long hugefree;
long hugesize;
#else
long bigfree;
#endif /*LARGEMEM*/
};
struct vm_stat {
long long nr_dirty;
long long nr_writeback;
long long nr_unstable;
long long nr_page_table_pages;
long long nr_mapped;
long long nr_slab;
long long pgpgin;
long long pgpgout;
long long pswpin;
long long pswpout;
long long pgalloc_high;
long long pgalloc_normal;
long long pgalloc_dma;
long long pgfree;
long long pgactivate;
long long pgdeactivate;
long long pgfault;
long long pgmajfault;
long long pgrefill_high;
long long pgrefill_normal;
long long pgrefill_dma;
long long pgsteal_high;
long long pgsteal_normal;
long long pgsteal_dma;
long long pgscan_kswapd_high;
long long pgscan_kswapd_normal;
long long pgscan_kswapd_dma;
long long pgscan_direct_high;
long long pgscan_direct_normal;
long long pgscan_direct_dma;
long long pginodesteal;
long long slabs_scanned;
long long kswapd_steal;
long long kswapd_inodesteal;
long long pageoutrun;
long long allocstall;
long long pgrotated;
};
char *nfs_v2_names[18] = {
"null", "getattr", "setattr", "root", "lookup", "readlink",
"read", "wrcache", "write", "create", "remove", "rename",
"link", "symlink", "mkdir", "rmdir", "readdir", "fsstat"};
char *nfs_v3_names[22] ={
"null", "getattr", "setattr", "lookup", "access", "readlink",
"read", "write", "create", "mkdir", "symlink", "mknod",
"remove", "rmdir", "rename", "link", "readdir", "readdirplus",
"fsstat", "fsinfo", "pathconf", "commit"};
char *nfs_v4s_names[40] = {
"op0-unused", "op1-unused", "op2-future", "access", "close", "commit",
"create", "delegpurge", "delegreturn", "getattr", "getfh", "link",
"lock", "lockt", "locku", "lookup", "lookup_root", "nverify",
"open", "openattr", "open_conf", "open_dgrd", "putfh", "putpubfh",
"putrootfh", "read", "readdir", "readlink", "remove", "rename",
"renew", "restorefh", "savefh", "secinfo", "setattr", "setcltid",
"setcltidconf", "verify", "write", "rellockowner" };
char *nfs_v4c_names[35] = {
"null", "read", "write", "commit", "open", "open_conf",
"open_noat", "open_dgrd", "close", "setattr", "fsinfo", "renew",
"setclntid", "confirm", "lock", "lockt", "locku", "access",
"getattr", "lookup", "lookup_root", "remove", "rename", "link",
"symlink", "create", "pathconf", "statfs", "readlink", "readdir",
"server_caps", "delegreturn", "getacl", "setacl", "fs_locations" };
int nfs_v2c_found=0;
int nfs_v2s_found=0;
int nfs_v3c_found=0;
int nfs_v3s_found=0;
int nfs_v4c_found=0;
int nfs_v4s_found=0;
int nfs_clear=0;
struct nfs_stat {
long v2c[18]; /* verison 2 client */
long v3c[22]; /* verison 3 client */
long v4c[35]; /* verison 4 client */
long v2s[18]; /* verison 2 server */
long v3s[22]; /* verison 3 server */
long v4s[40]; /* verison 4 server */
};
#define NETMAX 32
struct net_stat {
unsigned long if_name[17];
unsigned long long if_ibytes;
unsigned long long if_obytes;
unsigned long long if_ipackets;
unsigned long long if_opackets;
unsigned long if_ierrs;
unsigned long if_oerrs;
unsigned long if_idrop;
unsigned long if_ififo;
unsigned long if_iframe;
unsigned long if_odrop;
unsigned long if_ofifo;
unsigned long if_ocarrier;
unsigned long if_ocolls;
} ;
#ifdef PARTITIONS
#define PARTMAX 256
struct part_stat {
int part_major;
int part_minor;
unsigned long part_blocks;
char part_name[16];
unsigned long part_rio;
unsigned long part_rmerge;
unsigned long part_rsect;
unsigned long part_ruse;
unsigned long part_wio;
unsigned long part_wmerge;
unsigned long part_wsect;
unsigned long part_wuse;
unsigned long part_run;
unsigned long part_use;
unsigned long part_aveq;
};
#endif /*PARTITIONS*/
#ifdef POWER
/* XXXXXXX need to test if rewind() worked or not for lparcfg */
int lparcfg_reread=1;
/* Reset at end of each interval so LPAR cfg is only read once each interval
* even if proc_lparcfg() is called multiple times
* Note: lparcfg is not read via proc_read() !
*/
int lparcfg_processed=0;
struct {
char version_string[16]; /*lparcfg 1.3 */
int version;
char serial_number[16]; /*HAL,0210033EA*/
char system_type[16]; /*HAL,9124-720*/
int partition_id; /*11*/
/*
R4=0x14
R5=0x0
R6=0x800b0000
R7=0x1000000040004
*/
int BoundThrds; /*=1*/
int CapInc; /*=1*/
long long DisWheRotPer; /*=2070000*/
int MinEntCap; /*=10*/
int MinEntCapPerVP; /*=10*/
int MinMem; /*=2048*/
int DesMem; /*=4096*/
int MinProcs; /*=1*/
int partition_max_entitled_capacity; /*=400*/
int system_potential_processors; /*=4*/
/**/
int partition_entitled_capacity; /*=20*/
int system_active_processors; /*=4*/
int pool_capacity; /*=4*/
int unallocated_capacity_weight; /*=0*/
int capacity_weight; /*=0*/
int capped; /*=1*/
int unallocated_capacity; /*=0*/
long long pool_idle_time; /*=0*/
long long pool_idle_saved;
long long pool_idle_diff;
int pool_num_procs; /*=0*/
long long purr; /*=0*/
long long purr_saved;
long long purr_diff;
long long timebase;
int partition_active_processors; /*=1*/
int partition_potential_processors; /*=40*/
int shared_processor_mode; /*=1*/
int smt_mode; /* 1: off, 2: SMT-2, 4: SMT-4 */
int cmo_enabled; /* 1 means AMS is Active */
int entitled_memory_pool_number; /* pool number = 0 */
int entitled_memory_weight; /* 0 to 255 */
long cmo_faults; /* Hypervisor Page-in faults = big number */
long cmo_faults_save; /* above saved */
long cmo_faults_diff; /* delta */
long cmo_fault_time_usec; /* Hypervisor time in micro seconds = big */
long cmo_fault_time_usec_save; /* above saved */
long cmo_fault_time_usec_diff; /* delta */
long backing_memory; /* AIX pmem in bytes */
long cmo_page_size; /* AMS page size in bytes */
long entitled_memory_pool_size; /* AMS whole pool size in bytes */
long entitled_memory_loan_request; /* AMS requesting more memory loaning */
#ifdef EXPERIMENTAL
/* new data in SLES11 for POWER 2.6.27 (may be a little earlier too) */
long DesEntCap;
long DesProcs;
long DesVarCapWt;
long DedDonMode;
long group;
long pool;
long entitled_memory;
long entitled_memory_group_number;
long unallocated_entitled_memory_weight;
long unallocated_io_mapping_entitlement;
/* new data in SLES11 for POWER 2.6.27 */
#endif /* EXPERIMENTAL */
} lparcfg;
int lpar_count=0;
#define LPAR_LINE_MAX 50
#define LPAR_LINE_WIDTH 80
char lpar_buffer[LPAR_LINE_MAX][LPAR_LINE_WIDTH];
int lpar_sanity=55;
char *locate(char *s)
{
int i;
int len;
len=strlen(s);
for(i=0;i<lpar_count;i++)
if( !strncmp(s,lpar_buffer[i],len))
return lpar_buffer[i];
return "";
}
#define NUMBER_NOT_VALID -999
long long read_longlong(char *s)
{
long long x;
int ret;
int len;
int i;
char *str;
str = locate(s);
len=strlen(str);
if(len == 0) {
return NUMBER_NOT_VALID;
}
for(i=0;i<len;i++) {
if(str[i] == '=') {
ret = sscanf(&str[i+1], "%lld", &x);
if(ret != 1) {
fprintf(stderr,"sscanf for %s failed returned = %d line=%s\n", s, ret, str);
return -1;
}
/* fprintf(fp,"DEBUG read %s value %lld\n",s,x);*/
return x;
}
}
fprintf(stderr,"read_long_long failed returned line=%s\n", str);
return -2;
}
/* Return of 0 means data not available */
int proc_lparcfg()
{
static FILE *fp = (FILE *)-1;
/* Only try to read /proc/ppc64/lparcfg once - remember if it's readable */
static int lparinfo_not_available=0;
char *str;
/* If we already read and processed /proc/lparcfg in this interval - just return */
if( lparcfg_processed == 1)
return 1;
if( lparinfo_not_available == 1)
return 0;
if( fp == (FILE *)-1) {
if( (fp = fopen("/proc/ppc64/lparcfg","r")) == NULL) {
error("failed to open - /proc/ppc64/lparcfg");
fp = (FILE *)-1;
lparinfo_not_available = 1;
return 0;
}
}
for(lpar_count=0;lpar_count<LPAR_LINE_MAX-1;lpar_count++) {
if(fgets(lpar_buffer[lpar_count],LPAR_LINE_WIDTH-1,fp) == NULL)
break;
}
if(lparcfg_reread) { /* XXXX unclear is close open is necessary - unfortunately this requires version on Linux on POWER install to test early releases */
fclose(fp);
fp = (FILE *)-1;
} else rewind(fp);
str=locate("lparcfg"); sscanf(str, "lparcfg %s", lparcfg.version_string);
str=locate("serial_number"); sscanf(str, "serial_number=%s", lparcfg.serial_number);
str=locate("system_type"); sscanf(str, "system_type=%s", lparcfg.system_type);
#define GETDATA(variable) lparcfg.variable = read_longlong( __STRING(variable) );
GETDATA(partition_id);
GETDATA(BoundThrds);
GETDATA(CapInc);
GETDATA(DisWheRotPer);
GETDATA(MinEntCap);
GETDATA(MinEntCapPerVP);
GETDATA(MinMem);
GETDATA(DesMem);
GETDATA(MinProcs);
GETDATA(partition_max_entitled_capacity);
GETDATA(system_potential_processors);
GETDATA(partition_entitled_capacity);
GETDATA(system_active_processors);
GETDATA(pool_capacity);
GETDATA(unallocated_capacity_weight);
GETDATA(capacity_weight);
GETDATA(capped);
GETDATA(unallocated_capacity);
lparcfg.pool_idle_saved = lparcfg.pool_idle_time;
GETDATA(pool_idle_time);
lparcfg.pool_idle_diff = lparcfg.pool_idle_time - lparcfg.pool_idle_saved;
GETDATA(pool_num_procs);
lparcfg.purr_saved = lparcfg.purr;
GETDATA(purr);
lparcfg.purr_diff = lparcfg.purr - lparcfg.purr_saved;
GETDATA(partition_active_processors);
GETDATA(partition_potential_processors);
GETDATA(shared_processor_mode);
/* Brute force, may provide temporary incorrect data during
* dynamic reconfiguraiton envents
*/
lparcfg.smt_mode=cpus / lparcfg.partition_active_processors;
/* AMS additions */
GETDATA(cmo_enabled);
if( lparcfg.cmo_enabled == NUMBER_NOT_VALID ) {
lparcfg.cmo_enabled = 0;
}
if( lparcfg.cmo_enabled ) {
GETDATA(entitled_memory_pool_number); /* pool number = 0 */
GETDATA(entitled_memory_weight); /* 0 to 255 */
lparcfg.cmo_faults_save = lparcfg.cmo_faults;
GETDATA(cmo_faults); /* Hypervisor Page-in faults = big number */
lparcfg.cmo_faults_diff = lparcfg.cmo_faults - lparcfg.cmo_faults_save;
lparcfg.cmo_fault_time_usec_save = lparcfg.cmo_fault_time_usec;
GETDATA(cmo_fault_time_usec); /* Hypervisor time in micro seconds = big number */
lparcfg.cmo_fault_time_usec_diff = lparcfg.cmo_fault_time_usec - lparcfg.cmo_fault_time_usec_save;
GETDATA(backing_memory); /* AIX pmem in bytes */
GETDATA(cmo_page_size); /* AMS page size in bytes */
GETDATA(entitled_memory_pool_size); /* AMS whole pool size in bytes */
GETDATA(entitled_memory_loan_request); /* AMS requesting more memory loaning */
}
#ifdef EXPERIMENTAL
GETDATA(DesEntCap);
GETDATA(DesProcs);
GETDATA(DesVarCapWt);
GETDATA(DedDonMode);
GETDATA(group);
GETDATA(pool);
GETDATA(entitled_memory);
GETDATA(entitled_memory_group_number);
GETDATA(unallocated_entitled_memory_weight);
GETDATA(unallocated_io_mapping_entitlement);
#endif /* EXPERIMENTAL */
lparcfg_processed=1;
return 1;
}
#endif /*POWER*/
#define DISKMIN 256
#define DISKMAX diskmax
int diskmax = DISKMIN;
/* Supports up to 780, but not POWER6 595 follow-up with POWER7 */
/* XXXX needs rework to cope to with fairly rare but interesting higher numbers of CPU machines */
#define CPUMAX 256
struct data {
struct dsk_stat *dk;
struct cpu_stat cpu_total;
struct cpu_stat cpuN[CPUMAX];
struct mem_stat mem;
struct vm_stat vm;
struct nfs_stat nfs;
struct net_stat ifnets[NETMAX];
#ifdef PARTITIONS
struct part_stat parts[PARTMAX];
#endif /*PARTITIONS*/
struct timeval tv;
double time;
struct procsinfo *procs;
int nprocs;
} database[2], *p, *q;
long long get_vm_value( char *s) {
int currline;
int currchar;
long long result = -1;
char *check;
int len;
int found;
for(currline=0; currline<proc[P_VMSTAT].lines; currline++) {
len = strlen(s);
for(currchar=0,found=1; currchar<len; currchar++) {
if( proc[P_VMSTAT].line[currline][currchar] == 0 ||
s[currchar] != proc[P_VMSTAT].line[currline][currchar]) {
found=0;
break;
}
}
if(found && proc[P_VMSTAT].line[currline][currchar] == ' ') {
result = strtoll(&proc[P_VMSTAT].line[currline][currchar+1],&check,10);
if( *check == proc[P_VMSTAT].line[currline][currchar+1]) {
fprintf(stderr,"%s has an unexpected format: >%s<\n", proc[P_VMSTAT].filename, proc[P_VMSTAT].line[currline]);
return -1;
}
return result;
}
}
return -1;
}
#define GETVM(variable) p->vm.variable = get_vm_value(__STRING(variable) );
int read_vmstat()
{
proc_read(P_VMSTAT);
if( proc[P_VMSTAT].read_this_interval == 0 || proc[P_VMSTAT].lines == 0)
return(-1);
/* Note: if the variable requested is not found in /proc/vmstat then it is set to -1 */
GETVM(nr_dirty);
GETVM(nr_writeback);
GETVM(nr_unstable);
GETVM(nr_page_table_pages);
GETVM(nr_mapped);
GETVM(nr_slab);
GETVM(pgpgin);
GETVM(pgpgout);
GETVM(pswpin);
GETVM(pswpout);
GETVM(pgalloc_high);
GETVM(pgalloc_normal);
GETVM(pgalloc_dma);
GETVM(pgfree);
GETVM(pgactivate);
GETVM(pgdeactivate);
GETVM(pgfault);
GETVM(pgmajfault);
GETVM(pgrefill_high);
GETVM(pgrefill_normal);
GETVM(pgrefill_dma);
GETVM(pgsteal_high);
GETVM(pgsteal_normal);
GETVM(pgsteal_dma);
GETVM(pgscan_kswapd_high);
GETVM(pgscan_kswapd_normal);
GETVM(pgscan_kswapd_dma);
GETVM(pgscan_direct_high);
GETVM(pgscan_direct_normal);
GETVM(pgscan_direct_dma);
GETVM(pginodesteal);
GETVM(slabs_scanned);
GETVM(kswapd_steal);
GETVM(kswapd_inodesteal);
GETVM(pageoutrun);
GETVM(allocstall);
GETVM(pgrotated);
return 1;
}
/* These macro simplify the access to the Main data structure */
#define DKDELTA(member) ( (q->dk[i].member > p->dk[i].member) ? 0 : (p->dk[i].member - q->dk[i].member))
#define SIDELTA(member) ( (q->si.member > p->si.member) ? 0 : (p->si.member - q->si.member))
#define IFNAME 64
#define TIMEDELTA(member,index1,index2) ((p->procs[index1].member) - (q->procs[index2].member))
#define COUNTDELTA(member) ( (q->procs[topper[j].other].member > p->procs[i].member) ? 0 : (p->procs[i].member - q->procs[topper[j].other].member) )
#define TIMED(member) ((double)(p->procs[i].member.tv_sec))
double *cpu_peak; /* ptr to array - 1 for each cpu - 0 = average for machine */
double *disk_busy_peak;
double *disk_rate_peak;
double net_read_peak[NETMAX];
double net_write_peak[NETMAX];
int aiorunning;
int aiorunning_max = 0;
int aiocount;
int aiocount_max = 0;
float aiotime;
float aiotime_max =0.0;
char *dskgrp(int i)
{
static char error_string[] = { "Too-Many-Disks" };
static char *string[16] = {"", "1", "2", "3",
"4", "5", "6", "7",
"8", "9", "10", "11",
"12", "13", "14", "15"};
i = (int)((float)i/(float)disks_per_line);
if(0 <= i && i <= 15 )
return string[i];
return error_string;
}
/* command checking against a list */
#define CMDMAX 64
char *cmdlist[CMDMAX];
int cmdfound = 0;
int cmdcheck(char *cmd)
{
int i;
#ifdef CMDDEBUG
fprintf(stderr,"cmdfound=%d\n",cmdfound);
for(i=0;i<cmdfound;i++)
fprintf(stderr,"cmdlist[%d]=\"%s\"\n",i,cmdlist[i]);
#endif /* CMDDEBUG */
for(i=0;i<cmdfound;i++) {
if(strlen(cmdlist[i]) == 0)
continue;
if( !strncmp(cmdlist[i],cmd,strlen(cmdlist[i])) )
return 1;
}
return 0;
}
/* Convert secs + micro secs to a double */
double doubletime(void)
{
gettimeofday(&p->tv, 0);
return((double)p->tv.tv_sec + p->tv.tv_usec * 1.0e-6);
}
void get_cpu_cnt() {
int i;
/* Get CPU info from /proc/stat and populate proc[P_STAT] */
proc_read(P_STAT);
/* Start with index [1] as [0] contains overall CPU statistics */
for(i=1; i<proc[P_STAT].lines; i++) {
if(strncmp("cpu",proc[P_STAT].line[i],3) == 0)
cpus=i;
else
break;
}
}
int stat8 = 0; /* used to determine the number of variables on a line */
void proc_cpu()
{
int i;
int row;
static int intr_line = 0;
static int ctxt_line = 0;
static int btime_line= 0;
static int proc_line = 0;
static int run_line = 0;
static int block_line= 0;
static int proc_cpu_first_time = 1;
long long user;
long long nice;
long long sys;
long long idle;
long long iowait;
long long hardirq;
long long softirq;
long long steal;
/* Only read data once per interval */
if( proc_cpu_done == 1)
return;
/* If number of CPUs changed, then we need to find the index of intr_line, ... again */
if( old_cpus != cpus)
intr_line = 0;
if(proc_cpu_first_time) {
stat8 = sscanf(&proc[P_STAT].line[0][5], "%lld %lld %lld %lld %lld %lld %lld %lld",
&user,
&nice,
&sys,
&idle,
&iowait,
&hardirq,
&softirq,
&steal);
proc_cpu_first_time = 0;
}
user = nice = sys = idle = iowait = hardirq = softirq = steal = 0;
if(stat8 == 8) {
sscanf(&proc[P_STAT].line[0][5], "%lld %lld %lld %lld %lld %lld %lld %lld",
&user,
&nice,
&sys,
&idle,
&iowait,
&hardirq,
&softirq,
&steal);
} else { /* stat 4 variables here as older Linux proc */
sscanf(&proc[P_STAT].line[0][5], "%lld %lld %lld %lld",
&user,
&nice,
&sys,
&idle);
}
p->cpu_total.user = user + nice;
p->cpu_total.wait = iowait; /* in the case of 4 variables = 0 */
p->cpu_total.sys = sys;
/* p->cpu_total.sys = sys + hardirq + softirq + steal;*/
p->cpu_total.idle = idle;
p->cpu_total.irq = hardirq;
p->cpu_total.softirq = softirq;
p->cpu_total.steal = steal;
p->cpu_total.nice = nice;
#ifdef DEBUG
if(debug)fprintf(stderr,"XX user=%lld wait=%lld sys=%lld idle=%lld\n",
p->cpu_total.user,
p->cpu_total.wait,
p->cpu_total.sys,
p->cpu_total.idle);
#endif /*DEBUG*/
for(i=0;i<cpus;i++ ) {
user = nice = sys = idle = iowait = hardirq = softirq = steal = 0;
/* allow for large CPU numbers */
if(i+1 > 1000) row = 8;
else if(i+1 > 100) row = 7;
else if(i+1 > 10) row = 6;
else row = 5;
if(stat8 == 8) {
sscanf(&proc[P_STAT].line[i+1][row],
"%lld %lld %lld %lld %lld %lld %lld %lld",
&user,
&nice,
&sys,
&idle,
&iowait,
&hardirq,
&softirq,
&steal);
} else {
sscanf(&proc[P_STAT].line[i+1][row], "%lld %lld %lld %lld",
&user,
&nice,
&sys,
&idle);
}
p->cpuN[i].user = user + nice;
p->cpuN[i].wait = iowait;
p->cpuN[i].sys = sys;
/*p->cpuN[i].sys = sys + hardirq + softirq + steal;*/
p->cpuN[i].idle = idle;
p->cpuN[i].irq = hardirq;
p->cpuN[i].softirq = softirq;
p->cpuN[i].steal = steal;
p->cpuN[i].nice = nice;
}
if(intr_line == 0) {
if(proc[P_STAT].line[i+1][0] == 'p' &&
proc[P_STAT].line[i+1][1] == 'a' &&
proc[P_STAT].line[i+1][2] == 'g' &&
proc[P_STAT].line[i+1][3] == 'e' ) {
/* 2.4 kernel */
intr_line = i+3;
ctxt_line = i+5;
btime_line= i+6;
proc_line = i+7;
run_line = i+8;
block_line= i+9;
}else {
/* 2.6 kernel */
intr_line = i+1;
ctxt_line = i+2;
btime_line= i+3;
proc_line = i+4;
run_line = i+5;
block_line= i+6;
}
}
p->cpu_total.intr = -1;
p->cpu_total.ctxt = -1;
p->cpu_total.btime = -1;
p->cpu_total.procs = -1;
p->cpu_total.running = -1;
p->cpu_total.blocked = -1;
if(proc[P_STAT].lines >= intr_line)
sscanf(&proc[P_STAT].line[intr_line][0], "intr %lld", &p->cpu_total.intr);
if(proc[P_STAT].lines >= ctxt_line)
sscanf(&proc[P_STAT].line[ctxt_line][0], "ctxt %lld", &p->cpu_total.ctxt);
if(proc[P_STAT].lines >= btime_line)
sscanf(&proc[P_STAT].line[btime_line][0], "btime %lld", &p->cpu_total.btime);
if(proc[P_STAT].lines >= proc_line)
sscanf(&proc[P_STAT].line[proc_line][0], "processes %lld", &p->cpu_total.procs);
if(proc[P_STAT].lines >= run_line)
sscanf(&proc[P_STAT].line[run_line][0], "procs_running %lld", &p->cpu_total.running);
if(proc[P_STAT].lines >= block_line)
sscanf(&proc[P_STAT].line[block_line][0], "procs_blocked %lld", &p->cpu_total.blocked);
/* If we had a change in the number of CPUs, copy current interval data to the previous, so we
* get a "0" utilization interval, but better than negative or 100%.
* Heads-up - This effects POWER SMT changes too.
*/
if( old_cpus != cpus ) {
memcpy((void *) &(q->cpu_total), (void *) &(p->cpu_total), sizeof(struct cpu_stat));
memcpy((void *) q->cpuN, (void *) p->cpuN, sizeof(struct cpu_stat) * cpus );
}
/* Flag that we processed /proc/stat data; re-set in proc_read() when we re-read /proc/stat */
proc_cpu_done = 1;
}
void proc_nfs()
{
int i;
int j;
int len;
/* sample /proc/net/rpc/nfs
net 0 0 0 0
rpc 70137 0 0
proc2 18 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
proc3 22 0 27364 0 32 828 22 40668 0 1 0 0 0 0 0 0 0 0 1212 6 2 1 0
proc4 35 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
*/
if(proc[P_NFS].fp != 0) {
/* client version 2 line readers "proc2 18 num num etc" */
len=strlen(proc[P_NFS].line[2]);
for(j=0,i=8;i<len && j<18;i++) {
if(proc[P_NFS].line[2][i] == ' ') {
p->nfs.v2c[j] =atol(&proc[P_NFS].line[2][i+1]);
nfs_v2c_found=1;
j++;
}
}
/* client version 3 line readers "proc3 22 num num etc" */
len=strlen(proc[P_NFS].line[3]);
for(j=0,i=8;i<len && j<22;i++) {
if(proc[P_NFS].line[3][i] == ' ') {
p->nfs.v3c[j] =atol(&proc[P_NFS].line[3][i+1]);
nfs_v3c_found=1;
j++;
}
}
/* client version 4 line readers "proc4 35 num num etc" */
len=strlen(proc[P_NFS].line[4]);
for(j=0,i=8;i<len && j<35;i++) {
if(proc[P_NFS].line[4][i] == ' ') {
p->nfs.v4c[j] =atol(&proc[P_NFS].line[4][i+1]);
nfs_v4c_found=1;
j++;
}
}
}
/* sample /proc/net/rpc/nfsd
rc 0 0 0
fh 0 0 0 0 0
io 0 0
th 4 0 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
ra 32 0 0 0 0 0 0 0 0 0 0 0
net 0 0 0 0
rpc 0 0 0 0 0
proc2 18 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
proc3 22 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
proc4 2 0 0
proc4ops 40 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
*/
if(proc[P_NFSD].fp != 0) {
/* server version 2 line readers "proc2 18 num num etc" */
len=strlen(proc[P_NFSD].line[7]);
for(j=0,i=8;i<len && j<18;i++) {
if(proc[P_NFSD].line[2][i] == ' ') {
p->nfs.v2s[j] =atol(&proc[P_NFSD].line[7][i+1]);
nfs_v2s_found=1;
j++;
}
}
/* server version 3 line readers "proc3 22 num num etc" */
len=strlen(proc[P_NFSD].line[8]);
for(j=0,i=8;i<len && j<22;i++) {
if(proc[P_NFS].line[3][i] == ' ') {
p->nfs.v3s[j] =atol(&proc[P_NFSD].line[8][i+1]);
nfs_v3s_found=1;
j++;
}
}
/* server version 4 line readers "proc4ops 40 num num etc" NOTE: the "ops" hence starting in column 11 */
len=strlen(proc[P_NFSD].line[10]);
for(j=0,i=11;i<len && j<40;i++) {
if(proc[P_NFS].line[3][i] == ' ') {
p->nfs.v4s[j] =atol(&proc[P_NFSD].line[10][i+1]);
nfs_v4s_found=1;
j++;
}
}
}
}
void proc_kernel()
{
int i;
p->cpu_total.uptime=0.0;
p->cpu_total.idletime=0.0;
p->cpu_total.uptime=atof(proc[P_UPTIME].line[0]);
for(i=0;i<strlen(proc[P_UPTIME].line[0]);i++) {
if(proc[P_UPTIME].line[0][i] == ' ') {
p->cpu_total.idletime=atof(&proc[P_UPTIME].line[0][i+1]);
break;
}
}
sscanf(&proc[P_LOADAVG].line[0][0], "%f %f %f",
&p->cpu_total.mins1,
&p->cpu_total.mins5,
&p->cpu_total.mins15);
}
char *proc_find_sb(char * p)
{
for(; *p != 0;p++)
if(*p == ' ' && *(p+1) == '(')
return p;
return 0;
}
#define DISK_MODE_IO 1
#define DISK_MODE_DISKSTATS 2
#define DISK_MODE_PARTITIONS 3
int disk_mode = 0;
void proc_disk_io(double elapsed)
{
int diskline;
int i;
int ret;
char *str;
int fudged_busy;
disks = 0;
for(diskline=0;diskline<proc[P_STAT].lines;diskline++) {
if(strncmp("disk_io", proc[P_STAT].line[diskline],7) == 0)
break;
}
for(i=8;i<strlen(proc[P_STAT].line[diskline]);i++) {
if( proc[P_STAT].line[diskline][i] == ':')
disks++;
}
str=&proc[P_STAT].line[diskline][0];
for(i=0;i<disks;i++) {
str=proc_find_sb(str);
if(str == 0)
break;
ret = sscanf(str, " (%d,%d):(%ld,%ld,%ld,%ld,%ld",
&p->dk[i].dk_major,
&p->dk[i].dk_minor,
&p->dk[i].dk_noinfo,
&p->dk[i].dk_reads,
&p->dk[i].dk_rkb,
&p->dk[i].dk_writes,
&p->dk[i].dk_wkb);
if(ret != 7)
exit(7);
p->dk[i].dk_xfers = p->dk[i].dk_noinfo;
/* blocks are 512 bytes*/
p->dk[i].dk_rkb = p->dk[i].dk_rkb/2;
p->dk[i].dk_wkb = p->dk[i].dk_wkb/2;
p->dk[i].dk_bsize = (p->dk[i].dk_rkb+p->dk[i].dk_wkb)/p->dk[i].dk_xfers*1024;
/* assume a disk does 200 op per second */
fudged_busy = (p->dk[i].dk_reads + p->dk[i].dk_writes)/2;
if(fudged_busy > 100*elapsed)
p->dk[i].dk_time += 100*elapsed;
p->dk[i].dk_time = fudged_busy;
sprintf(p->dk[i].dk_name,"dev-%d-%d",p->dk[i].dk_major,p->dk[i].dk_minor);
/* fprintf(stderr,"disk=%d name=\"%s\" major=%d minor=%d\n", i,p->dk[i].dk_name, p->dk[i].dk_major,p->dk[i].dk_minor); */
str++;
}
}
void proc_diskstats(double elapsed)
{
static FILE *fp = (FILE *)-1;
char buf[1024];
int i;
int ret;
if( fp == (FILE *)-1) {
if( (fp = fopen("/proc/diskstats","r")) == NULL) {
/* DEBUG if( (fp = fopen("diskstats","r")) == NULL) { */
error("failed to open - /proc/diskstats");
disks=0;
return;
}
}
/*
2 0 fd0 1 0 2 13491 0 0 0 0 0 13491 13491
3 0 hda 41159 53633 1102978 620181 39342 67538 857108 4042631 0 289150 4668250
3 1 hda1 58209 58218 0 0
3 2 hda2 148 4794 10 20
3 3 hda3 65 520 0 0
3 4 hda4 35943 1036092 107136 857088
22 0 hdc 167 5394 22308 32250 0 0 0 0 0 22671 32250 <-- USB !!
8 0 sda 990 2325 4764 6860 9 3 12 417 0 6003 7277
8 1 sda1 3264 4356 12 12
*/
for(i=0;i<DISKMAX;) {
if(fgets(buf,1024,fp) == NULL)
break;
/* zero the data ready for reading */
p->dk[i].dk_major =
p->dk[i].dk_minor =
p->dk[i].dk_name[0] =
p->dk[i].dk_reads =
p->dk[i].dk_rmerge =
p->dk[i].dk_rkb =
p->dk[i].dk_rmsec =
p->dk[i].dk_writes =
p->dk[i].dk_wmerge =
p->dk[i].dk_wkb =
p->dk[i].dk_wmsec =
p->dk[i].dk_inflight =
p->dk[i].dk_time =
p->dk[i].dk_11 =0;
ret = sscanf(&buf[0], "%d %d %s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
&p->dk[i].dk_major,
&p->dk[i].dk_minor,
&p->dk[i].dk_name[0],
&p->dk[i].dk_reads,
&p->dk[i].dk_rmerge,
&p->dk[i].dk_rkb,
&p->dk[i].dk_rmsec,
&p->dk[i].dk_writes,
&p->dk[i].dk_wmerge,
&p->dk[i].dk_wkb,
&p->dk[i].dk_wmsec,
&p->dk[i].dk_inflight,
&p->dk[i].dk_time,
&p->dk[i].dk_11 );
if(ret == 7) { /* shuffle the data around due to missing columns for partitions */
p->dk[i].dk_partition = 1;
p->dk[i].dk_wkb = p->dk[i].dk_rmsec;
p->dk[i].dk_writes = p->dk[i].dk_rkb;
p->dk[i].dk_rkb = p->dk[i].dk_rmerge;
p->dk[i].dk_rmsec=0;
p->dk[i].dk_rmerge=0;
}
else if(ret == 14) p->dk[i].dk_partition = 0;
else fprintf(stderr,"disk sscanf wanted 14 but returned=%d line=%s\n",
ret,buf);
p->dk[i].dk_rkb /= 2; /* sectors = 512 bytes */
p->dk[i].dk_wkb /= 2;
p->dk[i].dk_xfers = p->dk[i].dk_reads + p->dk[i].dk_writes;
if(p->dk[i].dk_xfers == 0)
p->dk[i].dk_bsize = 0;
else
p->dk[i].dk_bsize = ((p->dk[i].dk_rkb+p->dk[i].dk_wkb)/p->dk[i].dk_xfers)*1024;
p->dk[i].dk_time /= 10.0; /* in milli-seconds to make it upto 100%, 1000/100 = 10 */
if( p->dk[i].dk_xfers > 0)
i++;
}
if(reread) {
fclose(fp);
fp = (FILE *)-1;
} else rewind(fp);
disks = i;
}
void strip_spaces(char *s)
{
char *p;
int spaced=1;
p=s;
for(p=s;*p!=0;p++) {
if(*p == ':')
*p=' ';
if(*p != ' ') {
*s=*p;
s++;
spaced=0;
} else if(spaced) {
/* do no thing as this is second space */
} else {
*s=*p;
s++;
spaced=1;
}
}
*s = 0;
}
void proc_partitions(double elapsed)
{
static FILE *fp = (FILE *)-1;
char buf[1024];
int i = 0;
int ret;
if( fp == (FILE *)-1) {
if( (fp = fopen("/proc/partitions","r")) == NULL) {
error("failed to open - /proc/partitions");
partitions=0;
return;
}
}
if(fgets(buf,1024,fp) == NULL) goto end; /* throw away the header lines */
if(fgets(buf,1024,fp) == NULL) goto end;
/*
major minor #blocks name rio rmerge rsect ruse wio wmerge wsect wuse running use aveq
33 0 1052352 hde 2855 15 2890 4760 0 0 0 0 -4 7902400 11345292
33 1 1050304 hde1 2850 0 2850 3930 0 0 0 0 0 3930 3930
3 0 39070080 hda 9287 19942 226517 90620 8434 25707 235554 425790 -12 7954830 33997658
3 1 31744408 hda1 651 90 5297 2030 0 0 0 0 0 2030 2030
3 2 6138720 hda2 7808 19561 218922 79430 7299 20529 222872 241980 0 59950 321410
3 3 771120 hda3 13 41 168 80 0 0 0 0 0 80 80
3 4 1 hda4 0 0 0 0 0 0 0 0 0 0 0
3 5 408208 hda5 812 241 2106 9040 1135 5178 12682 183810 0 11230 192850
*/
for(i=0;i<DISKMAX;i++) {
if(fgets(buf,1024,fp) == NULL)
break;
strip_spaces(buf);
ret = sscanf(&buf[0], "%d %d %lu %s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
&p->dk[i].dk_major,
&p->dk[i].dk_minor,
&p->dk[i].dk_blocks,
(char *)&p->dk[i].dk_name,
&p->dk[i].dk_reads,
&p->dk[i].dk_rmerge,
&p->dk[i].dk_rkb,
&p->dk[i].dk_rmsec,
&p->dk[i].dk_writes,
&p->dk[i].dk_wmerge,
&p->dk[i].dk_wkb,
&p->dk[i].dk_wmsec,
&p->dk[i].dk_inflight,
&p->dk[i].dk_use,
&p->dk[i].dk_aveq
);
p->dk[i].dk_rkb /= 2; /* sectors = 512 bytes */
p->dk[i].dk_wkb /= 2;
p->dk[i].dk_xfers = p->dk[i].dk_rkb + p->dk[i].dk_wkb;
if(p->dk[i].dk_xfers == 0)
p->dk[i].dk_bsize = 0;
else
p->dk[i].dk_bsize = (p->dk[i].dk_rkb+p->dk[i].dk_wkb)/p->dk[i].dk_xfers*1024;
p->dk[i].dk_time /= 10.0; /* in milli-seconds to make it upto 100%, 1000/100 = 10 */
if(ret != 15) {
#ifdef DEBUG
if(debug)fprintf(stderr,"sscanf wanted 15 returned = %d line=%s\n", ret,buf);
#endif /*DEBUG*/
partitions_short = 1;
} else partitions_short = 0;
}
end:
if(reread) {
fclose(fp);
fp = (FILE *)-1;
} else rewind(fp);
disks = i;
}
void proc_disk(double elapsed)
{
struct stat buf;
int ret;
if(disk_mode == 0) {
ret = stat("/proc/diskstats", &buf);
if(ret == 0) {
disk_mode=DISK_MODE_DISKSTATS;
} else {
ret = stat("/proc/partitions", &buf);
if(ret == 0) {
disk_mode=DISK_MODE_PARTITIONS;
} else {
disk_mode=DISK_MODE_IO;
}
}
}
switch(disk_mode){
case DISK_MODE_IO: proc_disk_io(elapsed); break;
case DISK_MODE_DISKSTATS: proc_diskstats(elapsed); break;
case DISK_MODE_PARTITIONS: proc_partitions(elapsed); break;
}
}
#undef isdigit
#define isdigit(ch) ( ( '0' <= (ch) && (ch) >= '9')? 0: 1 )
long proc_mem_search( char *s)
{
int i;
int j;
int len;
len=strlen(s);
for(i=0;i<proc[P_MEMINFO].lines;i++ ) {
if( !strncmp(s, proc[P_MEMINFO].line[i],len) ) {
for(j=len;
!isdigit(proc[P_MEMINFO].line[i][j]) &&
proc[P_MEMINFO].line[i][j] != 0;
j++)
/* do nothing */ ;
return atol( &proc[P_MEMINFO].line[i][j]);
}
}
return -1;
}
void proc_mem()
{
if( proc[P_MEMINFO].read_this_interval == 0)
proc_read(P_MEMINFO);
p->mem.memtotal = proc_mem_search("MemTotal");
p->mem.memfree = proc_mem_search("MemFree");
p->mem.memshared = proc_mem_search("MemShared");
p->mem.buffers = proc_mem_search("Buffers");
p->mem.cached = proc_mem_search("Cached");
p->mem.swapcached = proc_mem_search("SwapCached");
p->mem.active = proc_mem_search("Active");
p->mem.inactive = proc_mem_search("Inactive");
p->mem.hightotal = proc_mem_search("HighTotal");
p->mem.highfree = proc_mem_search("HighFree");
p->mem.lowtotal = proc_mem_search("LowTotal");
p->mem.lowfree = proc_mem_search("LowFree");
p->mem.swaptotal = proc_mem_search("SwapTotal");
p->mem.swapfree = proc_mem_search("SwapFree");
#ifdef LARGEMEM
p->mem.dirty = proc_mem_search("Dirty");
p->mem.writeback = proc_mem_search("Writeback");
p->mem.mapped = proc_mem_search("Mapped");
p->mem.slab = proc_mem_search("Slab");
p->mem.committed_as = proc_mem_search("Committed_AS");
p->mem.pagetables = proc_mem_search("PageTables");
p->mem.hugetotal = proc_mem_search("HugePages_Total");
p->mem.hugefree = proc_mem_search("HugePages_Free");
p->mem.hugesize = proc_mem_search("Hugepagesize");
#else
p->mem.bigfree = proc_mem_search("BigFree");
#endif /*LARGEMEM*/
}
#define MAX_SNAPS 72
#define MAX_SNAP_ROWS 20
#define SNAP_OFFSET 6
int next_cpu_snap = 0;
int cpu_snap_all = 0;
struct {
double user;
double kernel;
double iowait;
double idle;
} cpu_snap[MAX_SNAPS];
int snap_average()
{
int i;
int end;
int total = 0;
if(cpu_snap_all)
end = MAX_SNAPS;
else
end = next_cpu_snap;
for(i=0;i<end;i++) {
total = total + cpu_snap[i].user + cpu_snap[i].kernel;
}
return (total / end) ;
}
void snap_clear()
{
int i;
for(i=0;i<MAX_SNAPS;i++) {
cpu_snap[i].user = 0;
cpu_snap[i].kernel = 0;
cpu_snap[i].iowait = 0;
cpu_snap[i].idle = 0;
}
next_cpu_snap=0;
cpu_snap_all=0;
}
void plot_snap(WINDOW *pad)
{
int i;
int j;
if (cursed) {
mvwprintw(pad,0, 0, " CPU +-------------------------------------------------------------------------+");
mvwprintw(pad,1, 0,"100%%-|");
mvwprintw(pad,2, 1, "95%%-|");
mvwprintw(pad,3, 1, "90%%-|");
mvwprintw(pad,4, 1, "85%%-|");
mvwprintw(pad,5, 1, "80%%-|");
mvwprintw(pad,6, 1, "75%%-|");
mvwprintw(pad,7, 1, "70%%-|");
mvwprintw(pad,8, 1, "65%%-|");
mvwprintw(pad,9, 1, "60%%-|");
mvwprintw(pad,10, 1, "55%%-|");
mvwprintw(pad,11, 1, "50%%-|");
mvwprintw(pad,12, 1, "45%%-|");
mvwprintw(pad,13, 1, "40%%-|");
mvwprintw(pad,14, 1, "35%%-|");
mvwprintw(pad,15, 1, "30%%-|");
mvwprintw(pad,16, 1, "25%%-|");
mvwprintw(pad,17, 1, "20%%-|");
mvwprintw(pad,18, 1,"15%%-|");
mvwprintw(pad,19, 1,"10%%-|");
mvwprintw(pad,20, 1," 5%%-|");
if (colour){
mvwprintw(pad,21, 4, " +--------------------");
COLOUR wattrset(pad, COLOR_PAIR(2));
mvwprintw(pad,21, 26, "User%%");
COLOUR wattrset(pad, COLOR_PAIR(0));
mvwprintw(pad,21, 30, "---------");
COLOUR wattrset(pad, COLOR_PAIR(1));
mvwprintw(pad,21, 39, "System%%");
COLOUR wattrset(pad, COLOR_PAIR(0));
mvwprintw(pad,21, 45, "---------");
COLOUR wattrset(pad, COLOR_PAIR(4));
mvwprintw(pad,21, 54, "Wait%%");
COLOUR wattrset(pad, COLOR_PAIR(0));
mvwprintw(pad,21, 58, "---------------------+");
} else {
mvwprintw(pad,21, 4, " +-------------------------------------------------------------------------+");
}
for (j = 0; j < MAX_SNAPS; j++) {
for (i = 0; i < MAX_SNAP_ROWS; i++) {
wmove(pad,MAX_SNAP_ROWS-i, j+SNAP_OFFSET);
if( (cpu_snap[j].user / 100 * MAX_SNAP_ROWS) > i+0.5) {
COLOUR wattrset(pad,COLOR_PAIR(9));
wprintw(pad,"U");
COLOUR wattrset(pad,COLOR_PAIR(0));
} else if( (cpu_snap[j].user + cpu_snap[j].kernel )/ 100 * MAX_SNAP_ROWS > i+0.5) {
COLOUR wattrset(pad,COLOR_PAIR(8));
wprintw(pad,"s");
COLOUR wattrset(pad,COLOR_PAIR(0));
} else if( (cpu_snap[j].user + cpu_snap[j].kernel +cpu_snap[j].iowait )/ 100 * MAX_SNAP_ROWS > i+0.5) {
COLOUR wattrset(pad,COLOR_PAIR(10));
wprintw(pad,"w");
COLOUR wattrset(pad,COLOR_PAIR(0));
} else
wprintw(pad," ");
}
}
for (i = 0; i < MAX_SNAP_ROWS; i++) {
wmove(pad,MAX_SNAP_ROWS-i, next_cpu_snap+SNAP_OFFSET);
wprintw(pad,"|");
}
wmove(pad,MAX_SNAP_ROWS+1 - (snap_average() /5), next_cpu_snap+SNAP_OFFSET);
wprintw(pad,"+");
if(dotline) {
for (i = 0; i < MAX_SNAPS; i++) {
wmove(pad,MAX_SNAP_ROWS+1-dotline*2, i+SNAP_OFFSET);
wprintw(pad,"+");
}
dotline = 0;
}
}
}
/* This saves the CPU overall usage for later ploting on the screen */
void plot_save(double user, double kernel, double iowait, double idle)
{
cpu_snap[next_cpu_snap].user = user;
cpu_snap[next_cpu_snap].kernel = kernel;
cpu_snap[next_cpu_snap].iowait = iowait;
cpu_snap[next_cpu_snap].idle = idle;
next_cpu_snap++;
if(next_cpu_snap >= MAX_SNAPS) {
next_cpu_snap=0;
cpu_snap_all=1;
}
}
/* This puts the CPU usage on the screen and draws the CPU graphs or outputs to the file */
void save_smp(WINDOW *pad, int cpu_no, int row, long user, long kernel, long iowait, long idle, long nice, long irq, long softirq, long steal)
{
static int firsttime = 1;
if (cursed) {
mvwprintw(pad,row,0, "%3d usr=%4ld sys=%4ld wait=%4ld idle=%4ld steal=%2ld nice=%4ld irq=%2ld sirq=%2ld\n",
cpu_no, user, kernel, iowait, idle, steal, nice, irq, softirq, steal);
return;
}
if(firsttime) {
fprintf(fp,"CPUTICKS_ALL,AAA,user,sys,wait,idle,nice,irq,softirq,steal\n");
fprintf(fp,"CPUTICKS%03d,AAA,user,sys,wait,idle,nice,irq,softirq,steal\n", cpu_no);
firsttime=0;
}
if(cpu_no==0) {
fprintf(fp,"CPUTICKS_ALL,%s,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld\n",
LOOP, user, kernel, iowait, idle, nice, irq, softirq, steal);
} else {
fprintf(fp,"CPUTICKS%03d,%s,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld\n",
cpu_no, LOOP, user, kernel, iowait, idle, nice, irq, softirq, steal);
}
}
void plot_smp(WINDOW *pad, int cpu_no, int row, double user, double kernel, double iowait, double idle)
{
int i;
int peak_col;
if(show_rrd) return;
if(cpu_peak[cpu_no] < (user + kernel + iowait) )
cpu_peak[cpu_no] = (double)((int)user/2 + (int)kernel/2 + (int)iowait/2)*2.0;
if (cursed) {
if(cpu_no == 0)
mvwprintw(pad,row, 0, "Avg");
else
mvwprintw(pad,row, 0, "%3d", cpu_no);
mvwprintw(pad,row, 3, "% 6.1lf", user);
mvwprintw(pad,row, 9, "% 6.1lf", kernel);
mvwprintw(pad,row, 15, "% 6.1lf", iowait);
mvwprintw(pad,row, 21, "% 6.1lf", idle);
mvwprintw(pad,row, 27, "|");
wmove(pad,row, 28);
for (i = 0; i < (int)(user / 2); i++){
COLOUR wattrset(pad,COLOR_PAIR(9));
wprintw(pad,"U");
COLOUR wattrset(pad,COLOR_PAIR(0));
}
for (i = 0; i < (int)(kernel / 2); i++){
COLOUR wattrset(pad,COLOR_PAIR(8));
wprintw(pad,"s");
COLOUR wattrset(pad,COLOR_PAIR(0));
}
for (i = 0; i < (int)(iowait / 2); i++) {
COLOUR wattrset(pad,COLOR_PAIR(10));
wprintw(pad,"W");
COLOUR wattrset(pad,COLOR_PAIR(0));
}
for (i = 0; i < (int)(idle / 2); i++)
wprintw(pad," ");
mvwprintw(pad,row, 77, "|");
peak_col = 29 +(int)(cpu_peak[cpu_no]/2);
if(peak_col > 77)
peak_col=77;
mvwprintw(pad,row, peak_col, ">");
} else {
/* Sanity check the numnbers */
if( user < 0.0 || kernel < 0.0 || iowait < 0.0 || idle < 0.0 || idle >100.0) {
user = kernel = iowait = idle = 0;
}
if(cpu_no == 0)
fprintf(fp,"CPU_ALL,%s,%.1lf,%.1lf,%.1lf,%.1lf,,%d\n", LOOP,
user, kernel, iowait, idle,cpus);
else {
fprintf(fp,"CPU%03d,%s,%.1lf,%.1lf,%.1lf,%.1lf\n", cpu_no, LOOP,
user, kernel, iowait, idle);
}
}
}
/* Added variable to remember started children
* 0 - start
* 1 - snap
* 2 - end
*/
#define CHLD_START 0
#define CHLD_SNAP 1
#define CHLD_END 2
int nmon_children[3] = {-1,-1,-1};
void init_pairs()
{
COLOUR init_pair((short)0,(short)7,(short)0); /* White */
COLOUR init_pair((short)1,(short)1,(short)0); /* Red */
COLOUR init_pair((short)2,(short)2,(short)0); /* Green */
COLOUR init_pair((short)3,(short)3,(short)0); /* Yellow */
COLOUR init_pair((short)4,(short)4,(short)0); /* Blue */
COLOUR init_pair((short)5,(short)5,(short)0); /* Magenta */
COLOUR init_pair((short)6,(short)6,(short)0); /* Cyan */
COLOUR init_pair((short)7,(short)7,(short)0); /* White */
COLOUR init_pair((short)8,(short)0,(short)1); /* Red background, red text */
COLOUR init_pair((short)9,(short)0,(short)2); /* Green background, green text */
COLOUR init_pair((short)10,(short)0,(short)4); /* Blue background, blue text */
COLOUR init_pair((short)11,(short)0,(short)3); /* Yellow background, yellow text */
COLOUR init_pair((short)12,(short)0,(short)6); /* Cyan background, cyan text */
}
/* Signal handler
* SIGUSR1 or 2 is used to stop nmon cleanly
* SIGWINCH is used when the window size is changed
*/
void interrupt(int signum)
{
int child_pid;
int waitstatus;
if (signum == SIGCHLD ) {
while((child_pid = waitpid(0, &waitstatus, 0)) == -1 ) {
if( errno == EINTR) /* retry */
continue;
return; /* ECHLD, EFAULT */
}
if(child_pid == nmon_children[CHLD_SNAP])
nmon_children[CHLD_SNAP] = -1;
signal(SIGCHLD, interrupt);
return;
}
if (signum == SIGUSR1 || signum == SIGUSR2) {
maxloops = loop;
return;
}
if (signum == SIGWINCH) {
CURSE endwin(); /* stop + start curses so it works out the # of row and cols */
CURSE initscr();
CURSE cbreak();
signal(SIGWINCH, interrupt);
COLOUR colour = has_colors();
COLOUR start_color();
COLOUR init_pairs();
CURSE clear();
return;
}
CURSE endwin();
exit(0);
}
/* only place the q=previous and p=currect pointers are modified */
void switcher(void)
{
static int which = 1;
int i;
if (which) {
p = &database[0];
q = &database[1];
which = 0;
} else {
p = &database[1];
q = &database[0];
which = 1;
}
if(flash_on)
flash_on = 0;
else
flash_on = 1;
/* Reset flags so /proc/... is re-read in next interval */
for(i=0;i<P_NUMBER;i++) {
proc[i].read_this_interval = 0;
}
#ifdef POWER
lparcfg_processed=0;
#endif
}
/* Lookup the right string */
char *status(int n)
{
switch (n) {
case 0:
return "Run ";
default:
return "Sleep";
}
}
/* Lookup the right process state string */
char *get_state( char n)
{
static char duff[64];
switch (n) {
case 'R': return "Running ";
case 'S': return "Sleeping ";
case 'D': return "DiskSleep";
case 'Z': return "Zombie ";
case 'T': return "Traced ";
case 'W': return "Paging ";
default:
sprintf(duff, "%d", n);
return duff;
}
}
#ifdef GETUSER
/* Convert User id (UID) to a name with caching for speed
* getpwuid() should be NFS/yellow pages safe
*/
char *getuser(uid_t uid)
{
#define NAMESIZE 16
struct user_info {
uid_t uid;
char name[NAMESIZE];
};
static struct user_info *u = NULL;
static int used = 0;
int i;
struct passwd *pw;
i = 0;
if (u != NULL) {
for (i = 0; i < used; i++) {
if (u[i].uid == uid) {
return u[i].name;
}
}
u = (struct user_info *)realloc(u, (sizeof(struct user_info ) * (i + 1)));
} else
u = (struct user_info *)malloc(sizeof(struct user_info ));
used++;
/* failed to find a match so add it */
u[i].uid = uid;
pw = getpwuid(uid);
if (pw != NULL)
strncpy(u[i].name, pw->pw_name, NAMESIZE);
else
sprintf(u[i].name, "unknown%d",uid);
return u[i].name;
}
#endif /* GETUSER */
/* User Defined Disk Groups */
char *save_word(char *in, char *out)
{
int len;
int i;
len = strlen(in);
out[0] = 0;
for (i = 0; i < len; i++) {
if ( isalnum(in[i]) || in[i] == '_' || in[i] == '-' || in[i] == '/' ) {
out[i] = in[i];
out[i+1] = 0;
} else
break;
}
for (; i < len; i++)
if (isalnum(in[i]))
return &in[i];
return &in[i];
}
#define DGROUPS 64
#define DGROUPITEMS 512
char *dgroup_filename;
char *dgroup_name[DGROUPS];
int *dgroup_data;
int dgroup_disks[DGROUPS];
int dgroup_total_disks = 0;
int dgroup_total_groups;
void load_dgroup(struct dsk_stat *dk)
{
FILE * gp;
char line[4096];
char name[1024];
int i, j;
char *nextp;
if (dgroup_loaded == 2)
return;
dgroup_data = MALLOC(sizeof(int)*DGROUPS * DGROUPITEMS);
for (i = 0; i < DGROUPS; i++)
for (j = 0; j < DGROUPITEMS; j++)
dgroup_data[i*DGROUPITEMS+j] = -1;
gp = fopen(dgroup_filename, "r");
if (gp == NULL) {
perror("opening disk group file");
fprintf(stderr,"ERROR: failed to open %s\n", dgroup_filename);
exit(9);
}
for (dgroup_total_groups = 0;
fgets(line, 4096-1, gp) != NULL && dgroup_total_groups < DGROUPS;
dgroup_total_groups++) {
/* save the name */
nextp = save_word(line, name);
if(strlen(name) == 0) { /* was a blank line */
fprintf(stderr,"ERROR nmon:ignoring odd line in diskgroup file \"%s\"\n",line);
/* Decrement dgroup_total_groups by 1 to correct index for next loop */
--dgroup_total_groups;
continue;
}
/* Added +1 to be able to correctly store the terminating \0 character */
dgroup_name[dgroup_total_groups] = MALLOC(strlen(name)+1);
strcpy(dgroup_name[dgroup_total_groups], name);
/* save the hdisks */
for (i = 0; i < DGROUPITEMS && *nextp != 0; i++) {
nextp = save_word(nextp, name);
for (j = 0; j < disks; j++) {
if ( strcmp(dk[j].dk_name, name) == 0 ) {
/*DEBUG printf("DGadd group=%s,name=%s,disk=%s,dgroup_total_groups=%d,dgroup_total_disks=%d,j=%d,i=%d,index=%d.\n",
dgroup_name[dgroup_total_groups],
name, dk[j].dk_name, dgroup_total_groups, dgroup_total_disks, j, i,dgroup_total_groups*DGROUPITEMS+i);
*/
dgroup_data[dgroup_total_groups*DGROUPITEMS+i] = j;
dgroup_disks[dgroup_total_groups]++;
dgroup_total_disks++;
break;
}
}
if (j == disks)
fprintf(stderr,"ERROR nmon:diskgroup file - failed to find disk=%s for group=%s disks known=%d\n",
name, dgroup_name[dgroup_total_groups],disks);
}
}
fclose(gp);
dgroup_loaded = 2;
}
void list_dgroup(struct dsk_stat *dk)
{
int i, j, k, n;
int first = 1;
/* DEBUG for (n = 0, i = 0; i < dgroup_total_groups; i++) {
fprintf(fp, "CCCG,%03d,%s", n++, dgroup_name[i]);
for (j = 0; j < dgroup_disks[i]; j++) {
if (dgroup_data[i*DGROUPITEMS+j] != -1) {
fprintf(fp, ",%d=%d", j, dgroup_data[i*DGROUPITEMS+j]);
}
}
fprintf(fp, "\n");
}
*/
for (n = 0, i = 0; i < dgroup_total_groups; i++) {
if (first) {
fprintf(fp, "BBBG,%03d,User Defined Disk Groups Name,Disks\n", n++);
first = 0;
}
fprintf(fp, "BBBG,%03d,%s", n++, dgroup_name[i]);
for (k = 0, j = 0; j < dgroup_disks[i]; j++) {
if (dgroup_data[i*DGROUPITEMS+j] != -1) {
fprintf(fp, ",%s", dk[dgroup_data[i*DGROUPITEMS+j]].dk_name);
k++;
}
/* add extra line if we have lots to stop spreadsheet line width problems */
if (k == 128) {
fprintf(fp, "\nBBBG,%03d,%s continued", n++, dgroup_name[i]);
}
}
fprintf(fp, "\n");
}
fprintf(fp, "DGBUSY,Disk Group Busy %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGREAD,Disk Group Read KB/s %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGWRITE,Disk Group Write KB/s %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGSIZE,Disk Group Block Size KB %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGXFER,Disk Group Transfers/s %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
/* If requested provide additional data available in /proc/diskstats */
if( extended_disk == 1 && disk_mode == DISK_MODE_DISKSTATS ) {
fprintf(fp, "DGREADS,Disk Group read/s %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGREADMERGE,Disk Group merged read/s %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGREADSERV,Disk Group read service time (SUM ms) %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGWRITES,Disk Group write/s %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGWRITEMERGE,Disk Group merged write/s %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGWRITESERV,Disk Group write service time (SUM ms) %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGINFLIGHT,Disk Group in flight IO %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
fprintf(fp, "DGIOTIME,Disk Group time spent for IO (ms) %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
#ifdef EXPERIMENTAL
fprintf(fp, "DGF11,Disk Group field 11 %s", hostname);
for (i = 0; i < DGROUPS; i++) {
if (dgroup_name[i] != 0)
fprintf(fp, ",%s", dgroup_name[i]);
}
fprintf(fp, "\n");
#endif /*EXPERIMENTAL*/
}
}
void hint(void)
{
printf("\nHint: %s [-h] [-s <seconds>] [-c <count>] [-f -d <disks> -t -r <name>] [-x]\n\n", progname);
printf("\t-h FULL help information\n");
printf("\tInteractive-Mode:\n");
printf("\tread startup banner and type: \"h\" once it is running\n");
printf("\tFor Data-Collect-Mode (-f)\n");
printf("\t-f spreadsheet output format [note: default -s300 -c288]\n");
printf("\toptional\n");
printf("\t-s <seconds> between refreshing the screen [default 2]\n");
printf("\t-c <number> of refreshes [default millions]\n");
printf("\t-d <disks> to increase the number of disks [default 256]\n");
printf("\t-t spreadsheet includes top processes\n");
printf("\t-x capacity planning (15 min for 1 day = -fdt -s 900 -c 96)\n");
printf("\n");
}
void help(void)
{
hint();
printf("Version - %s\n\n",SccsId);
printf("For Interactive-Mode\n");
printf("\t-s <seconds> time between refreshing the screen [default 2]\n");
printf("\t-c <number> of refreshes [default millions]\n");
printf("\t-g <filename> User Defined Disk Groups [hit g to show them]\n");
printf("\t - file = on each line: group_name <disks list> space separated\n");
printf("\t - like: database sdb sdc sdd sde\n");
printf("\t - upto 64 disk groups, 512 disks per line\n");
printf("\t - disks can appear more than once and in many groups\n");
printf("\t-b black and white [default is colour]\n");
printf("\texample: %s -s 1 -c 100\n",progname);
printf("\n");
printf("For Data-Collect-Mode = spreadsheet format (comma separated values)\n");
printf("\tNote: use only one of f,F,z,x or X and make it the first argument\n");
printf("\t-f spreadsheet output format [note: default -s300 -c288]\n");
printf("\t\t\t output file is <hostname>_YYYYMMDD_HHMM.nmon\n");
printf("\t-F <filename> same as -f but user supplied filename\n");
printf("\t-r <runname> used in the spreadsheet file [default hostname]\n");
printf("\t-t include top processes in the output\n");
printf("\t-T as -t plus saves command line arguments in UARG section\n");
printf("\t-s <seconds> between snap shots\n");
printf("\t-c <number> of snapshots before nmon stops\n");
printf("\t-d <disks> to increase the number of disks [default 256]\n");
printf("\t-l <dpl> disks/line default 150 to avoid spreadsheet issues. EMC=64.\n");
printf("\t-g <filename> User Defined Disk Groups (see above) - see BBBG & DG lines\n");
printf("\t-N include NFS Network File System\n");
printf("\t-I <percent> Include process & disks busy threshold (default 0.1)\n");
printf("\t don't save or show proc/disk using less than this percent\n");
printf("\t-m <directory> nmon changes to this directory before saving to file\n");
printf("\texample: collect for 1 hour at 30 second intervals with top procs\n");
printf("\t\t %s -f -t -r Test1 -s30 -c120\n",progname);
printf("\n");
printf("\tTo load into a spreadsheet:\n");
printf("\tsort -A *nmon >stats.csv\n");
printf("\ttransfer the stats.csv file to your PC\n");
printf("\tStart spreadsheet & then Open type=comma-separated-value ASCII file\n");
printf("\t The nmon analyser or consolidator does not need the file sorted.\n");
printf("\n");
printf("Capacity planning mode - use cron to run each day\n");
printf("\t-x sensible spreadsheet output for CP = one day\n");
printf("\t every 15 mins for 1 day ( i.e. -ft -s 900 -c 96)\n");
printf("\t-X sensible spreadsheet output for CP = busy hour\n");
printf("\t every 30 secs for 1 hour ( i.e. -ft -s 30 -c 120)\n");
printf("\n");
printf("Interactive Mode Commands\n");
printf("\tkey --- Toggles to control what is displayed ---\n");
printf("\th = Online help information\n");
printf("\tr = Machine type, machine name, cache details and OS version + LPAR\n");
printf("\tc = CPU by processor stats with bar graphs\n");
printf("\tl = long term CPU (over 75 snapshots) with bar graphs\n");
printf("\tm = Memory stats\n");
printf("\tL = Huge memory page stats\n");
printf("\tV = Virtual Memory and Swap stats\n");
printf("\tk = Kernel Internal stats\n");
printf("\tn = Network stats and errors\n");
printf("\tN = NFS Network File System\n");
printf("\td = Disk I/O Graphs\n");
printf("\tD = Disk I/O Stats\n");
printf("\to = Disk I/O Map (one character per disk showing how busy it is)\n");
printf("\to = User Defined Disk Groups\n");
printf("\tj = File Systems \n");
printf("\tt = Top Process stats use 1,3,4,5 to select the data & order\n");
printf("\tu = Top Process full command details\n");
printf("\tv = Verbose mode - tries to make recommendations\n");
#ifdef PARTITIONS
printf("\tP = Partitions Disk I/O Stats\n");
#endif
#ifdef POWER
printf("\tp = Logical Partitions Stats\n");
#endif
printf("\tb = black and white mode (or use -b option)\n");
printf("\t. = minimum mode i.e. only busy disks and processes\n");
printf("\n");
printf("\tkey --- Other Controls ---\n");
printf("\t+ = double the screen refresh time\n");
printf("\t- = halves the screen refresh time\n");
printf("\tq = quit (also x, e or control-C)\n");
printf("\t0 = reset peak counts to zero (peak = \">\")\n");
printf("\tspace = refresh screen now\n");
printf("\n");
printf("Startup Control\n");
printf("\tIf you find you always type the same toggles every time you start\n");
printf("\tthen place them in the NMON shell variable. For example:\n");
printf("\t export NMON=cmdrvtan\n");
printf("\n");
printf("Others:\n");
printf("\ta) To you want to stop nmon - kill -USR2 <nmon-pid>\n");
printf("\tb) Use -p and nmon outputs the background process pid\n");
printf("\tc) To limit the processes nmon lists (online and to a file)\n");
printf("\t Either set NMONCMD0 to NMONCMD63 to the program names\n");
printf("\t or use -C cmd:cmd:cmd etc. example: -C ksh:vi:syncd\n");
printf("\td) If you want to pipe nmon output to other commands use a FIFO:\n");
printf("\t mkfifo /tmp/mypipe\n");
printf("\t nmon -F /tmp/mypipe &\n");
printf("\t grep /tmp/mypipe\n");
printf("\te) If nmon fails please report it with:\n");
printf("\t 1) nmon version like: %s\n",VERSION);
printf("\t 2) the output of cat /proc/cpuinfo\n");
printf("\t 3) some clue of what you were doing\n");
printf("\t 4) I may ask you to run the debug version\n");
printf("\n");
printf("\tDeveloper Nigel Griffiths\n");
printf("\tFeedback welcome - on the current release only and state exactly the problem\n");
printf("\tNo warranty given or implied.\n");
exit(0);
}
#define JFSMAX 128
#define LOAD 1
#define UNLOAD 0
#define JFSNAMELEN 64
#define JFSTYPELEN 8
struct jfs {
char name[JFSNAMELEN];
char device[JFSNAMELEN];
char type[JFSNAMELEN];
int fd;
int mounted;
} jfs[JFSMAX];
int jfses =0;
void jfs_load(int load)
{
int i;
struct stat stat_buffer;
FILE * mfp; /* FILE pointer for mtab file*/
struct mntent *mp; /* mnt point stats */
static int jfs_loaded = 0;
if(load==LOAD) {
if(jfs_loaded == 0) {
mfp = setmntent("/etc/mtab","r");
for(i=0; i<JFSMAX && (mp = getmntent(mfp) ) != NULL; i++) {
strncpy(jfs[i].device, mp->mnt_fsname,JFSNAMELEN);
strncpy(jfs[i].name,mp->mnt_dir,JFSNAMELEN);
strncpy(jfs[i].type, mp->mnt_type,JFSTYPELEN);
mp->mnt_fsname[JFSNAMELEN-1]=0;
mp->mnt_dir[JFSNAMELEN-1]=0;
mp->mnt_type[JFSTYPELEN-1]=0;
}
endfsent();
jfs_loaded = 1;
jfses=i;
}
/* 1st or later time - just reopen the mount points */
for(i=0;i<JFSMAX && jfs[i].name[0] !=0;i++) {
if(stat(jfs[i].name, &stat_buffer) != -1 ) {
jfs[i].fd = open(jfs[i].name, O_RDONLY);
if(jfs[i].fd != -1 )
jfs[i].mounted = 1;
else
jfs[i].mounted = 0;
}
else jfs[i].mounted = 0;
}
} else { /* this is an unload request */
if(jfs_loaded)
for(i=0;i<JFSMAX && jfs[i].name[0] != 0;i++) {
if(jfs[i].mounted)
close(jfs[i].fd);
jfs[i].fd=0;
}
else
/* do nothing */ ;
}
}
/* We order this array rather than the actual process tables
* the index is the position in the process table and
* the time is the CPU used in the last period in seconds
*/
struct topper {
int index;
int other;
double size;
double io;
int time;
} *topper;
int topper_size = 200;
/* Routine used by qsort to order the processes by CPU usage */
int cpu_compare(const void *a, const void *b)
{
return (int)(((struct topper *)b)->time - ((struct topper *)a)->time);
}
int size_compare(const void *a, const void *b)
{
return (int)((((struct topper *)b)->size - ((struct topper *)a)->size));
}
int disk_compare(void *a, void *b)
{
return (int)((((struct topper *)b)->io - ((struct topper *)a)->io));
}
/* checkinput is the subroutine to handle user input */
int checkinput(void)
{
static int use_env = 1;
char buf[1024];
int bytes;
int chars;
int i;
char *p;
if (!cursed) /* not user input so stop with control-C */
return 0;
ioctl(fileno(stdin), FIONREAD, &bytes);
if (bytes > 0 || use_env) {
if(use_env) {
use_env = 0;
p=getenv("NMON");
if(p!=0){
strcpy(buf,p);
chars = strlen(buf);
}
else chars = 0;
}
else
chars = read(fileno(stdin), buf, bytes);
if (chars > 0) {
welcome = 0;
for (i = 0; i < chars; i++) {
switch (buf[i]) {
case 'x':
case 'q':
nocbreak();
endwin();
exit(0);
case '6':
case '7':
case '8':
case '9':
dotline = buf[i] - '0';
break;
case '+':
seconds = seconds * 2;
break;
case '-':
seconds = seconds / 2;
if (seconds < 1)
seconds = 1;
break;
case '.':
if (show_all)
show_all = 0;
else {
show_all = 1;
show_disk = SHOW_DISK_STATS;
show_top = 1;
show_topmode =3;
}
clear();
break;
case '?':
case 'h':
case 'H':
if (show_help)
show_help = 0;
else {
show_help = 1;
show_verbose = 0;
}
clear();
break;
case 'b':
case 'B':
FLIP(colour);
clear();
break;
case 'Z':
FLIP(show_raw);
show_smp=1;
clear();
break;
case 'l':
FLIP (show_longterm);
clear();
break;
case 'p':
FLIP(show_lpar);
clear();
break;
case 'V':
FLIP(show_vm);
clear();
break;
case 'j':
case 'J':
FLIP(show_jfs);
jfs_load(show_jfs);
clear();
break;
#ifdef PARTITIONS
case 'P':
FLIP(show_partitions);
clear();
break;
#endif /*PARTITIONS*/
case 'k':
case 'K':
FLIP(show_kernel);
clear();
break;
case 'm':
case 'M':
FLIP(show_memory);
clear();
break;
case 'L':
FLIP(show_large);
clear();
break;
case 'D':
switch (show_disk) {
case SHOW_DISK_NONE:
show_disk = SHOW_DISK_STATS;
break;
case SHOW_DISK_STATS:
show_disk = SHOW_DISK_NONE;
break;
case SHOW_DISK_GRAPH:
show_disk = SHOW_DISK_STATS;
break;
}
clear();
break;
case 'd':
switch (show_disk) {
case SHOW_DISK_NONE:
show_disk = SHOW_DISK_GRAPH;
break;
case SHOW_DISK_STATS:
show_disk = SHOW_DISK_GRAPH;
break;
case SHOW_DISK_GRAPH:
show_disk = 0;
break;
}
clear();
break;
case 'o':
case 'O':
FLIP(show_diskmap);
clear();
break;
case 'n':
if (show_net) {
show_net = 0;
show_neterror = 0;
} else {
show_net = 1;
show_neterror = 3;
}
clear();
break;
case 'N':
if(show_nfs == 0)
show_nfs = 1;
else if(show_nfs == 1)
show_nfs = 2;
else if(show_nfs == 2)
show_nfs = 0;
nfs_clear=1;
clear();
break;
case 'c':
case 'C':
FLIP(show_smp);
clear();
break;
case 'r':
case 'R':
FLIP(show_cpu);
clear();
break;
case 't':
show_topmode = 3; /* Fall Through */
case 'T':
FLIP(show_top);
clear();
break;
case 'v':
FLIP(show_verbose);
clear();
break;
case 'u':
if (show_args == ARGS_NONE) {
args_load();
show_args = ARGS_ONLY;
show_top = 1;
if( show_topmode != 3 &&
show_topmode != 4 &&
show_topmode != 5 )
show_topmode = 3;
} else
show_args = ARGS_NONE;
clear();
break;
case '1':
show_topmode = 1;
show_top = 1;
clear();
break;
/*
case '2':
show_topmode = 2;
show_top = 1;
clear();
break;
*/
case '3':
show_topmode = 3;
show_top = 1;
clear();
break;
case '4':
show_topmode = 4;
show_top = 1;
clear();
break;
case '5':
show_topmode = 5;
show_top = 1;
clear();
break;
case '0':
for(i=0;i<(max_cpus+1);i++)
cpu_peak[i]=0;
for(i=0;i<networks;i++) {
net_read_peak[i]=0.0;
net_write_peak[i]=0.0;
}
for(i=0;i<disks;i++) {
disk_busy_peak[i]=0.0;
disk_rate_peak[i]=0.0;
}
snap_clear();
aiocount_max = 0;
aiotime_max = 0.0;
aiorunning_max = 0;
huge_peak = 0;
break;
case ' ':
clear();
break;
case 'g':
FLIP(show_dgroup);
clear();
break;
default: return 0;
}
}
return 1;
}
}
return 0;
}
void go_background(int def_loops, int def_secs)
{
cursed = 0;
if (maxloops == -1)
maxloops = def_loops;
if (seconds == -1)
seconds = def_secs;
show_cpu = 1;
show_smp = 1;
show_disk = SHOW_DISK_STATS;
show_jfs = 1;
show_memory = 1;
show_large = 1;
show_kernel = 1;
show_net = 1;
show_all = 1;
show_top = 0; /* top process */
show_topmode = 3;
show_partitions = 1;
show_lpar = 1;
show_vm = 1;
}
void proc_net()
{
static FILE *fp = (FILE *)-1;
char buf[1024];
int i=0;
int ret;
unsigned long junk;
if( fp == (FILE *)-1) {
if( (fp = fopen("/proc/net/dev","r")) == NULL) {
error("failed to open - /proc/net/dev");
networks=0;
return;
}
}
if(fgets(buf,1024,fp) == NULL) goto end; /* throw away the header lines */
if(fgets(buf,1024,fp) == NULL) goto end; /* throw away the header lines */
/*
Inter-| Receive | Transmit
face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed
lo: 1956 30 0 0 0 0 0 0 1956 30 0 0 0 0 0 0
eth0: 0 0 0 0 0 0 0 0 458718 0 781 0 0 0 781 0
sit0: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
eth1: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
*/
for(i=0;i<NETMAX;i++) {
if(fgets(buf,1024,fp) == NULL)
break;
strip_spaces(buf);
/* 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 */
ret = sscanf(&buf[0], "%s %llu %llu %lu %lu %lu %lu %lu %lu %llu %llu %lu %lu %lu %lu %lu",
(char *)&p->ifnets[i].if_name,
&p->ifnets[i].if_ibytes,
&p->ifnets[i].if_ipackets,
&p->ifnets[i].if_ierrs,
&p->ifnets[i].if_idrop,
&p->ifnets[i].if_ififo,
&p->ifnets[i].if_iframe,
&junk,
&junk,
&p->ifnets[i].if_obytes,
&p->ifnets[i].if_opackets,
&p->ifnets[i].if_oerrs,
&p->ifnets[i].if_odrop,
&p->ifnets[i].if_ofifo,
&p->ifnets[i].if_ocolls,
&p->ifnets[i].if_ocarrier
);
if(ret != 16)
fprintf(stderr,"sscanf wanted 16 returned = %d line=%s\n", ret, (char *)buf);
}
end:
if(reread) {
fclose(fp);
fp = (FILE *)-1;
} else rewind(fp);
networks = i;
}
int proc_procsinfo(int pid, int index)
{
FILE *fp;
char filename[64];
char buf[1024*4];
int size=0;
int ret=0;
int count=0;
sprintf(filename,"/proc/%d/stat",pid);
if( (fp = fopen(filename,"r")) == NULL) {
sprintf(buf,"failed to open file %s",filename);
error(buf);
return 0;
}
size = fread(buf, 1, 1024-1, fp);
fclose(fp);
if(size == -1) {
#ifdef DEBUG
fprintf(stderr,"procsinfo read returned = %d assuming process stopped pid=%d\n", ret,pid);
#endif /*DEBUG*/
return 0;
}
ret = sscanf(buf, "%d (%s)",
&p->procs[index].pi_pid,
&p->procs[index].pi_comm[0]);
if(ret != 2) {
fprintf(stderr,"procsinfo sscanf returned = %d line=%s\n", ret,buf);
return 0;
}
p->procs[index].pi_comm[strlen(p->procs[index].pi_comm)-1] = 0;
for(count=0; count<size;count++) /* now look for ") " as dumb Infiniban driver includes "()" */
if(buf[count] == ')' && buf[count+1] == ' ' ) break;
if(count == size) {
#ifdef DEBUG
fprintf(stderr,"procsinfo failed to find end of command buf=%s\n", buf);
#endif /*DEBUG*/
return 0;
}
count++; count++;
ret = sscanf(&buf[count],
#ifndef KERNEL_2_6_18
"%c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld %lu %lu %ld %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %d %d",
#else
"%c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld %lu %lu %ld %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu %llu",
#endif
&p->procs[index].pi_state,
&p->procs[index].pi_ppid,
&p->procs[index].pi_pgrp,
&p->procs[index].pi_session,
&p->procs[index].pi_tty_nr,
&p->procs[index].pi_tty_pgrp,
&p->procs[index].pi_flags,
&p->procs[index].pi_minflt,
&p->procs[index].pi_cmin_flt,
&p->procs[index].pi_majflt,
&p->procs[index].pi_cmaj_flt,
&p->procs[index].pi_utime,
&p->procs[index].pi_stime,
&p->procs[index].pi_cutime,
&p->procs[index].pi_cstime,
&p->procs[index].pi_pri,
&p->procs[index].pi_nice,
#ifndef KERNEL_2_6_18
&p->procs[index].junk,
#else
&p->procs[index].pi_num_threads,
#endif
&p->procs[index].pi_it_real_value,
&p->procs[index].pi_start_time,
&p->procs[index].pi_vsize,
&p->procs[index].pi_rss,
&p->procs[index].pi_rlim_cur,
&p->procs[index].pi_start_code,
&p->procs[index].pi_end_code,
&p->procs[index].pi_start_stack,
&p->procs[index].pi_esp,
&p->procs[index].pi_eip,
&p->procs[index].pi_pending_signal,
&p->procs[index].pi_blocked_sig,
&p->procs[index].pi_sigign,
&p->procs[index].pi_sigcatch,
&p->procs[index].pi_wchan,
&p->procs[index].pi_nswap,
&p->procs[index].pi_cnswap,
&p->procs[index].pi_exit_signal,
&p->procs[index].pi_cpu
#ifdef KERNEL_2_6_18
,
&p->procs[index].pi_rt_priority,
&p->procs[index].pi_policy,
&p->procs[index].pi_delayacct_blkio_ticks
#endif
);
#ifndef KERNEL_2_6_18
if(ret != 37) {
fprintf(stderr,"procsinfo2 sscanf wanted 37 returned = %d pid=%d line=%s\n", ret,pid,buf);
#else
if(ret != 40) {
fprintf(stderr,"procsinfo2 sscanf wanted 40 returned = %d pid=%d line=%s\n", ret,pid,buf);
#endif
return 0;
}
sprintf(filename,"/proc/%d/statm",pid);
if( (fp = fopen(filename,"r")) == NULL) {
sprintf(buf,"failed to open file %s",filename);
error(buf);
return 0;
}
size = fread(buf, 1, 1024*4-1, fp);
fclose(fp); /* close it even if the read failed, the file could have been removed
between open & read i.e. the device driver does not behave like a file */
if(size == -1) {
sprintf(buf,"failed to read file %s",filename);
error(buf);
return 0;
}
ret = sscanf(&buf[0], "%lu %lu %lu %lu %lu %lu %lu",
&p->procs[index].statm_size,
&p->procs[index].statm_resident,
&p->procs[index].statm_share,
&p->procs[index].statm_trs,
&p->procs[index].statm_lrs,
&p->procs[index].statm_drs,
&p->procs[index].statm_dt
);
if(ret != 7) {
fprintf(stderr,"sscanf wanted 7 returned = %d line=%s\n", ret,buf);
return 0;
}
return 1;
}
#ifdef DEBUGPROC
print_procs(int index)
{
printf("procs[%d].pid =%d\n",index,procs[index].pi_pid);
printf("procs[%d].comm[0] =%s\n",index,&procs[index].pi_comm[0]);
printf("procs[%d].state =%c\n",index,procs[index].pi_state);
printf("procs[%d].ppid =%d\n",index,procs[index].pi_ppid);
printf("procs[%d].pgrp =%d\n",index,procs[index].pi_pgrp);
printf("procs[%d].session =%d\n",index,procs[index].pi_session);
printf("procs[%d].tty_nr =%d\n",index,procs[index].pi_tty_nr);
printf("procs[%d].tty_pgrp =%d\n",index,procs[index].pi_tty_pgrp);
printf("procs[%d].flags =%lu\n",index,procs[index].pi_flags);
printf("procs[%d].minflt =%lu\n",index,procs[index].pi_minflt);
printf("procs[%d].cmin_flt =%lu\n",index,procs[index].pi_cmin_flt);
printf("procs[%d].majflt =%lu\n",index,procs[index].pi_majflt);
printf("procs[%d].cmaj_flt =%lu\n",index,procs[index].pi_cmaj_flt);
printf("procs[%d].utime =%lu\n",index,procs[index].pi_utime);
printf("procs[%d].stime =%lu\n",index,procs[index].pi_stime);
printf("procs[%d].cutime =%ld\n",index,procs[index].pi_cutime);
printf("procs[%d].cstime =%ld\n",index,procs[index].pi_cstime);
printf("procs[%d].pri =%d\n",index,procs[index].pi_pri);
printf("procs[%d].nice =%d\n",index,procs[index].pi_nice);
#ifndef KERNEL_2_6_18
printf("procs[%d].junk =%d\n",index,procs[index].junk);
#else
printf("procs[%d].num_threads =%ld\n",index,procs[index].num_threads);
#endif
printf("procs[%d].it_real_value =%lu\n",index,procs[index].pi_it_real_value);
printf("procs[%d].start_time =%lu\n",index,procs[index].pi_start_time);
printf("procs[%d].vsize =%lu\n",index,procs[index].pi_vsize);
printf("procs[%d].rss =%lu\n",index,procs[index].pi_rss);
printf("procs[%d].rlim_cur =%lu\n",index,procs[index].pi_rlim_cur);
printf("procs[%d].start_code =%lu\n",index,procs[index].pi_start_code);
printf("procs[%d].end_code =%lu\n",index,procs[index].pi_end_code);
printf("procs[%d].start_stack =%lu\n",index,procs[index].pi_start_stack);
printf("procs[%d].esp =%lu\n",index,procs[index].pi_esp);
printf("procs[%d].eip =%lu\n",index,procs[index].pi_eip);
printf("procs[%d].pending_signal=%lu\n",index,procs[index].pi_pending_signal);
printf("procs[%d].blocked_sig =%lu\n",index,procs[index].pi_blocked_sig);
printf("procs[%d].sigign =%lu\n",index,procs[index].pi_sigign);
printf("procs[%d].sigcatch =%lu\n",index,procs[index].pi_sigcatch);
printf("procs[%d].wchan =%lu\n",index,procs[index].pi_wchan);
printf("procs[%d].nswap =%lu\n",index,procs[index].pi_nswap);
printf("procs[%d].cnswap =%lu\n",index,procs[index].pi_cnswap);
printf("procs[%d].exit_signal =%d\n",index,procs[index].pi_exit_signal);
printf("procs[%d].cpu =%d\n",index,procs[index].pi_cpu);
#ifdef KERNEL_2_6_18
printf("procs[%d].rt_priority =%lu\n",index,procs[index].pi_rt_priority);
printf("procs[%d].policy =%lu\n",index,procs[index].pi_policy);
printf("procs[%d].delayacct_blkio_ticks=%llu\n",index,procs[index].pi_delayacct_blkio_ticks);
#endif
printf("OK\n");
}
#endif /*DEBUG*/
/* --- */
int isnumbers(char *s)
{
while(*s != 0) {
if( *s < '0' || *s > '9')
return 0;
s++;
}
return 1;
}
int getprocs(int details)
{
struct dirent *dent;
DIR *procdir;
int count =0;
if((char *)(procdir = opendir("/proc")) == NULL) {
printf("opendir(/proc) failed");
return 0;
}
while( (char *)(dent = readdir(procdir)) != NULL ) {
if(dent->d_type == 4) { /* is this a directlory */
/* mainframes report 0 = unknown every time !!!! */
/*
printf("inode=%d type=%d name=%s\n",
dent->d_ino,
dent->d_type,
dent->d_name);
*/
if(isnumbers(dent->d_name)) {
/* printf("%s pid\n",dent->d_name); */
if(details) {
count=count+proc_procsinfo(atoi(dent->d_name),count);
} else {
count++;
}
}
/*
else
printf("NOT numbers\n");
*/
}
}
closedir(procdir);
return count;
}
/* --- */
char cpu_line[] = "---------------------------+-------------------------------------------------+";
/* Start process as specified in cmd in a child process without waiting
* for completion
* not sure if want to prevent this funcitonality for root user
* when: CHLD_START, CHLD_SNAP or CHLD_END
* cmd: pointer to command string - assumed to be cleansed ....
* timestamp_type: 0 - T%04d, 1 - detailed time stamp
* loop: loop id (0 for CHLD_START)
* the_time: time to use for timestamp generation
*/
void child_start(int when,
char *cmd,
int timestamp_type,
int loop,
time_t the_time)
{
int i;
pid_t child_pid;
char time_stamp_str[20]="";
char *when_info="";
struct tm *tim; /* used to work out the hour/min/second */
#ifdef DEBUG2
fprintf(fp,"child start when=%d cmd=%s time=%d loop=%d\n",when,cmd,timestamp_type,loop);
#endif
/* Validate parameter and initialize error text */
switch( when ) {
case CHLD_START:
when_info = "nmon fork exec failure CHLD_START";
break;
case CHLD_END:
when_info = "nmon fork exec failure CHLD_END";
break;
case CHLD_SNAP:
/* check if old child has finished - otherwise we do nothing */
if( nmon_children[CHLD_SNAP] != -1 ) {
if(!cursed)fprintf(fp,"ERROR,T%04d, Starting snap command \"%s\" failed as previous child still running - killing it now\n", loop, cmd);
kill( nmon_children[CHLD_SNAP],9);
}
when_info = "nmon fork exec failure CHLD_SNAP";
break;
}
/* now fork off a child process. */
switch (child_pid = fork()) {
case -1: /* fork failed. */
perror(when_info);
return;
case 0: /* inside child process. */
/* create requested timestamp */
if( timestamp_type == 1 ) {
tim = localtime(&the_time);
sprintf(time_stamp_str,"%02d:%02d:%02d,%02d,%02d,%04d",
tim->tm_hour, tim->tm_min, tim->tm_sec,
tim->tm_mday, tim->tm_mon + 1, tim->tm_year + 1900);
}
else {
sprintf(time_stamp_str,"T%04d", loop);
}
/* close all open file pointers except the defaults */
for( i=3; i<5; ++i )
close(i);
/* Now switch to the defined command */
execlp(cmd, cmd, time_stamp_str,(void *)0);
/* If we get here the specified command could not be started */
perror(when_info);
exit(1); /* We can't do anything more */
/* never reached */
default: /* inside parent process. */
/* In father - remember child pid for future */
nmon_children[when] = child_pid;
}
}
int main(int argc, char **argv)
{
int secs;
int cpu_idle;
int cpu_user;
int cpu_sys;
int cpu_wait;
int n=0; /* reusable counters */
int i=0;
int j=0;
int k=0;
int ret=0;
int max_sorted;
int skipped;
int x = 0; /* curses row */
int y = 0; /* curses column */
double elapsed; /* actual seconds between screen updates */
double cpu_sum;
double cpu_busy;
double ftmp;
int top_first_time =1;
int disk_first_time =1;
int nfs_first_time =1;
int vm_first_time =1;
int bbbr_line=0;
#ifdef POWER
int lpar_first_time =1;
#endif /* POWER */
int smp_first_time =1;
int proc_first_time =1;
pid_t firstproc = (pid_t)0;
pid_t childpid = -1;
int ralfmode = 0;
char pgrp[32];
struct tm *tim; /* used to work out the hour/min/second */
float total_busy; /* general totals */
float total_rbytes; /* general totals */
float total_wbytes;
float total_xfers;
struct utsname uts; /* UNIX name, version, etc */
double top_disk_busy = 0.0;
char *top_disk_name = "";
int disk_mb;
double disk_total;
double disk_busy;
double disk_read;
double disk_size;
double disk_write;
double disk_xfers;
double total_disk_read;
double total_disk_write;
double total_disk_xfers;
double readers;
double writers;
/* for popen on oslevel */
char str[512];
char * str_p;
int varperftmp = 0;
char *formatstring;
char user_filename[512];
char user_filename_set = 0;
struct statfs statfs_buffer;
float fs_size;
float fs_bsize;
float fs_free;
float fs_size_used;
char cmdstr[256];
int disk_stats_read = 0;
int updays, uphours, upmins;
float v2c_total;
float v2s_total;
float v3c_total;
float v3s_total;
float v4c_total;
float v4s_total;
int room =1;
int errors=0;
WINDOW * padmem = NULL;
WINDOW * padlarge = NULL;
WINDOW * padpage = NULL;
WINDOW * padker = NULL;
WINDOW * padres = NULL;
WINDOW * padnet = NULL;
WINDOW * padneterr = NULL;
WINDOW * padnfs = NULL;
WINDOW * padcpu = NULL;
WINDOW * padsmp = NULL;
WINDOW * padlong = NULL;
WINDOW * paddisk = NULL;
WINDOW * paddg = NULL;
WINDOW * padmap = NULL;
WINDOW * padtop = NULL;
WINDOW * padjfs = NULL;
WINDOW * padlpar = NULL;
WINDOW * padverb = NULL;
WINDOW * padhelp = NULL;
char *nmon_start = (char *)NULL;
char *nmon_end = (char *)NULL;
char *nmon_snap = (char *)NULL;
char *nmon_tmp = (char *)NULL;
int nmon_one_in = 1;
/* Flag what kind of time stamp we give to started children
* 0: "T%04d"
* 1: "hh:mm:ss,dd,mm,yyyy"
*/
int time_stamp_type =0;
unsigned long pagesize = 1024*4; /* Default page size is 4 KB but newer servers compiled with 64 KB pages */
#define MAXROWS 256
#define MAXCOLS 150 /* changed to allow maximum column widths */
#define BANNER(pad,string) {mvwhline(pad, 0, 0, ACS_HLINE,COLS-2); \
wmove(pad,0,0); \
wattron(pad,A_STANDOUT); \
wprintw(pad," "); \
wprintw(pad,string); \
wprintw(pad," "); \
wattroff(pad,A_STANDOUT); }
#define DISPLAY(pad,rows) { \
if(x+2+(rows)>LINES)\
pnoutrefresh(pad, 0,0,x,1,LINES-2,COLS-2); \
else \
pnoutrefresh(pad, 0,0,x,1,x+rows+1,COLS-2); \
x=x+(rows); \
if(x+4>LINES) { \
room=0; \
mvwprintw(stdscr,LINES-1,10,"Warning: Some Statistics may not shown"); \
} \
}
/* check the user supplied options */
progname = argv[0];
for (i=(int)strlen(progname)-1;i>0;i--)
if(progname[i] == '/') {
progname = &progname[i+1];
}
if(getenv("NMONDEBUG") != NULL)
debug=1;
if(getenv("NMONERROR") != NULL)
error_on=1;
if(getenv("NMONBUG1") != NULL)
reread=1;
if (getenv("NMONDEBUG") != NULL)
debug = 1;
if ((nmon_start = getenv("NMON_START")) != NULL) {
nmon_start = check_call_string(nmon_start, "NMON_START");
}
if ((nmon_end = getenv("NMON_END")) != NULL) {
nmon_end = check_call_string(nmon_end, "NMON_END");
}
if ((nmon_tmp = getenv("NMON_ONE_IN")) != NULL) {
nmon_one_in = atoi(nmon_tmp);
if( errno != 0 ) {
fprintf(stderr,"ERROR nmon: invalid NMON_ONE_IN shell variable\n");
nmon_one_in = 1;
}
}
if ((nmon_snap = getenv("NMON_SNAP")) != NULL) {
nmon_snap = check_call_string(nmon_snap, "NMON_SNAP");
}
if ((nmon_tmp = getenv("NMON_TIMESTAMP")) != NULL) {
time_stamp_type = atoi(nmon_tmp);
if (time_stamp_type != 0 && time_stamp_type != 1 )
time_stamp_type = 1;
}
#ifdef DEBUG2
printf("NMON_START=%s.\n",nmon_start);
printf("NMON_END=%s.\n",nmon_end);
printf("NMON_SNAP=%s.\n",nmon_snap);
printf("ONE_IN=%d.\n",nmon_one_in);
printf("TIMESTAMP=%d.\n",time_stamp_type);
#endif
#ifdef REREAD
reread=1;
#endif
for(i=0; i<CMDMAX;i++) {
sprintf(cmdstr,"NMONCMD%d",i);
cmdlist[i] = getenv(cmdstr);
if(cmdlist[i] != 0)
cmdfound = i+1;
}
/* Setup long and short Hostname */
gethostname(hostname, sizeof(hostname));
strcpy(fullhostname, hostname);
for (i = 0; i < sizeof(hostname); i++)
if (hostname[i] == '.')
hostname[i] = 0;
if(run_name_set == 0)
strcpy(run_name,hostname);
/* Check the version of OS */
uname(&uts);
if(sysconf(_SC_PAGESIZE) > 1024*4) /* Check if we have the large 64 KB memory page sizes compiled in to the kernel */
pagesize = sysconf(_SC_PAGESIZE);
proc_init();
while ( -1 != (i = getopt(argc, argv, "?Rhs:bc:Dd:fF:r:tTxXzeEl:qpC:Vg:Nm:I:Z" ))) {
switch (i) {
case '?':
hint();
exit(0);
case 'h':
help();
break;
case 's':
seconds = atoi(optarg);
break;
case 'p':
ralfmode = 1;
break;
case 'b':
colour = 0;
break;
case 'c':
maxloops = atoi(optarg);
break;
case 'N':
show_nfs = 1;
break;
case 'm':
if(chdir(optarg) == -1) {
perror("changing directory failed");
printf("Directory attempted was:%s\n",optarg);
exit(993);
}
break;
case 'I':
ignore_procdisk_threshold = atof(optarg);
break;
case 'd':
diskmax = atoi(optarg);
if(diskmax < DISKMIN) {
printf("nmon: ignoring -d %d option as the minimum is %d\n", diskmax, DISKMIN);
diskmax = DISKMIN;
}
break;
case 'D':
extended_disk=1;
break;
case 'R':
show_rrd = 1;
go_background(288, 300);
show_aaa = 0;
show_para = 0;
show_headings = 0;
break;
case 'r': strcpy(run_name,optarg);
run_name_set++;
break;
case 'F': /* background mode with user supplied filename */
strcpy(user_filename,optarg);
user_filename_set++;
go_background(288, 300);
break;
case 'f': /* background mode i.e. for spread sheet output */
go_background(288, 300);
break;
case 'T':
show_args = ARGS_ONLY; /* drop through */
case 't':
show_top = 1; /* put top process output in spreadsheet mode */
show_topmode = 3;
break;
case 'z': /* background mode for 1 day output to /var/perf/tmp */
varperftmp++;
go_background(4*24, 15*60);
break;
case 'x': /* background mode for 1 day capacity planning */
go_background(4*24, 15*60);
show_top =1;
show_topmode = 3;
break;
case 'X': /* background mode for 1 hour capacity planning */
go_background(120, 30);
show_top =1;
show_topmode = 3;
break;
case 'Z':
show_raw=1;
break;
case 'l':
disks_per_line = atoi(optarg);
if(disks_per_line < 3 || disks_per_line >250) disks_per_line = 100;
break;
case 'C': /* commandlist argument */
cmdlist[0] = malloc(strlen(optarg)+1); /* create buffer */
strcpy(cmdlist[0],optarg);
if(cmdlist[0][0]!= 0)
cmdfound=1;
for(i=0,j=1;cmdlist[0][i] != 0;i++) {
if(cmdlist[0][i] == ':') {
cmdlist[0][i] = 0;
cmdlist[j] = &cmdlist[0][i+1];
j++;
cmdfound=j;
if(j >= CMDMAX) break;
}
}
break;
case 'V': /* nmon version */
printf("nmon verion %s\n",VERSION);
exit(0);
break;
case 'g': /* disk groups */
show_dgroup = 1;
dgroup_loaded = 1;
dgroup_filename = optarg;
break;
}
}
/* Set parameters if not set by above */
if (maxloops == -1)
maxloops = 9999999;
if (seconds == -1)
seconds = 2;
if (cursed)
show_dgroup = 0;
/* -D need -g filename */
if(extended_disk == 1 && show_dgroup == 0) {
printf("nmon: ignoring -D (extended disk stats) as -g filename is missing\n");
extended_disk=0;
}
/* To get the pointers setup */
switcher();
/* Initialise the time stamps for the first loop */
p->time = doubletime();
q->time = doubletime();
find_release();
/* Determine number of active LOGICAL cpu - depends on SMT mode ! */
get_cpu_cnt();
max_cpus=old_cpus=cpus;
proc_read(P_STAT);
proc_cpu();
proc_read(P_UPTIME);
proc_read(P_LOADAVG);
proc_kernel();
memcpy(&q->cpu_total, &p->cpu_total, sizeof(struct cpu_stat));
p->dk = malloc(sizeof(struct dsk_stat) * diskmax+1);
q->dk = malloc(sizeof(struct dsk_stat) * diskmax+1);
disk_busy_peak = malloc(sizeof(double) * diskmax);
disk_rate_peak = malloc(sizeof(double) * diskmax);
for(i=0;i<diskmax;i++) {
disk_busy_peak[i]=0.0;
disk_rate_peak[i]=0.0;
}
cpu_peak = malloc(sizeof(double) * (CPUMAX + 1)); /* MAGIC */
for(i=0;i < max_cpus+1;i++)
cpu_peak[i]=0.0;
n = getprocs(0);
p->procs = malloc(sizeof(struct procsinfo ) * n +8);
q->procs = malloc(sizeof(struct procsinfo ) * n +8);
p->nprocs = q->nprocs = n;
/* Initialise the top processes table */
topper = malloc(sizeof(struct topper ) * topper_size); /* round up */
/* Get Disk Stats. */
proc_disk(0.0);
memcpy(q->dk, p->dk, sizeof(struct dsk_stat) * disks);
/* load dgroup - if required */
if (dgroup_loaded == 1) {
load_dgroup(p->dk);
}
/* Get Network Stats. */
proc_net();
memcpy(q->ifnets, p->ifnets, sizeof(struct net_stat) * networks);
for(i=0;i<networks;i++) {
net_read_peak[i]=0.0;
net_write_peak[i]=0.0;
}
/* If we are running in spreadsheet mode initialize all other data sets as well
* so we do not get incorrect data for the first reported interval
*/
if( !cursed) {
/* Get VM Stats */
read_vmstat();
/* Get Memory info */
proc_mem();
#ifdef POWER
/* Get LPAR Stats */
proc_lparcfg();
#endif
}
/* Set the pointer ready for the next round */
switcher();
/* Initialise signal handlers so we can tidy up curses on exit */
signal(SIGUSR1, interrupt);
signal(SIGUSR2, interrupt);
signal(SIGINT, interrupt);
signal(SIGWINCH, interrupt);
signal(SIGCHLD, interrupt);
/* Start Curses */
if (cursed) {
initscr();
cbreak();
move(0, 0);
refresh();
COLOUR colour = has_colors();
COLOUR start_color();
COLOUR init_pairs();
clear();
padlpar = newpad(11,MAXCOLS);
padmap = newpad(24,MAXCOLS);
padhelp = newpad(24,MAXCOLS);
padmem = newpad(20,MAXCOLS);
padlarge = newpad(20,MAXCOLS);
padpage = newpad(20,MAXCOLS);
padcpu = newpad(20,MAXCOLS);
padsmp = newpad(MAXROWS,MAXCOLS);
padlong = newpad(MAXROWS,MAXCOLS);
padnet = newpad(MAXROWS,MAXCOLS);
padneterr = newpad(MAXROWS,MAXCOLS);
paddisk = newpad(MAXROWS,MAXCOLS);
paddg = newpad(MAXROWS,MAXCOLS);
padjfs = newpad(MAXROWS,MAXCOLS);
padker = newpad(5,MAXCOLS);
padverb = newpad(8,MAXCOLS);
padres = newpad(23,MAXCOLS);
padnfs = newpad(25,MAXCOLS);
padtop = newpad(MAXROWS,MAXCOLS*2);
} else {
/* Output the header lines for the spread sheet */
timer = time(0);
tim = localtime(&timer);
tim->tm_year += 1900 - 2000; /* read localtime() manual page!! */
tim->tm_mon += 1; /* because it is 0 to 11 */
if(varperftmp)
sprintf( str, "/var/perf/tmp/%s_%02d.nmon", hostname, tim->tm_mday);
else if(user_filename_set)
strcpy( str, user_filename);
else
sprintf( str, "%s_%02d%02d%02d_%02d%02d.nmon",
hostname,
tim->tm_year,
tim->tm_mon,
tim->tm_mday,
tim->tm_hour,
tim->tm_min);
if((fp = fopen(str,"w")) ==0 ) {
perror("nmon: failed to open output file");
printf("nmon: output filename=%s\n",str);
exit(42);
}
/* disconnect from terminal */
fflush(NULL);
if (!debug && (childpid = fork()) != 0) {
if(ralfmode)
printf("%d\n",childpid);
exit(0); /* parent returns OK */
}
if(!debug) {
close(0);
close(1);
close(2);
setpgrp(); /* become process group leader */
signal(SIGHUP, SIG_IGN); /* ignore hangups */
}
/* Do the nmon_start activity early on */
if (nmon_start) {
timer = time(0);
child_start(CHLD_START, nmon_start, time_stamp_type, 1, timer);
}
if(show_aaa) {
fprintf(fp,"AAA,progname,%s\n", progname);
fprintf(fp,"AAA,command,");
for(i=0;i<argc;i++)
fprintf(fp,"%s ",argv[i]);
fprintf(fp,"\n");
fprintf(fp,"AAA,version,%s\n", VERSION);
fprintf(fp,"AAA,disks_per_line,%d\n", disks_per_line);
fprintf(fp,"AAA,max_disks,%d,set by -d option\n", diskmax);
fprintf(fp,"AAA,disks,%d,\n", disks);
fprintf(fp,"AAA,host,%s\n", hostname);
fprintf(fp,"AAA,user,%s\n", getenv("USER"));
fprintf(fp,"AAA,OS,Linux,%s,%s,%s\n",uts.release,uts.version,uts.machine);
fprintf(fp,"AAA,runname,%s\n", run_name);
fprintf(fp,"AAA,time,%02d:%02d.%02d\n", tim->tm_hour, tim->tm_min, tim->tm_sec);
fprintf(fp,"AAA,date,%02d-%3s-%02d\n", tim->tm_mday, month[tim->tm_mon-1], tim->tm_year+2000);
fprintf(fp,"AAA,interval,%d\n", seconds);
fprintf(fp,"AAA,snapshots,%d\n", maxloops);
#ifdef POWER
fprintf(fp,"AAA,cpus,%d,%d\n", cpus/lparcfg.smt_mode,cpus); /* physical CPU, logical CPU */
fprintf(fp,"AAA,CPU ID length,3\n"); /* Give analyzer a chance to easily find length of CPU number - 3 digits here! */
#else
fprintf(fp,"AAA,cpus,%d\n", cpus);
#endif
fprintf(fp,"AAA,proc_stat_variables,%d\n", stat8);
fprintf(fp,"AAA,note0, Warning - use the UNIX sort command to order this file before loading into a spreadsheet\n");
fprintf(fp,"AAA,note1, The First Column is simply to get the output sorted in the right order\n");
fprintf(fp,"AAA,note2, The T0001-T9999 column is a snapshot number. To work out the actual time; see the ZZZ section at the end\n");
}
fflush(NULL);
for (i = 1; i <= cpus; i++)
fprintf(fp,"CPU%03d,CPU %d %s,User%%,Sys%%,Wait%%,Idle%%\n", i, i, run_name);
fprintf(fp,"CPU_ALL,CPU Total %s,User%%,Sys%%,Wait%%,Idle%%,Busy,CPUs\n", run_name);
fprintf(fp,"MEM,Memory MB %s,memtotal,hightotal,lowtotal,swaptotal,memfree,highfree,lowfree,swapfree,memshared,cached,active,bigfree,buffers,swapcached,inactive\n", run_name);
#ifdef POWER
proc_lparcfg();
if(lparcfg.cmo_enabled)
fprintf(fp,"MEMAMS,AMS %s,Poolid,Weight,Hypervisor-Page-in/s,HypervisorTime(seconds),not_available_1,not_available_2,not_available_3,Physical-Memory(MB),Page-Size(KB),Pool-Size(MB),Loan-Request(KB)\n", run_name);
#ifdef EXPERIMENTAL
fprintf(fp,"MEMEXPERIMENTAL,New lparcfg numbers %s,DesEntCap,DesProcs,DesVarCapWt,DedDonMode,group,pool,entitled_memory,entitled_memory_group_number,unallocated_entitled_memory_weight,unallocated_io_mapping_entitlement\n", run_name);
#endif /* EXPERIMENTAL */
#endif /* POWER */
fprintf(fp,"PROC,Processes %s,Runnable,Blocked,pswitch,syscall,read,write,fork,exec,sem,msg\n", run_name);
/*
fprintf(fp,"PAGE,Paging %s,faults,pgin,pgout,pgsin,pgsout,reclaims,scans,cycles\n", run_name);
fprintf(fp,"FILE,File I/O %s,iget,namei,dirblk,readch,writech,ttyrawch,ttycanch,ttyoutch\n", run_name);
*/
fprintf(fp,"NET,Network I/O %s,", run_name);
for (i = 0; i < networks; i++)
fprintf(fp,"%-2s-read-KB/s,", (char *)p->ifnets[i].if_name);
for (i = 0; i < networks; i++)
fprintf(fp,"%-2s-write-KB/s,", (char *)p->ifnets[i].if_name);
fprintf(fp,"\n");
fprintf(fp,"NETPACKET,Network Packets %s,", run_name);
for (i = 0; i < networks; i++)
fprintf(fp,"%-2s-read/s,", (char *)p->ifnets[i].if_name);
for (i = 0; i < networks; i++)
fprintf(fp,"%-2s-write/s,", (char *)p->ifnets[i].if_name);
/* iremoved as it is not below in the BUSY line fprintf(fp,"\n"); */
#ifdef DEBUG
if(debug)printf("disks=%d x%sx\n",(char *)disks,p->dk[0].dk_name);
#endif /*DEBUG*/
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,"\nDISKBUSY%s,Disk %%Busy %s", dskgrp(i) ,run_name);
fprintf(fp,",%s", (char *)p->dk[i].dk_name);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,"\nDISKREAD%s,Disk Read KB/s %s", dskgrp(i),run_name);
fprintf(fp,",%s", (char *)p->dk[i].dk_name);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,"\nDISKWRITE%s,Disk Write KB/s %s", (char *)dskgrp(i),run_name);
fprintf(fp,",%s", (char *)p->dk[i].dk_name);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,"\nDISKXFER%s,Disk transfers per second %s", (char *)dskgrp(i),run_name);
fprintf(fp,",%s", p->dk[i].dk_name);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,"\nDISKBSIZE%s,Disk Block Size %s", dskgrp(i),run_name);
fprintf(fp,",%s", (char *)p->dk[i].dk_name);
}
if( extended_disk == 1 && disk_mode == DISK_MODE_DISKSTATS ) {
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,"\nDISKREADS%s,Disk Rd/s %s", dskgrp(i),run_name);
fprintf(fp,",%s", (char *)p->dk[i].dk_name);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,"\nDISKWRITES%s,Disk Wrt/s %s", dskgrp(i),run_name);
fprintf(fp,",%s", (char *)p->dk[i].dk_name);
}
}
fprintf(fp,"\n");
list_dgroup(p->dk);
jfs_load(LOAD);
fprintf(fp,"JFSFILE,JFS Filespace %%Used %s", hostname);
for (k = 0; k < jfses; k++) {
if(jfs[k].mounted && strncmp(jfs[k].name,"/proc",5)
&& strncmp(jfs[k].name,"/sys",4)
&& strncmp(jfs[k].name,"/dev/pts",8)
&& strncmp(jfs[k].name,"/dev/shm",8)
&& strncmp(jfs[k].name,"/var/lib/nfs/rpc",16)
) /* /proc gives invalid/insane values */
fprintf(fp,",%s", jfs[k].name);
}
fprintf(fp,"\n");
jfs_load(UNLOAD);
#ifdef POWER
if( proc_lparcfg() && lparcfg.shared_processor_mode != 0 ){
fprintf(fp,"LPAR,Shared CPU LPAR Stats %s,PhysicalCPU,capped,shared_processor_mode,system_potential_processors,system_active_processors,pool_capacity,MinEntCap,partition_entitled_capacity,partition_max_entitled_capacity,MinProcs,Logical CPU,partition_active_processors,partition_potential_processors,capacity_weight,unallocated_capacity_weight,BoundThrds,MinMem,unallocated_capacity,pool_idle_time\n",hostname);
}
#endif /*POWER*/
if(show_top){
fprintf(fp,"TOP,%%CPU Utilisation\n");
#ifndef KERNEL_2_6_18
fprintf(fp,"TOP,+PID,Time,%%CPU,%%Usr,%%Sys,Size,ResSet,ResText,ResData,ShdLib,MinorFault,MajorFault,Command\n");
#else
fprintf(fp,"TOP,+PID,Time,%%CPU,%%Usr,%%Sys,Size,ResSet,ResText,ResData,ShdLib,MinorFault,MajorFault,Command,Threads,IOwaitTime\n");
#endif
}
linux_bbbp("/etc/release", "/bin/cat /etc/*ease 2>/dev/null", WARNING);
linux_bbbp("lsb_release", "/usr/bin/lsb_release -a 2>/dev/null", WARNING);
linux_bbbp("fdisk-l", "/sbin/fdisk -l 2>/dev/null", WARNING);
linux_bbbp("/proc/cpuinfo", "/bin/cat /proc/cpuinfo 2>/dev/null", WARNING);
linux_bbbp("/proc/meminfo", "/bin/cat /proc/meminfo 2>/dev/null", WARNING);
linux_bbbp("/proc/stat", "/bin/cat /proc/stat 2>/dev/null", WARNING);
linux_bbbp("/proc/version", "/bin/cat /proc/version 2>/dev/null", WARNING);
linux_bbbp("/proc/net/dev", "/bin/cat /proc/net/dev 2>/dev/null", WARNING);
#ifdef POWER
linux_bbbp("ppc64_utils - lscfg", "/usr/sbin/lscfg 2>/dev/null", WARNING);
linux_bbbp("ppc64_utils - ls-vdev", "/usr/sbin/ls-vdev 2>/dev/null", WARNING);
linux_bbbp("ppc64_utils - ls-veth", "/usr/sbin/ls-veth 2>/dev/null", WARNING);
linux_bbbp("ppc64_utils - ls-vscsi", "/usr/sbin/ls-vscsi 2>/dev/null", WARNING);
linux_bbbp("ppc64_utils - lsmcode", "/usr/sbin/lsmcode 2>/dev/null", WARNING);
#endif
linux_bbbp("/proc/diskinfo", "/bin/cat /proc/diskinfo 2>/dev/null", WARNING);
linux_bbbp("/proc/diskstats", "/bin/cat /proc/diskstats 2>/dev/null", WARNING);
linux_bbbp("/sbin/multipath", "/sbin/multipath -l 2>/dev/null", WARNING);
linux_bbbp("/dev/mapper", "ls -l /dev/mapper 2>/dev/null", WARNING);
linux_bbbp("/dev/mpath", "ls -l /dev/mpath 2>/dev/null", WARNING);
linux_bbbp("/dev/dm-*", "ls -l /dev/dm-* 2>/dev/null", WARNING);
linux_bbbp("/dev/md*", "ls -l /dev/md* 2>/dev/null", WARNING);
linux_bbbp("/dev/sd*", "ls -l /dev/sd* 2>/dev/null", WARNING);
linux_bbbp("/proc/partitions", "/bin/cat /proc/partitions 2>/dev/null", WARNING);
linux_bbbp("/proc/1/stat", "/bin/cat /proc/1/stat 2>/dev/null", WARNING);
#ifndef KERNEL_2_6_18
linux_bbbp("/proc/1/statm", "/bin/cat /proc/1/statm 2>/dev/null", WARNING);
#endif
#ifdef POWER
linux_bbbp("/proc/ppc64/lparcfg", "/bin/cat /proc/ppc64/lparcfg 2>/dev/null", WARNING);
#endif
#ifdef MAINFRAME
linux_bbbp("/proc/sysinfo", "/bin/cat /proc/sysinfo 2>/dev/null", WARNING);
#endif
linux_bbbp("/proc/net/rpc/nfs", "/bin/cat /proc/net/rpc/nfs 2>/dev/null", WARNING);
linux_bbbp("/proc/net/rpc/nfsd", "/bin/cat /proc/net/rpc/nfsd 2>/dev/null", WARNING);
linux_bbbp("ifconfig", "/sbin/ifconfig 2>/dev/null", WARNING);
linux_bbbp("/bin/df-m", "/bin/df -m 2>/dev/null", WARNING);
linux_bbbp("/bin/mount", "/bin/mount 2>/dev/null", WARNING);
linux_bbbp("/etc/fstab", "/bin/cat /etc/fstab 2>/dev/null", WARNING);
linux_bbbp("netstat -r", "/bin/netstat -r 2>/dev/null", WARNING);
linux_bbbp("uptime", "/usr/bin/uptime 2>/dev/null", WARNING);
linux_bbbp("getconf PAGESIZE", "/usr/bin/getconf PAGESIZE 2>/dev/null", WARNING);
sleep(1); /* to get the first stats to cover this one second and avoids divide by zero issues */
}
/* To get the pointers setup */
/* Was already done earlier, DONT'T switch back here to the old pointer! - switcher(); */
checkinput();
fflush(NULL);
#ifdef POWER
lparcfg.timebase = -1;
#endif
/* Main loop of the code */
for(loop=1; ; loop++) {
/* Save the time and work out how long we were actually asleep
* Do this as early as possible and close to reading the CPU statistics in /proc/stat
*/
p->time = doubletime();
elapsed = p->time - q->time;
timer = time(0);
tim = localtime(&timer);
/* Get current count of CPU
* As side effect /proc/stat is read
*/
old_cpus = cpus;
get_cpu_cnt();
#ifdef POWER
/* Always get lpar info as well so we can report physical CPU usage
* to make data more meaningful. Return value is ignored here, but
* remembered in proc_lparcfg() !
*/
proc_lparcfg();
#endif
disk_stats_read = 0;
if(loop <= 3) /* This stops the nmon causing the cpu peak at startup */
for(i=0;i < max_cpus+1;i++)
cpu_peak[i]=0.0;
/* Reset the cursor position to top left */
y = x = 0;
if (cursed) { /* Top line */
box(stdscr,0,0);
mvprintw(x, 1, "nmon");
mvprintw(x, 6, "%s", VERSION);
if(flash_on) mvprintw(x,15,"[H for help]");
mvprintw(x, 30, "Hostname=%s", hostname);
mvprintw(x, 52, "Refresh=%2.0fsecs ", elapsed);
mvprintw(x, 70, "%02d:%02d.%02d",
tim->tm_hour, tim->tm_min, tim->tm_sec);
wnoutrefresh(stdscr);
x = x + 1;
if(welcome && getenv("NMON") == 0) {
COLOUR attrset(COLOR_PAIR(2));
mvprintw(x+1, 3, "------------------------------");
mvprintw(x+2, 3, "# # # # #### # #");
mvprintw(x+3, 3, "## # ## ## # # ## #");
mvprintw(x+4, 3, "# # # # ## # # # # # #");
mvprintw(x+5, 3, "# # # # # # # # # #");
mvprintw(x+6, 3, "# ## # # # # # ##");
mvprintw(x+7, 3, "# # # # #### # #");
mvprintw(x+8, 3, "------------------------------");
COLOUR attrset(COLOR_PAIR(0));
mvprintw(x+1, 40, "For help type H or ...");
mvprintw(x+2, 40, " nmon -? - hint");
mvprintw(x+3, 40, " nmon -h - full");
mvprintw(x+5, 40, "To start the same way every time");
mvprintw(x+6, 40, " set the NMON ksh variable");
mvprintw(x+10, 3, "Use these keys to toggle statistics on/off:");
mvprintw(x+11, 3, " c = CPU l = CPU Long-term - = Faster screen updates");
mvprintw(x+12, 3, " m = Memory j = Filesystems + = Slower screen updates");
mvprintw(x+13, 3, " d = Disks n = Network V = Virtual Memory");
mvprintw(x+14, 3, " r = Resource N = NFS v = Verbose hints");
mvprintw(x+15, 3, " k = kernel t = Top-processes . = only busy disks/procs");
mvprintw(x+16, 3, " h = more options q = Quit");
x = x + 17;
}
} else {
if (!cursed && nmon_snap && (loop % nmon_one_in) == 0 ) {
child_start(CHLD_SNAP, nmon_snap, time_stamp_type, loop, timer);
}
if(!show_rrd)
fprintf(fp,"ZZZZ,%s,%02d:%02d:%02d,%02d-%s-%4d\n", LOOP,
tim->tm_hour, tim->tm_min, tim->tm_sec,
tim->tm_mday, month[tim->tm_mon], tim->tm_year+1900);
fflush(NULL);
}
if (show_verbose && cursed) {
BANNER(padverb, "Verbose Mode");
mvwprintw(padverb,1, 0, " Code Resource Stats Now\tWarn\tDanger ");
/* DISPLAY(padverb,7); */
/* move(x,0); */
x=x+6;
}
if (show_help && cursed) {
BANNER(padhelp, "HELP");
mvwprintw(padhelp, 1, 5, "key --- statistics which toggle on/off ---");
mvwprintw(padhelp, 2, 5, "h = This help information");
mvwprintw(padhelp, 3, 5, "r = RS6000/pSeries CPU/cache/OS/kernel/hostname details + LPAR");
mvwprintw(padhelp, 4, 5, "t = Top Process Stats 1=basic 3=CPU");
mvwprintw(padhelp, 5, 5, " u = shows command arguments (hit twice to refresh)");
mvwprintw(padhelp, 6, 5, "c = CPU by processor l = longer term CPU averages");
mvwprintw(padhelp, 7, 5, "m = Memory & Swap stats L=Huge j = JFS Usage Stats");
mvwprintw(padhelp, 8, 5, "n = Network stats N = NFS");
mvwprintw(padhelp, 9, 5, "d = Disk I/O Graphs D=Stats o = Disks %%Busy Map");
mvwprintw(padhelp,10, 5, "k = Kernel stats & loadavg V = Virtual Memory");
mvwprintw(padhelp,11, 5, "g = User Defined Disk Groups [start nmon with -g <filename>]");
mvwprintw(padhelp,12, 5, "v = Verbose Simple Checks - OK/Warnings/Danger");
mvwprintw(padhelp,13, 5, "b = black & white mode");
mvwprintw(padhelp,14, 5, "--- controls ---");
mvwprintw(padhelp,15, 5, "+ and - = double or half the screen refresh time");
mvwprintw(padhelp,16, 5, "q = quit space = refresh screen now");
mvwprintw(padhelp,17, 5, ". = Minimum Mode =display only busy disks and processes");
mvwprintw(padhelp,18, 5, "0 = reset peak counts to zero (peak = \">\")");
mvwprintw(padhelp,19, 5, "Developer Nigel Griffiths see http://nmon.sourceforge.net");
DISPLAY(padhelp,20);
}
/*
if(error_on && errorstr[0] != 0) {
mvprintw(x, 0, "Error: %s ",errorstr);
x = x + 1;
}
*/
if (show_cpu && cursed) {
proc_read(P_CPUINFO);
proc_read(P_VERSION);
BANNER(padcpu,"Linux and Processor Details");
mvwprintw(padcpu,1, 4, "Linux: %s", proc[P_VERSION].line[0]);
mvwprintw(padcpu,2, 4, "Build: %s", proc[P_VERSION].line[1]);
mvwprintw(padcpu,3, 4, "Release : %s", uts.release );
mvwprintw(padcpu,4, 4, "Version : %s", uts.version);
#ifdef POWER
mvwprintw(padcpu,5, 4, "cpuinfo: %s", proc[P_CPUINFO].line[1]);
mvwprintw(padcpu,6, 4, "cpuinfo: %s", proc[P_CPUINFO].line[2]);
mvwprintw(padcpu,7, 4, "cpuinfo: %s", proc[P_CPUINFO].line[3]);
mvwprintw(padcpu,8, 4, "cpuinfo: %s", proc[P_CPUINFO].line[proc[P_CPUINFO].lines-1]);
/* needs lparcfg to be already processed */
proc_lparcfg();
mvwprintw(padcpu,9, 4, "phys/virt CPUs:%3d logical CPU (SMT):%3d", lparcfg.partition_active_processors, cpus);
#else
#ifdef MAINFRAME
mvwprintw(padcpu,5, 4, "cpuinfo: %s", proc[P_CPUINFO].line[1]);
mvwprintw(padcpu,6, 4, "cpuinfo: %s", proc[P_CPUINFO].line[2]);
mvwprintw(padcpu,7, 4, "cpuinfo: %s", proc[P_CPUINFO].line[3]);
mvwprintw(padcpu,8, 4, "cpuinfo: %s", proc[P_CPUINFO].line[4]);
#else /* Intel is the default */
mvwprintw(padcpu,5, 4, "cpuinfo: %s", proc[P_CPUINFO].line[4]);
mvwprintw(padcpu,6, 4, "cpuinfo: %s", proc[P_CPUINFO].line[1]);
mvwprintw(padcpu,7, 4, "cpuinfo: %s", proc[P_CPUINFO].line[6]);
mvwprintw(padcpu,8, 4, "cpuinfo: %s", proc[P_CPUINFO].line[17]);
#endif /*MAINFRAME*/
mvwprintw(padcpu,9, 4, "# of CPUs: %d", cpus);
#endif /*POWER*/
mvwprintw(padcpu,10, 4,"Machine : %s", uts.machine);
mvwprintw(padcpu,11, 4,"Nodename : %s", uts.nodename);
mvwprintw(padcpu,12, 4,"/etc/*ease[1]: %s", easy[0]);
mvwprintw(padcpu,13, 4,"/etc/*ease[2]: %s", easy[1]);
mvwprintw(padcpu,14, 4,"/etc/*ease[3]: %s", easy[2]);
mvwprintw(padcpu,15, 4,"/etc/*ease[4]: %s", easy[3]);
mvwprintw(padcpu,16, 4,"lsb_release: %s", lsb_release[0]);
mvwprintw(padcpu,17, 4,"lsb_release: %s", lsb_release[1]);
mvwprintw(padcpu,18, 4,"lsb_release: %s", lsb_release[2]);
mvwprintw(padcpu,19, 4,"lsb_release: %s", lsb_release[3]);
DISPLAY(padcpu,20);
}
if (show_longterm ) {
proc_read(P_STAT);
proc_cpu();
cpu_user = p->cpu_total.user - q->cpu_total.user;
cpu_sys = p->cpu_total.sys - q->cpu_total.sys;
cpu_wait = p->cpu_total.wait - q->cpu_total.wait;
cpu_idle = p->cpu_total.idle - q->cpu_total.idle;
cpu_sum = cpu_idle + cpu_user + cpu_sys + cpu_wait;
plot_save(
(double)cpu_user / (double)cpu_sum * 100.0,
(double)cpu_sys / (double)cpu_sum * 100.0,
(double)cpu_wait / (double)cpu_sum * 100.0,
(double)cpu_idle / (double)cpu_sum * 100.0);
plot_snap(padlong);
DISPLAY(padlong,MAX_SNAP_ROWS+2);
}
if (show_smp || show_verbose) {
if(cpus>max_cpus && !cursed) {
for (i = max_cpus+1; i <= cpus; i++)
fprintf(fp,"CPU%03d,CPU %d %s,User%%,Sys%%,Wait%%,Idle%%\n", i, i, run_name);
max_cpus= cpus;
}
if( old_cpus != cpus ) {
if( !cursed ) {
if( bbbr_line == 0) {
fprintf(fp,"BBBR,0,Reconfig,action,old,new\n");
bbbr_line++;
}
fprintf(fp,"BBBR,%03d,%s,cpuchg,%d,%d\n",bbbr_line++,LOOP,old_cpus,cpus);
}
else {
/* wmove(padsmp,0,0); */
/* doesn't work CURSE wclrtobot(padsmp); */
/* Do BRUTE force overwrite of previous data */
if( cpus < old_cpus) {
for(i=cpus; i < old_cpus; i++)
mvwprintw(padsmp,i+4,0," ");
}
}
}
if (show_smp) {
if(cursed) {
BANNER(padsmp,"CPU Utilisation");
/* mvwprintw(padsmp,1, 0, cpu_line);*/
/*
*mvwprintw(padsmp,2, 0, "CPU User%% Sys%% Wait%% Idle|0 |25 |50 |75 100|");
*/
mvwprintw(padsmp,1, 0, cpu_line);
mvwprintw(padsmp,2, 0, "CPU ");
COLOUR wattrset(padsmp, COLOR_PAIR(2));
mvwprintw(padsmp,2, 5, "User%%");
COLOUR wattrset(padsmp, COLOR_PAIR(1));
mvwprintw(padsmp,2, 10, " Sys%%");
COLOUR wattrset(padsmp, COLOR_PAIR(4));
mvwprintw(padsmp,2, 16, " Wait%%");
COLOUR wattrset(padsmp, COLOR_PAIR(0));
mvwprintw(padsmp,2, 22, " Idle|0 |25 |50 |75 100|");
} /* if (show_smp) AND if(cursed) */
proc_read(P_STAT);
proc_cpu();
#ifdef POWER
/* Always get lpar info as well so we can report physical CPU usage
* to make data more meaningful
* This assumes that LPAR info is available in q and p !
*/
if( proc_lparcfg() > 0 ) {
if( lparcfg.shared_processor_mode == 1) {
if(lparcfg.timebase == -1) {
lparcfg.timebase=0;
proc_read(P_CPUINFO);
for(i=0;i<proc[P_CPUINFO].lines-1;i++) {
if(!strncmp("timebase",proc[P_CPUINFO].line[i],8)) {
sscanf(proc[P_CPUINFO].line[i],"timebase : %lld",&lparcfg.timebase);
break;
}
}
}
else {
if( lparcfg.purr_diff == 0 ) {
mvwprintw(padsmp,1,29," Phys. CPU used: <not available>");
} else {
mvwprintw(padsmp,1,29," Phys. CPU used:% 7.2f ",
(double)lparcfg.purr_diff/(double)lparcfg.timebase/elapsed);
}
}
}
}
#endif
for (i = 0; i < cpus; i++) {
cpu_user = p->cpuN[i].user - q->cpuN[i].user;
cpu_sys = p->cpuN[i].sys - q->cpuN[i].sys;
cpu_wait = p->cpuN[i].wait - q->cpuN[i].wait;
cpu_idle = p->cpuN[i].idle - q->cpuN[i].idle;
cpu_sum = cpu_idle + cpu_user + cpu_sys + cpu_wait;
/* Check if we had a CPU # change and have to set idle to 100 */
if( cpu_sum == 0)
cpu_sum = cpu_idle = 100.0;
if(smp_first_time && cursed) {
mvwprintw(padsmp,3 + i, 27, "| Please wait gathering data");
} else {
if(!show_raw)
plot_smp(padsmp,i+1, 3 + i,
(double)cpu_user / (double)cpu_sum * 100.0,
(double)cpu_sys / (double)cpu_sum * 100.0,
(double)cpu_wait / (double)cpu_sum * 100.0,
(double)cpu_idle / (double)cpu_sum * 100.0);
else
save_smp(padsmp,i+1, 3+i,
RAW(user) - RAW(nice),
RAW(sys),
RAW(wait),
RAW(idle),
RAW(nice),
RAW(irq),
RAW(softirq),
RAW(steal));
RRD fprintf(fp,"rrdtool update cpu%02d.rrd %s:%.1f:%.1f:%.1f:%.1f\n",i,LOOP,
(double)cpu_user / (double)cpu_sum * 100.0,
(double)cpu_sys / (double)cpu_sum * 100.0,
(double)cpu_wait / (double)cpu_sum * 100.0,
(double)cpu_idle / (double)cpu_sum * 100.0);
}
} /* for (i = 0; i < cpus; i++) */
CURSE mvwprintw(padsmp,i + 3, 0, cpu_line);
cpu_user = p->cpu_total.user - q->cpu_total.user;
cpu_sys = p->cpu_total.sys - q->cpu_total.sys;
cpu_wait = p->cpu_total.wait - q->cpu_total.wait;
cpu_idle = p->cpu_total.idle - q->cpu_total.idle;
cpu_sum = cpu_idle + cpu_user + cpu_sys + cpu_wait;
/* Check if we had a CPU # change and have to set idle to 100 */
if( cpu_sum == 0)
cpu_sum = cpu_idle = 100.0;
RRD fprintf(fp,"rrdtool update cpu.rrd %s:%.1f:%.1f:%.1f:%.1f\n",LOOP,
(double)cpu_user / (double)cpu_sum * 100.0,
(double)cpu_sys / (double)cpu_sum * 100.0,
(double)cpu_wait / (double)cpu_sum * 100.0,
(double)cpu_idle / (double)cpu_sum * 100.0);
if (cpus > 1 || !cursed) {
if(!smp_first_time || !cursed) {
if(!show_raw) {
plot_smp(padsmp,0, 4 + i,
(double)cpu_user / (double)cpu_sum * 100.0,
(double)cpu_sys / (double)cpu_sum * 100.0,
(double)cpu_wait / (double)cpu_sum * 100.0,
(double)cpu_idle / (double)cpu_sum * 100.0);
} else {
save_smp(padsmp,0, 4+i,
RAWTOTAL(user) - RAWTOTAL(nice),
RAWTOTAL(sys),
RAWTOTAL(wait),
RAWTOTAL(idle),
RAWTOTAL(nice),
RAWTOTAL(irq),
RAWTOTAL(softirq),
RAWTOTAL(steal));
}
}
CURSE mvwprintw(padsmp, i + 5, 0, cpu_line);
i = i + 2;
} /* if (cpus > 1 || !cursed) */
smp_first_time=0;
DISPLAY(padsmp, i + 4);
} /* if (show_smp) { */
if(show_verbose && cursed) {
cpu_user = p->cpu_total.user - q->cpu_total.user;
cpu_sys = p->cpu_total.sys - q->cpu_total.sys;
cpu_wait = p->cpu_total.wait - q->cpu_total.wait;
cpu_idle = p->cpu_total.idle - q->cpu_total.idle;
cpu_sum = cpu_idle + cpu_user + cpu_sys + cpu_wait;
cpu_busy= (double)(cpu_user + cpu_sys)/ (double)cpu_sum * 100.0;
mvwprintw(padverb,2, 0, " -> CPU %%busy %5.1f%%\t>80%%\t>90%% ",cpu_busy);
if(cpu_busy > 90.0){
COLOUR wattrset(padverb,COLOR_PAIR(1));
mvwprintw(padverb,2, 0, " DANGER");
}
else if(cpu_busy > 80.0) {
COLOUR wattrset(padverb,COLOR_PAIR(4));
mvwprintw(padverb,2, 0, "Warning");
}
else {
COLOUR wattrset(padverb,COLOR_PAIR(2));
mvwprintw(padverb,2, 0, " OK");
}
COLOUR wattrset(padverb,COLOR_PAIR(0));
} /* if(show_verbose && cursed) */
} /* if (show_smp || show_verbose) */
#ifdef POWER
if (show_lpar) {
if(lparcfg.timebase == -1) {
lparcfg.timebase=0;
proc_read(P_CPUINFO);
for(i=0;i<proc[P_CPUINFO].lines-1;i++) {
if(!strncmp("timebase",proc[P_CPUINFO].line[i],8)) {
sscanf(proc[P_CPUINFO].line[i],"timebase : %lld",&lparcfg.timebase);
break;
}
}
}
ret = proc_lparcfg();
if(cursed) {
BANNER(padlpar,"LPAR Stats");
if(ret == 0) {
mvwprintw(padlpar,2, 0, "Reading data from /proc/ppc64/lparcfg failed");
mvwprintw(padlpar,3, 0, "Either run as the root user or ");
mvwprintw(padlpar,4, 0, "as the root user run: chmod ugo+r /proc/ppc64/lparcfg");
} else {
mvwprintw(padlpar,1, 0, "LPAR=%d SerialNumber=%s Type=%s",
lparcfg.partition_id, lparcfg.serial_number, lparcfg.system_type);
mvwprintw(padlpar,2, 0, "Flags: Shared-CPU=%-5s Capped=%-5s SMT-mode=%-7s",
lparcfg.shared_processor_mode?"true":"false",
lparcfg.capped?"true":"false",
lparcfg.smt_mode == 1 ? "off" : lparcfg.smt_mode==2 ? "SMT-2" : lparcfg.smt_mode==4 ? "SMT-4" : "unknown");
mvwprintw(padlpar,3, 0, "Systems CPU Pool=%8.2f Active=%8.2f Total=%8.2f",
(float)lparcfg.pool_capacity,
(float)lparcfg.system_active_processors,
(float)lparcfg.system_potential_processors);
mvwprintw(padlpar,4, 0, "LPARs CPU Min=%8.2f Entitlement=%8.2f Max=%8.2f",
lparcfg.MinEntCap/100.0,
lparcfg.partition_entitled_capacity/100.0,
lparcfg.partition_max_entitled_capacity/100.0);
mvwprintw(padlpar,5, 0, "Virtual CPU Min=%8.2f VP Now=%8.2f Max=%8.2f",
(float)lparcfg.MinProcs,
(float)lparcfg.partition_active_processors,
(float)lparcfg.partition_potential_processors);
mvwprintw(padlpar,6, 0, "Memory Min= unknown Now=%8.2f Max=%8.2f",
(float)lparcfg.MinMem,
(float)lparcfg.DesMem);
mvwprintw(padlpar,7, 0, "Other Weight=%8.2f UnallocWeight=%8.2f Capacity=%8.2f",
(float)lparcfg.capacity_weight,
(float)lparcfg.unallocated_capacity_weight,
(float)lparcfg.CapInc/100.0);
mvwprintw(padlpar,8, 0, " BoundThrds=%8.2f UnallocCapacity=%8.2f Increment",
(float)lparcfg.BoundThrds,
(float)lparcfg.unallocated_capacity);
if(lparcfg.purr_diff == 0 || lparcfg.timebase <1) {
mvwprintw(padlpar,9, 0, "lparcfg: purr field always zero, upgrade to SLES9+sp1 or RHEL4+u1");
} else {
if(lpar_first_time) {
mvwprintw(padlpar,9, 0, "Please wait gathering data");
lpar_first_time=0;
} else {
mvwprintw(padlpar,9, 0, "Physical CPU use=%8.3f ",
(double)lparcfg.purr_diff/(double)lparcfg.timebase/elapsed);
if( lparcfg.pool_idle_time != NUMBER_NOT_VALID && lparcfg.pool_idle_saved != 0)
mvwprintw(padlpar,9, 29, "PoolIdleTime=%8.2f",
(double)lparcfg.pool_idle_diff/(double)lparcfg.timebase/elapsed);
mvwprintw(padlpar,9, 54, "[timebase=%lld]", lparcfg.timebase);
}
}
}
DISPLAY(padlpar,10);
} else {
/* Only print LPAR info to spreadsheet if in shared processor mode */
if(ret != 0 && lparcfg.shared_processor_mode > 0)
fprintf(fp,"LPAR,%s,%9.6f,%d,%d,%d,%d,%d,%.1f,%.1f,%.1f,%d,%d,%d,%d,%d,%d,%d,%d,%d,%lld\n",
LOOP,
(double)lparcfg.purr_diff/(double)lparcfg.timebase/elapsed,
lparcfg.capped,
lparcfg.shared_processor_mode,
lparcfg.system_potential_processors,
lparcfg.system_active_processors,
lparcfg.pool_capacity,
lparcfg.MinEntCap/100.0,
lparcfg.partition_entitled_capacity/100.0,
lparcfg.partition_max_entitled_capacity/100.0,
lparcfg.MinProcs,
cpus, /* report logical CPU here so analyser graph CPU% vs VPs reports correctly */
lparcfg.partition_active_processors,
lparcfg.partition_potential_processors,
lparcfg.capacity_weight,
lparcfg.unallocated_capacity_weight,
lparcfg.BoundThrds,
lparcfg.MinMem,
lparcfg.unallocated_capacity,
lparcfg.pool_idle_time);
}
}
#endif /*POWER*/
if (show_memory) {
proc_read(P_MEMINFO);
proc_mem();
if(cursed) {
BANNER(padmem,"Memory Stats");
mvwprintw(padmem,1, 1, " RAM High Low Swap Page Size=%d KB",pagesize/1024);
mvwprintw(padmem,2, 1, "Total MB %8.1f %8.1f %8.1f %8.1f ",
p->mem.memtotal/1024.0,
p->mem.hightotal/1024.0,
p->mem.lowtotal/1024.0,
p->mem.swaptotal/1024.0);
mvwprintw(padmem,3, 1, "Free MB %8.1f %8.1f %8.1f %8.1f ",
p->mem.memfree/1024.0,
p->mem.highfree/1024.0,
p->mem.lowfree/1024.0,
p->mem.swapfree/1024.0);
mvwprintw(padmem,4, 1, "Free Percent %7.1f%% %7.1f%% %7.1f%% %7.1f%% ",
p->mem.memfree == 0 ? 0.0 : 100.0*(float)p->mem.memfree/(float)p->mem.memtotal,
p->mem.highfree == 0 ? 0.0 : 100.0*(float)p->mem.highfree/(float)p->mem.hightotal,
p->mem.lowfree == 0 ? 0.0 : 100.0*(float)p->mem.lowfree/(float)p->mem.lowtotal,
p->mem.swapfree == 0 ? 0.0 : 100.0*(float)p->mem.swapfree/(float)p->mem.swaptotal);
mvwprintw(padmem,5, 1, " MB MB MB");
#ifdef LARGEMEM
mvwprintw(padmem,6, 1, " Cached=%8.1f Active=%8.1f",
p->mem.cached/1024.0,
p->mem.active/1024.0);
#else
mvwprintw(padmem,6, 1, " Shared=%8.1f Cached=%8.1f Active=%8.1f",
p->mem.memshared/1024.0,
p->mem.cached/1024.0,
p->mem.active/1024.0);
mvwprintw(padmem,5, 68, "MB");
mvwprintw(padmem,6, 55, "bigfree=%8.1f",
p->mem.bigfree/1024);
#endif /*LARGEMEM*/
mvwprintw(padmem,7, 1, "Buffers=%8.1f Swapcached=%8.1f Inactive =%8.1f",
p->mem.buffers/1024.0,
p->mem.swapcached/1024.0,
p->mem.inactive/1024.0);
mvwprintw(padmem,8, 1, "Dirty =%8.1f Writeback =%8.1f Mapped =%8.1f",
p->mem.dirty/1024.0,
p->mem.writeback/1024.0,
p->mem.mapped/1024.0);
mvwprintw(padmem,9, 1, "Slab =%8.1f Commit_AS =%8.1f PageTables=%8.1f",
p->mem.slab/1024.0,
p->mem.committed_as/1024.0,
p->mem.pagetables/1024.0);
#ifdef POWER
if(!show_lpar) /* check if already called above */
proc_lparcfg();
if(lparcfg.cmo_enabled == 0)
mvwprintw(padmem,10, 1, "AMS is not active");
else
mvwprintw(padmem,10, 1, "AMS id=%d Weight=%-3d pmem=%ldMB hpi=%.1f/s hpit=%.1f(sec) Pool=%ldMB Loan=%ldKB ",
(int)lparcfg.entitled_memory_pool_number,
(int)lparcfg.entitled_memory_weight,
(long)(lparcfg.backing_memory)/1024/1024,
(double)(lparcfg.cmo_faults_diff)/elapsed,
(double)(lparcfg.cmo_fault_time_usec_diff)/1000/1000/elapsed,
(long)lparcfg.entitled_memory_pool_size/1024/1024,
(long)lparcfg.entitled_memory_loan_request/1024);
DISPLAY(padmem,11);
#else /* POWER */
DISPLAY(padmem,10);
#endif /* POWER */
} else {
if(show_rrd)
str_p = "rrdtool update mem.rrd %s:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f\n";
else
str_p = "MEM,%s,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f\n";
fprintf(fp,str_p,
LOOP,
p->mem.memtotal/1024.0,
p->mem.hightotal/1024.0,
p->mem.lowtotal/1024.0,
p->mem.swaptotal/1024.0,
p->mem.memfree/1024.0,
p->mem.highfree/1024.0,
p->mem.lowfree/1024.0,
p->mem.swapfree/1024.0,
p->mem.memshared/1024.0,
p->mem.cached/1024.0,
p->mem.active/1024.0,
#ifdef LARGEMEM
-1.0,
#else
p->mem.bigfree/1024.0,
#endif /*LARGEMEM*/
p->mem.buffers/1024.0,
p->mem.swapcached/1024.0,
p->mem.inactive/1024.0);
#ifdef POWER
if(lparcfg.cmo_enabled != 0) {
if(!show_rrd)fprintf(fp,"MEMAMS,%s,%d,%d,%.1f,%.3lf,0,0,0,%.1f,%ld,%ld,%ld\n",
LOOP,
(int)lparcfg.entitled_memory_pool_number,
(int)lparcfg.entitled_memory_weight,
(float)(lparcfg.cmo_faults_diff)/elapsed,
(float)(lparcfg.cmo_fault_time_usec_diff)/1000/1000/elapsed,
/* three zeros here */
(float)(lparcfg.backing_memory)/1024/1024,
lparcfg.cmo_page_size/1024,
lparcfg.entitled_memory_pool_size/1024/1024,
lparcfg.entitled_memory_loan_request/1024);
}
#ifdef EXPERIMENTAL
if(!show_rrd)fprintf(fp,"MEMEXPERIMENTAL,%s,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld\n",
LOOP,
(long)lparcfg.DesEntCap,
(long)lparcfg.DesProcs,
(long)lparcfg.DesVarCapWt,
(long)lparcfg.DedDonMode,
(long)lparcfg.group,
(long)lparcfg.pool,
(long)lparcfg.entitled_memory,
(long)lparcfg.entitled_memory_group_number,
(long)lparcfg.unallocated_entitled_memory_weight,
(long)lparcfg.unallocated_io_mapping_entitlement);
#endif /* EXPERIMENTAL */
#endif /* POWER */
}
/* for testing large page
p->mem.hugefree = 250;
p->mem.hugetotal = 1000;
p->mem.hugesize = 16*1024;
*/
}
if (show_large) {
proc_read(P_MEMINFO);
proc_mem();
if(cursed) {
BANNER(padlarge,"Large (Huge) Page Stats");
if(p->mem.hugetotal > 0) {
if(p->mem.hugetotal - p->mem.hugefree > huge_peak)
huge_peak = p->mem.hugetotal - p->mem.hugefree;
mvwprintw(padlarge,1, 1, "Total Pages=%7ld 100.0%% Huge Page Size =%ld KB", p->mem.hugetotal, p->mem.hugesize);
mvwprintw(padlarge,2, 1, "Used Pages=%7ld %5.1f%% Used Pages Peak=%-8ld",
(long)(p->mem.hugetotal - p->mem.hugefree),
(p->mem.hugetotal - p->mem.hugefree)/(float)p->mem.hugetotal*100.0,
huge_peak);
mvwprintw(padlarge,3, 1, "Free Pages=%7ld %5.1f%%", p->mem.hugefree, p->mem.hugefree/(float)p->mem.hugetotal*100.0);
} else {
mvwprintw(padlarge,1, 1, " There are no Huge Pages");
mvwprintw(padlarge,2, 1, " - see /proc/meminfo");
}
DISPLAY(padlarge,4);
} else {
if(p->mem.hugetotal > 0) {
if(first_huge == 1){
first_huge=0;
fprintf(fp,"HUGEPAGES,Huge Page Use %s,HugeTotal,HugeFree,HugeSizeMB\n", run_name);
}
fprintf(fp,"HUGEPAGES,%s,%ld,%ld,%.1f\n",
LOOP,
p->mem.hugetotal,
p->mem.hugefree,
p->mem.hugesize/1024.0);
}
}
}
if (show_vm) {
#define VMDELTA(variable) (p->vm.variable - q->vm.variable)
#define VMCOUNT(variable) (p->vm.variable )
ret = read_vmstat();
if(cursed) {
BANNER(padpage,"Virtual-Memory");
if(ret < 0 ) {
mvwprintw(padpage,2, 2, "Virtual Memory stats not supported with this kernel");
mvwprintw(padpage,3, 2, "/proc/vmstat only seems to appear in 2.6 onwards");
} else {
if(vm_first_time) {
mvwprintw(padpage,2, 2, "Please wait - collecting data");
vm_first_time=0;
} else {
mvwprintw(padpage,1, 0, "nr_dirty =%9lld pgpgin =%8lld",
VMCOUNT(nr_dirty),
VMDELTA(pgpgin));
mvwprintw(padpage,2, 0, "nr_writeback=%9lld pgpgout =%8lld",
VMCOUNT(nr_writeback),
VMDELTA(pgpgout));
mvwprintw(padpage,3, 0, "nr_unstable =%9lld pgpswpin =%8lld",
VMCOUNT(nr_unstable),
VMDELTA(pswpin));
mvwprintw(padpage,4, 0, "nr_table_pgs=%9lld pgpswpout =%8lld",
VMCOUNT(nr_page_table_pages),
VMDELTA(pswpout));
mvwprintw(padpage,5, 0, "nr_mapped =%9lld pgfree =%8lld",
VMCOUNT(nr_mapped),
VMDELTA(pgfree));
mvwprintw(padpage,6, 0, "nr_slab =%9lld pgactivate =%8lld",
VMCOUNT(nr_slab),
VMDELTA(pgactivate));
mvwprintw(padpage,7, 0, " pgdeactivate=%8lld",
VMDELTA(pgdeactivate));
mvwprintw(padpage,8, 0, "allocstall =%9lld pgfault =%8lld kswapd_steal =%7lld",
VMDELTA(allocstall),
VMDELTA(pgfault),
VMDELTA(kswapd_steal));
mvwprintw(padpage,9, 0, "pageoutrun =%9lld pgmajfault =%8lld kswapd_inodesteal=%7lld",
VMDELTA(pageoutrun),
VMDELTA(pgmajfault),
VMDELTA(kswapd_inodesteal));
mvwprintw(padpage,10, 0,"slabs_scanned=%8lld pgrotated =%8lld pginodesteal =%7lld",
VMDELTA(slabs_scanned),
VMDELTA(pgrotated),
VMDELTA(pginodesteal));
mvwprintw(padpage,1, 46, " High Normal DMA");
mvwprintw(padpage,2, 46, "alloc %7lld%7lld%7lld",
VMDELTA(pgalloc_high),
VMDELTA(pgalloc_normal),
VMDELTA(pgalloc_dma));
mvwprintw(padpage,3, 46, "refill %7lld%7lld%7lld",
VMDELTA(pgrefill_high),
VMDELTA(pgrefill_normal),
VMDELTA(pgrefill_dma));
mvwprintw(padpage,4, 46, "steal %7lld%7lld%7lld",
VMDELTA(pgsteal_high),
VMDELTA(pgsteal_normal),
VMDELTA(pgsteal_dma));
mvwprintw(padpage,5, 46, "scan_kswapd%7lld%7lld%7lld",
VMDELTA(pgscan_kswapd_high),
VMDELTA(pgscan_kswapd_normal),
VMDELTA(pgscan_kswapd_dma));
mvwprintw(padpage,6, 46, "scan_direct%7lld%7lld%7lld",
VMDELTA(pgscan_direct_high),
VMDELTA(pgscan_direct_normal),
VMDELTA(pgscan_direct_dma));
}
}
DISPLAY(padpage,11);
} else {
if( ret < 0) {
show_vm=0;
} else if(vm_first_time) {
vm_first_time=0;
fprintf(fp,"VM,Paging and Virtual Memory,nr_dirty,nr_writeback,nr_unstable,nr_page_table_pages,nr_mapped,nr_slab,pgpgin,pgpgout,pswpin,pswpout,pgfree,pgactivate,pgdeactivate,pgfault,pgmajfault,pginodesteal,slabs_scanned,kswapd_steal,kswapd_inodesteal,pageoutrun,allocstall,pgrotated,pgalloc_high,pgalloc_normal,pgalloc_dma,pgrefill_high,pgrefill_normal,pgrefill_dma,pgsteal_high,pgsteal_normal,pgsteal_dma,pgscan_kswapd_high,pgscan_kswapd_normal,pgscan_kswapd_dma,pgscan_direct_high,pgscan_direct_normal,pgscan_direct_dma\n");
}
if(show_rrd)
str_p = "rrdtool update vm.rrd %s"
":%lld:%lld:%lld:%lld:%lld"
":%lld:%lld:%lld:%lld:%lld"
":%lld:%lld:%lld:%lld:%lld"
":%lld:%lld:%lld:%lld:%lld"
":%lld:%lld:%lld:%lld:%lld"
":%lld:%lld:%lld:%lld:%lld"
":%lld:%lld:%lld:%lld:%lld"
":%lld:%lld\n";
else
str_p = "VM,%s"
",%lld,%lld,%lld,%lld,%lld"
",%lld,%lld,%lld,%lld,%lld"
",%lld,%lld,%lld,%lld,%lld"
",%lld,%lld,%lld,%lld,%lld"
",%lld,%lld,%lld,%lld,%lld"
",%lld,%lld,%lld,%lld,%lld"
",%lld,%lld,%lld,%lld,%lld"
",%lld,%lld\n";
fprintf(fp, str_p,
LOOP,
VMCOUNT(nr_dirty),
VMCOUNT(nr_writeback),
VMCOUNT(nr_unstable),
VMCOUNT(nr_page_table_pages),
VMCOUNT(nr_mapped),
VMCOUNT(nr_slab),
VMDELTA(pgpgin),
VMDELTA(pgpgout),
VMDELTA(pswpin),
VMDELTA(pswpout),
VMDELTA(pgfree),
VMDELTA(pgactivate),
VMDELTA(pgdeactivate),
VMDELTA(pgfault),
VMDELTA(pgmajfault),
VMDELTA(pginodesteal),
VMDELTA(slabs_scanned),
VMDELTA(kswapd_steal),
VMDELTA(kswapd_inodesteal),
VMDELTA(pageoutrun),
VMDELTA(allocstall),
VMDELTA(pgrotated),
VMDELTA(pgalloc_high),
VMDELTA(pgalloc_normal),
VMDELTA(pgalloc_dma),
VMDELTA(pgrefill_high),
VMDELTA(pgrefill_normal),
VMDELTA(pgrefill_dma),
VMDELTA(pgsteal_high),
VMDELTA(pgsteal_normal),
VMDELTA(pgsteal_dma),
VMDELTA(pgscan_kswapd_high),
VMDELTA(pgscan_kswapd_normal),
VMDELTA(pgscan_kswapd_dma),
VMDELTA(pgscan_direct_high),
VMDELTA(pgscan_direct_normal),
VMDELTA(pgscan_direct_dma));
}
}
if (show_kernel) {
proc_read(P_STAT);
proc_cpu();
proc_read(P_UPTIME);
proc_read(P_LOADAVG);
proc_kernel();
if(cursed) {
BANNER(padker,"Kernel Stats");
mvwprintw(padker,1, 1, "RunQueue %8lld Load Average CPU use since boot time",
p->cpu_total.running);
updays=p->cpu_total.uptime/60/60/24;
uphours=(p->cpu_total.uptime-updays*60*60*24)/60/60;
upmins=(p->cpu_total.uptime-updays*60*60*24-uphours*60*60)/60;
mvwprintw(padker,2, 1, "ContextSwitch %8.1f 1 mins %5.2f Uptime Days=%3d Hours=%2d Mins=%2d",
(float)(p->cpu_total.ctxt - q->cpu_total.ctxt)/elapsed,
(float)p->cpu_total.mins1,
updays, uphours, upmins);
updays=p->cpu_total.idletime/60/60/24;
uphours=(p->cpu_total.idletime-updays*60*60*24)/60/60;
upmins=(p->cpu_total.idletime-updays*60*60*24-uphours*60*60)/60;
mvwprintw(padker,3, 1, "Forks %8.1f 5 mins %5.2f Idle Days=%3d Hours=%2d Mins=%2d",
(float)(p->cpu_total.procs - q->cpu_total.procs)/elapsed,
(float)p->cpu_total.mins5,
updays, uphours, upmins);
mvwprintw(padker,4, 1, "Interrupts %8.1f 15 mins %5.2f Average CPU use=%6.2f%%",
(float)(p->cpu_total.intr - q->cpu_total.intr)/elapsed,
(float)p->cpu_total.mins15,
(float)(
(p->cpu_total.uptime -
p->cpu_total.idletime)/
p->cpu_total.uptime *100.0));
DISPLAY(padker,5);
} else {
if(proc_first_time) {
q->cpu_total.ctxt = p->cpu_total.ctxt;
q->cpu_total.procs= p->cpu_total.procs;
proc_first_time=0;
}
if(show_rrd)
str_p = "rrdtool update proc.rrd %s:%.0f:%.0f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f:%.1f\n";
else
str_p = "PROC,%s,%.0f,%.0f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f\n";
fprintf(fp,str_p,
LOOP,
(float)p->cpu_total.running,/*runqueue*/
(float)p->cpu_total.blocked,/*swapin (# of processes waiting for IO completion */
/*pswitch*/
(float)(p->cpu_total.ctxt - q->cpu_total.ctxt)/elapsed,
-1.0, /*syscall*/
-1.0, /*read*/
-1.0, /*write*/
/*fork*/
(float)(p->cpu_total.procs - q->cpu_total.procs)/elapsed,
-1.0, /*exec*/
-1.0, /*sem*/
-1.0); /*msg*/
}
}
if (show_nfs) {
proc_read(P_NFS);
proc_read(P_NFSD);
proc_nfs();
if(cursed) {
if(nfs_first_time) {
memcpy(&q->nfs,&p->nfs,sizeof(struct nfs_stat));
nfs_first_time=0;
}
if(nfs_clear) {
nfs_clear=0;
for(i=0;i<25;i++)
mvwprintw(padnfs,i, 0, " ");
}
BANNER(padnfs,"Network Filesystem (NFS) I/O Operations per second");
if(show_nfs == 1) {
mvwprintw(padnfs,1, 0, " Version 2 Client Server");
mvwprintw(padnfs,1, 41, "Version 3 Client Server");
} else {
mvwprintw(padnfs,1, 0, " Version 4 Client Client");
mvwprintw(padnfs,1, 42, "Version 4 Server Server");
}
#define NFS_TOTAL(member) (double)(p->member)
#define NFS_DELTA(member) (((double)(p->member - q->member)/elapsed))
v2c_total =0;
v2s_total =0;
v3c_total =0;
v3s_total =0;
v4c_total =0;
v4s_total =0;
for(i=0;i<18;i++) {
if(show_nfs == 1)
mvwprintw(padnfs,2+i, 3, "%12s %8.1f %8.1f",
nfs_v2_names[i],
NFS_DELTA(nfs.v2c[i]),
NFS_DELTA(nfs.v2s[i]));
v2c_total +=NFS_DELTA(nfs.v2c[i]);
v2s_total +=NFS_DELTA(nfs.v2s[i]);
}
for(i=0;i<22;i++) {
if(show_nfs == 1)
mvwprintw(padnfs,2+i, 41, "%12s %8.1f %8.1f",
nfs_v3_names[i],
NFS_DELTA(nfs.v3c[i]),
NFS_DELTA(nfs.v3s[i]));
v3c_total +=NFS_DELTA(nfs.v3c[i]);
v3s_total +=NFS_DELTA(nfs.v3s[i]);
}
for(i=0;i<18;i++) {
if(show_nfs == 2) {
mvwprintw(padnfs,2+i, 1, "%9s%7.1f",
nfs_v4c_names[i],
NFS_DELTA(nfs.v4c[i]));
}
v4c_total +=NFS_DELTA(nfs.v4c[i]);
}
for(i=18;i<35;i++) {
if(show_nfs == 2) {
mvwprintw(padnfs,2+i-18, 19, "%12s%7.1f",
nfs_v4c_names[i],
NFS_DELTA(nfs.v4c[i]));
}
v4c_total +=NFS_DELTA(nfs.v4c[i]);
}
for(i=0;i<20;i++) {
if(show_nfs == 2) {
mvwprintw(padnfs,2+i, 40, "%11s%7.1f",
nfs_v4s_names[i],
NFS_DELTA(nfs.v4s[i]));
}
v4s_total +=NFS_DELTA(nfs.v4s[i]);
}
for(i=20;i<40;i++) {
if(show_nfs == 2) {
mvwprintw(padnfs,2+i-20, 59, "%12s%7.1f",
nfs_v4s_names[i],
NFS_DELTA(nfs.v4s[i]));
}
v4s_total +=NFS_DELTA(nfs.v4s[i]);
}
mvwprintw(padnfs,2+19, 1, "NFSv2 Totals->%9.1f %9.1f", v2c_total,v2s_total);
mvwprintw(padnfs,2+20, 1, "NFSv3 Totals->%9.1f %9.1f", v3c_total,v3s_total);
mvwprintw(padnfs,2+21, 1, "NFSv4 Totals->%9.1f %9.1f", v4c_total,v4s_total);
DISPLAY(padnfs,24);
} else {
if(nfs_first_time && ! show_rrd) {
if(nfs_v2c_found) {
fprintf(fp,"NFSCLIV2,NFS Client v2");
for(i=0;i<18;i++)
fprintf(fp,",%s",nfs_v2_names[i]);
fprintf(fp,"\n");
}
if(nfs_v2s_found) {
fprintf(fp,"NFSSVRV2,NFS Server v2");
for(i=0;i<18;i++)
fprintf(fp,",%s",nfs_v2_names[i]);
fprintf(fp,"\n");
}
if(nfs_v3c_found) {
fprintf(fp,"NFSCLIV3,NFS Client v3");
for(i=0;i<22;i++)
fprintf(fp,",%s",nfs_v3_names[i]);
fprintf(fp,"\n");
}
if(nfs_v3s_found) {
fprintf(fp,"NFSSVRV3,NFS Server v3");
for(i=0;i<22;i++)
fprintf(fp,",%s",nfs_v3_names[i]);
fprintf(fp,"\n");
}
if(nfs_v4c_found) {
fprintf(fp,"NFSCLIV4,NFS Client v4");
for(i=0;i<35;i++)
fprintf(fp,",%s",nfs_v4c_names[i]);
fprintf(fp,"\n");
}
if(nfs_v4s_found) {
fprintf(fp,"NFSSVRV4,NFS Server v4");
for(i=0;i<40;i++)
fprintf(fp,",%s",nfs_v4s_names[i]);
fprintf(fp,"\n");
}
memcpy(&q->nfs,&p->nfs,sizeof(struct nfs_stat));
nfs_first_time=0;
}
if(nfs_v2c_found) {
fprintf(fp,show_rrd ? "rrdtool update nfscliv2.rrd %s" : "NFSCLIV2,%s", LOOP);
for(i=0;i<18;i++) {
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
(double)NFS_DELTA(nfs.v2c[i]));
}
fprintf(fp,"\n");
}
if(nfs_v2s_found) {
fprintf(fp,show_rrd ? "rrdtool update nfsvrv2.rrd %s" : "NFSSVRV2,%s", LOOP);
for(i=0;i<18;i++) {
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
(double)NFS_DELTA(nfs.v2s[i]));
}
fprintf(fp,"\n");
}
if(nfs_v3c_found) {
fprintf(fp,show_rrd ? "rrdtool update nfscliv3.rrd %s" : "NFSCLIV3,%s", LOOP);
for(i=0;i<22;i++) {
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
(double)NFS_DELTA(nfs.v3c[i]));
}
fprintf(fp,"\n");
}
if(nfs_v3s_found) {
fprintf(fp,show_rrd ? "rrdtool update nfsvrv3.rrd %s" : "NFSSVRV3,%s", LOOP);
for(i=0;i<22;i++) {
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
(double)NFS_DELTA(nfs.v3s[i]));
}
fprintf(fp,"\n");
}
if(nfs_v4c_found) {
fprintf(fp,show_rrd ? "rrdtool update nfscliv4.rrd %s" : "NFSCLIV4,%s", LOOP);
for(i=0;i<35;i++) {
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
(double)NFS_DELTA(nfs.v4c[i]));
}
fprintf(fp,"\n");
}
if(nfs_v4s_found) {
fprintf(fp,show_rrd ? "rrdtool update nfsvrv4.rrd %s" : "NFSSVRV4,%s", LOOP);
for(i=0;i<40;i++) {
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
(double)NFS_DELTA(nfs.v4s[i]));
}
fprintf(fp,"\n");
}
}
}
if (show_net) {
if(cursed) {
BANNER(padnet,"Network I/O");
mvwprintw(padnet,1, 0, "I/F Name Recv=KB/s Trans=KB/s packin packout insize outsize Peak->Recv Trans");
}
proc_net();
for (i = 0; i < networks; i++) {
#define IFDELTA(member) ((float)( (q->ifnets[i].member > p->ifnets[i].member) ? 0 : (p->ifnets[i].member - q->ifnets[i].member)/elapsed) )
#define IFDELTA_ZERO(member1,member2) ((IFDELTA(member1) == 0) || (IFDELTA(member2)== 0)? 0.0 : IFDELTA(member1)/IFDELTA(member2) )
if(net_read_peak[i] < IFDELTA(if_ibytes) / 1024.0)
net_read_peak[i] = IFDELTA(if_ibytes) / 1024.0;
if(net_write_peak[i] < IFDELTA(if_obytes) / 1024.0)
net_write_peak[i] = IFDELTA(if_obytes) / 1024.0;
CURSE mvwprintw(padnet,2 + i, 0, "%8s %7.1f %7.1f %6.1f %6.1f %6.1f %6.1f %7.1f %7.1f ",
&p->ifnets[i].if_name[0],
IFDELTA(if_ibytes) / 1024.0,
IFDELTA(if_obytes) / 1024.0,
IFDELTA(if_ipackets),
IFDELTA(if_opackets),
IFDELTA_ZERO(if_ibytes, if_ipackets),
IFDELTA_ZERO(if_obytes, if_opackets),
net_read_peak[i],
net_write_peak[i]
);
}
DISPLAY(padnet,networks + 2);
if (!cursed) {
fprintf(fp,show_rrd ? "rrdtool update net.rrd %s" : "NET,%s,", LOOP);
for (i = 0; i < networks; i++) {
fprintf(fp,show_rrd ? ":%.1f" : "%.1f,", IFDELTA(if_ibytes) / 1024.0);
}
for (i = 0; i < networks; i++) {
fprintf(fp,show_rrd ? ":%.1f" : "%.1f,", IFDELTA(if_obytes) / 1024.0);
}
fprintf(fp,"\n");
fprintf(fp,show_rrd ? "rrdtool update netpacket.rrd %s" : "NETPACKET,%s,", LOOP);
for (i = 0; i < networks; i++) {
fprintf(fp,show_rrd ? ":%.1f" : "%.1f,", IFDELTA(if_ipackets) );
}
for (i = 0; i < networks; i++) {
fprintf(fp,show_rrd ? ":%.1f" : "%.1f,", IFDELTA(if_opackets) );
}
fprintf(fp,"\n");
}
}
errors=0;
for (i = 0; i < networks; i++) {
errors += p->ifnets[i].if_ierrs - q->ifnets[i].if_ierrs
+ p->ifnets[i].if_oerrs - q->ifnets[i].if_oerrs
+ p->ifnets[i].if_ocolls - q->ifnets[i].if_ocolls;
}
if(errors) show_neterror=3;
if(show_neterror) {
if(cursed) {
BANNER(padneterr,"Network Error Counters");
mvwprintw(padneterr,1, 0, "I/F Name iErrors iDrop iOverrun iFrame oErrors oDrop oOverrun oCarrier oColls ");
}
for (i = 0; i < networks; i++) {
CURSE mvwprintw(padneterr,2 + i, 0, "%8s %7lu %7lu %7lu %7lu %7lu %7lu %7lu %7lu %7lu",
&p->ifnets[i].if_name[0],
p->ifnets[i].if_ierrs,
p->ifnets[i].if_idrop,
p->ifnets[i].if_ififo,
p->ifnets[i].if_iframe,
p->ifnets[i].if_oerrs,
p->ifnets[i].if_odrop,
p->ifnets[i].if_ofifo,
p->ifnets[i].if_ocarrier,
p->ifnets[i].if_ocolls);
}
DISPLAY(padneterr,networks + 2);
if(show_neterror > 0) show_neterror--;
}
#ifdef JFS
if (show_jfs) {
if(cursed) {
BANNER(padjfs,"Filesystems");
mvwprintw(padjfs,1, 0, "Filesystem SizeMB FreeMB Use%% Type MountPoint");
for (k = 0; k < jfses; k++) {
fs_size=0;
fs_bsize=0;
fs_free=0;
fs_size_used=100.0;
if(jfs[k].mounted) {
if(!strncmp(jfs[k].name,"/proc/",6) /* sub directorys have to be fake too */
|| !strncmp(jfs[k].name,"/sys/",5)
|| !strncmp(jfs[k].name,"/dev/",5)
|| !strncmp(jfs[k].name,"/proc",6) /* one more than the string to ensure the NULL */
|| !strncmp(jfs[k].name,"/sys",5)
|| !strncmp(jfs[k].name,"/dev",5)
|| !strncmp(jfs[k].name,"/rpc_pipe",10)
) { /* /proc gives invalid/insane values */
mvwprintw(padjfs,2+k, 0, "%-14s", jfs[k].name);
mvwprintw(padjfs,2+k, 27, "-");
mvwprintw(padjfs,2+k, 35, "-");
mvwprintw(padjfs,2+k, 41, "-");
mvwprintw(padjfs,2+k, 43, "%-8s not a real filesystem",jfs[k].type);
} else {
statfs_buffer.f_blocks=0;
if((ret=fstatfs( jfs[k].fd, &statfs_buffer)) != -1) {
if(statfs_buffer.f_blocks != 0) {
/* older Linux seemed to always report in 4KB blocks but
newer Linux release use the f_bsize block sizes but
the man statfs docs the field as the natural I/O size so
the blocks reported here are ambigous in size */
if(statfs_buffer.f_bsize == 0)
fs_bsize = 4.0 * 1024.0;
else
fs_bsize = statfs_buffer.f_bsize;
/* convery blocks to MB */
fs_size = (float)statfs_buffer.f_blocks * fs_bsize/1024.0/1024.0;
/* fine the best size info available f_bavail is like df reports
otherwise use f_bsize (this includes inode blocks) */
if(statfs_buffer.f_bavail == 0)
fs_free = (float)statfs_buffer.f_bfree * fs_bsize/1024.0/1024.0;
else
fs_free = (float)statfs_buffer.f_bavail * fs_bsize/1024.0/1024.0;
/* this is a percentage */
fs_size_used = (fs_size - (float)statfs_buffer.f_bfree * fs_bsize/1024.0/1024.0)/fs_size * 100.0;
/* try to get the same number as df using kludge */
fs_size_used += 1.0;
if (fs_size_used >100.0)
fs_size_used = 100.0;
if( (i=strlen(jfs[k].device)) <20)
str_p=&jfs[k].device[0];
else {
str_p=&jfs[k].device[i-20];
}
mvwprintw(padjfs,2+k, 0, "%-20s %7.0f %7.0f %4.0f%% %-8s %s",
str_p,
fs_size,
fs_free,
fs_size_used,
jfs[k].type,
jfs[k].name
);
} else {
mvwprintw(padjfs,2+k, 0, "%s", jfs[k].name);
mvwprintw(padjfs,2+k, 43, "%-8s size=zero blocks!", jfs[k].type);
}
}
else {
mvwprintw(padjfs,2+k, 0, "%s", jfs[k].name);
mvwprintw(padjfs,2+k, 43, "%-8s statfs failed", jfs[k].type);
}
}
} else {
mvwprintw(padjfs,2+k, 0, "%-14s", jfs[k].name);
mvwprintw(padjfs,2+k, 43, "%-8s not mounted",jfs[k].type);
}
}
DISPLAY(padjfs,2 + jfses);
} else {
jfs_load(LOAD);
fprintf(fp,show_rrd ? "rrdtool update jfsfile.rrd %s" : "JFSFILE,%s", LOOP);
for (k = 0; k < jfses; k++) {
if(jfs[k].mounted && strncmp(jfs[k].name,"/proc",5)
&& strncmp(jfs[k].name,"/sys",4)
&& strncmp(jfs[k].name,"/dev/pts",8)
&& strncmp(jfs[k].name,"/dev/shm",8)
&& strncmp(jfs[k].name,"/var/lib/nfs/rpc",16)
) { /* /proc gives invalid/insane values */
if(fstatfs( jfs[k].fd, &statfs_buffer) != -1) {
fprintf(fp, show_rrd ? ":%.1f" : ",%.1f",
((float)statfs_buffer.f_blocks - (float)statfs_buffer.f_bfree)/(float)statfs_buffer.f_blocks*100.0);
}
else
fprintf(fp, show_rrd? ":U" : ",0.0");
}
}
fprintf(fp, "\n");
jfs_load(UNLOAD);
}
}
#endif /* JFS */
if (show_disk || show_verbose || show_diskmap || show_dgroup) {
proc_read(P_STAT);
proc_disk(elapsed);
}
if (show_diskmap) {
BANNER(padmap,"Disk %%Busy Map");
mvwprintw(padmap,0, 18,"Key: @=90 #=80 X=70 8=60 O=50 0=40 o=30 +=20 -=10 .=5 _=0%%");
mvwprintw(padmap,1, 0," Disk No. 1 2 3 4 5 6 ");
if(disk_first_time) {
disk_first_time=0;
mvwprintw(padmap,2, 0,"Please wait - collecting disk data");
} else {
mvwprintw(padmap,2, 0,"Disks=%-4d 0123456789012345678901234567890123456789012345678901234567890123", disks);
mvwprintw(padmap,3, 0,"disk 0 to 63 ");
for (i = 0; i < disks; i++) {
disk_busy = DKDELTA(dk_time) / elapsed;
disk_read = DKDELTA(dk_rkb) / elapsed;
disk_write = DKDELTA(dk_wkb) / elapsed;
/* ensure boundaries */
if (disk_busy < 0)
disk_busy=0;
else
if (disk_busy > 99) disk_busy=99;
#define MAPWRAP 64
mvwprintw(padmap,3 + (int)(i/MAPWRAP), 13+ (i%MAPWRAP), "%c",disk_busy_map_ch[(int)disk_busy]);
}
}
DISPLAY(padmap,4 + disks/MAPWRAP);
}
if(show_verbose) {
top_disk_busy = 0.0;
top_disk_name = "";
for (i = 0,k=0; i < disks; i++) {
disk_busy = DKDELTA(dk_time) / elapsed;
if( disk_busy > top_disk_busy) {
top_disk_busy = disk_busy;
top_disk_name = p->dk[i].dk_name;
}
}
if(top_disk_busy > 80.0) {
COLOUR wattrset(padverb,COLOR_PAIR(1));
mvwprintw(padverb,3, 0, " DANGER");
}
else if(top_disk_busy > 60.0) {
COLOUR wattrset(padverb,COLOR_PAIR(4));
mvwprintw(padverb,3, 0, "Warning");
}
else {
COLOUR wattrset(padverb,COLOR_PAIR(2));
mvwprintw(padverb,3, 0, " OK");
}
COLOUR wattrset(padverb,COLOR_PAIR(0));
mvwprintw(padverb,3, 8, "-> Top Disk %8s %%busy %5.1f%%\t>40%%\t>60%% ",top_disk_name,top_disk_busy);
move(x,0);
}
if (show_disk) {
if (cursed) {
if(show_disk) {
BANNER(paddisk,"Disk I/O");
switch(disk_mode) {
case DISK_MODE_PARTITIONS: mvwprintw(paddisk, 0, 12, "/proc/partitions");break;
case DISK_MODE_DISKSTATS: mvwprintw(paddisk, 0, 12, "/proc/diskstats");break;
case DISK_MODE_IO: mvwprintw(paddisk, 0, 12, "/proc/stat+disk_io");break;
}
mvwprintw(paddisk,0, 31, "mostly in KB/s");
mvwprintw(paddisk,0, 50, "Warning:contains duplicates");
switch (show_disk) {
case SHOW_DISK_STATS:
mvwprintw(paddisk,1, 0, "DiskName Busy Read Write Xfers Size Peak%% Peak-RW InFlight ");
break;
case SHOW_DISK_GRAPH:
mvwprintw(paddisk,1, 0, "DiskName Busy ");
COLOUR wattrset(paddisk,COLOR_PAIR(6));
mvwprintw(paddisk,1, 15, "Read ");
COLOUR wattrset(paddisk,COLOR_PAIR(3));
mvwprintw(paddisk,1, 20, "Write");
COLOUR wattrset(paddisk,COLOR_PAIR(0));
mvwprintw(paddisk,1, 25, "KB|0 |25 |50 |75 100|");
break;
}
}
if(disk_first_time) {
disk_first_time=0;
mvwprintw(paddisk,2, 0, "Please wait - collecting disk data");
} else {
total_disk_read = 0.0;
total_disk_write = 0.0;
total_disk_xfers = 0.0;
disk_mb = 0;
for (i = 0,k=0; i < disks; i++) {
disk_read = DKDELTA(dk_rkb) / elapsed;
disk_write = DKDELTA(dk_wkb) / elapsed;
if((show_disk == SHOW_DISK_GRAPH) && (disk_read > 9999.9 || disk_write > 9999.9)) {
disk_mb=1;
COLOUR wattrset(paddisk, COLOR_PAIR(1));
mvwprintw(paddisk,1, 25, "MB");
COLOUR wattrset(paddisk, COLOR_PAIR(0));
break;
}
}
for (i = 0,k=0; i < disks; i++) {
/*
if(p->dk[i].dk_name[0] == 'h')
continue;
*/
disk_busy = DKDELTA(dk_time) / elapsed;
disk_read = DKDELTA(dk_rkb) / elapsed;
disk_write = DKDELTA(dk_wkb) / elapsed;
disk_xfers = DKDELTA(dk_xfers);
total_disk_read +=disk_read;
total_disk_write +=disk_write;
total_disk_xfers +=disk_xfers;
if(disk_busy_peak[i] < disk_busy)
disk_busy_peak[i] = disk_busy;
if(disk_rate_peak[i] < (disk_read+disk_write))
disk_rate_peak[i] = disk_read+disk_write;
if(!show_all && disk_busy < 1)
continue;
if(strlen(p->dk[i].dk_name) > 8)
str_p = &p->dk[i].dk_name[strlen(p->dk[i].dk_name) -8];
else
str_p = &p->dk[i].dk_name[0];
if(show_disk == SHOW_DISK_STATS) {
/* output disks stats */
mvwprintw(paddisk,2 + k, 0, "%-8s %3.0f%% %8.1f %8.1fKB/s %6.1f %5.1fKB %3.0f%% %9.1fKB/s %3d",
str_p,
disk_busy,
disk_read,
disk_write,
disk_xfers / elapsed,
disk_xfers == 0.0 ? 0.0 :
(DKDELTA(dk_rkb) + DKDELTA(dk_wkb) ) / disk_xfers,
disk_busy_peak[i],
disk_rate_peak[i],
p->dk[i].dk_inflight);
k++;
}
if(show_disk == SHOW_DISK_GRAPH) {
/* output disk bar graphs */
if(disk_mb) mvwprintw(paddisk,2 + k, 0, "%-8s %3.0f%% %6.1f %6.1f",
str_p,
disk_busy,
disk_read/1024.0,
disk_write/1024.0);
else mvwprintw(paddisk,2 + k, 0, "%-8s %3.0f%% %6.1f %6.1f",
str_p,
disk_busy,
disk_read,
disk_write);
mvwprintw(paddisk,2 + k, 27, "| ");
wmove(paddisk,2 + k, 28);
if(disk_busy >100) disk_busy=100;
if( disk_busy > 0.0 && (disk_write+disk_read) > 0.1) {
/* 50 columns in the disk graph area so divide % by two */
readers = disk_busy*disk_read/(disk_write+disk_read)/2;
writers = disk_busy*disk_write/(disk_write+disk_read)/2;
if(readers + writers > 50) {
readers=0;
writers=0;
}
/* don't go beyond row 78 i.e. j = 28 + 50 */
for (j = 0; j < readers && j<50; j++) {
COLOUR wattrset(paddisk,COLOR_PAIR(12));
wprintw(paddisk,"R");
COLOUR wattrset(paddisk,COLOR_PAIR(0));
}
for (; j < readers + writers && j<50; j++) {
COLOUR wattrset(paddisk,COLOR_PAIR(11));
wprintw(paddisk,"W");
COLOUR wattrset(paddisk,COLOR_PAIR(0));
}
for (j = disk_busy; j < 50; j++)
wprintw(paddisk," ");
} else {
for (j = 0; j < 50; j++)
wprintw(paddisk," ");
if(p->dk[i].dk_time == 0.0)
mvwprintw(paddisk,2 + k, 27, "| disk busy not available");
}
if(disk_busy_peak[i] >100)
disk_busy_peak[i]=100;
mvwprintw(paddisk,2 + i, 77, "|");
/* check rounding has not got the peak ">" over the 100% */
j = 28+(int)(disk_busy_peak[i]/2);
if(j>77)
j=77;
mvwprintw(paddisk,2 + i, j, ">");
k++;
}
}
mvwprintw(paddisk,2 + k, 0, "Totals Read-MB/s=%-8.1f Writes-MB/s=%-8.1f Transfers/sec=%-8.1f",
total_disk_read / 1024.0,
total_disk_write / 1024.0,
total_disk_xfers / elapsed);
}
DISPLAY(paddisk,3 + k);
} else {
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,show_rrd ? "%srrdtool update diskbusy%s.rrd %s" : "%sDISKBUSY%s,%s",i == 0 ? "": "\n", dskgrp(i), LOOP);
/* check percentage is correct */
ftmp = DKDELTA(dk_time) / elapsed;
if(ftmp > 100.0 || ftmp < 0.0)
fprintf(fp,show_rrd ? ":U" : ",101.00");
else
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
DKDELTA(dk_time) / elapsed);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,show_rrd ? "\nrrdtool update diskread%s.rrd %s" : "\nDISKREAD%s,%s", dskgrp(i),LOOP);
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
DKDELTA(dk_rkb) / elapsed);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,show_rrd ? "\nrrdtool update diskwrite%s.rrd %s" : "\nDISKWRITE%s,%s", dskgrp(i),LOOP);
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
DKDELTA(dk_wkb) / elapsed);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,show_rrd ? "\nrrdtool update diskxfer%s.rrd %s" : "\nDISKXFER%s,%s", dskgrp(i),LOOP);
disk_xfers = DKDELTA(dk_xfers);
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
disk_xfers / elapsed);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i))
fprintf(fp,show_rrd ? "\nrrdtool update diskbsize%s.rrd %s" : "\nDISKBSIZE%s,%s", dskgrp(i),LOOP);
disk_xfers = DKDELTA(dk_xfers);
fprintf(fp,show_rrd ? ":%.1f" : ",%.1f",
disk_xfers == 0.0 ? 0.0 :
(DKDELTA(dk_rkb) + DKDELTA(dk_wkb) ) / disk_xfers);
}
if( extended_disk == 1 && disk_mode == DISK_MODE_DISKSTATS ) {
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i)) {
fprintf(fp,"\nDISKREADS%s,%s", dskgrp(i),LOOP);
}
disk_read = DKDELTA(dk_reads);
fprintf(fp,",%.1f", disk_read / elapsed);
}
for (i = 0; i < disks; i++) {
if(NEWDISKGROUP(i)) {
fprintf(fp,"\nDISKWRITES%s,%s", dskgrp(i),LOOP);
}
disk_write = DKDELTA(dk_writes);
fprintf(fp,",%.1f", disk_write / elapsed);
}
}
fprintf(fp,"\n");
}
}
if ((show_dgroup || (!cursed && dgroup_loaded))) {
if (cursed) {
BANNER(paddg,"Disk-Group-I/O");
if (dgroup_loaded != 2 || dgroup_total_disks == 0) {
mvwprintw(paddg, 1, 1, "No Disk Groups found use -g groupfile when starting nmon");
n = 0;
} else if (disk_first_time) {
disk_first_time=0;
mvwprintw(paddg, 1, 1, "Please wait - collecting disk data");
} else {
mvwprintw(paddg, 1, 1, "Name Disks AvgBusy Read|Write-KB/s TotalMB/s xfers/s BlockSizeKB");
total_busy = 0.0;
total_rbytes = 0.0;
total_wbytes = 0.0;
total_xfers = 0.0;
for(k = n = 0; k < dgroup_total_groups; k++) {
/*
if (dgroup_name[k] == 0 )
continue;
*/
disk_busy = 0.0;
disk_read = 0.0;
disk_write = 0.0;
disk_xfers = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_busy += DKDELTA(dk_time) / elapsed;
/*
disk_read += DKDELTA(dk_reads) * p->dk[i].dk_bsize / 1024.0 /elapsed;
disk_write += DKDELTA(dk_writes) * p->dk[i].dk_bsize / 1024.0 /elapsed;
*/
disk_read += DKDELTA(dk_rkb) /elapsed;
disk_write += DKDELTA(dk_wkb) /elapsed;
disk_xfers += DKDELTA(dk_xfers) /elapsed;
}
}
if (dgroup_disks[k] == 0)
disk_busy = 0.0;
else
disk_busy = disk_busy / dgroup_disks[k];
total_busy += disk_busy;
total_rbytes += disk_read;
total_wbytes += disk_write;
total_xfers += disk_xfers;
/* if (!show_all && (disk_read < 1.0 && disk_write < 1.0))
continue;
*/
if ((disk_read + disk_write) == 0 || disk_xfers == 0)
disk_size = 0.0;
else
disk_size = ((float)disk_read + (float)disk_write) / (float)disk_xfers;
mvwprintw(paddg, n + 2, 1, "%-14s %3d %5.1f%% %9.1f|%-9.1f %6.1f %9.1f %6.1f ",
dgroup_name[k],
dgroup_disks[k],
disk_busy,
disk_read,
disk_write,
(disk_read + disk_write) / 1024, /* in MB */
disk_xfers,
disk_size
);
n++;
}
mvwprintw(paddg, n + 2, 1, "Groups=%2d TOTALS %3d %5.1f%% %9.1f|%-9.1f %6.1f %9.1f",
n,
dgroup_total_disks,
total_busy / dgroup_total_disks,
total_rbytes,
total_wbytes,
(((double)total_rbytes + (double)total_wbytes)) / 1024, /* in MB */
total_xfers
);
}
DISPLAY(paddg, 3 + dgroup_total_groups);
} else {
if (dgroup_loaded == 2) {
fprintf(fp, show_rrd ? "rrdtool update dgbusy.rdd %s" : "DGBUSY,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_time) / elapsed;
}
}
fprintf(fp, show_rrd ? ":%.1f" : ",%.1f", (float)(disk_total / dgroup_disks[k]));
}
}
fprintf(fp, "\n");
fprintf(fp, show_rrd ? "rrdtool update dgread.rdd %s" : "DGREAD,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
/*
disk_total += DKDELTA(dk_reads) * p->dk[i].dk_bsize / 1024.0;
*/
disk_total += DKDELTA(dk_rkb);
}
}
fprintf(fp, show_rrd ? ":%.1f" : ",%.1f", disk_total / elapsed);
}
}
fprintf(fp, "\n");
fprintf(fp, show_rrd ? "rrdtool update dgwrite.rdd %s" : "DGWRITE,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
/*
disk_total += DKDELTA(dk_writes) * p->dk[i].dk_bsize / 1024.0;
*/
disk_total += DKDELTA(dk_wkb);
}
}
fprintf(fp, show_rrd ? ":%.1f" : ",%.1f", disk_total / elapsed);
}
}
fprintf(fp, "\n");
fprintf(fp, show_rrd ? "rrdtool update dgbsize.rdd %s" : "DGSIZE,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_write = 0.0;
disk_xfers = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
/*
disk_write += (DKDELTA(dk_reads) + DKDELTA(dk_writes) ) * p->dk[i].dk_bsize / 1024.0;
*/
disk_write += (DKDELTA(dk_rkb) + DKDELTA(dk_wkb) );
disk_xfers += DKDELTA(dk_xfers);
}
}
if ( disk_write == 0.0 || disk_xfers == 0.0)
disk_size = 0.0;
else
disk_size = disk_write / disk_xfers;
fprintf(fp, show_rrd ? ":%.1f" : ",%.1f", disk_size);
}
}
fprintf(fp, "\n");
fprintf(fp, show_rrd ? "rrdtool update dgxfer.rdd %s" : "DGXFER,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_xfers);
}
}
fprintf(fp, show_rrd ? ":%.1f" : ",%.1f", disk_total / elapsed);
}
}
fprintf(fp, "\n");
if( extended_disk == 1 && disk_mode == DISK_MODE_DISKSTATS ) {
fprintf(fp,"DGREADS,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_reads);
}
}
fprintf(fp,",%.1f", disk_total / elapsed);
}
}
fprintf(fp, "\n");
fprintf(fp,"DGREADMERGE,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_rmerge);
}
}
fprintf(fp,",%.1f", disk_total / elapsed);
}
}
fprintf(fp, "\n");
fprintf(fp,"DGREADSERV,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_rmsec);
}
}
fprintf(fp,",%.1f", disk_total);
}
}
fprintf(fp, "\n");
fprintf(fp,"DGWRITES,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_writes);
}
}
fprintf(fp,",%.1f", disk_total / elapsed);
}
}
fprintf(fp, "\n");
fprintf(fp,"DGWRITEMERGE,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_wmerge);
}
}
fprintf(fp,",%.1f", disk_total / elapsed);
}
}
fprintf(fp, "\n");
fprintf(fp,"DGWRITESERV,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_wmsec);
}
}
fprintf(fp,",%.1f", disk_total);
}
}
fprintf(fp, "\n");
fprintf(fp,"DGINFLIGHT,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += p->dk[i].dk_inflight;
}
}
fprintf(fp,",%.1f", disk_total);
}
}
fprintf(fp, "\n");
fprintf(fp,"DGIOTIME,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_time);
}
}
fprintf(fp,",%.1f", disk_total);
}
}
fprintf(fp, "\n");
#ifdef EXPERIMENTAL
fprintf(fp,"DGF11,%s", LOOP);
for (k = 0; k < dgroup_total_groups; k++) {
if (dgroup_name[k] != 0) {
disk_total = 0.0;
for (j = 0; j < dgroup_disks[k]; j++) {
i = dgroup_data[k*DGROUPITEMS+j];
if (i != -1) {
disk_total += DKDELTA(dk_11);
}
}
fprintf(fp,",%.1f", disk_total);
}
}
fprintf(fp, "\n");
#endif /*EXPERIMENTAL*/
} /* if( extended_disk == 1 && disk_mode == DISK_MODE_DISKSTATS */
} /* if (dgroup_loaded == 2) */
} /* else from if(cursed) */
} /* if ((show_dgroup || (!cursed && dgroup_loaded))) { */
if (show_top) {
/* Get the details of the running processes */
firstproc = 0;
skipped = 0;
n = getprocs(0);
if (n > p->nprocs) {
n = n +128; /* allow for growth in the number of processes in the mean time */
p->procs = realloc(p->procs, sizeof(struct procsinfo ) * (n+1) ); /* add one to avoid overrun */
p->nprocs = n;
}
firstproc = 0;
n = getprocs(1);
if (topper_size < n) {
topper = realloc(topper, sizeof(struct topper ) * (n+1) ); /* add one to avoid overrun */
topper_size = n;
}
/* Sort the processes by CPU utilisation */
for ( i = 0, max_sorted = 0; i < n; i++) {
/* move forward in the previous array to find a match*/
for(j=0;j < q->nprocs;j++) {
if (p->procs[i].pi_pid == q->procs[j].pi_pid) { /* found a match */
topper[max_sorted].index = i;
topper[max_sorted].other = j;
topper[max_sorted].time = TIMEDELTA(pi_utime,i,j) +
TIMEDELTA(pi_stime,i,j);
topper[max_sorted].size = p->procs[i].statm_resident;
max_sorted++;
break;
}
}
}
switch(show_topmode) {
default:
case 3: qsort((void *) & topper[0], max_sorted, sizeof(struct topper ), &cpu_compare );
break;
case 4: qsort((void *) & topper[0], max_sorted, sizeof(struct topper ), &size_compare );
break;
#ifdef DISK
case 5: qsort((void *) & topper[0], max_sorted, sizeof(struct topper ), &disk_compare );
break;
#endif /* DISK */
}
CURSE BANNER(padtop,"Top Processes");
CURSE mvwprintw(padtop,0, 15, "Procs=%d mode=%d (1=Basic, 3=Perf 4=Size 5=I/O)", n, show_topmode);
if(cursed && top_first_time) {
top_first_time = 0;
mvwprintw(padtop,1, 1, "Please wait - information being collected");
}
else {
switch (show_topmode) {
case 1:
CURSE mvwprintw(padtop,1, 1, " PID PPID Pgrp Nice Prior Status proc-Flag Command");
for (j = 0; j < max_sorted; j++) {
i = topper[j].index;
if (p->procs[i].pi_pgrp == p->procs[i].pi_pid)
strcpy(pgrp, "none");
else
sprintf(&pgrp[0], "%d", p->procs[i].pi_pgrp);
/* skip over processes with 0 CPU */
if(!show_all && (topper[j].time/elapsed < ignore_procdisk_threshold) && !cmdfound)
break;
if( x + j + 2 - skipped > LINES+2) /* +2 to for safety :-) */
break;
CURSE mvwprintw(padtop,j + 2 - skipped, 1, "%7d %7d %6s %4d %4d %9s 0x%08x %1s %-32s",
p->procs[i].pi_pid,
p->procs[i].pi_ppid,
pgrp,
p->procs[i].pi_nice,
p->procs[i].pi_pri,
(topper[j].time * 100 / elapsed) ? "Running "
: get_state(p->procs[i].pi_state),
p->procs[i].pi_flags,
(p->procs[i].pi_tty_nr ? "F" : " "),
p->procs[i].pi_comm);
}
break;
case 3:
case 4:
case 5:
if(show_args == ARGS_ONLY)
formatstring = " PID %%CPU ResSize Command ";
else if(COLS > 119)
formatstring = " PID %%CPU Size Res Res Res Res Shared Faults Command";
else
formatstring = " PID %%CPU Size Res Res Res Res Shared Faults Command";
CURSE mvwprintw(padtop,1, y, formatstring);
if(show_args == ARGS_ONLY)
formatstring = " Used KB ";
else if(COLS > 119)
formatstring = " Used KB Set Text Data Lib KB Min Maj";
else
formatstring = " Used KB Set Text Data Lib KB Min Maj ";
CURSE mvwprintw(padtop,2, 1, formatstring);
for (j = 0; j < max_sorted; j++) {
i = topper[j].index;
if(!show_all) {
/* skip processes with zero CPU/io */
if(show_topmode == 3 && (topper[j].time/elapsed) < ignore_procdisk_threshold && !cmdfound)
break;
if(show_topmode == 5 && (topper[j].io < ignore_io_threshold && !cmdfound))
break;
}
if(cursed) {
if( x + j + 3 - skipped > LINES+2) /* +2 to for safety :-) */
break;
if(cmdfound && !cmdcheck(p->procs[i].pi_comm)) {
skipped++;
continue;
}
if(show_args == ARGS_ONLY){
mvwprintw(padtop,j + 3 - skipped, 1,
"%7d %5.1f %7lu %-120s",
p->procs[i].pi_pid,
topper[j].time / elapsed,
p->procs[i].statm_resident*pagesize/1024, /* in KB */
args_lookup(p->procs[i].pi_pid,
p->procs[i].pi_comm));
}
else {
if(COLS > 119)
formatstring = "%8d %7.1f %7lu %7lu %7lu %7lu %7lu %5lu %6d %6d %-32s";
else
formatstring = "%7d %5.1f %5lu %5lu %5lu %5lu %5lu %5lu %4d %4d %-32s";
mvwprintw(padtop,j + 3 - skipped, 1, formatstring,
p->procs[i].pi_pid,
topper[j].time/elapsed,
/* topper[j].time /1000.0 / elapsed,*/
p->procs[i].statm_size*pagesize/1024UL, /* in KB */
p->procs[i].statm_resident*pagesize/1024UL, /* in KB */
p->procs[i].statm_trs*pagesize/1024UL, /* in KB */
p->procs[i].statm_drs*pagesize/1024UL, /* in KB */
p->procs[i].statm_lrs*pagesize/1024UL, /* in KB */
p->procs[i].statm_share*pagesize/1024UL, /* in KB */
(int)(COUNTDELTA(pi_minflt) / elapsed),
(int)(COUNTDELTA(pi_majflt) / elapsed),
p->procs[i].pi_comm);
}
}
else {
if((cmdfound && cmdcheck(p->procs[i].pi_comm)) ||
(!cmdfound && ((topper[j].time / elapsed) > ignore_procdisk_threshold)) )
{
#ifndef KERNEL_2_6_18
fprintf(fp,"TOP,%07d,%s,%.2f,%.2f,%.2f,%lu,%lu,%lu,%lu,%lu,%d,%d,%s\n",
#else
fprintf(fp,"TOP,%07d,%s,%.2f,%.2f,%.2f,%lu,%lu,%lu,%lu,%lu,%d,%d,%s,%ld,%llu\n",
#endif
/* 1 */ p->procs[i].pi_pid,
/* 2 */ LOOP,
/* 3 */ topper[j].time / elapsed,
/* 4 */ TIMEDELTA(pi_utime,i,topper[j].other) / elapsed,
/* 5 */ TIMEDELTA(pi_stime,i,topper[j].other) / elapsed,
/* 6 */ p->procs[i].statm_size*pagesize/1024UL, /* in KB */
/* 7 */ p->procs[i].statm_resident*pagesize/1024UL, /* in KB */
/* 8 */ p->procs[i].statm_trs*pagesize/1024UL, /* in KB */
/* 9 */ p->procs[i].statm_drs*pagesize/1024UL, /* in KB */
/* 10*/ p->procs[i].statm_share*pagesize/1024UL, /* in KB */
/* 11*/ (int)(COUNTDELTA(pi_minflt) / elapsed),
/* 12*/ (int)(COUNTDELTA(pi_majflt) / elapsed),
/* 13*/ p->procs[i].pi_comm
#ifndef KERNEL_2_6_18
);
#else
,
p->procs[i].pi_num_threads,
COUNTDELTA(pi_delayacct_blkio_ticks)
);
#endif
if(show_args)
args_output(p->procs[i].pi_pid,loop, p->procs[i].pi_comm);
} else skipped++;
}
}
break;
}
}
CURSE DISPLAY(padtop,j + 3);
}
if(cursed) {
if(show_verbose) {
y=x;
x=1;
DISPLAY(padverb,4);
x=y;
}
if(x<LINES-2)mvwhline(stdscr, x, 1, ACS_HLINE,COLS-2);
wmove(stdscr,0, 0);
wrefresh(stdscr);
doupdate();
for (i = 0; i < seconds; i++) {
sleep(1);
if (checkinput())
break;
}
}
else {
fflush(NULL);
secs = seconds;
redo:
errno = 0;
ret = sleep(secs);
if( (ret != 0 || errno != 0) && loop != maxloops ) {
fprintf(fp,"ERROR,%s,sleep got interrupted:",LOOP);
fprintf(fp,"ret was %d, ",ret);
fprintf(fp,"errno was %d\n",errno);
secs=ret;
goto redo;
}
}
switcher();
if (loop >= maxloops) {
CURSE endwin();
if (nmon_end) {
child_start(CHLD_END, nmon_end, time_stamp_type, loop, timer);
/* Give the end - processing some time - 5s for now */
sleep(5);
}
fflush(NULL);
exit(0);
}
}
}