BSD 4 release

[unix-history] / usr / src / cmd / analyze.c

diff --git a/usr/src/cmd/analyze.c b/usr/src/cmd/analyze.c
index 9b3d99a..cc0e271 100644 (file)
--- a/usr/src/cmd/analyze.c
+++ b/usr/src/cmd/analyze.c
@@ -1,11 +1,12 @@
+static char *sccsid = "@(#)analyze.c   4.1 (Berkeley) 10/1/80";

 #include <stdio.h>
 #include <sys/param.h>
 #include <sys/dir.h>
 #include <stdio.h>
 #include <sys/param.h>
 #include <sys/dir.h>

-#include <sys/proc.h>

 #include <sys/pte.h>
 #include <sys/pte.h>

-#include <a.out.h>
+#include <nlist.h>

 #include <sys/map.h>
 #include <sys/user.h>
 #include <sys/map.h>
 #include <sys/user.h>

+#include <sys/proc.h>

 #include <sys/text.h>
 #include <sys/cmap.h>
 #include <sys/vm.h>
 #include <sys/text.h>
 #include <sys/cmap.h>
 #include <sys/vm.h>


@@ -81,27 +82,26 @@ int fswap = -1;
 
 struct nlist nl[] = {
 #define        X_PROC 0
 
 struct nlist nl[] = {
 #define        X_PROC 0

-       "_proc",        0, 0, 0, 0,
+       { "_proc" },

 #define        X_USRPT 1
 #define        X_USRPT 1

-       "_usrpt",       0, 0, 0, 0,
+       { "_usrpt" },

 #define        X_PTMA  2
 #define        X_PTMA  2

-       "_Usrptma",     0, 0, 0, 0,
+       { "_Usrptma" },

 #define        X_FIRSTFREE 3
 #define        X_FIRSTFREE 3

-       "_firstfr",     0, 0, 0, 0,
+       { "_firstfr" },

 #define        X_MAXFREE 4
 #define        X_MAXFREE 4

-       "_maxfree",     0, 0, 0, 0,
+       { "_maxfree" },

 #define        X_TEXT 5
 #define        X_TEXT 5

-       "_text",        0, 0, 0, 0,
+       { "_text" },

 #define        X_FREEMEM 6
 #define        X_FREEMEM 6

-       "_freemem",     0, 0, 0, 0,
+       { "_freemem" },

 #define        X_CMAP 7
 #define        X_CMAP 7

-       "_cmap",        0, 0, 0, 0,
+       { "_cmap" },

 #define        X_ECMAP 8
 #define        X_ECMAP 8

-       "_ecmap",       0, 0, 0, 0,
+       { "_ecmap" },

 #define        X_SWAPMAP 9
 #define        X_SWAPMAP 9

-       "_swapmap",     0, 0, 0, 0,
-       0,              0, 0, 0, 0,
-
+       { "_swapmap" },
+       { 0 }

 };
 
 main(argc, argv)
 };
 
 main(argc, argv)


@@ -214,21 +214,16 @@ usage:
        }
        for (p = &proc[1]; p < &proc[NPROC]; p++) {
                p->p_p0br = (struct pte *)clear(p->p_p0br);
        }
        for (p = &proc[1]; p < &proc[NPROC]; p++) {
                p->p_p0br = (struct pte *)clear(p->p_p0br);

+               p->p_addr = (struct pte *)clear(p->p_addr);

                if (p->p_stat == 0)
                        continue;
                printf("proc %d ", p->p_pid);
                if (p->p_stat == 0)
                        continue;
                printf("proc %d ", p->p_pid);

-               if (p->p_stat != SZOMB) {
-                       if (getu(p))
-                               continue;
-                       u.u_procp = p;
-               }

                if (p->p_stat == SZOMB) {
                        printf("zombie\n");
                        continue;
                }
                if (p->p_flag & SLOAD) {
                        printf("loaded, p0br %x, ", p->p_p0br);
                if (p->p_stat == SZOMB) {
                        printf("zombie\n");
                        continue;
                }
                if (p->p_flag & SLOAD) {
                        printf("loaded, p0br %x, ", p->p_p0br);

-                       p->p_szpt = u.u_pcb.pcb_szpt;

                        printf("%d pages of page tables:", p->p_szpt);
                        a = btokmx(p->p_p0br);
                        for (i = 0; i < p->p_szpt; i++) {
                        printf("%d pages of page tables:", p->p_szpt);
                        a = btokmx(p->p_p0br);
                        for (i = 0; i < p->p_szpt; i++) {


@@ -251,9 +246,13 @@ usage:
                            /* i, DPAGET, p - proc); */
                }
                p->p_p0br = (struct pte *)p0br;
                            /* i, DPAGET, p - proc); */
                }
                p->p_p0br = (struct pte *)p0br;

+               p->p_addr = uaddr(p);

                p->p_textp = &text[p->p_textp - (struct text *)nl[X_TEXT].n_value];
                if (p->p_pid == 2)
                        continue;
                p->p_textp = &text[p->p_textp - (struct text *)nl[X_TEXT].n_value];
                if (p->p_pid == 2)
                        continue;

+               if (getu(p))
+                       continue;
+               u.u_procp = p;

                pdmap();
                if ((p->p_flag & SLOAD) == 0)
                        continue;
                pdmap();
                if ((p->p_flag & SLOAD) == 0)
                        continue;


@@ -288,19 +287,21 @@ usage:
                                count(p, pte, ZSTACK);
                }
                vprintf("\n");
                                count(p, pte, ZSTACK);
                }
                vprintf("\n");

-               for (w = 0; w < UPAGES; w++) {
-                       int l = p->p_addr[w];
-                       count(p, (struct pte *)&l, ZUDOT);
-               }
+               for (i = 0; i < UPAGES; i++)
+                       count(p, &p->p_addr[i], ZUDOT);

                vprintf("\n");
                vprintf("\n");
        }
        for (xp = &text[0]; xp < &text[NTEXT]; xp++)
                if (xp->x_iptr) {
                vprintf("\n");
                vprintf("\n");
        }
        for (xp = &text[0]; xp < &text[NTEXT]; xp++)
                if (xp->x_iptr) {

-                       duse(xp->x_daddr, xp->x_size, DTEXT, xp - text);
+                       for (i = 0; i < xp->x_size; i += DMTEXT)
+                               duse(xp->x_daddr[i],
+                                   (xp->x_size - i) > DMTEXT
+                                       ? DMTEXT : xp->x_size - i,
+                                   DTEXT, xp - text);

                        if (xp->x_flag & XPAGI)
                        if (xp->x_flag & XPAGI)

-                               duse(xp->x_daddr + xp->x_size,
-                                   clrnd(ctopt(xp->x_size)), DTEXT, xp - text);
+                               duse(xp->x_ptdaddr, clrnd(ctopt(xp->x_size)),
+                                   DTEXT, xp - text);

                }
        dmcheck();
        fixfree();
                }
        dmcheck();
        fixfree();


@@ -316,17 +317,30 @@ pdmap()
                return;
        if (Dflg)
                printf("disk for pid %d", u.u_procp->p_pid);
                return;
        if (Dflg)
                printf("disk for pid %d", u.u_procp->p_pid);

-       if (xp = u.u_procp->p_textp) {
-               xp = &text[xp - (struct text *)nl[X_TEXT].n_value];
-               if (Dflg)
-                       printf(", text: %x<%x>", xp->x_daddr, xp->x_size);
-       }
+       if ((xp = u.u_procp->p_textp) && Dflg)
+               ptdmap(xp->x_daddr, xp->x_size);

        pdmseg("data", &u.u_dmap, DDATA);
        pdmseg("stack", &u.u_smap, DSTACK);
        if (Dflg)
                printf("\n");
 }
 
        pdmseg("data", &u.u_dmap, DDATA);
        pdmseg("stack", &u.u_smap, DSTACK);
        if (Dflg)
                printf("\n");
 }
 

+ptdmap(dp, size)
+       register daddr_t *dp;
+       int size;
+{
+       register int i;
+       int rem;
+
+       if (Dflg)
+               printf(" text:");
+       for (i = 0, rem = size; rem > 0; i++) {
+               if (Dflg)
+                       printf(" %x<%x>", dp[i], rem < DMTEXT ? rem : DMTEXT);
+               rem -= rem < DMTEXT ? rem : DMTEXT;
+       }
+}
+

 pdmseg(cp, dmp, type)
        char *cp;
        struct dmap *dmp;
 pdmseg(cp, dmp, type)
        char *cp;
        struct dmap *dmp;


@@ -378,6 +392,7 @@ dmcheck()
 
        for (smp = swapmap; smp->m_size; smp++)
                duse(smp->m_addr, smp->m_size, DFREE, 0);
 
        for (smp = swapmap; smp->m_size; smp++)
                duse(smp->m_addr, smp->m_size, DFREE, 0);

+       duse(CLSIZE, DMTEXT - CLSIZE, DFREE, 0);

        qsort(dblks, ndblks, sizeof (struct dblks), dsort);
        d = &dblks[ndblks - 1];
        if (d->d_first > 1)
        qsort(dblks, ndblks, sizeof (struct dblks), dsort);
        d = &dblks[ndblks - 1];
        if (d->d_first > 1)


@@ -499,12 +514,11 @@ checkpg(p, pte, type)
 getu(p)
        register struct proc *p;
 {
 getu(p)
        register struct proc *p;
 {

-       int i, w, errs = 0;
+       int i, w, cc, errs = 0;

 
        for (i = 0; i < UPAGES; i++) {
                if (p->p_flag & SLOAD) {
 
        for (i = 0; i < UPAGES; i++) {
                if (p->p_flag & SLOAD) {

-                       w = p->p_addr[i];
-                       lseek(fcore, (long)(NBPG * clear(w)), 0);
+                       lseek(fcore, ctob(p->p_addr[i].pg_pfnum), 0);

                        if (read(fcore, u_area.buf[i], NBPG) != NBPG)
                                perror("core u. read"), errs++;
                } else if (fswap >= 0) {
                        if (read(fcore, u_area.buf[i], NBPG) != NBPG)
                                perror("core u. read"), errs++;
                } else if (fswap >= 0) {


@@ -594,27 +608,35 @@ summary()
                if (zp->z_type == ZLOST)
                        dumpcm("lost", i);
                pfnum = pgtocm(i);
                if (zp->z_type == ZLOST)
                        dumpcm("lost", i);
                pfnum = pgtocm(i);

-               if ((cmap[pfnum].c_flag & MLOCK) && !(cmap[pfnum].c_flag & MSYS))
+               if (cmap[pfnum].c_lock && cmap[pfnum].c_type != CSYS)

                        dumpcm("locked", i);
                if (mflg)
                        dumpcm("mem", i);
        }
 }
 
                        dumpcm("locked", i);
                if (mflg)
                        dumpcm("mem", i);
        }
 }
 

+char   *tynames[] = {
+       "sys",
+       "text",
+       "data",
+       "stack"
+};

 dumpcm(cp, pg)
        char *cp;
        int pg;
 {
        int pslot;
        int cm;
 dumpcm(cp, pg)
        char *cp;
        int pg;
 {
        int pslot;
        int cm;

+       register struct cmap *c;

 
        printf("%s page %x ", cp, pg);
        cm = pgtocm(pg);
 
        printf("%s page %x ", cp, pg);
        cm = pgtocm(pg);

-       printf("\t[%x, %x", cmap[cm].c_page, cmap[cm].c_ndx);
-       if ((cmap[cm].c_flag&MTEXT) == 0)
-               printf(" (=pid %d)", proc[cmap[cm].c_ndx].p_pid);
+       c = &cmap[cm];
+       printf("\t[%x, %x", c->c_page, c->c_ndx);
+       if (c->c_type != CTEXT)
+               printf(" (=pid %d)", proc[c->c_ndx].p_pid);

        else {
        else {

-               pslot=(text[cmap[cm].c_ndx].x_caddr - (struct proc *)nl[X_PROC].n_value);
+               pslot=(text[c->c_ndx].x_caddr - (struct proc *)nl[X_PROC].n_value);

                printf(" (=pid");
                for(;;) {
                        printf(" %d", proc[pslot].p_pid);
                printf(" (=pid");
                for(;;) {
                        printf(" %d", proc[pslot].p_pid);


@@ -624,15 +646,21 @@ dumpcm(cp, pg)
                }
                printf(")");
        }
                }
                printf(")");
        }

-
-#define        Mflag(x,y)      if (cmap[cm].c_flag&x) printf(y);
-       Mflag(MTEXT, " MTEXT");
-       Mflag(MDATA, " MDATA");
-       Mflag(MSTACK, "MSTACK");
-       Mflag(MSYS, " MSYS");
-       Mflag(MFREE, " MFREE");
-       Mflag(MLOCK, " MLOCK");
-       printf("]\n");
+       printf("] ");
+       printf(tynames[c->c_type]);
+       if (c->c_free)
+               printf(" free");
+       if (c->c_gone)
+               printf(" gone");
+       if (c->c_lock)
+               printf(" lock");
+       if (c->c_want)
+               printf(" want");
+       if (c->c_intrans)
+               printf(" intrans");
+       if (c->c_blkno)
+               printf(" blkno %x mdev %d", c->c_blkno, c->c_mdev);
+       printf("\n");

 }
 
 fixfree()
 }
 
 fixfree()


@@ -643,7 +671,7 @@ fixfree()
        for (i=freemem/CLSIZE; --i >=0; ) {
                prev = next;
                next = cmap[next].c_next;
        for (i=freemem/CLSIZE; --i >=0; ) {
                prev = next;
                next = cmap[next].c_next;

-               if ((cmap[next].c_flag&MFREE) == 0) {
+               if (cmap[next].c_free == 0) {

                        printf("link to non free block: in %x to %x\n", cmtopg(prev), cmtopg(next));
                        dumpcm("bad free link in", cmtopg(prev));
                        dumpcm("to non free block", cmtopg(next));
                        printf("link to non free block: in %x to %x\n", cmtopg(prev), cmtopg(next));
                        dumpcm("bad free link in", cmtopg(prev));
                        dumpcm("to non free block", cmtopg(next));


@@ -686,7 +714,7 @@ vtod(p, v, dmap, smap)
        struct dblock db;
 
        if (v < p->p_tsize)
        struct dblock db;
 
        if (v < p->p_tsize)

-               return(p->p_textp->x_daddr + v);
+               return(p->p_textp->x_daddr[v / DMTEXT] + v % DMTEXT);

        if (isassv(p, v))
                vstodb(vtosp(p, v), 1, smap, &db, 1);
        else
        if (isassv(p, v))
                vstodb(vtosp(p, v), 1, smap, &db, 1);
        else