-#ifndef lint
-static char *sccsid = "@(#)pstat.c 4.24 (Berkeley) %G%";
-#endif
/*
- * Print system stuff
+ * Copyright (c) 1980 Regents of the University of California.
+ * All rights reserved. The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
*/
-#define mask(x) (x&0377)
-#define clear(x) ((int)x&0x7fffffff)
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1980 Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+#ifndef lint
+static char sccsid[] = "@(#)pstat.c 5.26 (Berkeley) 6/29/90";
+#endif /* not lint */
+
+/*
+ * Print system stuff
+ */
#include <sys/param.h>
-#include <sys/dir.h>
-#define KERNEL
-#include <sys/file.h>
-#undef KERNEL
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/text.h>
-#include <sys/inode.h>
+#include <sys/time.h>
+#include <sys/vnode.h>
#include <sys/map.h>
+#define KERNEL
+#define NFS
+#include <sys/file.h>
+#include <sys/mount.h>
+#include <ufs/quota.h>
+#include <ufs/inode.h>
+#include <sys/stat.h>
+#include <nfs/nfsv2.h>
+#include <nfs/nfs.h>
+#include <nfs/nfsnode.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
+#undef KERNEL
#include <sys/conf.h>
#include <sys/vm.h>
-#include <nlist.h>
#include <machine/pte.h>
-char *fcore = "/dev/kmem";
-char *fnlist = "/vmunix";
-int fc;
+#include <kvm.h>
+#include <nlist.h>
+#include <stdio.h>
+#include "pathnames.h"
+
+#define mask(x) (x&0377)
+#define clear(x) ((int)x &~ KERNBASE)
+
+char *fnlist = NULL;
+char *fcore = NULL;
struct nlist nl[] = {
-#define SINODE 0
- { "_inode" },
-#define STEXT 1
+#define STEXT 0
{ "_text" },
+#define SCONS 1
+ { "_cons" },
#define SPROC 2
{ "_proc" },
-#define SDZ 3
- { "_dz_tty" },
-#define SNDZ 4
- { "_dz_cnt" },
-#define SKL 5
- { "_cons" },
-#define SFIL 6
+#define SFIL 3
{ "_file" },
-#define USRPTMA 7
- { "_Usrptmap" },
-#define USRPT 8
- { "_usrpt" },
-#define SWAPMAP 9
+#define SWAPMAP 4
{ "_swapmap" },
-#define SDH 10
- { "_dh11" },
-#define SNDH 11
- { "_ndh11" },
-#define SNPROC 12
+#define SNPROC 5
{ "_nproc" },
-#define SNTEXT 13
+#define SNTEXT 6
{ "_ntext" },
-#define SNFILE 14
+#define SNFILE 7
{ "_nfile" },
-#define SNINODE 15
- { "_ninode" },
-#define SNSWAPMAP 16
+#define SNSWAPMAP 8
{ "_nswapmap" },
-#define SPTY 17
+#define SPTY 9
{ "_pt_tty" },
-#define SDMMIN 18
+#define SDMMIN 10
{ "_dmmin" },
-#define SDMMAX 19
+#define SDMMAX 11
{ "_dmmax" },
-#define SNSWDEV 20
+#define SNSWDEV 12
{ "_nswdev" },
-#define SSWDEVT 21
+#define SSWDEVT 13
{ "_swdevt" },
+#define SNPTY 14
+ { "_npty" },
+#ifdef vax
+#define SDZ (SNPTY+1)
+ { "_dz_tty" },
+#define SNDZ (SNPTY+2)
+ { "_dz_cnt" },
+#define SDMF (SNPTY+3)
+ { "_dmf_tty" },
+#define SNDMF (SNPTY+4)
+ { "_ndmf" },
+#define SDH (SNPTY+5)
+ { "_dh11" },
+#define SNDH (SNPTY+6)
+ { "_ndh11" },
+#define SDHU (SNPTY+7)
+ { "_dhu_tty" },
+#define SNDHU (SNPTY+8)
+ { "_ndhu" },
+#define SDMZ (SNPTY+9)
+ { "_dmz_tty" },
+#define SNDMZ (SNPTY+10)
+ { "_ndmz" },
+#define SQD (SNPTY+11)
+ { "_qd_tty" },
+#define SNQD (SNPTY+12)
+ { "_nNQD" },
+#endif
+#ifdef tahoe
+#define SVX (SNPTY+1)
+ { "_vx_tty" },
+#define SNVX (SNPTY+2)
+ { "_nvx" },
+#define SMP (SNPTY+3)
+ { "_mp_tty" },
+#define SNMP (SNPTY+4)
+ { "_nmp" },
+#endif
{ "" }
};
-int inof;
+int vnof;
int txtf;
int prcf;
int ttyf;
int usrf;
-long ubase;
+int upid;
int filf;
int swpf;
int totflg;
struct cdevsw cdevsw[1];
struct bdevsw bdevsw[1];
int allflg;
-int kflg;
-struct pte *Usrptma;
-struct pte *usrpt;
+int nflg;
+u_long getword();
+off_t mkphys();
+
+char *Program;
main(argc, argv)
-char **argv;
+ int argc;
+ char **argv;
{
- register char *argp;
- int allflags;
-
- argc--, argv++;
- while (argc > 0 && **argv == '-') {
- argp = *argv++;
- argp++;
- argc--;
- while (*argp++)
- switch (argp[-1]) {
+ extern char *optarg;
+ extern int optind;
+ int ch;
+ Program = argv[0];
+ while ((ch = getopt(argc, argv, "Tafvikptu:sxn")) != EOF)
+ switch((char)ch) {
case 'T':
totflg++;
break;
-
case 'a':
allflg++;
- break;
-
- case 'i':
- inof++;
- break;
-
- case 'k':
- kflg++;
- fcore = "/vmcore";
- break;
-
- case 'x':
- txtf++;
- break;
-
+ /*FALLTHROUGH*/
case 'p':
prcf++;
break;
-
+ case 'f':
+ filf++;
+ break;
+ case 'v':
+ case 'i':
+ vnof++;
+ break;
case 't':
ttyf++;
break;
-
case 'u':
- if (argc == 0)
- break;
- argc--;
usrf++;
- sscanf( *argv++, "%x", &ubase);
- break;
-
- case 'f':
- filf++;
+ sscanf(optarg, "%d", &upid);
break;
case 's':
swpf++;
break;
+ case 'x':
+ txtf++;
+ break;
+ case 'n':
+ nflg++;
+ break;
+ case '?':
default:
- usage();
+ printf("usage: pstat -[Tafiptsx] [-u [pid]] [system] [core]\n");
exit(1);
}
- }
- if (argc>1)
+ argc -= optind;
+ argv += optind;
+
+ if (argc > 1)
fcore = argv[1];
- if ((fc = open(fcore, 0)) < 0) {
- printf("Can't find %s\n", fcore);
+ if (argc > 0)
+ fnlist = argv[0];
+ if (kvm_openfiles(fnlist, fcore, NULL) == -1) {
+ syserror("kvm_openfiles: %s", kvm_geterr());
exit(1);
}
- if (argc>0)
- fnlist = argv[0];
- 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");
+ if (kvm_nlist(nl) != 0) {
+ syserror("kvm_nlist: %s", kvm_geterr());
exit(1);
}
- allflags = filf | totflg | inof | prcf | txtf | ttyf | usrf | swpf;
- if (allflags == 0) {
- printf("pstat: one or more of -[aixptfsu] is required\n");
+ if (!(filf | totflg | vnof | prcf | txtf | ttyf | usrf | swpf)) {
+ printf("pstat: one or more of -[aivxptfsu] is required\n");
exit(1);
}
if (filf||totflg)
dofile();
- if (inof||totflg)
- doinode();
+ if (vnof||totflg)
+ dovnode();
if (prcf||totflg)
doproc();
if (txtf||totflg)
doswap();
}
-usage()
-{
-
- printf("usage: pstat -[aixptfs] [-u [ubase]] [system] [core]\n");
-}
+struct e_vnode {
+ struct vnode *avnode;
+ struct vnode vnode;
+};
-doinode()
+dovnode()
{
+ register struct e_vnode *e_vnodebase, *endvnode, *evp;
+ register struct vnode *vp;
+ register struct mount *maddr = NULL, *mp;
register struct inode *ip;
- struct inode *xinode, *ainode;
- register int nin;
- int ninode;
-
- nin = 0;
- 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++;
+ int numvnodes;
+ struct e_vnode *loadvnodes();
+ struct mount *getmnt();
+
+ e_vnodebase = loadvnodes(&numvnodes);
if (totflg) {
- printf("%3d/%3d inodes\n", nin, ninode);
+ printf("%7d vnodes\n", numvnodes);
return;
}
- printf("%d/%d active inodes\n", nin, ninode);
-printf(" LOC FLAGS CNT DEVICE RDC WRC INO MODE NLK UID SIZE/DEV\n");
- for (ip = xinode; ip < &xinode[ninode]; ip++) {
- if (ip->i_count == 0)
- continue;
- printf("%8.1x ", ainode + (ip - xinode));
- putf(ip->i_flag&ILOCKED, 'L');
- putf(ip->i_flag&IUPD, 'U');
- putf(ip->i_flag&IACC, 'A');
- putf(ip->i_flag&IMOUNT, 'M');
- putf(ip->i_flag&IWANT, 'W');
- putf(ip->i_flag&ITEXT, 'T');
- putf(ip->i_flag&ICHG, 'C');
- putf(ip->i_flag&ISHLOCK, 'S');
- putf(ip->i_flag&IEXLOCK, 'E');
- putf(ip->i_flag&ILWAIT, 'Z');
- printf("%4d", ip->i_count&0377);
- printf("%4d,%3d", major(ip->i_dev), minor(ip->i_dev));
- printf("%4d", ip->i_shlockc&0377);
- printf("%4d", ip->i_exlockc&0377);
- 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("%6d,%3d", major(ip->i_rdev), minor(ip->i_rdev));
- else
- printf("%10ld", ip->i_size);
+ endvnode = e_vnodebase + numvnodes;
+ printf("%d active vnodes\n", numvnodes);
+
+
+#define ST mp->mnt_stat
+ for (evp = e_vnodebase; evp < endvnode; evp++) {
+ vp = &evp->vnode;
+ if (vp->v_mount != maddr) {
+ /*
+ * New filesystem
+ */
+ if ((mp = getmnt(vp->v_mount)) == NULL)
+ continue;
+ maddr = vp->v_mount;
+ mount_print(mp);
+ vnode_header();
+ switch(ST.f_type) {
+ case MOUNT_UFS:
+ case MOUNT_MFS:
+ ufs_header();
+ break;
+ case MOUNT_NFS:
+ nfs_header();
+ break;
+ case MOUNT_NONE:
+ case MOUNT_PC:
+ default:
+ break;
+ }
+ printf("\n");
+ }
+ vnode_print(evp->avnode, vp);
+ switch(ST.f_type) {
+ case MOUNT_UFS:
+ case MOUNT_MFS:
+ ufs_print(vp);
+ break;
+ case MOUNT_NFS:
+ nfs_print(vp);
+ break;
+ case MOUNT_NONE:
+ case MOUNT_PC:
+ default:
+ break;
+ }
printf("\n");
}
- free(xinode);
+ free(e_vnodebase);
}
-getw(loc)
+vnode_header()
+{
+ printf("ADDR TYP VFLAG USE REF");
+}
+
+vnode_print(avnode, vp)
+ struct vnode *avnode;
+ struct vnode *vp;
+{
+ char *type, flags[16];
+ char *fp = flags;
+ register flag;
+
+ /*
+ * set type
+ */
+ switch(vp->v_type) {
+ case VNON:
+ type = "non"; break;
+ case VREG:
+ type = "reg"; break;
+ case VDIR:
+ type = "dir"; break;
+ case VBLK:
+ type = "blk"; break;
+ case VCHR:
+ type = "chr"; break;
+ case VLNK:
+ type = "lnk"; break;
+ case VSOCK:
+ type = "soc"; break;
+ case VFIFO:
+ type = "fif"; break;
+ case VBAD:
+ type = "bad"; break;
+ default:
+ type = "unk"; break;
+ }
+ /*
+ * gather flags
+ */
+ flag = vp->v_flag;
+ if (flag & VROOT)
+ *fp++ = 'R';
+ if (flag & VTEXT)
+ *fp++ = 'T';
+ if (flag & VXLOCK)
+ *fp++ = 'L';
+ if (flag & VXWANT)
+ *fp++ = 'W';
+ if (flag & VEXLOCK)
+ *fp++ = 'E';
+ if (flag & VSHLOCK)
+ *fp++ = 'S';
+ if (flag & VLWAIT)
+ *fp++ = 'T';
+ if (flag & VALIASED)
+ *fp++ = 'A';
+ if (flag & VBWAIT)
+ *fp++ = 'B';
+ if (flag == 0)
+ *fp++ = '-';
+ *fp = '\0';
+ /*
+ * print it
+ */
+ printf("%8x %s %5s %4d %4d",
+ avnode, type, flags, vp->v_usecount, vp->v_holdcnt);
+}
+
+ufs_header()
+{
+ printf(" FILEID IFLAG RDEV|SZ");
+}
+
+ufs_print(vp)
+ struct vnode *vp;
+{
+ struct inode *ip = VTOI(vp);
+ char flagbuf[16], *flags = flagbuf;
+ register flag;
+ char *name;
+ mode_t type;
+ extern char *devname();
+
+ flag = ip->i_flag;
+ if (flag & ILOCKED)
+ *flags++ = 'L';
+ if (flag & IWANT)
+ *flags++ = 'W';
+ if (flag & IRENAME)
+ *flags++ = 'R';
+ if (flag & IUPD)
+ *flags++ = 'U';
+ if (flag & IACC)
+ *flags++ = 'A';
+ if (flag & ICHG)
+ *flags++ = 'C';
+ if (flag & IMOD)
+ *flags++ = 'M';
+ if (flag & ISHLOCK)
+ *flags++ = 'S';
+ if (flag & IEXLOCK)
+ *flags++ = 'E';
+ if (flag & ILWAIT)
+ *flags++ = 'Z';
+ if (flag == 0)
+ *flags++ = '-';
+ *flags = '\0';
+
+ printf(" %6d %5s", ip->i_number, flagbuf);
+ type = ip->i_mode & S_IFMT;
+ if (type == S_IFCHR || type == S_IFBLK)
+ if (nflg || ((name = devname(ip->i_rdev, type)) == NULL))
+ printf(" %2d,%-2d",
+ major(ip->i_rdev), minor(ip->i_rdev));
+ else
+ printf(" %7s", name);
+ else
+ printf(" %7d", ip->i_size);
+}
+
+nfs_header()
+{
+ printf(" FILEID NFLAG RDEV|SZ");
+}
+
+nfs_print(vp)
+ struct vnode *vp;
+{
+ struct nfsnode *np = VTONFS(vp);
+ char flagbuf[16], *flags = flagbuf;
+ register flag;
+ char *name;
+ mode_t type;
+ extern char *devname();
+
+ flag = np->n_flag;
+ if (flag & NLOCKED)
+ *flags++ = 'L';
+ if (flag & NWANT)
+ *flags++ = 'W';
+ if (flag & NMODIFIED)
+ *flags++ = 'M';
+ if (flag & NWRITEERR)
+ *flags++ = 'E';
+ if (flag == 0)
+ *flags++ = '-';
+ *flags = '\0';
+
+#define VT np->n_vattr
+ printf(" %6d %5s", VT.va_fileid, flagbuf);
+ type = VT.va_mode & S_IFMT;
+ if (type == S_IFCHR || type == S_IFBLK)
+ if (nflg || ((name = devname(VT.va_rdev, type)) == NULL))
+ printf(" %2d,%-2d",
+ major(VT.va_rdev), minor(VT.va_rdev));
+ else
+ printf(" %7s", name);
+ else
+ printf(" %7d", np->n_size);
+}
+
+/*
+ * Given a pointer to a mount structure in kernel space,
+ * read it in and return a usable pointer to it.
+ */
+struct mount *
+getmnt(maddr)
+ struct mount *maddr;
+{
+ static struct mtab {
+ struct mtab *next;
+ struct mount *maddr;
+ struct mount mount;
+ } *mhead = NULL;
+ register struct mtab *mt;
+
+ for (mt = mhead; mt != NULL; mt = mt->next)
+ if (maddr == mt->maddr)
+ return (&mt->mount);
+ if ((mt = (struct mtab *)malloc(sizeof (struct mtab))) == NULL) {
+ error("out of memory");
+ exit(1);
+ }
+ if (kvm_read((off_t)maddr, &mt->mount, sizeof(struct mount)) !=
+ sizeof(struct mount)) {
+ error("can't read mount table at %x", maddr);
+ return (NULL);
+ }
+ mt->maddr = maddr;
+ mt->next = mhead;
+ mhead = mt;
+ return (&mt->mount);
+}
+
+mount_print(mp)
+ struct mount *mp;
+{
+ char *type = "unknown";
+ register flags;
+
+#define ST mp->mnt_stat
+ printf("*** MOUNT ");
+ switch (ST.f_type) {
+ case MOUNT_NONE:
+ type = "none";
+ break;
+ case MOUNT_UFS:
+ type = "ufs";
+ break;
+ case MOUNT_NFS:
+ type = "nfs";
+ break;
+ case MOUNT_MFS:
+ type = "mfs";
+ break;
+ case MOUNT_PC:
+ type = "pc";
+ break;
+ }
+ printf("%s %s on %s", type, ST.f_mntfromname, ST.f_mntonname);
+ if (flags = mp->mnt_flag) {
+ char *comma = "(";
+
+ putchar(' ');
+ /* user visable flags */
+ if (flags & MNT_RDONLY) {
+ printf("%srdonly", comma);
+ flags &= ~MNT_RDONLY;
+ comma = ",";
+ }
+ if (flags & MNT_SYNCHRONOUS) {
+ printf("%ssynchronous", comma);
+ flags &= ~MNT_SYNCHRONOUS;
+ comma = ",";
+ }
+ if (flags & MNT_NOEXEC) {
+ printf("%snoexec", comma);
+ flags &= ~MNT_NOEXEC;
+ comma = ",";
+ }
+ if (flags & MNT_NOSUID) {
+ printf("%snosuid", comma);
+ flags &= ~MNT_NOSUID;
+ comma = ",";
+ }
+ if (flags & MNT_NODEV) {
+ printf("%snodev", comma);
+ flags &= ~MNT_NODEV;
+ comma = ",";
+ }
+ if (flags & MNT_EXPORTED) {
+ printf("%sexport", comma);
+ flags &= ~MNT_EXPORTED;
+ comma = ",";
+ }
+ if (flags & MNT_EXRDONLY) {
+ printf("%sexrdonly", comma);
+ flags &= ~MNT_EXRDONLY;
+ comma = ",";
+ }
+ if (flags & MNT_LOCAL) {
+ printf("%slocal", comma);
+ flags &= ~MNT_LOCAL;
+ comma = ",";
+ }
+ if (flags & MNT_QUOTA) {
+ printf("%squota", comma);
+ flags &= ~MNT_QUOTA;
+ comma = ",";
+ }
+ /* filesystem control flags */
+ if (flags & MNT_UPDATE) {
+ printf("%supdate", comma);
+ flags &= ~MNT_UPDATE;
+ comma = ",";
+ }
+ if (flags & MNT_MLOCK) {
+ printf("%slock", comma);
+ flags &= ~MNT_MLOCK;
+ comma = ",";
+ }
+ if (flags & MNT_MWAIT) {
+ printf("%swait", comma);
+ flags &= ~MNT_MWAIT;
+ comma = ",";
+ }
+ if (flags & MNT_MPBUSY) {
+ printf("%sbusy", comma);
+ flags &= ~MNT_MPBUSY;
+ comma = ",";
+ }
+ if (flags & MNT_MPWANT) {
+ printf("%swant", comma);
+ flags &= ~MNT_MPWANT;
+ comma = ",";
+ }
+ if (flags & MNT_UNMOUNT) {
+ printf("%sunmount", comma);
+ flags &= ~MNT_UNMOUNT;
+ comma = ",";
+ }
+ if (flags)
+ printf("%sunknown_flags:%x", flags);
+ printf(")");
+ }
+ printf("\n");
+#undef ST
+}
+
+struct e_vnode *
+loadvnodes(avnodes)
+ int *avnodes;
+{
+ int ret, copysize, i;
+ struct e_vnode *vnodebase;
+
+ if (fcore != NULL) {
+ error("vnodes on dead kernel, not impl yet\n");
+ exit(1);
+ }
+ if ((ret = getkerninfo(KINFO_VNODE, NULL, NULL, 0)) == -1) {
+ syserror("can't get estimate for kerninfo");
+ exit(1);
+ }
+ copysize = ret;
+ if ((vnodebase = (struct e_vnode *)malloc(copysize))
+ == NULL) {
+ error("out of memory");
+ exit(1);
+ }
+ if ((ret = getkerninfo(KINFO_VNODE, vnodebase, ©size, 0))
+ == -1) {
+ syserror("can't get vnode list");
+ exit(1);
+ }
+ if (copysize % sizeof (struct e_vnode)) {
+ error("vnode size mismatch");
+ error(1);
+ }
+ *avnodes = copysize / sizeof (struct e_vnode);
+
+ return (vnodebase);
+}
+
+u_long
+getword(loc)
off_t loc;
{
- int word;
-
- if (kflg)
- loc &= 0x7fffffff;
- lseek(fc, loc, 0);
- read(fc, &word, sizeof (word));
- if (kflg)
- word &= 0x7fffffff;
+ u_long word;
+
+ kvm_read(loc, &word, sizeof (word));
return (word);
}
register struct text *xp;
int ntext;
struct text *xtext, *atext;
- int ntx;
+ int ntx, ntxca;
- ntx = 0;
- ntext = getw(nl[SNTEXT].n_value);
+ ntx = ntxca = 0;
+ ntext = getword(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)
+ atext = (struct text *)getword(nl[STEXT].n_value);
+ if (ntext < 0 || ntext > 10000) {
+ fprintf(stderr, "number of texts is preposterous (%d)\n",
+ ntext);
+ return;
+ }
+ if (xtext == NULL) {
+ fprintf(stderr, "can't allocate memory for text table\n");
+ return;
+ }
+ kvm_read(atext, xtext, ntext * sizeof (struct text));
+ for (xp = xtext; xp < &xtext[ntext]; xp++) {
+ if (xp->x_vptr != NULL)
+ ntxca++;
+ if (xp->x_count != 0)
ntx++;
+ }
if (totflg) {
- printf("%3d/%3d texts\n", ntx, ntext);
+ printf("%3d/%3d texts active, %3d used\n", ntx, ntext, ntxca);
return;
}
- printf("%d/%d active texts\n", ntx, ntext);
- printf(" LOC FLAGS DADDR CADDR RSS SIZE IPTR CNT CCNT\n");
+ printf("%d/%d active texts, %d used\n", ntx, ntext, ntxca);
+ printf("\
+ LOC FLAGS DADDR CADDR RSS SIZE VPTR CNT CCNT FORW BACK\n");
for (xp = xtext; xp < &xtext[ntext]; xp++) {
- if (xp->x_iptr == NULL)
+ if (xp->x_vptr == NULL)
continue;
printf("%8.1x", atext + (xp - xtext));
printf(" ");
- putf(xp->x_flag&XPAGI, 'P');
+ putf(xp->x_flag&XPAGV, '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');
printf("%5x", xp->x_daddr[0]);
- printf("%11x", xp->x_caddr);
+ printf("%10x", xp->x_caddr);
printf("%5d", xp->x_rssize);
printf("%5d", xp->x_size);
- printf("%10.1x", xp->x_iptr);
+ printf("%10.1x", xp->x_vptr);
printf("%5d", xp->x_count&0377);
printf("%5d", xp->x_ccount);
+ printf("%10x", xp->x_forw);
+ printf("%9x", xp->x_back);
printf("\n");
}
free(xtext);
register loc, np;
struct pte apte;
- nproc = getw(nl[SNPROC].n_value);
+ nproc = getword(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));
+ aproc = (struct proc *)getword(nl[SPROC].n_value);
+ if (nproc < 0 || nproc > 10000) {
+ fprintf(stderr, "number of procs is preposterous (%d)\n",
+ nproc);
+ return;
+ }
+ if (xproc == NULL) {
+ fprintf(stderr, "can't allocate memory for proc table\n");
+ return;
+ }
+ kvm_read(aproc, xproc, nproc * sizeof (struct proc));
np = 0;
for (pp=xproc; pp < &xproc[nproc]; pp++)
if (pp->p_stat)
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");
+ printf(" LOC S F POIP PRI SIG UID SLP TIM CPU NI PID PPID ADDR RSS SRSS SIZE WCHAN LINK TEXTP\n");
for (pp=xproc; pp<&xproc[nproc]; pp++) {
if (pp->p_stat==0 && allflg==0)
continue;
printf("%8x", aproc + (pp - xproc));
printf(" %2d", pp->p_stat);
- printf(" %4x", pp->p_flag & 0xffff);
+ printf(" %8x", pp->p_flag);
printf(" %4d", pp->p_poip);
printf(" %3d", pp->p_pri);
printf(" %8x", pp->p_sig);
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);
+ /*
+ if (pp->p_flag & SLOAD) {
+ kvm_read(pp->p_addr, &apte, sizeof(apte));
+ printf(" %8x", apte.pg_pfnum);
+ } else
+ printf(" %8x", pp->p_swaddr);
+ */
printf(" %4x", pp->p_rssize);
printf(" %4x", pp->p_swrss);
printf(" %5x", pp->p_dsize+pp->p_ssize);
printf(" %7x", clear(pp->p_textp));
printf("\n");
}
+ free(xproc);
}
+char mesg[] = "LINE RAW CAN OUT RCC CCC OCC HWT LWT ADDR COL STATE PGID DISC\n";
+int ttyspace = 128;
+struct tty *tty;
+
dotty()
{
- struct tty dz_tty[128];
- int ndz;
- register struct tty *tp;
- register char *mesg;
+ if ((tty = (struct tty *)malloc(ttyspace * sizeof(*tty))) == 0) {
+ printf("pstat: out of memory\n");
+ return;
+ }
printf("1 cons\n");
- 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]));
- mesg = " # RAW CAN OUT MODE ADDR DEL COL STATE PGRP DISC\n";
+ kvm_read((long)nl[SCONS].n_value, tty, sizeof(*tty));
+ printf(mesg);
+ ttyprt(&tty[0], 0);
+#ifdef vax
+ if (nl[SNQD].n_type != 0)
+ doqdss();
+ if (nl[SNDZ].n_type != 0)
+ dottytype("dz", SDZ, SNDZ);
+ if (nl[SNDH].n_type != 0)
+ dottytype("dh", SDH, SNDH);
+ if (nl[SNDMF].n_type != 0)
+ dottytype("dmf", SDMF, SNDMF);
+ if (nl[SNDHU].n_type != 0)
+ dottytype("dhu", SDHU, SNDHU);
+ if (nl[SNDMZ].n_type != 0)
+ dottytype("dmz", SDMZ, SNDMZ);
+#endif
+#ifdef tahoe
+ if (nl[SNVX].n_type != 0)
+ dottytype("vx", SVX, SNVX);
+ if (nl[SNMP].n_type != 0)
+ dottytype("mp", SMP, SNMP);
+#endif
+ if (nl[SNPTY].n_type != 0)
+ dottytype("pty", SPTY, SNPTY);
+}
+
+/*
+ * Special case the qdss: there are 4 ttys per qdss,
+ * but only the first of each is used as a tty.
+ */
+#ifdef vax
+doqdss()
+{
+ int nqd;
+ register struct tty *tp;
+
+ kvm_read((long)nl[SNQD].n_value, &nqd, sizeof(nqd));
+ printf("%d qd\n", nqd);
+ kvm_read((long)nl[SQD].n_value, tty, nqd * sizeof(struct tty) * 4);
+ printf(mesg);
+ for (tp = tty; tp < &tty[nqd * 4]; tp += 4)
+ ttyprt(tp, tp - tty);
+}
+#endif
+
+dottytype(name, type, number)
+char *name;
+{
+ int ntty;
+ register struct tty *tp;
+ extern char *realloc();
+
+ if (tty == (struct tty *)0)
+ return;
+ kvm_read((long)nl[number].n_value, &ntty, sizeof(ntty));
+ printf("%d %s lines\n", ntty, name);
+ if (ntty > ttyspace) {
+ ttyspace = ntty;
+ if ((tty = (struct tty *)realloc(tty, ttyspace * sizeof(*tty))) == 0) {
+ printf("pstat: out of memory\n");
+ return;
+ }
+ }
+ kvm_read((long)nl[type].n_value, tty, ntty * sizeof(struct tty));
printf(mesg);
- 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);
- lseek(fc, (long)nl[SDZ].n_value, 0);
- read(fc, dz_tty, ndz * sizeof (struct tty));
- for (tp = dz_tty; tp < &dz_tty[ndz]; tp++)
- ttyprt(tp, tp - dz_tty);
-dh:
- if (nl[SNDH].n_type == 0)
- goto pty;
- 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, ndz * sizeof(struct tty));
- for (tp = dz_tty; tp < &dz_tty[ndz]; tp++)
- ttyprt(tp, tp - dz_tty);
-pty:
- if (nl[SPTY].n_type == 0)
- goto pty;
- if (kflg) {
- nl[SPTY].n_value = clear(nl[SPTY].n_value);
- }
- printf("32 pty lines\n");
- lseek(fc, (long)nl[SPTY].n_value, 0);
- read(fc, dz_tty, 32*sizeof(struct tty));
- for (tp = dz_tty; tp < &dz_tty[32]; tp++)
- ttyprt(tp, tp - dz_tty);
+ for (tp = tty; tp < &tty[ntty]; tp++)
+ ttyprt(tp, tp - tty);
}
+struct {
+ int flag;
+ char val;
+} ttystates[] = {
+ TS_WOPEN, 'W',
+ TS_ISOPEN, 'O',
+ TS_CARR_ON, 'C',
+ TS_TIMEOUT, 'T',
+ TS_FLUSH, 'F',
+ TS_BUSY, 'B',
+ TS_ASLEEP, 'A',
+ TS_XCLUDE, 'X',
+ TS_TTSTOP, 'S',
+ TS_HUPCLS, 'H',
+ TS_TBLOCK, 'K',
+ TS_RCOLL, 'R',
+ TS_WCOLL, 'I', /* running short on letters ! */
+ TS_ASYNC, 'Y',
+ TS_BKSL, 'D',
+ TS_ERASE, 'E',
+ TS_LNCH, 'L',
+ TS_TYPEN, 'P',
+ TS_CNTTB, 'N',
+ 0, 0
+};
+
ttyprt(atp, line)
struct tty *atp;
{
register struct tty *tp;
+ char state[20];
+ register i, j;
+ char *name;
+ extern char *devname();
+ pid_t pgid;
- printf("%2d", line);
tp = atp;
+ if (nflg || tp->t_dev == 0 || /* XXX */
+ (name = devname(tp->t_dev, S_IFCHR)) == NULL)
+ printf("%7d ", line);
+ else
+ printf("%7s ", name);
+ printf("%2d %3d ", tp->t_rawq.c_cc, tp->t_canq.c_cc);
+ printf("%3d %6d %6d %6d %4d %3d %8x %3d ", tp->t_outq.c_cc,
+ tp->t_rawcc, tp->t_cancc, tp->t_outcc,
+ tp->t_hiwat, tp->t_lowat, tp->t_addr, tp->t_col);
+ for (i = j = 0; ttystates[i].flag; i++)
+ if (tp->t_state&ttystates[i].flag)
+ state[j++] = ttystates[i].val;
+ state[j] = '\0';
+ printf("%-4s ", state);
+ if (tp->t_pgrp == NULL || kvm_read(&tp->t_pgrp->pg_id, &pgid,
+ sizeof (pid_t)) != sizeof (pid_t))
+ pgid = 0;
+ printf("%6d ", pgid);
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);
+ case 0:
+ printf("term\n");
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.1x", tp->t_flags);
- printf(" %8.1x", tp->t_addr);
- printf("%3d", tp->t_delct);
- printf("%4d ", tp->t_col);
- putf(tp->t_state&TS_TIMEOUT, 'T');
- putf(tp->t_state&TS_WOPEN, 'W');
- putf(tp->t_state&TS_ISOPEN, 'O');
- putf(tp->t_state&TS_CARR_ON, 'C');
- putf(tp->t_state&TS_BUSY, 'B');
- putf(tp->t_state&TS_ASLEEP, 'A');
- putf(tp->t_state&TS_XCLUDE, 'X');
- putf(tp->t_state&TS_HUPCLS, 'H');
- printf("%6d", tp->t_pgrp);
- switch (tp->t_line) {
- case NTTYDISC:
- printf(" ntty");
+ case TABLDISC:
+ printf("tab\n");
break;
- case NETLDISC:
- printf(" net");
+ case SLIPDISC:
+ printf("slip\n");
break;
+
+ default:
+ printf("%d\n", tp->t_line);
}
- printf("\n");
}
dousr()
{
- struct user U;
+#ifdef notyet
+ register struct user *up;
register i, j, *ip;
+ register struct nameidata *nd = &U.u_nd;
+ struct proc *p;
- /* This wins only if PAGSIZ > sizeof (struct user) */
- lseek(fc, ubase * NBPG, 0);
- read(fc, &U, sizeof(U));
+ /* This wins only if CLBYTES >= sizeof (struct user) */
+ /* (WHICH IT ISN'T, but u. is going away - so who cares */
+ if (kvm_getprocs(KINFO_PROC_PID, upid) != 0) {
+ error("kvm_getproc: %s", kvm_geterr());
+ return (1);
+ }
+ if ((p = kvm_nextproc()); == NULL) {
+ error("kvm_nextproc: %s", kvm_geterr());
+ return (1);
+ }
+ if (up = kvm_getu(p)) == NULL) {
+ error("kvm_getu: %s", kvm_geterr());
+ return (1);
+ }
printf("pcb");
- ip = (int *)&U.u_pcb;
- while (ip < &U.u_arg[0]) {
- if ((ip - (int *)&U.u_pcb) % 4 == 0)
+ ip = (int *)&up->u_pcb;
+ while (ip < &up->u_arg[0]) {
+ if ((ip - (int *)&up->u_pcb) % 4 == 0)
printf("\t");
printf("%x ", *ip++);
- if ((ip - (int *)&U.u_pcb) % 4 == 0)
+ if ((ip - (int *)&up->u_pcb) % 4 == 0)
printf("\n");
}
- if ((ip - (int *)&U.u_pcb) % 4 != 0)
+ if ((ip - (int *)&up->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++) {
+ printf("arg");
+ for (i=0; i<sizeof(up->u_arg)/sizeof(up->u_arg[0]); i++) {
if (i%5==0)
printf("\t");
- printf("%9.1x", U.u_ssave.val[i]);
+ printf(" %.1x", up->u_arg[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("cdir rdir %.1x %.1x\n", U.u_cdir, U.u_rdir);
- 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++)
- printf("%9.1x", U.u_ofile[i]);
- printf("\n\t");
- for (i=10; i<NOFILE; i++)
- 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("segflg\t%d\nerror %d\n", nd->ni_segflg, up->u_error);
+ printf("uids\t%d,%d,%d,%d\n", up->u_uid,up->u_gid,up->u_ruid,up->u_rgid);
+ printf("procp\t%.1x\n", up->u_procp);
+ printf("ap\t%.1x\n", up->u_ap);
+ printf("r_val?\t%.1x %.1x\n", up->u_r.r_val1, up->u_r.r_val2);
+ printf("base, count, offset %.1x %.1x %ld\n", nd->ni_base,
+ nd->ni_count, nd->ni_offset);
+ printf("cdir rdir %.1x %.1x\n", up->u_cdir, up->u_rdir);
+ printf("dirp %.1x\n", nd->ni_dirp);
+ printf("dent %d %.14s\n", nd->ni_dent.d_ino, nd->ni_dent.d_name);
+ printf("dvp vp %.1x %.1x\n", nd->ni_dvp, nd->ni_vp);
+ printf("file");
+ for (i=0; i<NOFILE; i++) {
+ if (i % 8 == 0)
+ printf("\t");
+ printf("%9.1x", up->u_ofile[i]);
+ if (i % 8 == 7)
+ printf("\n");
+ }
+ if (i % 8)
+ printf("\n");
+ printf("pofile");
+ for (i=0; i<NOFILE; i++) {
+ if (i % 8 == 0)
+ printf("\t");
+ printf("%9.1x", up->u_pofile[i]);
+ if (i % 8 == 7)
+ printf("\n");
+ }
+ if (i % 8)
+ printf("\n");
printf("ssave");
for (i=0; i<sizeof(label_t)/sizeof(int); i++) {
if (i%5==0)
printf("\t");
- printf("%9.1x", U.u_ssave.val[i]);
+ printf("%9.1x", up->u_ssave.val[i]);
if (i%5==4)
printf("\n");
}
if (i%5)
printf("\n");
- printf("sigs\t");
- for (i=0; i<NSIG; i++)
- 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("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("cmask\t%D\n", U.u_cmask);
- printf("sizes\t%.1x %.1x %.1x\n", U.u_tsize, U.u_dsize, U.u_ssize);
+ printf("sigs");
+ for (i=0; i<NSIG; i++) {
+ if (i % 8 == 0)
+ printf("\t");
+ printf("%.1x ", up->u_signal[i]);
+ if (i % 8 == 7)
+ printf("\n");
+ }
+ if (i % 8)
+ printf("\n");
+ printf("code\t%.1x\n", up->u_code);
+ printf("ar0\t%.1x\n", up->u_ar0);
+ printf("prof\t%x %x %x %x\n", up->u_prof.pr_base, up->u_prof.pr_size,
+ up->u_prof.pr_off, up->u_prof.pr_scale);
+ printf("start\t%ld\n", up->u_start.tv_sec);
+ printf("acflag\t%ld\n", up->u_acflag);
+ printf("cmask\t%ld\n", up->u_cmask);
+ printf("sizes\t%.1x %.1x %.1x\n", up->u_tsize, up->u_dsize, up->u_ssize);
printf("ru\t");
- ip = (int *)&U.u_ru;
- for (i = 0; i < sizeof(U.u_ru)/sizeof(int); i++)
- printf("%D ", ip[i]);
+ ip = (int *)&up->u_ru;
+ for (i = 0; i < sizeof(up->u_ru)/sizeof(int); i++)
+ printf("%ld ", ip[i]);
printf("\n");
- ip = (int *)&U.u_cru;
+ ip = (int *)&up->u_cru;
printf("cru\t");
- for (i = 0; i < sizeof(U.u_cru)/sizeof(int); i++)
- printf("%D ", ip[i]);
+ for (i = 0; i < sizeof(up->u_cru)/sizeof(int); i++)
+ printf("%ld ", ip[i]);
printf("\n");
-/*
- i = U.u_stack - &U;
+#ifdef notdef
+ i = up->u_stack - &U;
while (U[++i] == 0);
i &= ~07;
while (i < 512) {
printf("%9x", U[i++]);
printf("\n");
}
-*/
+#endif
+#endif
}
oatoi(s)
static char *dtypes[] = { "???", "inode", "socket" };
nf = 0;
- nfile = getw(nl[SNFILE].n_value);
+ nfile = getword(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));
+ afile = (struct file *)getword(nl[SFIL].n_value);
+ if (nfile < 0 || nfile > 10000) {
+ fprintf(stderr, "number of files is preposterous (%d)\n",
+ nfile);
+ return;
+ }
+ if (xfile == NULL) {
+ fprintf(stderr, "can't allocate memory for file table\n");
+ return;
+ }
+ kvm_read(afile, xfile, nfile * sizeof (struct file));
for (fp=xfile; fp < &xfile[nfile]; fp++)
if (fp->f_count)
nf++;
if (fp->f_type <= DTYPE_SOCKET)
printf("%-8.8s", dtypes[fp->f_type]);
else
- printf("8d", fp->f_type);
+ printf("%8d", fp->f_type);
putf(fp->f_flag&FREAD, 'R');
putf(fp->f_flag&FWRITE, 'W');
putf(fp->f_flag&FAPPEND, 'A');
else
printf(" %ld\n", fp->f_offset);
}
+ free(xfile);
}
int dmmin, dmmax, nswdev;
register struct mapent *me;
register struct text *xp;
int i, j;
+ long rmalloc();
- nproc = getw(nl[SNPROC].n_value);
+ nproc = getword(nl[SNPROC].n_value);
+ ntext = getword(nl[SNTEXT].n_value);
+ if (nproc < 0 || nproc > 10000 || ntext < 0 || ntext > 10000) {
+ fprintf(stderr, "number of procs/texts is preposterous (%d, %d)\n",
+ nproc, ntext);
+ return;
+ }
proc = (struct proc *)calloc(nproc, sizeof (struct proc));
- ntext = getw(nl[SNTEXT].n_value);
+ if (proc == NULL) {
+ fprintf(stderr, "can't allocate memory for proc table\n");
+ exit(1);
+ }
xtext = (struct text *)calloc(ntext, sizeof (struct text));
- nswapmap = getw(nl[SNSWAPMAP].n_value);
+ if (xtext == NULL) {
+ fprintf(stderr, "can't allocate memory for text table\n");
+ exit(1);
+ }
+ nswapmap = getword(nl[SNSWAPMAP].n_value);
swapmap = (struct map *)calloc(nswapmap, sizeof (struct map));
- nswdev = getw(nl[SNSWDEV].n_value);
+ if (swapmap == NULL) {
+ fprintf(stderr, "can't allocate memory for swapmap\n");
+ exit(1);
+ }
+ nswdev = getword(nl[SNSWDEV].n_value);
swdevt = (struct swdevt *)calloc(nswdev, sizeof (struct swdevt));
- lseek(fc, nl[SSWDEVT].n_value, L_SET);
- read(fc, swdevt, nswdev * sizeof (struct swdevt));
- lseek(fc, getw(nl[SPROC].n_value), 0);
- read(fc, proc, nproc * sizeof (struct proc));
- lseek(fc, getw(nl[STEXT].n_value), 0);
- read(fc, xtext, ntext * sizeof (struct text));
- lseek(fc, getw(nl[SWAPMAP].n_value), 0);
- read(fc, swapmap, nswapmap * sizeof (struct map));
+ if (swdevt == NULL) {
+ fprintf(stderr, "can't allocate memory for swdevt table\n");
+ exit(1);
+ }
+ kvm_read(nl[SSWDEVT].n_value, swdevt, nswdev * sizeof (struct swdevt));
+ kvm_read(nl[SPROC].n_value, proc, nproc * sizeof (struct proc));
+ kvm_read(nl[STEXT].n_value, xtext, ntext * sizeof (struct text));
+ kvm_read(nl[SWAPMAP].n_value, swapmap, nswapmap * sizeof (struct map));
+
swapmap->m_name = "swap";
swapmap->m_limit = (struct mapent *)&swapmap[nswapmap];
- dmmin = getw(nl[SDMMIN].n_value);
- dmmax = getw(nl[SDMMAX].n_value);
+ dmmin = getword(nl[SDMMIN].n_value);
+ dmmax = getword(nl[SDMMAX].n_value);
nswap = 0;
for (sw = swdevt; sw < &swdevt[nswdev]; sw++)
- nswap += sw->sw_nblks,
+ if (sw->sw_freed)
+ nswap += sw->sw_nblks;
free = 0;
for (me = (struct mapent *)(swapmap+1);
me < (struct mapent *)&swapmap[nswapmap]; me++)
free += me->m_size;
tused = 0;
for (xp = xtext; xp < &xtext[ntext]; xp++)
- if (xp->x_iptr!=NULL) {
- tused += ctod(xp->x_size);
- if (xp->x_flag & XPAGI)
- tused += ctod(ctopt(xp->x_size));
+ if (xp->x_vptr!=NULL) {
+ tused += ctod(clrnd(xp->x_size));
+ if (xp->x_flag & XPAGV)
+ tused += ctod(clrnd(ctopt(xp->x_size)));
}
used = tused;
waste = 0;
used += sb;
waste += sb - db;
if ((pp->p_flag&SLOAD) == 0)
- used += vusize(pp);
+ used += ctod(vusize(pp));
}
if (totflg) {
#define btok(x) ((x) / (1024 / DEV_BSIZE))
badrmfree:
printf("bad rmfree\n");
}
+
+#include <varargs.h>
+
+error(va_alist)
+ va_dcl
+{
+ char *fmt;
+ va_list ap;
+ extern errno;
+
+ fprintf(stderr, "%s: ", Program);
+ va_start(ap);
+ fmt = va_arg(ap, char *);
+ (void) vfprintf(stderr, fmt, ap);
+ va_end(ap);
+ fprintf(stderr, "\n");
+}
+
+syserror(va_alist)
+ va_dcl
+{
+ char *fmt;
+ va_list ap;
+ extern errno;
+
+ fprintf(stderr, "%s: ", Program);
+ va_start(ap);
+ fmt = va_arg(ap, char *);
+ (void) vfprintf(stderr, fmt, ap);
+ va_end(ap);
+ fprintf(stderr, ": %s\n", strerror(errno));
+}