projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
BSD 4 release
[unix-history] / usr / src / cmd / pstat.c
diff --git a/usr/src/cmd/pstat.c b/usr/src/cmd/pstat.c
index 17a7474..2455dc7 100644 (file)
--- a/usr/src/cmd/pstat.c
+++ b/usr/src/cmd/pstat.c
@@ -1,35 +1,56 @@
+static char *sccsid = "@(#)pstat.c     4.3 (Berkeley) 11/15/80";
 /*
  * 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>
 
 
-char   *fcore  = "/dev/mem";
-char   *fnlist = "/unix";
+char   *fcore  = "/dev/kmem";
+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,
-#define        SDH     3
-       "_dh11", 0, 0,
-#define        SNDH    4
-       "_ndh11", 0, 0,
+       { "_proc" },
+#define        SDZ     3
+       { "_dz_tty" },
+#define        SNDZ    4
+       { "_dz_cnt" },
 #define        SKL     5
 #define        SKL     5
-       "_kl11", 0, 0,
+       { "_cons" },
 #define        SFIL    6
 #define        SFIL    6
-       "_file", 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" },
        0,
 };
 
        0,
 };
 
@@ -40,15 +61,32 @@ int ttyf;
 int    usrf;
 long   ubase;
 int    filf;
 int    usrf;
 long   ubase;
 int    filf;
+int    swpf;
+int    totflg;
+char   partab[1];
+struct cdevsw  cdevsw[1];
+struct bdevsw  bdevsw[1];
 int    allflg;
 int    allflg;
+int    kflg;
+struct pte *Usrptma;
+struct pte *usrpt;
 
 main(argc, argv)
 char **argv;
 {
 
 main(argc, argv)
 char **argv;
 {
+       register char *argp;
 
 
-       while (--argc && **++argv == '-') {
-               while (*++*argv)
-               switch (**argv) {
+       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++;
@@ -58,9 +96,15 @@ char **argv;
                        inof++;
                        break;
 
                        inof++;
                        break;
 
+               case 'k':
+                       kflg++;
+                       fcore = "/vmcore";
+                       break;
+
                case 'x':
                        txtf++;
                        break;
                case 'x':
                        txtf++;
                        break;
+
                case 'p':
                        prcf++;
                        break;
                case 'p':
                        prcf++;
                        break;
@@ -70,15 +114,19 @@ char **argv;
                        break;
 
                case 'u':
                        break;
 
                case 'u':
-                       if (--argc == 0)
+                       if (argc == 0)
                                break;
                                break;
+                       argc--;
                        usrf++;
                        usrf++;
-                       ubase = oatoi(*++argv);
+                       sscanf( *argv++, "%x", &ubase);
                        break;
 
                case 'f':
                        filf++;
                        break;
                        break;
 
                case 'f':
                        filf++;
                        break;
+               case 's':
+                       swpf++;
+                       break;
                }
        }
        if (argc>0)
                }
        }
        if (argc>0)
@@ -89,45 +137,57 @@ char **argv;
        }
        if (argc>1)
                fnlist = argv[1];
        }
        if (argc>1)
                fnlist = argv[1];
-       nlist(fnlist, setup);
-       if (setup[SINODE].type == -1) {
+       nlist(fnlist, nl);
+       if (kflg) {
+               register struct nlist *nlp;
+               for (nlp=nl; nlp < &nl[sizeof (nl)/sizeof(nl[0])]; nlp++)
+                       nlp->n_value = clear(nlp->n_value);
+       }
+       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)
+               dofil();
+       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 (swpf||totflg)
+               doswap();
 }
 
 doinode()
 {
 }
 
 doinode()
 {
-#include <sys/inode.h>
        register struct inode *ip;
        struct inode xinode[NINODE];
        register int nin, loc;
 
        nin = 0;
        register struct inode *ip;
        struct inode xinode[NINODE];
        register int nin, loc;
 
        nin = 0;
-       lseek(fc, (long)setup[SINODE].value, 0);
-       read(fc, (char *)xinode, sizeof(xinode));
+       lseek(fc, (long)nl[SINODE].n_value, 0);
+       read(fc, xinode, sizeof(xinode));
        for (ip = xinode; ip < &xinode[NINODE]; ip++)
                if (ip->i_count)
                        nin++;
        for (ip = xinode; ip < &xinode[NINODE]; ip++)
                if (ip->i_count)
                        nin++;
-       printf("%d active inodes\n", nin);
-       printf("   LOC  FLAGS  CNT DEVICE   INO   MODE NLK UID  SIZE/DEV\n");
-       loc = setup[SINODE].value;
+       if (totflg) {
+               printf("%3d/%3d inodes\n", nin, NINODE);
+               return;
+       }
+       printf("%d/%d active xinodes\n", nin, NINODE);
+       printf("   LOC    FLAGS  CNT DEVICE   INO  MODE  NLK UID   SIZE/DEV\n");
+       loc = nl[SINODE].n_value;
        for (ip = xinode; ip < &xinode[NINODE]; ip++, loc += sizeof(xinode[0])) {
                if (ip->i_count == 0)
                        continue;
        for (ip = xinode; ip < &xinode[NINODE]; ip++, loc += sizeof(xinode[0])) {
                if (ip->i_count == 0)
                        continue;
-               printf("%7.1o ", loc);
+               printf("%8.1x ", loc);
                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');
@@ -135,9 +195,9 @@ doinode()
                putf(ip->i_flag&IWANT, 'W');
                putf(ip->i_flag&ITEXT, 'T');
                printf("%4d", ip->i_count&0377);
                putf(ip->i_flag&IWANT, 'W');
                putf(ip->i_flag&ITEXT, 'T');
                printf("%4d", ip->i_count&0377);
-               printf("%3d,%3d", major(ip->i_dev), minor(ip->i_dev));
-               printf("%6l", ip->i_number);
-               printf("%7o", ip->i_mode);
+               printf("%4d,%3d", major(ip->i_dev), minor(ip->i_dev));
+               printf("%6d", ip->i_number);
+               printf("%6x", ip->i_mode & 0xffff);
                printf("%4d", ip->i_nlink);
                printf("%4d", ip->i_uid);
                if ((ip->i_mode&IFMT)==IFBLK || (ip->i_mode&IFMT)==IFCHR)
                printf("%4d", ip->i_nlink);
                printf("%4d", ip->i_uid);
                if ((ip->i_mode&IFMT)==IFBLK || (ip->i_mode&IFMT)==IFCHR)
@@ -158,117 +218,154 @@ putf(v, n)
 
 dotext()
 {
 
 dotext()
 {
-#include <sys/text.h>
        register struct text *xp;
        struct text xtext[NTEXT];
        register loc;
        int ntx;
 
        ntx = 0;
        register struct text *xp;
        struct text xtext[NTEXT];
        register loc;
        int ntx;
 
        ntx = 0;
-       lseek(fc, (long)setup[STEXT].value, 0);
-       read(fc, (char *)xtext, sizeof(xtext));
+       lseek(fc, (long)nl[STEXT].n_value, 0);
+       read(fc, xtext, sizeof(xtext));
        for (xp = xtext; xp < &xtext[NTEXT]; xp++)
                if (xp->x_iptr!=NULL)
                        ntx++;
        for (xp = xtext; xp < &xtext[NTEXT]; xp++)
                if (xp->x_iptr!=NULL)
                        ntx++;
-       printf("%d text segments\n", ntx);
-       printf("   LOC FLAGS DADDR  CADDR SIZE   IPTR  CNT CCNT\n");
-       loc = setup[STEXT].value;
+       if (totflg) {
+               printf("%3d/%3d texts\n", ntx, NTEXT);
+               return;
+       }
+       printf("   LOC   FLAGS DADDR      CADDR  RSS SIZE      IPTR  CNT CCNT\n");
+       loc = nl[STEXT].n_value;
        for (xp = xtext; xp < &xtext[NTEXT]; xp++, loc+=sizeof(xtext[0])) {
                if (xp->x_iptr == NULL)
                        continue;
        for (xp = xtext; xp < &xtext[NTEXT]; xp++, loc+=sizeof(xtext[0])) {
                if (xp->x_iptr == NULL)
                        continue;
-               printf("%7.1o", loc);
+               printf("%8.1x", loc);
                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("%7.1o", xp->x_caddr);
+               printf("%5x", xp->x_daddr[0]);
+               printf("%11x", xp->x_caddr);
+               printf("%5d", xp->x_rssize);
                printf("%5d", xp->x_size);
                printf("%5d", xp->x_size);
-               printf("%8.1o", xp->x_iptr);
-               printf("%4d", xp->x_count&0377);
-               printf("%4d", xp->x_ccount);
+               printf("%10.1x", xp->x_iptr);
+               printf("%5d", xp->x_count&0377);
+               printf("%5d", xp->x_ccount);
                printf("\n");
        }
 }
 
 doproc()
 {
                printf("\n");
        }
 }
 
 doproc()
 {
-#include <sys/proc.h>
        struct proc xproc[NPROC];
        register struct proc *pp;
        register loc, np;
        struct proc xproc[NPROC];
        register struct proc *pp;
        register loc, np;
+       struct pte apte;
 
 
-       lseek(fc, (long)setup[SPROC].value, 0);
-       read(fc, (char *)xproc, sizeof(xproc));
+       lseek(fc, (long)nl[SPROC].n_value, 0);
+       read(fc, xproc, sizeof(xproc));
        np = 0;
        for (pp=xproc; pp < &xproc[NPROC]; pp++)
                if (pp->p_stat)
                        np++;
        np = 0;
        for (pp=xproc; pp < &xproc[NPROC]; pp++)
                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 (loc=nl[SPROC].n_value,pp=xproc; pp<&xproc[NPROC]; pp++,loc+=sizeof(xproc[0])) {
                if (pp->p_stat==0 && allflg==0)
                        continue;
                if (pp->p_stat==0 && allflg==0)
                        continue;
-               printf("%6o", loc);
-               printf("%2d", pp->p_stat);
-               printf("%3o", pp->p_flag);
-               printf("%5d", pp->p_pri);
-               printf("%7o", pp->p_sig);
-               printf("%4d", pp->p_uid&0377);
-               printf("%4d", 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("%5o", pp->p_addr);
-               printf("%5o", pp->p_size);
-               printf("%7o", pp->p_wchan);
-               printf("%7o", pp->p_link);
-               printf("%7o", pp->p_textp);
-               printf(" %u", pp->p_clktim);
+               printf("%8x", loc);
+               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 dh11[48];
-       int ndh;
+       struct tty dz_tty[64];
+       int ndz;
        register struct tty *tp;
        register char *mesg;
 
        register struct tty *tp;
        register char *mesg;
 
-       printf("1 kl11\n");
-       lseek(fc, (long)setup[SKL].value, 0);
-       read(fc, (char *)dh11, sizeof(dh11[0]));
-       mesg = " # RAW CAN OUT   MODE   ADDR   DEL COL  STATE   PGRP\n";
+       printf("1 cons\n");
+       lseek(fc, (long)nl[SKL].n_value, 0);
+       read(fc, dz_tty, sizeof(dz_tty[0]));
+       mesg = " # RAW CAN OUT   MODE    ADDR   DEL COL  STATE   PGRP DISC\n";
        printf(mesg);
        printf(mesg);
-       ttyprt(0, &dh11[0]);
-       if (setup[SNDH].type == -1)
+       ttyprt(&dz_tty[0], 0);
+       if (nl[SNDZ].n_type == 0)
+               goto dh;
+       lseek(fc, (long)nl[SNDZ].n_value, 0);
+       read(fc, &ndz, sizeof(ndz));
+       printf("%d dz lines\n", ndz);
+       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;
                return;
-       lseek(fc, (long)setup[SNDH].value, 0);
-       read(fc, (char *)&ndh, sizeof(ndh));
-       printf("%d dh lines\n", ndh);
-       lseek(fc, (long)setup[SDH].value, 0);
-       read(fc, (char *)dh11, sizeof(dh11));
-       for (tp = dh11; tp < &dh11[ndh]; tp++)
-               ttyprt(tp-dh11, tp);
+       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++)
+               ttyprt(tp, tp - dz_tty);
 }
 
 }
 
-ttyprt(n, 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("%2d", n);
-       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("%4d", tp->t_outq.c_cc);
        printf("%8.1o", tp->t_flags);
-       printf("%8.1o", tp->t_addr);
+       printf(" %8.1x", tp->t_addr);
        printf("%3d", tp->t_delct);
        printf("%4d ", tp->t_col);
        putf(tp->t_state&TIMEOUT, 'T');
        printf("%3d", tp->t_delct);
        printf("%4d ", tp->t_col);
        putf(tp->t_state&TIMEOUT, 'T');
@@ -278,78 +375,135 @@ struct tty *atp;
        putf(tp->t_state&BUSY, 'B');
        putf(tp->t_state&ASLEEP, 'A');
        putf(tp->t_state&XCLUDE, 'X');
        putf(tp->t_state&BUSY, 'B');
        putf(tp->t_state&ASLEEP, 'A');
        putf(tp->t_state&XCLUDE, 'X');
+/*
        putf(tp->t_state&HUPCLS, 'H');
        putf(tp->t_state&HUPCLS, 'H');
+ */
        printf("%6d", tp->t_pgrp);
        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>
-       union {
-               struct  user rxu;
-               char    fxu[ctob(USIZE)];
-       } xu;
-       register struct user *up;
-       register i;
-
-       lseek(fc, ubase<<6, 0);
-       read(fc, (char *)&xu, sizeof(xu));
-       up = &xu.rxu;
-       printf("rsav %.1o %.1o\n", up->u_rsav[0], up->u_rsav[1]);
-       printf("segflg, error %d, %d\n", up->u_segflg, up->u_error);
-       printf("uids %d,%d,%d,%d\n", up->u_uid,up->u_gid,up->u_ruid,up->u_rgid);
-       printf("procp %.1o\n", up->u_procp);
-       printf("base, count, offset %.1o %.1o %ld\n", up->u_base,
-               up->u_count, up->u_offset);
-       printf("cdir %.1o\n", up->u_cdir);
-       printf("dbuf %.14s\n", up->u_dbuf);
-       printf("dirp %.1o\n", up->u_dirp);
-       printf("dent %d %.14s\n", up->u_dent.d_ino, up->u_dent.d_name);
-       printf("pdir %.1o\n", up->u_pdir);
-       printf("dseg");
-       for (i=0; i<8; i++)
-               printf("%8.1o", up->u_uisa[i]);
-       printf("\n    ");
-       for (i=0; i<8; i++)
-               printf("%8.1o", up->u_uisd[i]);
-       if (up->u_sep) {
-               printf("\ntseg");
-               for (i=8; i<16; i++)
-                       printf("%8.1o", up->u_uisa[i]);
-               printf("\n    ");
-               for (i=8; i<16; i++)
-                       printf("%8.1o", up->u_uisd[i]);
+       struct user U;
+       register i, j, *ip;
+
+       /* This wins only if PAGSIZ > sizeof (struct user) */
+       lseek(fc, ubase * NBPG, 0);
+       read(fc, &U, sizeof(U));
+       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");
        }
        }
-       printf("\nfile");
+       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("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("file\t");
        for (i=0; i<10; i++)
        for (i=0; i<10; i++)
-               printf("%8.1o", up->u_ofile[i]);
-       printf("\n    ");
+               printf("%9.1x", U.u_ofile[i]);
+       printf("\n\t");
        for (i=10; i<NOFILE; i++)
        for (i=10; i<NOFILE; i++)
-               printf("%8.1o", up->u_ofile[i]);
-       printf("\nargs");
-       for (i=0; i<5; i++)
-               printf(" %.1o", up->u_arg[i]);
-       printf("\nsizes %.1o %.1o %.1o\n", up->u_tsize, up->u_dsize, up->u_ssize);
-       printf("sep %d\n", up->u_sep);
-       printf("qsav %.1o %.1o\n", up->u_qsav[0], up->u_qsav[1]);
-       printf("ssav %.1o %.1o\n", up->u_ssav[0], up->u_ssav[1]);
-       printf("sigs");
+               printf("%9.1x", U.u_ofile[i]);
+       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(" %.1o", up->u_signal[i]);
-       printf("\ntimes %ld %ld\n", up->u_utime/60, up->u_stime/60);
-       printf("ctimes %ld %ld\n", up->u_cutime/60, up->u_cstime/60);
-       printf("ar0 %.1o\n", up->u_ar0);
+               printf("%.1x ", U.u_signal[i]);
+       printf("\n");
+       printf("cfcode\t%.1x\n", U.u_cfcode);
+       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("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");
 /*
 /*
-       printf("prof");
-       for (i=0; i<4; i++)
-               printf(" %.1o", up->u_prof[i]);
+       i =  U.u_stack - &U;
+       while (U[++i] == 0);
+       i &= ~07;
+       while (i < 512) {
+               printf("%x ", 0140000+2*i);
+               for (j=0; j<8; j++)
+                       printf("%9x", U[i++]);
+               printf("\n");
+       }
 */
 */
-       printf("\nintflg %d\n", up->u_intflg);
-       printf("ttyp %.1o\n", up->u_ttyp);
-       printf("ttydev %d,%d\n", major(up->u_ttyd), minor(up->u_ttyd));
-       printf("comm %.14s\n", up->u_comm);
 }
 
 oatoi(s)
 }
 
 oatoi(s)
@@ -365,29 +519,108 @@ char *s;
 
 dofil()
 {
 
 dofil()
 {
-#include <sys/file.h>
        struct file xfile[NFILE];
        register struct file *fp;
        register nf;
        int loc;
 
        nf = 0;
        struct file xfile[NFILE];
        register struct file *fp;
        register nf;
        int loc;
 
        nf = 0;
-       lseek(fc, (long)setup[SFIL].value, 0);
-       read(fc, (char *)xfile, sizeof(xfile));
+       lseek(fc, (long)nl[SFIL].n_value, 0);
+       read(fc, xfile, sizeof(xfile));
        for (fp=xfile; fp < &xfile[NFILE]; fp++)
                if (fp->f_count)
                        nf++;
        for (fp=xfile; fp < &xfile[NFILE]; fp++)
                if (fp->f_count)
                        nf++;
-       printf("%d open files\n", nf);
-       printf("  LOC   FLG CNT   INO    OFFS\n");
-       for (fp=xfile,loc=setup[SFIL].value; fp < &xfile[NFILE]; fp++,loc+=sizeof(xfile[0])) {
+       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");
+       for (fp=xfile,loc=nl[SFIL].n_value; fp < &xfile[NFILE]; fp++,loc+=sizeof(xfile[0])) {
                if (fp->f_count==0)
                        continue;
                if (fp->f_count==0)
                        continue;
-               printf("%7.1o ", loc);
+               printf("%8x ", loc);
                putf(fp->f_flag&FREAD, 'R');
                putf(fp->f_flag&FWRITE, 'W');
                putf(fp->f_flag&FPIPE, 'P');
                printf("%4d", mask(fp->f_count));
                putf(fp->f_flag&FREAD, 'R');
                putf(fp->f_flag&FWRITE, 'W');
                putf(fp->f_flag&FPIPE, 'P');
                printf("%4d", mask(fp->f_count));
-               printf("%8.1o", fp->f_inode);
-               printf(" %ld\n", fp->f_un.f_offset);
+               printf("%9.1x", fp->f_inode);
+               printf("  %ld\n", fp->f_un.f_offset);
+       }
+}
+
+doswap()
+{
+       struct proc proc[NPROC];
+       struct text xtext[NTEXT];
+       struct map swapmap[SMAPSIZ];
+       register struct proc *pp;
+       int nswap, used, tused, free;
+       register struct map *mp;
+       register struct text *xp;
+
+       lseek(fc, (long)nl[SPROC].n_value, 0);
+       read(fc, proc, sizeof(proc));
+       lseek(fc, (long)nl[SWAPMAP].n_value, 0);
+       read(fc, swapmap, sizeof(swapmap));
+       lseek(fc, (long)nl[SNSWAP].n_value, 0);
+       read(fc, &nswap, sizeof(nswap));
+       free = 0;
+       for (mp = swapmap; mp < &swapmap[SMAPSIZ]; mp++)
+               free += mp->m_size;
+       lseek(fc, (long)nl[STEXT].n_value, 0);
+       read(fc, xtext, sizeof(xtext));
+       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;
+               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 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 - (used + free))/2);
+}
+
+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);
 }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.