BSD 4_1_snap release

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

diff --git a/usr/src/cmd/pstat.c b/usr/src/cmd/pstat.c
index 4a65cb9..2843106 100644 (file)
--- a/usr/src/cmd/pstat.c
+++ b/usr/src/cmd/pstat.c
@@ -1,45 +1,75 @@
+static char *sccsid = "@(#)pstat.c     4.9 (Berkeley) 5/7/81";

 /*
  * Print system stuff
  */
 
 #define mask(x) (x&0377)
 /*
  * Print system stuff
  */
 
 #define mask(x) (x&0377)

+#define        clear(x) ((int)x&0x7fffffff)
+

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

-#include <sys/conf.h>
+#include <sys/dir.h>
+#include <sys/file.h>
+#include <sys/user.h>
+#include <sys/proc.h>
+#include <sys/text.h>
+#include <sys/inode.h>
+#include <sys/map.h>

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

+#include <sys/conf.h>
+#include <sys/vm.h>
+#include <nlist.h>
+#include <sys/pte.h>
+#define        KERNEL
+#include <sys/mx.h>
+#undef KERNEL

 
 char   *fcore  = "/dev/kmem";
 
 char   *fcore  = "/dev/kmem";

-char   *fnlist = "/unix";
+char   *fnlist = "/vmunix";

 int    fc;
 
 int    fc;
 

-struct setup {
-       char    name[8];
-       int     type;
-       unsigned        value;
-} setup[] = {
+struct nlist nl[] = {

 #define        SINODE  0
 #define        SINODE  0

-       "_inode", 0, 0,
+       { "_inode" },

 #define        STEXT   1
 #define        STEXT   1

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

 #define        SPROC   2
 #define        SPROC   2

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

 #define        SDZ     3
 #define        SDZ     3

-       "_dz_tty", 0, 0,
+       { "_dz_tty" },

 #define        SNDZ    4
 #define        SNDZ    4

-       "_dz_cnt", 0, 0,
+       { "_dz_cnt" },

 #define        SKL     5
 #define        SKL     5

-       "_cons", 0, 0,
+       { "_cons" },

 #define        SFIL    6
 #define        SFIL    6

-       "_file", 0, 0,
-#define        SMPXC   7
-       "_mpx_chan", 0, 0,
-#define        SMPXM   8
-       "_mpx_mach", 0, 0,
-#define        SMPXB1  9
-       "_mptbc", 0, 0,
-#define        SMPXB2  10
-       "_mptbuf", 0, 0,
-#define        SMPSM   11
-       "_mpsm", 0, 0,
+       { "_file" },
+#define        USRPTMA 7
+       { "_Usrptmap" },
+#define        USRPT   8
+       { "_usrpt" },
+#define        SNSWAP  9
+       { "_nswap" },
+#define        SWAPMAP 10
+       { "_swapmap" },
+#define        SDH     11
+       { "_dh11" },
+#define        SNDH    12
+       { "_ndh11" },
+#define        SGROUP  13
+       { "_groups" },
+#define        SCHANS  14
+       { "_chans" },
+#define        SSCHANS 15
+       { "_schans" },
+#define        SNPROC  16
+       { "_nproc" },
+#define        SNTEXT  17
+       { "_ntext" },
+#define        SNFILE  18
+       { "_nfile" },
+#define        SNINODE 19
+       { "_ninode" },
+#define        SNSWAPMAP 20
+       { "_nswapmap" },

        0,
 };
 
        0,
 };
 


@@ -47,23 +77,37 @@ int inof;
 int    txtf;
 int    prcf;
 int    ttyf;
 int    txtf;
 int    prcf;
 int    ttyf;

-int    mpxf;

 int    usrf;
 int    usrf;

+int    mpxf;
+int    groupf;

 long   ubase;
 int    filf;
 long   ubase;
 int    filf;

+int    swpf;
+int    totflg;

 char   partab[1];
 struct cdevsw  cdevsw[1];
 struct bdevsw  bdevsw[1];
 int    allflg;
 int    kflg;
 char   partab[1];
 struct cdevsw  cdevsw[1];
 struct bdevsw  bdevsw[1];
 int    allflg;
 int    kflg;

+struct pte *Usrptma;
+struct pte *usrpt;

 
 main(argc, argv)
 char **argv;
 {
 
 main(argc, argv)
 char **argv;
 {

-
-       while (--argc && **++argv == '-') {
-               while (*++*argv)
-               switch (**argv) {
+       register char *argp;
+
+       argc--, argv++;
+       while (argc > 0 && **argv == '-') {
+               argp = *argv++;
+               argp++;
+               argc--;
+               while (*argp++)
+               switch (argp[-1]) {
+
+               case 'T':
+                       totflg++;
+                       break;

 
                case 'a':
                        allflg++;
 
                case 'a':
                        allflg++;


@@ -75,11 +119,13 @@ char **argv;
 
                case 'k':
                        kflg++;
 
                case 'k':
                        kflg++;

+                       fcore = "/vmcore";

                        break;
 
                case 'x':
                        txtf++;
                        break;
                        break;
 
                case 'x':
                        txtf++;
                        break;

+

                case 'p':
                        prcf++;
                        break;
                case 'p':
                        prcf++;
                        break;


@@ -88,21 +134,26 @@ char **argv;
                        ttyf++;
                        break;
 
                        ttyf++;
                        break;
 

-               case 'm':
-                       mpxf++;
-                       break;
-

                case 'u':
                case 'u':

-                       printf("pstat: -u not implemented\n");
-                       if (--argc == 0)
+                       if (argc == 0)

                                break;
                                break;

+                       argc--;

                        usrf++;
                        usrf++;

-                       sscanf( *++argv, "%x", &ubase);
+                       sscanf( *argv++, "%x", &ubase);

                        break;
 
                case 'f':
                        filf++;
                        break;
                        break;
 
                case 'f':
                        filf++;
                        break;

+               case 's':
+                       swpf++;
+                       break;
+               case 'm':
+                       mpxf++;
+                       break;
+               case 'g':
+                       groupf++;
+                       break;

                }
        }
        if (argc>0)
                }
        }
        if (argc>0)


@@ -113,57 +164,58 @@ char **argv;
        }
        if (argc>1)
                fnlist = argv[1];
        }
        if (argc>1)
                fnlist = argv[1];

-       nlist(fnlist, setup);
-       if (kflg) {
-               register struct setup *sp;
-
-               for (sp=setup; sp->value; sp++)
-                       sp->value &= 0x7fffffff;
-       }
-       if (setup[SINODE].type == -1) {
+       nlist(fnlist, nl);
+       usrpt = (struct pte *)nl[USRPT].n_value;
+       Usrptma = (struct pte *)nl[USRPTMA].n_value;
+       if (nl[0].n_type == 0) {

                printf("no namelist\n");
                exit(1);
        }
                printf("no namelist\n");
                exit(1);
        }

-       if (inof)
+       if (filf||totflg)
+               dofile();
+       if (inof||totflg)

                doinode();
                doinode();

-       if (txtf)
+       if (prcf||totflg)
+               doproc();
+       if (txtf||totflg)

                dotext();
        if (ttyf)
                dotty();
                dotext();
        if (ttyf)
                dotty();

-       if (prcf)
-               doproc();
-/*

        if (usrf)
                dousr();
        if (usrf)
                dousr();

- */
-       if (filf)
-               dofil();
-/*
-       if(mpxf)
+       if (swpf||totflg)
+               doswap();
+       if (mpxf)

                dompx();
                dompx();

-*/
+       if (groupf)
+               dogroup();

 }
 
 doinode()
 {
 }
 
 doinode()
 {

-#include <sys/inode.h>

        register struct inode *ip;
        register struct inode *ip;

-       struct inode xinode[NINODE];
-       register int nin, loc;
+       struct inode *xinode, *ainode;
+       register int nin;
+       int ninode;

 
        nin = 0;
 
        nin = 0;

-       lseek(fc, (long)setup[SINODE].value, 0);
-       read(fc, xinode, sizeof(xinode));
-       for (ip = xinode; ip < &xinode[NINODE]; ip++)
+       ninode = getw(nl[SNINODE].n_value);
+       xinode = (struct inode *)calloc(ninode, sizeof (struct inode));
+       lseek(fc, (int)(ainode = (struct inode *)getw(nl[SINODE].n_value)), 0);
+       read(fc, xinode, ninode * sizeof(struct inode));
+       for (ip = xinode; ip < &xinode[ninode]; ip++)

                if (ip->i_count)
                        nin++;
                if (ip->i_count)
                        nin++;

-       printf("%d active xinodes\n", nin);
-       printf("   LOC    FLAGS  CNT DEVICE  INO  MODE  NLK UID   SIZE/DEV\n");
-       loc = setup[SINODE].value;
-       for (ip = xinode; ip < &xinode[NINODE]; ip++, loc += sizeof(xinode[0])) {
+       if (totflg) {
+               printf("%3d/%3d inodes\n", nin, ninode);
+               return;
+       }
+       printf("%d/%d active inodes\n", nin, ninode);
+       printf("   LOC    FLAGS  CNT DEVICE   INO  MODE  NLK UID   SIZE/DEV\n");
+       for (ip = xinode; ip < &xinode[ninode]; ip++) {

                if (ip->i_count == 0)
                        continue;
                if (ip->i_count == 0)
                        continue;

-               printf("%8.1x ", loc);
+               printf("%8.1x ", ainode + (ip - xinode));

                putf(ip->i_flag&ILOCK, 'L');
                putf(ip->i_flag&IUPD, 'U');
                putf(ip->i_flag&IACC, 'A');
                putf(ip->i_flag&ILOCK, 'L');
                putf(ip->i_flag&IUPD, 'U');
                putf(ip->i_flag&IACC, 'A');


@@ -172,7 +224,7 @@ doinode()
                putf(ip->i_flag&ITEXT, 'T');
                printf("%4d", ip->i_count&0377);
                printf("%4d,%3d", major(ip->i_dev), minor(ip->i_dev));
                putf(ip->i_flag&ITEXT, 'T');
                printf("%4d", ip->i_count&0377);
                printf("%4d,%3d", major(ip->i_dev), minor(ip->i_dev));

-               printf("%5l", ip->i_number);
+               printf("%6d", ip->i_number);

                printf("%6x", ip->i_mode & 0xffff);
                printf("%4d", ip->i_nlink);
                printf("%4d", ip->i_uid);
                printf("%6x", ip->i_mode & 0xffff);
                printf("%4d", ip->i_nlink);
                printf("%4d", ip->i_uid);


@@ -182,6 +234,21 @@ doinode()
                        printf("%10ld", ip->i_size);
                printf("\n");
        }
                        printf("%10ld", ip->i_size);
                printf("\n");
        }

+       free(xinode);
+}
+
+getw(loc)
+       off_t loc;
+{
+       int word;
+
+       if (kflg)
+               loc &= 0x7fffffff;
+       lseek(fc, loc, 0);
+       read(fc, &word, sizeof (word));
+       if (kflg)
+               word &= 0x7fffffff;
+       return (word);

 }
 
 putf(v, n)
 }
 
 putf(v, n)


@@ -194,112 +261,167 @@ putf(v, n)
 
 dotext()
 {
 
 dotext()
 {

-#include <sys/text.h>
-       struct text xtext[NTEXT], *xp;
-       register loc;
+       register struct text *xp;
+       int ntext;
+       struct text *xtext, *atext;

        int ntx;
 
        ntx = 0;
        int ntx;
 
        ntx = 0;

-       lseek(fc, (long)setup[STEXT].value, 0);
-       read(fc, xtext, sizeof(xtext));
-       for (xp = xtext; xp < &xtext[NTEXT]; xp++)
+       ntext = getw(nl[SNTEXT].n_value);
+       xtext = (struct text *)calloc(ntext, sizeof (struct text));
+       lseek(fc, (int)(atext = (struct text *)getw(nl[STEXT].n_value)), 0);
+       read(fc, xtext, ntext * sizeof (struct text));
+       for (xp = xtext; xp < &xtext[ntext]; xp++)

                if (xp->x_iptr!=NULL)
                        ntx++;
                if (xp->x_iptr!=NULL)
                        ntx++;

-       printf("%d text segments\n", ntx);
-       printf("   LOC   FLAGS  DADDR   CADDR   SIZE   ITPR    CNT CCNT\n");
-       loc = setup[STEXT].value;
-       for (xp = xtext; xp < &xtext[NTEXT]; xp++, loc+=sizeof(xtext[0])) {
+       if (totflg) {
+               printf("%3d/%3d texts\n", ntx, ntext);
+               return;
+       }
+       printf("%d/%d active texts\n", ntx, ntext);
+       printf("   LOC   FLAGS DADDR      CADDR  RSS SIZE      IPTR  CNT CCNT\n");
+       for (xp = xtext; xp < &xtext[ntext]; xp++) {

                if (xp->x_iptr == NULL)
                        continue;
                if (xp->x_iptr == NULL)
                        continue;

-               printf("%8.1x", loc);
+               printf("%8.1x", atext + (xp - xtext));

                printf(" ");
                printf(" ");

+               putf(xp->x_flag&XPAGI, 'P');

                putf(xp->x_flag&XTRC, 'T');
                putf(xp->x_flag&XWRIT, 'W');
                putf(xp->x_flag&XLOAD, 'L');
                putf(xp->x_flag&XLOCK, 'K');
                putf(xp->x_flag&XWANT, 'w');
                putf(xp->x_flag&XTRC, 'T');
                putf(xp->x_flag&XWRIT, 'W');
                putf(xp->x_flag&XLOAD, 'L');
                putf(xp->x_flag&XLOCK, 'K');
                putf(xp->x_flag&XWANT, 'w');

-               printf("%5u", xp->x_daddr);
+               printf("%5x", xp->x_daddr[0]);

                printf("%11x", xp->x_caddr);
                printf("%11x", xp->x_caddr);

+               printf("%5d", xp->x_rssize);

                printf("%5d", xp->x_size);
                printf("%10.1x", xp->x_iptr);
                printf("%5d", xp->x_count&0377);
                printf("%5d", xp->x_size);
                printf("%10.1x", xp->x_iptr);
                printf("%5d", xp->x_count&0377);

-               printf("%4d", xp->x_ccount);
+               printf("%5d", xp->x_ccount);

                printf("\n");
        }
                printf("\n");
        }

+       free(xtext);

 }
 
 doproc()
 {
 }
 
 doproc()
 {

-#include <sys/proc.h>
-       struct proc xproc[NPROC];
+       struct proc *xproc, *aproc;
+       int nproc;

        register struct proc *pp;
        register loc, np;
        register struct proc *pp;
        register loc, np;

+       struct pte apte;

 
 

-       lseek(fc, (long)setup[SPROC].value, 0);
-       read(fc, xproc, sizeof(xproc));
+       nproc = getw(nl[SNPROC].n_value);
+       xproc = (struct proc *)calloc(nproc, sizeof (struct proc));
+       lseek(fc, (int)(aproc = (struct proc *)getw(nl[SPROC].n_value)), 0);
+       read(fc, xproc, nproc * sizeof (struct proc));

        np = 0;
        np = 0;

-       for (pp=xproc; pp < &xproc[NPROC]; pp++)
+       for (pp=xproc; pp < &xproc[nproc]; pp++)

                if (pp->p_stat)
                        np++;
                if (pp->p_stat)
                        np++;

-       printf("%d processes\n", np);
-       printf("   LOC   S  F   PRI SIGNAL UID TIM CPU NI   PGRP  PID  PPID   ADDR  SIZE  WCHAN      LINK    TEXTP  CLKT\n");
-       for (loc=setup[SPROC].value,pp=xproc; pp<&xproc[NPROC]; pp++,loc+=sizeof(xproc[0])) {
+       if (totflg) {
+               printf("%3d/%3d processes\n", np, nproc);
+               return;
+       }
+       printf("%d/%d processes\n", np, nproc);
+       printf("   LOC    S    F POIP PRI      SIG  UID SLP TIM  CPU  NI   PGRP    PID   PPID    ADDR   RSS SRSS SIZE    WCHAN    LINK   TEXTP CLKT\n");
+       for (pp=xproc; pp<&xproc[nproc]; pp++) {

                if (pp->p_stat==0 && allflg==0)
                        continue;
                if (pp->p_stat==0 && allflg==0)
                        continue;

-               printf("%8x", loc);
-               printf("%2d", pp->p_stat);
-               printf("%3o", pp->p_flag&0377);
-               printf("%5d", pp->p_pri);
-               printf("%7o", pp->p_sig);
-               printf("%4d", pp->p_uid&0377);
-               printf("%5d", pp->p_time&0377);
-               printf("%4d", pp->p_cpu&0377);
-               printf("%3d", pp->p_nice);
-               printf("%6d", pp->p_pgrp);
-               printf("%6d", pp->p_pid);
-               printf("%6d", pp->p_ppid);
-               printf("%8x", pp->p_addr[0]);
-               printf("%5x", pp->p_size);
-               printf("%9x", pp->p_wchan);
-               printf("%9x", pp->p_link);
-               printf("%9x", pp->p_textp);
-               printf("   %u", pp->p_clktim);
+               printf("%8x", aproc + (pp - xproc));
+               printf(" %2d", pp->p_stat);
+               printf(" %4x", pp->p_flag & 0xffff);
+               printf(" %4d", pp->p_poip);
+               printf(" %3d", pp->p_pri);
+               printf(" %8x", pp->p_sig);
+               printf(" %4d", pp->p_uid);
+               printf(" %3d", pp->p_slptime);
+               printf(" %3d", pp->p_time);
+               printf(" %4d", pp->p_cpu&0377);
+               printf(" %3d", pp->p_nice);
+               printf(" %6d", pp->p_pgrp);
+               printf(" %6d", pp->p_pid);
+               printf(" %6d", pp->p_ppid);
+               if (kflg)
+                       pp->p_addr = (struct pte *)clear((int)pp->p_addr);
+               lseek(fc, (long)(Usrptma+btokmx(pp->p_addr)), 0);
+               read(fc, &apte, sizeof(apte));
+               printf(" %8x", ctob(apte.pg_pfnum+1) - sizeof(struct pte) * UPAGES);
+               printf(" %4x", pp->p_rssize);
+               printf(" %4x", pp->p_swrss);
+               printf(" %5x", pp->p_dsize+pp->p_ssize);
+               printf(" %7x", clear(pp->p_wchan));
+               printf(" %7x", clear(pp->p_link));
+               printf(" %7x", clear(pp->p_textp));
+               printf("    %u", pp->p_clktim);

                printf("\n");
        }
 }
 
 dotty()
 {
                printf("\n");
        }
 }
 
 dotty()
 {

-       struct tty dz_tty[32];
+       struct tty dz_tty[64];

        int ndz;
        register struct tty *tp;
        register char *mesg;
 
        printf("1 cons\n");
        int ndz;
        register struct tty *tp;
        register char *mesg;
 
        printf("1 cons\n");

-       lseek(fc, (long)setup[SKL].value, 0);
+       if (kflg)
+               nl[SKL].n_value = clear(nl[SKL].n_value);
+       lseek(fc, (long)nl[SKL].n_value, 0);

        read(fc, dz_tty, sizeof(dz_tty[0]));
        read(fc, dz_tty, sizeof(dz_tty[0]));

-       mesg = " RAW CAN OUT   MODE    ADDR   DEL COL  STATE   PGRP\n";
+       mesg = " # RAW CAN OUT   MODE    ADDR   DEL COL  STATE   PGRP DISC\n";

        printf(mesg);
        printf(mesg);

-       ttyprt(&dz_tty[0]);
-       if (setup[SNDZ].type == -1)
-               return;
-       lseek(fc, (long)setup[SNDZ].value, 0);
+       ttyprt(&dz_tty[0], 0);
+       if (nl[SNDZ].n_type == 0)
+               goto dh;
+       if (kflg) {
+               nl[SNDZ].n_value = clear(nl[SNDZ].n_value);
+               nl[SDZ].n_value = clear(nl[SDZ].n_value);
+       }
+       lseek(fc, (long)nl[SNDZ].n_value, 0);

        read(fc, &ndz, sizeof(ndz));
        printf("%d dz lines\n", ndz);
        read(fc, &ndz, sizeof(ndz));
        printf("%d dz lines\n", ndz);

-       lseek(fc, (long)setup[SDZ].value, 0);
+       lseek(fc, (long)nl[SDZ].n_value, 0);
+       read(fc, dz_tty, sizeof(dz_tty));
+       for (tp = dz_tty; tp < &dz_tty[ndz]; tp++)
+               ttyprt(tp, tp - dz_tty);
+dh:
+       if (nl[SNDH].n_type == 0)
+               return;
+       if (kflg) {
+               nl[SNDH].n_value = clear(nl[SNDH].n_value);
+               nl[SDH].n_value = clear(nl[SDH].n_value);
+       }
+       lseek(fc, (long)nl[SNDH].n_value, 0);
+       read(fc, &ndz, sizeof(ndz));
+       printf("%d dh lines\n", ndz);
+       lseek(fc, (long)nl[SDH].n_value, 0);

        read(fc, dz_tty, sizeof(dz_tty));
        for (tp = dz_tty; tp < &dz_tty[ndz]; tp++)
        read(fc, dz_tty, sizeof(dz_tty));
        for (tp = dz_tty; tp < &dz_tty[ndz]; tp++)

-               ttyprt(tp);
+               ttyprt(tp, tp - dz_tty);

 }
 
 }
 

-ttyprt(atp)
+ttyprt(atp, line)

 struct tty *atp;
 {
        register struct tty *tp;
 
 struct tty *atp;
 {
        register struct tty *tp;
 

+       printf("%2d", line);

        tp = atp;
        tp = atp;

-       printf("%4d", tp->t_rawq.c_cc);
-       printf("%4d", tp->t_canq.c_cc);
+       switch (tp->t_line) {
+
+       case NETLDISC:
+               if (tp->t_rec)
+                       printf("%4d%4d", 0, tp->t_inbuf);
+               else
+                       printf("%4d%4d", tp->t_inbuf, 0);
+               break;
+
+       default:
+               printf("%4d", tp->t_rawq.c_cc);
+               printf("%4d", tp->t_canq.c_cc);
+       }

        printf("%4d", tp->t_outq.c_cc);
        printf("%8.1o", tp->t_flags);
        printf(" %8.1x", tp->t_addr);
        printf("%4d", tp->t_outq.c_cc);
        printf("%8.1o", tp->t_flags);
        printf(" %8.1x", tp->t_addr);


@@ -316,75 +438,120 @@ struct tty *atp;
        putf(tp->t_state&HUPCLS, 'H');
  */
        printf("%6d", tp->t_pgrp);
        putf(tp->t_state&HUPCLS, 'H');
  */
        printf("%6d", tp->t_pgrp);

+       switch (tp->t_line) {
+
+       case NTTYDISC:
+               printf(" ntty");
+               break;
+
+       case NETLDISC:
+               printf(" net");
+               break;
+       }

        printf("\n");
 }
 
 dousr()
 {
        printf("\n");
 }
 
 dousr()
 {

-#include <sys/dir.h>
-#include <sys/user.h>

        struct user U;
        register i, j, *ip;
 
        struct user U;
        register i, j, *ip;
 

-       lseek(fc, ubase, 0);
+       /* This wins only if PAGSIZ > sizeof (struct user) */
+       lseek(fc, ubase * NBPG, 0);

        read(fc, &U, sizeof(U));
        read(fc, &U, sizeof(U));

-/*
-       printf("rsav %.1o %.1o\n", U.u_rsav[0], U.u_rsav[1]);
- */
-       printf("segflg, error %d, %d\n", U.u_segflg, U.u_error);
-       printf("uids %d,%d,%d,%d\n", U.u_uid,U.u_gid,U.u_ruid,U.u_rgid);
-       printf("procp %.1x\n", U.u_procp);
+       printf("pcb");
+       ip = (int *)&U.u_pcb;
+       while (ip < &U.u_arg[0]) {
+               if ((ip - (int *)&U.u_pcb) % 4 == 0)
+                       printf("\t");
+               printf("%x ", *ip++);
+               if ((ip - (int *)&U.u_pcb) % 4 == 0)
+                       printf("\n");
+       }
+       if ((ip - (int *)&U.u_pcb) % 4 != 0)
+               printf("\n");
+       printf("arg\t");
+       for (i=0; i<5; i++)
+               printf(" %.1x", U.u_arg[i]);
+       printf("\n");
+       for (i=0; i<sizeof(label_t)/sizeof(int); i++) {
+               if (i%5==0)
+                       printf("\t");
+               printf("%9.1x", U.u_ssav[i]);
+               if (i%5==4)
+                       printf("\n");
+       }
+       if (i%5)
+               printf("\n");
+       printf("segflg\t%d\nerror %d\n", U.u_segflg, U.u_error);
+       printf("uids\t%d,%d,%d,%d\n", U.u_uid,U.u_gid,U.u_ruid,U.u_rgid);
+       printf("procp\t%.1x\n", U.u_procp);
+       printf("ap\t%.1x\n", U.u_ap);
+       printf("r_val?\t%.1x %.1x\n", U.u_r.r_val1, U.u_r.r_val2);

        printf("base, count, offset %.1x %.1x %ld\n", U.u_base,
                U.u_count, U.u_offset);
        printf("base, count, offset %.1x %.1x %ld\n", U.u_base,
                U.u_count, U.u_offset);

-       printf("cdir %.1x\n", U.u_cdir);
+       printf("cdir rdir %.1x %.1x\n", U.u_cdir, U.u_rdir);

        printf("dbuf %.14s\n", U.u_dbuf);
        printf("dirp %.1x\n", U.u_dirp);
        printf("dent %d %.14s\n", U.u_dent.d_ino, U.u_dent.d_name);
        printf("pdir %.1o\n", U.u_pdir);
        printf("dbuf %.14s\n", U.u_dbuf);
        printf("dirp %.1x\n", U.u_dirp);
        printf("dent %d %.14s\n", U.u_dent.d_ino, U.u_dent.d_name);
        printf("pdir %.1o\n", U.u_pdir);

-/*
-       printf("dseg");
-       for (i=0; i<8; i++)
-               printf("%8.1o", U.u_uisa[i]);
-       printf("\n    ");
-       for (i=0; i<8; i++)
-               printf("%8.1o", U.u_uisd[i]);
-       if (U.u_sep) {
-               printf("\ntseg");
-               for (i=8; i<16; i++)
-                       printf("%8.1o", U.u_uisa[i]);
-               printf("\n    ");
-               for (i=8; i<16; i++)
-                       printf("%8.1o", U.u_uisd[i]);
-       }
- */
-       printf("\nfile");
+       printf("file\t");

        for (i=0; i<10; i++)
                printf("%9.1x", U.u_ofile[i]);
        for (i=0; i<10; i++)
                printf("%9.1x", U.u_ofile[i]);

-       printf("\n    ");
+       printf("\n\t");

        for (i=10; i<NOFILE; i++)
                printf("%9.1x", U.u_ofile[i]);
        for (i=10; i<NOFILE; i++)
                printf("%9.1x", U.u_ofile[i]);

-       printf("\nargs");
-       for (i=0; i<5; i++)
-               printf(" %.1x", U.u_arg[i]);
-       printf("\nsizes %.1x %.1x %.1x\n", U.u_tsize, U.u_dsize, U.u_ssize);
-       printf("sep %d\n", U.u_sep);
-       printf("qsav %.1x %.1x\n", U.u_qsav[0], U.u_qsav[1]);
-       printf("ssav %.1x %.1x\n", U.u_ssav[0], U.u_ssav[1]);
-       printf("sigs");
+       printf("\n");
+       printf("pofile\t");
+       for (i=0; i<10; i++)
+               printf("%9.1x", U.u_pofile[i]);
+       printf("\n\t");
+       for (i=10; i<NOFILE; i++)
+               printf("%9.1x", U.u_pofile[i]);
+       printf("\n");
+       printf("ssav");
+       for (i=0; i<sizeof(label_t)/sizeof(int); i++) {
+               if (i%5==0)
+                       printf("\t");
+               printf("%9.1x", U.u_ssav[i]);
+               if (i%5==4)
+                       printf("\n");
+       }
+       if (i%5)
+               printf("\n");
+       printf("sigs\t");

        for (i=0; i<NSIG; i++)
        for (i=0; i<NSIG; i++)

-               printf(" %.1x", U.u_signal[i]);
-       printf("\ntimes %ld %ld\n", U.u_utime/60, U.u_stime/60);
-       printf("ctimes %ld %ld\n", U.u_cutime/60, U.u_cstime/60);
-       printf("ar0 %.1x\n", U.u_ar0);
-/*
-       printf("prof");
-       for (i=0; i<4; i++)
-               printf(" %.1o", U.u_prof[i]);
-*/
-       printf("\nintflg %d\n", U.u_intflg);
-       printf("ttyp %.1x\n", U.u_ttyp);
-       printf("ttydev %d,%d\n", major(U.u_ttyd), minor(U.u_ttyd));
+               printf("%.1x ", U.u_signal[i]);
+       printf("\n");
+       printf("code\t%.1x\n", U.u_code);
+       printf("ar0\t%.1x\n", U.u_ar0);
+       printf("prof\t%X %X %X %X\n", U.u_prof.pr_base, U.u_prof.pr_size,
+           U.u_prof.pr_off, U.u_prof.pr_scale);
+       printf("\neosys\t%d\n", U.u_eosys);
+       printf("sep\t%d\n", U.u_sep);
+       printf("ttyp\t%.1x\n", U.u_ttyp);
+       printf("ttyd\t%d,%d\n", major(U.u_ttyd), minor(U.u_ttyd));
+       printf("exdata\t");
+       ip = (int *)&U.u_exdata;
+       for (i = 0; i < 8; i++)
+               printf("%.1D ", *ip++);
+       printf("\n");

        printf("comm %.14s\n", U.u_comm);
        printf("comm %.14s\n", U.u_comm);

+       printf("start\t%D\n", U.u_start);
+       printf("acflag\t%D\n", U.u_acflag);
+       printf("fpflag\t%D\n", U.u_fpflag);
+       printf("cmask\t%D\n", U.u_cmask);
+       printf("sizes\t%.1x %.1x %.1x\n", U.u_tsize, U.u_dsize, U.u_ssize);
+       printf("vm\t");
+       ip = (int *)&U.u_vm;
+       for (i = 0; i < sizeof(U.u_vm)/sizeof(int); i++)
+               printf("%D ", ip[i]);
+       printf("\n");
+       ip = (int *)&U.u_cvm;
+       printf("cvm\t");
+       for (i = 0; i < sizeof(U.u_vm)/sizeof(int); i++)
+               printf("%D ", ip[i]);
+       printf("\n");

 /*
        i =  U.u_stack - &U;
        while (U[++i] == 0);
 /*
        i =  U.u_stack - &U;
        while (U[++i] == 0);


@@ -409,23 +576,29 @@ char *s;
        return(v);
 }
 
        return(v);
 }
 

-dofil()
+dofile()

 {
 {

-#include <sys/file.h>
-       struct file xfile[NFILE];
+       int nfile;
+       struct file *xfile, *afile;

        register struct file *fp;
        register nf;
        int loc;
 
        nf = 0;
        register struct file *fp;
        register nf;
        int loc;
 
        nf = 0;

-       lseek(fc, (long)setup[SFIL].value, 0);
-       read(fc, xfile, sizeof(xfile));
-       for (fp=xfile; fp < &xfile[NFILE]; fp++)
+       nfile = getw(nl[SNFILE].n_value);
+       xfile = (struct file *)calloc(nfile, sizeof (struct file));
+       lseek(fc, (int)(afile = (struct file *)getw(nl[SFIL].n_value)), 0);
+       read(fc, xfile, nfile * sizeof (struct file));
+       for (fp=xfile; fp < &xfile[nfile]; fp++)

                if (fp->f_count)
                        nf++;
                if (fp->f_count)
                        nf++;

-       printf("%d open files\n", nf);
+       if (totflg) {
+               printf("%3d/%3d files\n", nf, nfile);
+               return;
+       }
+       printf("%d/%d open files\n", nf, nfile);

        printf("   LOC   FLG  CNT   INO    OFFS\n");
        printf("   LOC   FLG  CNT   INO    OFFS\n");

-       for (fp=xfile,loc=setup[SFIL].value; fp < &xfile[NFILE]; fp++,loc+=sizeof(xfile[0])) {
+       for (fp=xfile,loc=nl[SFIL].n_value; fp < &xfile[nfile]; fp++,loc+=sizeof(xfile[0])) {

                if (fp->f_count==0)
                        continue;
                printf("%8x ", loc);
                if (fp->f_count==0)
                        continue;
                printf("%8x ", loc);


@@ -438,106 +611,185 @@ dofil()
        }
 }
 
        }
 }
 

-/*********
-dompx()
+doswap()

 {
 {

-#include <sys/mpx.h>
-       struct chan chan[C];
-       struct mach mach[M];
-       struct line line[M-1];
-       int mptbc;
-       char mptbuf[TBSIZ];
-       register struct chan *cp;
-       register struct mach *mp;
-       register struct line *lp;
-       int loc, nc;
-
-       lseek(fc, (long)setup[SMPXC].value, 0);
-       read(fc, chan, sizeof(chan));
-       lseek(fc, (long)setup[SMPXM].value, 0);
-       read(fc, mach, sizeof(mach));
-       lseek(fc, (long)setup[SMPXB1].value, 0);
-       read(fc, &mptbc, sizeof(mptbc));
-       lseek(fc, (long)setup[SMPXB2].value, 0);
-       read(fc, mptbuf, sizeof(mptbuf));
-       lseek(fc, (long)setup[SMPSM].value, 0);
-       read(fc, line, sizeof(line));
-       nc = 0;
-       for(cp=chan; cp < &chan[C]; cp++)
-               if(cp->cflag&ALLOC)
-                       nc++;
-       printf("%d mpx channels\n", nc);
-       printf("   LOC      FLG M   C    DEST\n");
-       for(cp=chan,loc=setup[SMPXC].value; cp < &chan[C]; cp++,loc=+sizeof(chan[0])) {
-               if((cp->cflag&ALLOC) == 0)
+       struct proc *proc;
+       int nproc;
+       struct text *xtext;
+       int ntext;
+       struct map *swapmap;
+       int nswapmap;
+       register struct proc *pp;
+       int nswap, used, tused, free;
+       register struct mapent *me;
+       register struct text *xp;
+
+       nproc = getw(nl[SNPROC].n_value);
+       proc = (struct proc *)calloc(nproc, sizeof (struct proc));
+       lseek(fc, getw(nl[SPROC].n_value), 0);
+       read(fc, proc, nproc * sizeof (struct proc));
+       nswapmap = getw(nl[SNSWAPMAP].n_value);
+       swapmap = (struct map *)calloc(nswapmap, sizeof (struct map));
+       lseek(fc, getw(nl[SWAPMAP].n_value), 0);
+       read(fc, swapmap, nswapmap * sizeof (struct map));
+       nswap = getw(nl[SNSWAP].n_value);
+       free = 0;
+       for (me = (struct mapent *)(swapmap+1);
+           me < (struct mapent *)&swapmap[nswapmap]; me++)
+               free += me->m_size;
+       ntext = getw(nl[SNTEXT].n_value);
+       xtext = (struct text *)calloc(ntext, sizeof (struct text));
+       lseek(fc, getw(nl[STEXT].n_value), 0);
+       read(fc, xtext, ntext * sizeof (struct text));
+       tused = 0;
+       for (xp = xtext; xp < &xtext[ntext]; xp++)
+               if (xp->x_iptr!=NULL)
+                       tused += xdsize(xp);
+       used = tused;
+       for (pp = proc; pp < &proc[nproc]; pp++) {
+               if (pp->p_stat == 0 || pp->p_stat == SZOMB)

                        continue;
                        continue;

-               printf("%7.1o ", loc);
-               putf(cp->cflag&BLOCK, 'B');
-               putf(cp->cflag&WWAIT, 'B');
-               putf(cp->cflag&CRUN, 'R');
-               putf(cp->cflag&RWAIT, 'W');
-               putf(cp->cflag&ALLOC, 'A');
-               putf(cp->cflag&DIS, 'D');
-               putf(cp->cflag&DLY, 'D');
-               printf(" %1d %3d ", mask(cp->m), mask(cp->c));
-               printf("%7.1o ", cp->dest);
-               printf("\n");
+               if (pp->p_flag & SSYS)
+                       continue;
+               used += up(pp->p_dsize) + up(pp->p_ssize);
+               if ((pp->p_flag&SLOAD) == 0)
+                       used += vusize(pp);

        }
        }

+       /* a DMMAX/2 block goes to argmap */
+       if (totflg) {
+               printf("%3d/%3d 00k swap\n", used/2/100, (used+free)/2/100);
+               return;
+       }
+       printf("%d used (%d text), %d free, %d missing\n",
+           used/2, tused/2, free/2, (nswap - DMMAX/2 - (used + free))/2);
+}

 
 

-       printf("%d mpx machines\n", M);
-       printf("   LOC  FLG RCH RCN XCH XCN\n");
-       for(mp=mach,loc=setup[SMPXM].value; mp < &mach[M]; mp++,loc=+sizeof(mach[0])) {
-               printf("%7.1o ", loc);
-               putf(mp->mflag&RNEXT, 'N');
-               putf(mp->mflag&MRUN, 'R');
-               putf(mp->mflag&XNEXT, 'N');
-               printf(" %3d", mask(mp->rchan));
-               printf(" %3d", mask(mp->rcount));
-               printf(" %3d", mask(mp->xchan));
-               printf(" %3d", mask(mp->xcount));
-               for(nc=0; nc<128; nc++) {
-                       cp = mp->chanp[nc];
-                       if(cp == 0)
-                               continue;
-                       printf(" %d-%o", nc, cp);
-               }
-               printf("\n");
+up(size)
+       register int size;
+{
+       register int i, block;
+
+       i = 0;
+       block = DMMIN;
+       while (i < size) {
+               i += block;
+               if (block < DMMAX)
+                       block *= 2;
+       }
+       return (i);
+}
+
+vusize(p)
+struct proc *p;
+{
+       register int tsz = p->p_tsize / NPTEPG;
+
+       return (clrnd(UPAGES + clrnd(ctopt(p->p_tsize+p->p_dsize+p->p_ssize+UPAGES)) - tsz));
+}
+
+xdsize(xp)
+struct text *xp;
+{
+
+       if (xp->x_flag & XPAGI)
+               return (clrnd(xp->x_size + ctopt(xp->x_size)));
+       return (xp->x_size);
+}
+
+dompx()
+{
+       register int i;
+       struct chan chans[NCHANS];
+       struct schan schans[NPORTS];
+
+       lseek(fc, (long)nl[SCHANS].n_value, 0);
+       read(fc, chans, sizeof chans);
+       lseek(fc, (long)nl[SSCHANS].n_value, 0);
+       read(fc, schans, sizeof schans);
+
+       printf("CHAN  FLAGS            INDEX     LINE  GROUP     FILE      TTYP      CTLX      PGRP    OTTYP     OLINE  DATQ      CTLY\n");
+       for (i = 0; i < NCHANS; i++) {
+               printf("%3d   ", i);
+               putf(chans[i].c_flags&INUSE, 'I');
+               putf(chans[i].c_flags&SIOCTL, 'S');
+               putf(chans[i].c_flags&XGRP, 'X');
+               putf(chans[i].c_flags&YGRP, 'Y');
+               putf(chans[i].c_flags&WCLOSE, 'W');
+               putf(chans[i].c_flags&ISGRP, 'i');
+               putf(chans[i].c_flags&BLOCK, 'B');
+               putf(chans[i].c_flags&EOTMARK, 'E');
+               putf(chans[i].c_flags&SIGBLK, 's');
+               putf(chans[i].c_flags&BLKMSG, 'b');
+               putf(chans[i].c_flags&ENAMSG, 'e');
+               putf(chans[i].c_flags&WFLUSH, 'w');
+               putf(chans[i].c_flags&NMBUF, 'N');
+               putf(chans[i].c_flags&PORT, 'P');
+               putf(chans[i].c_flags&ALT, 'A');
+               putf(chans[i].c_flags&FBLOCK, 'F');
+               printf("%8x  ", chans[i].c_index);
+               printf("%3d   ", chans[i].c_line);
+               printf("%8x  ", chans[i].c_group);
+               printf("%8x  ", chans[i].c_fy);
+               printf("%8x  ", chans[i].c_ttyp);
+               printf("%8x  ", chans[i].c_ctlx);
+               printf("%6d  ", chans[i].c_pgrp);
+               printf("%8x  ", chans[i].c_ottyp);
+               printf("%3d   ", chans[i].c_oline);
+               printf("%8x  ", chans[i].cx.datq);
+               printf("%8x\n", chans[i].c_ctly);

        }
        }

-       printf("%d mpx lines\n", M-1);
-       printf("   LOC  RSQ XSQ AKF XMF STE TIM SUM\n");
-       for(lp=line,loc=setup[SMPSM].value; lp < &line[M-1]; lp++, loc =+ sizeof(line[0])) {
-               printf("%7.1o ", loc);
-               printf("%3o ", lp->rseq);
-               printf("%3o ", lp->xseq);
-               printf("%3o ", lp->ackf);
-               printf("%3o ", lp->xflag);
-               printf("%3d ", lp->state);
-               printf("%3d ", lp->time);
-               printf("%7o\n", lp->sum);
+
+       printf("\nCHAN  FLAGS            INDEX     LINE  GROUP     FILE      TTYP      CTLX      PGRP\n");
+       for (i = 0; i < NPORTS; i++) {
+               printf("%3d  ", i);
+               putf(schans[i].c_flags&INUSE, 'I');
+               putf(schans[i].c_flags&SIOCTL, 'S');
+               putf(schans[i].c_flags&XGRP, 'X');
+               putf(schans[i].c_flags&YGRP, 'Y');
+               putf(schans[i].c_flags&WCLOSE, 'W');
+               putf(schans[i].c_flags&ISGRP, 'i');
+               putf(schans[i].c_flags&BLOCK, 'B');
+               putf(schans[i].c_flags&EOTMARK, 'E');
+               putf(schans[i].c_flags&SIGBLK, 's');
+               putf(schans[i].c_flags&BLKMSG, 'b');
+               putf(schans[i].c_flags&ENAMSG, 'e');
+               putf(schans[i].c_flags&WFLUSH, 'w');
+               putf(schans[i].c_flags&NMBUF, 'N');
+               putf(schans[i].c_flags&PORT, 'P');
+               putf(schans[i].c_flags&ALT, 'A');
+               putf(schans[i].c_flags&FBLOCK, 'F');
+               printf("%8x  ", schans[i].c_index);
+               printf("%3d   ", schans[i].c_line);
+               printf("%8x  ", schans[i].c_group);
+               printf("%8x  ", schans[i].c_fy);
+               printf("%8x  ", schans[i].c_ttyp);
+               printf("%8x  ", schans[i].c_ctlx);
+               printf("%6d\n", schans[i].c_pgrp);

        }
        }

-       printf("last characters recieved\n");
-       nc = -1;
-       loc = mptbc;
-       for(;;) {
-               if(nc != mptbuf[loc]) {
-                       if(nc >= 0)
-                               printf(")\n");
-                       nc = mptbuf[loc];
-                       printf("%d(", nc);
-               } else
-                       printf(",");
-               loc++;
-               if(loc >= TBSIZ)
-                       loc = 0;
-               if(loc == mptbc)
-                       break;
-               printf("%o", mask(mptbuf[loc]));
-               loc++;
-               if(loc >= TBSIZ)
-                       loc = 0;
-               if(loc == mptbc)
-                       break;
+}
+
+dogroup()
+{
+       register int i, j;
+       struct group *groups[NGROUPS];
+       struct group g;
+
+       lseek(fc, (long)nl[SGROUP].n_value, 0);
+       read(fc, groups, sizeof groups);
+       printf("GROUP STATE      INDEX     ROT  *GROUP    *INODE    *FILE     ROTM  DATQ\n");
+       for (i = 0; i < NGROUPS; i++) {
+               if (groups[i] == 0)
+                       continue;
+               lseek(fc, (long) groups[i], 0);
+               read(fc, &g, sizeof g);
+               printf("%3d   ", i);
+               printf("%8x  ", g.g_state);
+               printf("%8x  ", g.g_index);
+               printf("%3d  ", g.g_rot);
+               printf("%8x  ", g.g_group);
+               printf("%8x  ", g.g_inode);
+               printf("%8x  ", g.g_file);
+               printf("%3d   ", g.g_rotmask);
+               printf("%3d\n", g.g_datq);

        }
        }

-       printf(")\n");

 }
 }

-*********/