Return to load.c CVS log

Up to [Research Unix] / researchv10dc / cmd / load

Annotation of researchv10dc/cmd/load/load.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *     Print the system load average,
                      3:  *     and the time of day.
                      4:  */
                      5: 
                      6: #include <stdio.h>
                      7: #include <nlist.h>
                      8: 
                      9: struct nlist nl[] = {
                     10:        {"_avenrun"},
                     11:        {0}
                     12: };
                     13: 
                     14: double avenrun[3];
                     15: 
                     16: main(argc,argv)
                     17: char **argv;
                     18: {
                     19:        register int i,kmem;
                     20:        long maddr;
                     21:        long t;
                     22:        int count = -1, interval = 0;
                     23:        register char *dunix = "/unix", *dkmem = "/dev/kmem";
                     24:        extern char _sobuf[BUFSIZ];
                     25: 
                     26:        setbuf (stdout, _sobuf);
                     27: 
                     28:        switch (argc) {
                     29:        case 5:
                     30:                dkmem = argv[4];
                     31:                /* no break */
                     32:        case 4:
                     33:                dunix = argv[3];
                     34:        case 3:
                     35:                count = atoi (argv[2]);
                     36:        case 2:
                     37:                interval = atoi (argv[1]);
                     38:        case 1:
                     39:                break;
                     40:        default:
                     41:                err("usage: load [interval [count  [/unix  [/dev/kmem]]]]");
                     42:        }
                     43:        
                     44:        nlist(dunix, nl);
                     45:        if (nl[0].n_type==0) err("no namelist");
                     46:        if ((kmem=open(dkmem,0))<0) err("no kmem");
                     47:        if (0==strcmp(dkmem,"/dev/kmem")) maddr=0;
                     48:        else maddr=0x80000000;
                     49:        time (&t);
                     50:        printf ("    1m    5m   15m\n");
                     51: 
                     52:        do {
                     53:                register int i;
                     54: 
                     55:                kseek(kmem,nl[0].n_value,0,maddr);
                     56:                kread(kmem,avenrun,sizeof(avenrun));
                     57: 
                     58:                for (i = 0; i < sizeof(avenrun)/sizeof(*avenrun); i++)
                     59:                        printf ("%6.1f", avenrun[i]);
                     60:                putchar ('\n');
                     61:                fflush (stdout);
                     62: 
                     63:                if (count && interval)
                     64:                        sleep (interval);
                     65:        } while (--count && interval);
                     66: }
                     67: 
                     68: err(why)
                     69: char *why;
                     70: {
                     71:        extern int errno;
                     72:        fprintf (stderr,"load: %s",why);
                     73:        if (errno)
                     74:                fprintf (stderr, " (%d)", errno);
                     75:        fprintf (stderr, "\n");
                     76:        exit(2);
                     77: }
                     78: 
                     79: kseek(fd,offset,whence,maddr)
                     80: long offset;
                     81: {
                     82:        if (-1==lseek(fd,offset&~maddr,whence)) err("kmem seek error");
                     83: }
                     84: 
                     85: kread(fd,buf,siz)
                     86: char *buf;
                     87: {
                     88:        if (siz!=read(fd,buf,siz)) err("kmem read error");
                     89: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.