1996-06-16 04:49:29 +02:00
|
|
|
/*
|
|
|
|
* ttyload
|
|
|
|
*
|
|
|
|
* tty equivelant to xload
|
|
|
|
*
|
|
|
|
* Copyright 1996 by David Lindes
|
|
|
|
* all right reserved.
|
|
|
|
*
|
2001-08-24 05:48:58 +02:00
|
|
|
* Version information: $Id: ttyload.c,v 1.14 2001-08-24 03:48:58 lindes Exp $
|
1996-06-16 04:49:29 +02:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
1996-06-15 22:30:09 +02:00
|
|
|
#include <limits.h>
|
|
|
|
#include <stdio.h>
|
1996-06-16 21:28:21 +02:00
|
|
|
#include <stdlib.h>
|
1996-06-15 22:30:09 +02:00
|
|
|
#include <sys/fcntl.h>
|
|
|
|
#include <sys/stat.h>
|
2000-08-17 00:02:31 +02:00
|
|
|
#include <time.h>
|
1996-06-15 22:30:09 +02:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <unistd.h>
|
2001-02-24 10:06:13 +01:00
|
|
|
#include <time.h>
|
1996-06-15 22:30:09 +02:00
|
|
|
|
1996-06-16 04:49:29 +02:00
|
|
|
#include "ttyload.h"
|
1996-06-15 22:30:09 +02:00
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
#define HEIGHTPAD 9
|
|
|
|
#define WIDTHPAD 14
|
|
|
|
#define CLOCKWIDTH 7
|
|
|
|
#define HOSTLENGTH 20
|
|
|
|
|
|
|
|
#define MINROWS (HEIGHTPAD + 6)
|
|
|
|
#define MINCOLS (WIDTHPAD + 6)
|
|
|
|
|
2001-08-24 05:48:58 +02:00
|
|
|
char *c="$Id: ttyload.c,v 1.14 2001-08-24 03:48:58 lindes Exp $";
|
1996-06-16 21:28:21 +02:00
|
|
|
|
2001-08-24 05:48:58 +02:00
|
|
|
char strbuf[BUFSIZ],
|
2001-08-23 02:52:44 +02:00
|
|
|
*optstring = "i:hv",
|
1996-06-16 21:28:21 +02:00
|
|
|
*usage =
|
|
|
|
"Usage: %s [-i secs]\n"
|
2001-08-23 02:52:44 +02:00
|
|
|
" -h -- show this help, then exit\n"
|
|
|
|
" -v -- show version info, then exit\n"
|
1996-06-16 21:28:21 +02:00
|
|
|
" -i secs\n"
|
|
|
|
" Alter the number of seconds in "
|
2001-08-23 02:52:44 +02:00
|
|
|
"the interval between refreshes\n"
|
1996-06-16 21:28:21 +02:00
|
|
|
" The default is 4, and the minimum "
|
2001-08-23 02:52:44 +02:00
|
|
|
"is 1, which is silently clamped.\n\n"
|
2001-08-24 03:57:03 +02:00
|
|
|
" (Note: use ctrl-C to quit)\n\n"
|
|
|
|
" For updates and other info, see http://"
|
|
|
|
"www.daveltd.com/src/util/ttyload/\n";
|
2001-08-24 05:48:58 +02:00
|
|
|
int clockpad, clocks;
|
1996-06-16 21:28:21 +02:00
|
|
|
clock_info *theclocks;
|
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
/* version ID, passed in by the Makefile: */
|
|
|
|
char *version = VERSION;
|
|
|
|
|
2000-05-20 03:31:30 +02:00
|
|
|
char *loadstrings[] = {
|
|
|
|
" ", /* blank */
|
|
|
|
"\033[31m*\033[m", /* one minute average */
|
|
|
|
"\033[32m*\033[m", /* five minute average */
|
|
|
|
"\033[33m*\033[m", /* one & five, together */
|
|
|
|
"\033[34m*\033[m", /* fifteen minute average */
|
|
|
|
"\033[35m*\033[m", /* one & fifteen, together */
|
|
|
|
"\033[36m*\033[m", /* five & fifteen, together */
|
|
|
|
"\033[37m*\033[m" /* one, five & fifteen, together */
|
|
|
|
};
|
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
/* The following two variables should probably be assigned
|
|
|
|
using some sort of real logic, rather than these hard-coded
|
|
|
|
defaults, but the defaults work for now... */
|
|
|
|
int rows = 40,
|
|
|
|
cols = 80,
|
|
|
|
|
|
|
|
intsecs = 4,
|
|
|
|
debug = 3,
|
|
|
|
theclock = 0,
|
|
|
|
|
|
|
|
height, width/* ,
|
2001-02-24 10:06:13 +01:00
|
|
|
c, i, j, k */;
|
1996-06-16 04:53:30 +02:00
|
|
|
|
1996-06-15 22:30:09 +02:00
|
|
|
|
2000-05-20 03:31:30 +02:00
|
|
|
void getload(load_list *);
|
2001-02-24 10:06:13 +01:00
|
|
|
int compute_height(load_t, load_t, int);
|
1996-06-16 04:49:29 +02:00
|
|
|
void showloads(load_list *);
|
|
|
|
void clear_screen();
|
2001-02-27 04:23:22 +01:00
|
|
|
void home_screen();
|
2001-02-24 10:06:13 +01:00
|
|
|
void cycle_load_list(load_list*, load_list, int);
|
1996-06-16 04:49:29 +02:00
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
int main(argc, argv, envp)
|
1996-06-15 22:30:09 +02:00
|
|
|
int argc;
|
|
|
|
char *argv[],
|
|
|
|
*envp[];
|
|
|
|
{
|
|
|
|
float multiplier;
|
1996-06-16 04:49:29 +02:00
|
|
|
load_list *loadavgs, newload;
|
2001-08-23 02:52:44 +02:00
|
|
|
int c, i, j, k, errflag=0, versflag=0;
|
1996-06-16 21:28:21 +02:00
|
|
|
char *basename;
|
2001-02-24 10:06:13 +01:00
|
|
|
char hostname[HOSTLENGTH + 1];
|
1996-06-16 21:28:21 +02:00
|
|
|
time_t thetime;
|
|
|
|
struct tm *thetimetm;
|
|
|
|
|
2001-08-23 02:52:44 +02:00
|
|
|
/* set up the basename variable, used for Usage, etc. */
|
|
|
|
basename = (char *)strrchr(*argv, '/');
|
|
|
|
if(!basename)
|
|
|
|
basename = *argv;
|
|
|
|
else
|
|
|
|
basename++; /* go past the '/' */
|
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
while((c = getopt(argc, argv, optstring)) != EOF)
|
1996-06-16 21:28:21 +02:00
|
|
|
{
|
|
|
|
switch(c)
|
|
|
|
{
|
|
|
|
case 'i':
|
|
|
|
intsecs = atoi(optarg);
|
|
|
|
break;
|
2001-08-23 02:52:44 +02:00
|
|
|
case 'v':
|
|
|
|
versflag++;
|
|
|
|
break;
|
|
|
|
case 'h':
|
1996-06-16 21:28:21 +02:00
|
|
|
default:
|
|
|
|
errflag++;
|
|
|
|
break; /* redundant */
|
|
|
|
}
|
|
|
|
}
|
2001-08-23 02:52:44 +02:00
|
|
|
|
|
|
|
/* version info requested, show it: */
|
|
|
|
if(versflag)
|
|
|
|
fprintf(stderr, "%s version %s\n", basename, version);
|
|
|
|
/* error, show usage: */
|
1996-06-16 21:28:21 +02:00
|
|
|
if(errflag)
|
2001-02-24 10:06:13 +01:00
|
|
|
fprintf(stderr, usage, basename);
|
2001-08-23 02:52:44 +02:00
|
|
|
/* for either, we exit: */
|
|
|
|
if(errflag || versflag)
|
1996-06-16 21:28:21 +02:00
|
|
|
exit(1);
|
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
if(gethostname(hostname, HOSTLENGTH))
|
1996-06-16 21:28:21 +02:00
|
|
|
{
|
|
|
|
perror("NOTICE: couldn't determine hostname");
|
2001-02-24 10:06:13 +01:00
|
|
|
strcpy(hostname, "localhost");
|
1996-06-16 21:28:21 +02:00
|
|
|
sleep(2);
|
|
|
|
}
|
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
/* do space-padding of hostname out to HOSTLENGTH chars: */
|
|
|
|
for(i = 0; i < (HOSTLENGTH); i++)
|
|
|
|
{
|
|
|
|
if(hostname[i] == '\0')
|
|
|
|
{
|
|
|
|
hostname[i] = ' ';
|
|
|
|
hostname[i + 1] = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
intsecs = MAX(1, intsecs); /* must be positive */
|
1996-06-16 21:28:21 +02:00
|
|
|
height = rows - HEIGHTPAD;
|
|
|
|
width = cols - WIDTHPAD;
|
2001-02-24 10:06:13 +01:00
|
|
|
clocks = MAX(width/intsecs, width/CLOCKWIDTH);
|
1996-06-16 21:28:21 +02:00
|
|
|
clockpad = (width / clocks) - CLOCKWIDTH;
|
|
|
|
|
|
|
|
if(rows < MINROWS)
|
|
|
|
{
|
2001-02-24 10:06:13 +01:00
|
|
|
fprintf(stderr, "Sorry, %s requires at least %d rows to run.\n",
|
1996-06-16 21:28:21 +02:00
|
|
|
basename,
|
|
|
|
MINROWS,
|
|
|
|
NULL);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if(cols < MINCOLS)
|
|
|
|
{
|
2001-02-24 10:06:13 +01:00
|
|
|
fprintf(stderr, "Sorry, %s requires at least %d cols to run.\n",
|
1996-06-16 21:28:21 +02:00
|
|
|
basename,
|
|
|
|
MINCOLS,
|
|
|
|
NULL);
|
|
|
|
exit(1);
|
|
|
|
}
|
1996-06-15 22:30:09 +02:00
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
loadavgs = (load_list *)calloc(width, sizeof(load_list));
|
|
|
|
theclocks = (clock_info *)calloc(clocks, sizeof(clock_info));
|
1996-06-15 22:30:09 +02:00
|
|
|
|
|
|
|
if(!loadavgs)
|
|
|
|
{
|
1996-06-16 04:49:29 +02:00
|
|
|
perror("calloc for loadavgs failed");
|
1996-06-16 21:28:21 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!theclocks)
|
|
|
|
{
|
|
|
|
perror("calloc for clocks failed");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2001-08-24 05:48:58 +02:00
|
|
|
/* run getload one time before clear_screen, in case it
|
|
|
|
* errors (as it will on IRIX if the program doesn't have
|
|
|
|
* read access to /dev/kmem, for example). */
|
|
|
|
getload(&loadavgs[0]);
|
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
for(i=0;i<clocks;i++)
|
|
|
|
{
|
|
|
|
theclocks[i].pos = -1;
|
1996-06-15 22:30:09 +02:00
|
|
|
}
|
|
|
|
|
2001-02-27 04:23:22 +01:00
|
|
|
clear_screen();
|
|
|
|
|
1996-06-15 22:30:09 +02:00
|
|
|
for(i=0;i<width;i++)
|
|
|
|
{
|
|
|
|
if(i != 0)
|
|
|
|
{
|
1996-06-16 21:28:21 +02:00
|
|
|
sleep(intsecs);
|
1996-06-15 22:30:09 +02:00
|
|
|
}
|
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
time(&thetime);
|
2001-02-24 10:06:13 +01:00
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
thetimetm = localtime(&thetime);
|
|
|
|
|
2000-05-20 03:31:30 +02:00
|
|
|
getload(&loadavgs[i]);
|
1996-06-15 22:30:09 +02:00
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
if(((thetimetm->tm_sec) / intsecs) == 0)
|
|
|
|
{
|
2001-02-24 10:06:13 +01:00
|
|
|
if(!ascftime(strbuf, "^%H:%M", thetimetm))
|
1996-06-16 21:28:21 +02:00
|
|
|
{
|
|
|
|
/* This should never happen, I hope... */
|
|
|
|
perror("ascftime failed");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
theclocks[theclock].pos = i;
|
2001-02-24 10:06:13 +01:00
|
|
|
strcpy(theclocks[theclock].clock, strbuf);
|
1996-06-16 21:28:21 +02:00
|
|
|
theclock++;
|
|
|
|
theclock %= clocks;
|
|
|
|
|
|
|
|
if(theclock >= clocks)
|
|
|
|
{
|
|
|
|
/* Hopefully, I'll get this to the point
|
|
|
|
where it well never happen... As I first
|
|
|
|
write it, I'm fairly certain it will, but
|
|
|
|
that should be fixable... */
|
2001-02-24 10:06:13 +01:00
|
|
|
fprintf(stderr, "Internal error: too many clocks!");
|
1996-06-16 21:28:21 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2001-02-27 04:52:51 +01:00
|
|
|
|
|
|
|
/* as a temporoary cleanup functionality after
|
|
|
|
* changing from clear_screen on every iteration to
|
|
|
|
* home_screen on all but the first, but since it's
|
|
|
|
* nice to occasionally actually clear (at least
|
|
|
|
* until we're actually using curses or the like,
|
|
|
|
* when we can put that activity on SIGWINCH and
|
|
|
|
* ctrl-L command, or the like), I'm using the
|
|
|
|
* enclosing if() condition as a "good" time to do
|
|
|
|
* that: */
|
|
|
|
clear_screen();
|
1996-06-16 21:28:21 +02:00
|
|
|
}
|
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
if(!ascftime(strbuf, "%T", thetimetm))
|
1996-06-16 21:28:21 +02:00
|
|
|
{
|
|
|
|
/* This should never happen, I hope... */
|
|
|
|
perror("ascftime failed");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2001-02-27 04:23:22 +01:00
|
|
|
home_screen();
|
1996-06-16 21:28:21 +02:00
|
|
|
|
2001-02-24 11:00:51 +01:00
|
|
|
printf("%s %.2f, %.2f, %.2f %s ttyload, v%s\n\n",
|
1996-06-16 21:28:21 +02:00
|
|
|
hostname,
|
2001-02-24 10:06:13 +01:00
|
|
|
(loadavgs[i].one_minute / 1024.),
|
|
|
|
(loadavgs[i].five_minute / 1024.),
|
|
|
|
(loadavgs[i].fifteen_minute / 1024.),
|
|
|
|
strbuf + 1,
|
|
|
|
version,
|
1996-06-16 21:28:21 +02:00
|
|
|
NULL);
|
|
|
|
|
1996-06-16 04:49:29 +02:00
|
|
|
if(debug > 3)
|
|
|
|
printf("Load averages: %f, %f, %f\n",
|
|
|
|
loadavgs[i].one_minute / 1024.,
|
|
|
|
loadavgs[i].five_minute / 1024.,
|
|
|
|
loadavgs[i].fifteen_minute / 1024.,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
showloads(loadavgs);
|
|
|
|
|
|
|
|
if(i == (width - 1))
|
|
|
|
{
|
|
|
|
if(debug > 4)
|
|
|
|
{
|
|
|
|
printf("CYCLING LOAD LIST...\n");
|
|
|
|
sleep(3);
|
|
|
|
}
|
2000-05-20 03:31:30 +02:00
|
|
|
getload(&newload);
|
2001-02-24 10:06:13 +01:00
|
|
|
cycle_load_list(loadavgs, newload, width);
|
1996-06-16 04:49:29 +02:00
|
|
|
i--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void showloads(loadavgs)
|
|
|
|
load_list *loadavgs;
|
|
|
|
{
|
2001-02-24 10:06:13 +01:00
|
|
|
load_list min = {LONG_MAX-1, LONG_MAX-1, LONG_MAX-1, 0, 0, 0},
|
|
|
|
max = {0, 0, 0, 0, 0, 0};
|
|
|
|
load_t lmin, lmax;
|
|
|
|
float omin, omax;
|
|
|
|
int i, j, k;
|
1996-06-16 04:49:29 +02:00
|
|
|
|
|
|
|
if(debug>3)
|
|
|
|
{
|
2001-02-24 10:06:13 +01:00
|
|
|
printf("Starting with min set: %d, %d, %d\n",
|
1996-06-16 04:49:29 +02:00
|
|
|
min.one_minute,
|
|
|
|
min.five_minute,
|
|
|
|
min.fifteen_minute,
|
|
|
|
NULL);
|
2001-02-24 10:06:13 +01:00
|
|
|
printf("Starting with first set: %d, %d, %d\n",
|
1996-06-16 04:49:29 +02:00
|
|
|
loadavgs[0].one_minute,
|
|
|
|
loadavgs[0].five_minute,
|
|
|
|
loadavgs[0].fifteen_minute,
|
1996-06-15 22:30:09 +02:00
|
|
|
NULL);
|
1996-06-16 04:49:29 +02:00
|
|
|
sleep(1);
|
1996-06-15 22:30:09 +02:00
|
|
|
}
|
|
|
|
for(i=0;i<width;i++)
|
|
|
|
{
|
1996-06-16 04:49:29 +02:00
|
|
|
if(debug>9)
|
|
|
|
{
|
2001-02-24 10:06:13 +01:00
|
|
|
printf("Checking for min/max at %d...\n", i);
|
1996-06-16 04:49:29 +02:00
|
|
|
printf("Comparing, for example, %d <=> %d\n",
|
2001-02-24 10:06:13 +01:00
|
|
|
min.one_minute, loadavgs[i].one_minute,
|
1996-06-16 04:49:29 +02:00
|
|
|
NULL);
|
|
|
|
}
|
2001-02-24 10:06:13 +01:00
|
|
|
min.one_minute = MIN(min.one_minute, loadavgs[i].one_minute);
|
|
|
|
min.five_minute = MIN(min.five_minute, loadavgs[i].five_minute);
|
1996-06-15 22:30:09 +02:00
|
|
|
min.fifteen_minute
|
2001-02-24 10:06:13 +01:00
|
|
|
= MIN(min.fifteen_minute, loadavgs[i].fifteen_minute);
|
|
|
|
max.one_minute = MAX(max.one_minute, loadavgs[i].one_minute);
|
|
|
|
max.five_minute = MAX(max.five_minute, loadavgs[i].five_minute);
|
1996-06-15 22:30:09 +02:00
|
|
|
max.fifteen_minute
|
2001-02-24 10:06:13 +01:00
|
|
|
= MAX(max.fifteen_minute, loadavgs[i].fifteen_minute);
|
1996-06-15 22:30:09 +02:00
|
|
|
}
|
1996-06-16 04:49:29 +02:00
|
|
|
if(debug>3)
|
|
|
|
{
|
|
|
|
printf("Continuing with min set: %d,%d,%d\n",
|
|
|
|
min.one_minute,
|
|
|
|
min.five_minute,
|
|
|
|
min.fifteen_minute,
|
|
|
|
NULL);
|
|
|
|
printf("Continuing with first set: %d,%d,%d\n",
|
|
|
|
loadavgs[0].one_minute,
|
|
|
|
loadavgs[0].five_minute,
|
|
|
|
loadavgs[0].fifteen_minute,
|
|
|
|
NULL);
|
|
|
|
sleep(1);
|
1996-06-16 21:28:21 +02:00
|
|
|
printf("MIN Load averages: %f, %f, %f\n",
|
|
|
|
min.one_minute / 1024.,
|
|
|
|
min.five_minute / 1024.,
|
|
|
|
min.fifteen_minute / 1024.,
|
|
|
|
NULL);
|
|
|
|
printf("MAX Load averages: %f, %f, %f\n",
|
|
|
|
max.one_minute / 1024.,
|
|
|
|
max.five_minute / 1024.,
|
|
|
|
max.fifteen_minute / 1024.,
|
|
|
|
NULL);
|
1996-06-16 04:49:29 +02:00
|
|
|
}
|
2001-02-24 10:06:13 +01:00
|
|
|
lmin=MIN(min.one_minute, MIN(min.five_minute, min.fifteen_minute));
|
|
|
|
lmax=MAX(max.one_minute, MAX(max.five_minute, max.fifteen_minute));
|
1996-06-15 22:30:09 +02:00
|
|
|
|
1996-06-16 04:49:29 +02:00
|
|
|
if(debug > 3)
|
2001-02-24 10:06:13 +01:00
|
|
|
printf("Overall MIN, MAX: %f, %f\n", lmin/1024., lmax/1024.);
|
1996-06-15 22:30:09 +02:00
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
omin = (int)(lmin / 1024);
|
1996-06-15 22:30:09 +02:00
|
|
|
lmin = 1024 * omin;
|
1996-06-16 21:28:21 +02:00
|
|
|
|
|
|
|
if((lmax / 1024.) < .25)
|
|
|
|
{
|
|
|
|
omax = .25;
|
|
|
|
}
|
|
|
|
else if((lmax / 1024.) < .5)
|
|
|
|
{
|
|
|
|
omax = .5;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
omax = (int)(lmax / 1024) + 1;
|
|
|
|
}
|
1996-06-15 22:30:09 +02:00
|
|
|
lmax = 1024 * omax;
|
|
|
|
|
1996-06-16 04:49:29 +02:00
|
|
|
if(debug > 3)
|
|
|
|
{
|
2001-02-24 10:06:13 +01:00
|
|
|
printf("Boundaries: %d, %d... ", omin, omax);
|
|
|
|
printf("Long Boundaries: %d, %d\n", lmin, lmax);
|
1996-06-16 04:49:29 +02:00
|
|
|
}
|
1996-06-15 22:30:09 +02:00
|
|
|
|
|
|
|
|
|
|
|
for(i=0;i<width;i++)
|
|
|
|
{
|
1996-06-16 04:49:29 +02:00
|
|
|
loadavgs[i].height1 =
|
2001-02-24 10:06:13 +01:00
|
|
|
compute_height(loadavgs[i].one_minute, lmax, height);
|
1996-06-16 04:49:29 +02:00
|
|
|
loadavgs[i].height5 =
|
2001-02-24 10:06:13 +01:00
|
|
|
compute_height(loadavgs[i].five_minute, lmax, height);
|
1996-06-16 04:49:29 +02:00
|
|
|
loadavgs[i].height15 =
|
2001-02-24 10:06:13 +01:00
|
|
|
compute_height(loadavgs[i].fifteen_minute, lmax, height);
|
1996-06-16 04:49:29 +02:00
|
|
|
|
|
|
|
if(debug > 3)
|
|
|
|
{
|
|
|
|
printf("Load averages: %f, %f, %f -- ",
|
|
|
|
loadavgs[i].one_minute / 1024.,
|
|
|
|
loadavgs[i].five_minute / 1024.,
|
|
|
|
loadavgs[i].fifteen_minute / 1024.,
|
|
|
|
NULL);
|
|
|
|
printf("Heights: %d, %d, %d\n",
|
|
|
|
loadavgs[i].height1,
|
|
|
|
loadavgs[i].height5,
|
|
|
|
loadavgs[i].height15,
|
|
|
|
NULL);
|
|
|
|
}
|
1996-06-15 22:30:09 +02:00
|
|
|
}
|
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
for(j=0;j<=height;j++)
|
1996-06-15 22:30:09 +02:00
|
|
|
{
|
1996-06-16 04:49:29 +02:00
|
|
|
printf("%6.2f ",
|
1996-06-16 21:28:21 +02:00
|
|
|
(((omax)*(height-j)) / (height))
|
1996-06-15 22:30:09 +02:00
|
|
|
);
|
|
|
|
for(i=0;i<width;i++)
|
|
|
|
{
|
|
|
|
k=0;
|
|
|
|
if(loadavgs[i].height1 == j)
|
|
|
|
k+=ONE;
|
|
|
|
if(loadavgs[i].height5 == j)
|
|
|
|
k+=FIVE;
|
|
|
|
if(loadavgs[i].height15 == j)
|
|
|
|
k+=FIFTEEN;
|
2001-02-24 10:06:13 +01:00
|
|
|
printf("%s", loadstrings[k]);
|
1996-06-15 22:30:09 +02:00
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
1996-06-16 04:49:29 +02:00
|
|
|
|
2001-02-24 11:57:53 +01:00
|
|
|
memset(strbuf, '\0', BUFSIZ);
|
|
|
|
memset(strbuf, ' ', cols - 1);
|
1996-06-16 21:28:21 +02:00
|
|
|
|
|
|
|
for(i=0;i<clocks;i++)
|
|
|
|
{
|
|
|
|
if(theclocks[i].pos > 0)
|
|
|
|
{
|
|
|
|
strncpy(
|
|
|
|
&strbuf[9+theclocks[i].pos],
|
|
|
|
theclocks[i].clock,
|
2001-08-24 05:48:58 +02:00
|
|
|
6);
|
1996-06-16 21:28:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-27 04:52:51 +01:00
|
|
|
/* make sure the string still terminates in the same place: */
|
|
|
|
strbuf[cols -1] = '\0';
|
|
|
|
|
1996-06-16 21:28:21 +02:00
|
|
|
printf("%s\n Legend:\n"
|
|
|
|
" 1 min: %s, 5 min: %s, 15 min: %s\n"
|
|
|
|
" 1&5 same: %s, 1&15: %s, 5&15: %s, all: %s\n",
|
|
|
|
strbuf,
|
1996-06-16 04:49:29 +02:00
|
|
|
loadstrings[1],
|
|
|
|
loadstrings[2],
|
|
|
|
loadstrings[4],
|
|
|
|
loadstrings[3],
|
|
|
|
loadstrings[5],
|
|
|
|
loadstrings[6],
|
|
|
|
loadstrings[7],
|
|
|
|
NULL);
|
1996-06-15 22:30:09 +02:00
|
|
|
}
|
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
int compute_height(thisload, maxload, height)
|
1996-06-15 22:30:09 +02:00
|
|
|
load_t thisload,
|
|
|
|
maxload;
|
|
|
|
int height;
|
|
|
|
{
|
|
|
|
return(/*height-*/(height*((maxload-thisload)/(float)maxload)));
|
|
|
|
}
|
1996-06-16 04:49:29 +02:00
|
|
|
|
|
|
|
void clear_screen()
|
|
|
|
{
|
|
|
|
printf("\033[H\033[2J");
|
|
|
|
}
|
|
|
|
|
2001-02-27 04:23:22 +01:00
|
|
|
void home_screen()
|
|
|
|
{
|
|
|
|
printf("\033[H");
|
|
|
|
}
|
|
|
|
|
2001-02-24 10:06:13 +01:00
|
|
|
void cycle_load_list(loadavgs, newload, width)
|
1996-06-16 04:49:29 +02:00
|
|
|
load_list *loadavgs,
|
|
|
|
newload;
|
|
|
|
int width;
|
|
|
|
{
|
|
|
|
/* This function will eventually have code to
|
|
|
|
clear locations on the screen that change. */
|
|
|
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i=0;i<(width-1);i++)
|
|
|
|
{
|
|
|
|
loadavgs[i] = loadavgs[i+1];
|
|
|
|
}
|
|
|
|
loadavgs[i] = newload;
|
1996-06-16 21:28:21 +02:00
|
|
|
|
|
|
|
for(i=0;i<clocks;i++)
|
|
|
|
{
|
|
|
|
theclocks[i].pos--;
|
|
|
|
}
|
1996-06-16 04:49:29 +02:00
|
|
|
}
|