date and time created 82/06/21 00:52:43 by mckusick

[unix-history] / usr / src / usr.sbin / kgmon / kgmon.c

/* Copyright (c) 1982 Regents of the University of California */

#ifndef lint
static char sccsid[] = "@(#)kgmon.c     4.1 82/06/21";
#endif

#include <sys/param.h>
#include <sys/pte.h>
#include <stdio.h>
#include <nlist.h>
#include <ctype.h>
#include <sys/crt0.h>

#define PROFILING_ON    0
#define PROFILING_OFF   3

/*
* froms is actually a bunch of unsigned shorts indexing tos
*/
u_short *froms;
struct  tostruct *tos;
char    *s_lowpc;
u_long  s_textsize;
int     ssiz;
off_t   sbuf;

struct nlist nl[] = {
#define N_SYSMAP        0
       { "_Sysmap" },
#define N_SYSSIZE       1
       { "_Syssize" },
#define N_FROMS         2
       { "_froms" },
#define N_PROFILING     3
       { "_profiling" },
#define N_S_LOWPC       4
       { "_s_lowpc" },
#define N_S_TEXTSIZE    5
       { "_s_textsize" },
#define N_SBUF          6
       { "_sbuf" },
#define N_SSIZ          7
       { "_ssiz" },
#define N_TOS           8
       { "_tos" },
       0,
};

struct  pte *Sysmap;

char    *system = "/vmunix";
char    *kmemf = "/dev/kmem";
int     kmem;
int     kflg;

main(argc, argv)
       int argc;
       char *argv[];
{
       int i, j, k;
       char *cp;
       long conptr;
       int fd;
       int fromindex;
       u_long frompc;
       int toindex;
       struct rawarc rawarc;
       off_t kfroms, ktos;
       char buf[BUFSIZ];
       int debug = 0;

       argc--, argv++;
       if (argc > 0) {
               system = *argv;
               argv++, argc--;
       }
       nlist(system, nl);
       if (nl[0].n_type == 0) {
               fprintf(stderr, "%s: no namelist\n", system);
               exit(1);
       }
       if (argc > 0) {
               kmemf = *argv;
               kflg++;
       }
       kmem = open(kmemf, 2);
       if (kmem < 0) {
               kmem = open(kmemf, 0);
               if (kmem < 0) {
                       fprintf(stderr, "cannot open ");
                       perror(kmemf);
                       exit(1);
               }
               fprintf(stderr,
                   "%s opened read-only, data may be inconsistent\n",
                   kmemf);
       }
       if (kflg) {
               off_t off;

               off = nl[N_SYSMAP].n_value & 0x7fffffff;
               lseek(kmem, off, 0);
               nl[N_SYSSIZE].n_value *= 4;
               Sysmap = (struct pte *)malloc(nl[N_SYSSIZE].n_value);
               if (Sysmap == 0) {
                       perror("Sysmap");
                       exit(1);
               }
               read(kmem, Sysmap, nl[N_SYSSIZE].n_value);
       }
       turnonoff(PROFILING_OFF);
       fd = creat("gmon.out", 0666);
       if (fd < 0) {
               perror("gmon.out");
               return;
       }
       ssiz = kfetch(N_SSIZ);
       sbuf = kfetch(N_SBUF);
       klseek(kmem, (off_t)sbuf, 0);
       for (i = ssiz; i > 0; i -= BUFSIZ) {
               read(kmem, buf, i < BUFSIZ ? i : BUFSIZ);
               write(fd, buf, i < BUFSIZ ? i : BUFSIZ);
       }
       s_textsize = kfetch(N_S_TEXTSIZE);
       froms = (u_short *)malloc(s_textsize);
       kfroms = kfetch(N_FROMS);
       klseek(kmem, kfroms, 0);
       for (i = 0; i < s_textsize; i += BUFSIZ) {
               j = s_textsize - i;
               if (j > BUFSIZ)
                       j = BUFSIZ;
               k = read(kmem, ((char *)(froms)) + i, j);
               if (j != k) {
                       fprintf(stderr, "read tos: loc %d, request %d, got %d",
                           i, j, k);
                       perror("");
                       exit(5);
               }
       }
       tos = (struct tostruct *)malloc(s_textsize);
       ktos = kfetch(N_TOS);
       klseek(kmem, ktos, 0);
       for (i = 0; i < s_textsize; i += BUFSIZ) {
               j = s_textsize - i;
               if (j > BUFSIZ)
                       j = BUFSIZ;
               k = read(kmem, ((char *)(tos)) + i, j);
               if (j != k) {
                       fprintf(stderr, "read tos: loc %d, request %d, got %d",
                           i, j, k);
                       perror("");
                       exit(6);
               }
       }
       s_lowpc = (char *)kfetch(N_S_LOWPC);
       if (debug)
               fprintf(stderr, "s_lowpc 0x%x, s_textsize 0x%x\n",
                   s_lowpc, s_textsize);
       for (fromindex = 0; fromindex < s_textsize>>1; fromindex++) {
               if (froms[fromindex] == 0)
                       continue;
               frompc = (u_long)s_lowpc + (fromindex<<1);
               for (toindex = froms[fromindex]; toindex != 0;
                  toindex = tos[toindex].link) {
                       if (debug)
                           fprintf(stderr,
                           "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
                           frompc, tos[toindex].selfpc, tos[toindex].count);
                       rawarc.raw_frompc = frompc;
                       rawarc.raw_selfpc = (u_long)tos[toindex].selfpc;
                       rawarc.raw_count = tos[toindex].count;
                       write(fd, &rawarc, sizeof (rawarc));
               }
       }
       close(fd);
       turnonoff(PROFILING_ON);
}

turnonoff(onoff)
       int onoff;
{
       off_t off;

       if ((off = nl[N_PROFILING].n_value) == 0) {
               printf("profiling: not defined in kernel\n");
               exit(1);
       }
       klseek(kmem, off, 0);
       write(kmem, (char *)&onoff, sizeof (onoff));
}

kfetch(index)
       int index;
{
       off_t off;
       int value;

       if ((off = nl[index].n_value) == 0) {
               printf("%s: not defined in kernel\n", nl[index].n_name);
               exit(1);
       }
       if (klseek(kmem, off, 0) == -1) {
               perror("lseek");
               exit(2);
       }
       if (read(kmem, (char *)&value, sizeof (value)) != sizeof (value)) {
               perror("read");
               exit(3);
       }
       return (value);
}

klseek(fd, base, off)
       int fd, base, off;
{

       if (kflg) {
               /* get kernel pte */
               base &= 0x7fffffff;
               base = Sysmap[base >> 9].pg_pfnum * 512 + (base & 0x1ff);
       }
       return (lseek(fd, base, off));
}