date and time created 92/02/29 12:43:13 by bostic
[unix-history] / usr / src / lib / libkvm / kvm_proc.c
index 5ac7266..79f5420 100644 (file)
@@ -6,32 +6,47 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)kvm_proc.c 5.12 (Berkeley) %G%";
+static char sccsid[] = "@(#)kvm_proc.c 5.21 (Berkeley) %G%";
 #endif /* LIBC_SCCS and not lint */
 
 #endif /* LIBC_SCCS and not lint */
 
-#include <machine/pte.h>
-#include <machine/vmparam.h>
 #include <sys/param.h>
 #include <sys/param.h>
-#include <sys/vmmac.h>
 #include <sys/user.h>
 #include <sys/proc.h>
 #include <sys/user.h>
 #include <sys/proc.h>
-#include <sys/text.h>
 #include <sys/ioctl.h>
 #include <sys/kinfo.h>
 #include <sys/tty.h>
 #include <sys/ioctl.h>
 #include <sys/kinfo.h>
 #include <sys/tty.h>
+#include <machine/vmparam.h>
 #include <fcntl.h>
 #include <fcntl.h>
-#include <kvm.h>
 #include <nlist.h>
 #include <nlist.h>
+#include <kvm.h>
 #include <ndbm.h>
 #include <limits.h>
 #include <paths.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <ndbm.h>
 #include <limits.h>
 #include <paths.h>
 #include <stdio.h>
 #include <string.h>
 
+#ifdef SPPWAIT
+#define NEWVM
+#endif
+
+#ifdef NEWVM
+#define        btop(x)         (((unsigned)(x)) >> PGSHIFT)    /* XXX */
+#define        ptob(x)         ((caddr_t)((x) << PGSHIFT))     /* XXX */
+#include <vm/vm.h>     /* ??? kinfo_proc currently includes this*/
+#include <sys/kinfo_proc.h>
+#ifdef hp300
+#include <hp300/hp300/pte.h>
+#endif
+#else /* NEWVM */
+#include <machine/pte.h>
+#include <sys/vmmac.h>
+#include <sys/text.h>
+#endif /* NEWVM */
+
 /*
  * files
  */
 /*
  * files
  */
-static char *unixf, *memf, *kmemf, *swapf;
+static const char *unixf, *memf, *kmemf, *swapf;
 static int unixx, mem, kmem, swap;
 static DBM *db;
 /*
 static int unixx, mem, kmem, swap;
 static DBM *db;
 /*
@@ -55,10 +70,12 @@ static union {
 /*
  * random other stuff
  */
 /*
  * random other stuff
  */
+#ifndef NEWVM
 static struct pte *Usrptmap, *usrpt;
 static struct pte *Usrptmap, *usrpt;
-static int     dmmin, dmmax;
 static struct  pte *Sysmap;
 static int     Syssize;
 static struct  pte *Sysmap;
 static int     Syssize;
+#endif
+static int     dmmin, dmmax;
 static int     pcbpf;
 static int     argaddr0;       /* XXX */
 static int     argaddr1;
 static int     pcbpf;
 static int     argaddr0;       /* XXX */
 static int     argaddr1;
@@ -66,6 +83,7 @@ static        int     nswap;
 static char    *tmp;
 #if defined(hp300)
 static int     lowram;
 static char    *tmp;
 #if defined(hp300)
 static int     lowram;
+static struct ste *Sysseg;
 #endif
 
 #define basename(cp)   ((tmp=rindex((cp), '/')) ? tmp+1 : (cp))
 #endif
 
 #define basename(cp)   ((tmp=rindex((cp), '/')) ? tmp+1 : (cp))
@@ -80,49 +98,48 @@ static      int     lowram;
 #define pftoc(f)       (f)
 #endif
 #ifndef iskva
 #define pftoc(f)       (f)
 #endif
 #ifndef iskva
-#define iskva(v)       ((v) & KERNBASE)
+#define iskva(v)       ((u_long)(v) & KERNBASE)
 #endif
 
 static struct nlist nl[] = {
 #endif
 
 static struct nlist nl[] = {
-       { "_Usrptmap" },
-#define        X_USRPTMAP      0
-       { "_usrpt" },
-#define        X_USRPT         1
        { "_nswap" },
        { "_nswap" },
-#define        X_NSWAP         2
+#define        X_NSWAP         0
        { "_dmmin" },
        { "_dmmin" },
-#define        X_DMMIN         3
+#define        X_DMMIN         X_NSWAP+1
        { "_dmmax" },
        { "_dmmax" },
-#define        X_DMMAX         4
+#define        X_DMMAX         X_DMMIN+1
        /*
         * everything here and down, only if a dead kernel
         */
        { "_Sysmap" },
        /*
         * everything here and down, only if a dead kernel
         */
        { "_Sysmap" },
-#define        X_SYSMAP        5
+#define        X_SYSMAP        X_DMMAX+1
 #define        X_DEADKERNEL    X_SYSMAP
 #define        X_DEADKERNEL    X_SYSMAP
-       { "_Syssize" },
-#define        X_SYSSIZE       6
        { "_allproc" },
        { "_allproc" },
-#define X_ALLPROC      7
+#define X_ALLPROC      X_SYSMAP+1
        { "_zombproc" },
        { "_zombproc" },
-#define X_ZOMBPROC     8
-       { "_nproc" },
-#define        X_NPROC         9
-#define        X_LAST          9
+#define X_ZOMBPROC     X_ALLPROC+1
+       { "_nprocs" },
+#define        X_NPROCS        X_ZOMBPROC+1
 #if defined(hp300)
 #if defined(hp300)
+       { "_Sysseg" },
+#define        X_SYSSEG        (X_NPROCS+1)
        { "_lowram" },
        { "_lowram" },
-#define        X_LOWRAM        (X_LAST+1)
+#define        X_LOWRAM        (X_SYSSEG+1)
 #endif
        { "" },
 };
 
 #endif
        { "" },
 };
 
+static off_t vtophys();
+static void seterr(), setsyserr(), vstodb();
+static int getkvars(), kvm_doprocs(), kvm_init(), klseek();
+
 /*
  * returns     0 if files were opened now,
  *             1 if files were already opened,
  *             -1 if files could not be opened.
  */
 kvm_openfiles(uf, mf, sf)
 /*
  * returns     0 if files were opened now,
  *             1 if files were already opened,
  *             -1 if files could not be opened.
  */
 kvm_openfiles(uf, mf, sf)
-       char *uf, *mf, *sf; 
+       const char *uf, *mf, *sf; 
 {
        if (kvmfilesopen)
                return (1);
 {
        if (kvmfilesopen)
                return (1);
@@ -211,10 +228,12 @@ kvm_close()
        kvminit = 0;
        kvmfilesopen = 0;
        deadkernel = 0;
        kvminit = 0;
        kvmfilesopen = 0;
        deadkernel = 0;
+#ifndef NEWVM
        if (Sysmap) {
                free(Sysmap);
                Sysmap = NULL;
        }
        if (Sysmap) {
                free(Sysmap);
                Sysmap = NULL;
        }
+#endif
 }
 
 kvm_nlist(nl)
 }
 
 kvm_nlist(nl)
@@ -293,7 +312,7 @@ win:
                 * query db
                 */
                if ((len = strlen(n->n_name)) > MAXSYMSIZE) {
                 * query db
                 */
                if ((len = strlen(n->n_name)) > MAXSYMSIZE) {
-                       seterr("kvm_nlist: symbol too large");
+                       seterr("symbol too large");
                        return (-1);
                }
                (void)strcpy(symbuf, n->n_name);
                        return (-1);
                }
                (void)strcpy(symbuf, n->n_name);
@@ -313,10 +332,14 @@ hard1:
        dbm_close(db);
        db = NULL;
 hard2:
        dbm_close(db);
        db = NULL;
 hard2:
-       return (nlist(unixf, nl));      /* XXX seterr if -1 */
+       num = nlist(unixf, nl);
+       if (num == -1)
+               seterr("nlist (hard way) failed");
+       return (num);
 }
 
 kvm_getprocs(what, arg)
 }
 
 kvm_getprocs(what, arg)
+       int what, arg;
 {
        if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1)
                return (NULL);
 {
        if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1)
                return (NULL);
@@ -339,23 +362,23 @@ kvm_getprocs(what, arg)
                        return (-1);
                }
                if (copysize % sizeof (struct kinfo_proc)) {
                        return (-1);
                }
                if (copysize % sizeof (struct kinfo_proc)) {
-                       seterr("proc size mismatch (kinfo_proc: %d)",
-                               sizeof (struct kinfo_proc));
+                       seterr("proc size mismatch (got %d total, kinfo_proc: %d)",
+                               copysize, sizeof (struct kinfo_proc));
                        return (-1);
                }
                kvmnprocs = copysize / sizeof (struct kinfo_proc);
        } else {
                        return (-1);
                }
                kvmnprocs = copysize / sizeof (struct kinfo_proc);
        } else {
-               int nproc;
+               int nprocs;
 
 
-               if (kvm_read(nl[X_NPROC].n_value, &nproc, sizeof (int)) !=
-                   sizeof (int)) {
+               if (kvm_read((void *)nl[X_NPROCS].n_value, &nprocs,
+                   sizeof (int)) != sizeof (int)) {
                        seterr("can't read nproc");
                        return (-1);
                }
                if ((kvmprocbase = (struct kinfo_proc *)
                        seterr("can't read nproc");
                        return (-1);
                }
                if ((kvmprocbase = (struct kinfo_proc *)
-                    malloc(nproc * sizeof (struct kinfo_proc))) == NULL) {
-                       seterr("out of memory (addr: %x nproc = %d)",
-                               nl[X_NPROC].n_value, nproc);
+                    malloc(nprocs * sizeof (struct kinfo_proc))) == NULL) {
+                       seterr("out of memory (addr: %x nprocs = %d)",
+                               nl[X_NPROCS].n_value, nprocs);
                        return (-1);
                }
                kvmnprocs = kvm_doprocs(what, arg, kvmprocbase);
                        return (-1);
                }
                kvmnprocs = kvm_doprocs(what, arg, kvmprocbase);
@@ -385,10 +408,12 @@ kvm_doprocs(what, arg, buff)
        struct pgrp pgrp;
        struct session sess;
        struct tty tty;
        struct pgrp pgrp;
        struct session sess;
        struct tty tty;
+#ifndef NEWVM
        struct text text;
        struct text text;
+#endif
 
        /* allproc */
 
        /* allproc */
-       if (kvm_read(nl[X_ALLPROC].n_value, &p, 
+       if (kvm_read((void *) nl[X_ALLPROC].n_value, &p, 
            sizeof (struct proc *)) != sizeof (struct proc *)) {
                seterr("can't read allproc");
                return (-1);
            sizeof (struct proc *)) != sizeof (struct proc *)) {
                seterr("can't read allproc");
                return (-1);
@@ -401,6 +426,30 @@ again:
                        seterr("can't read proc at %x", p);
                        return (-1);
                }
                        seterr("can't read proc at %x", p);
                        return (-1);
                }
+#ifdef NEWVM
+               if (kvm_read(proc.p_cred, &eproc.e_pcred,
+                   sizeof (struct pcred)) == sizeof (struct pcred))
+                       (void) kvm_read(eproc.e_pcred.pc_ucred, &eproc.e_ucred,
+                           sizeof (struct ucred));
+               switch(ki_op(what)) {
+                       
+               case KINFO_PROC_PID:
+                       if (proc.p_pid != (pid_t)arg)
+                               continue;
+                       break;
+
+
+               case KINFO_PROC_UID:
+                       if (eproc.e_ucred.cr_uid != (uid_t)arg)
+                               continue;
+                       break;
+
+               case KINFO_PROC_RUID:
+                       if (eproc.e_pcred.p_ruid != (uid_t)arg)
+                               continue;
+                       break;
+               }
+#else
                switch(ki_op(what)) {
                        
                case KINFO_PROC_PID:
                switch(ki_op(what)) {
                        
                case KINFO_PROC_PID:
@@ -419,6 +468,7 @@ again:
                                continue;
                        break;
                }
                                continue;
                        break;
                }
+#endif
                /*
                 * gather eproc
                 */
                /*
                 * gather eproc
                 */
@@ -456,8 +506,17 @@ again:
                                eproc.e_tpgid = -1;
                } else
                        eproc.e_tdev = NODEV;
                                eproc.e_tpgid = -1;
                } else
                        eproc.e_tdev = NODEV;
+               eproc.e_flag = sess.s_ttyvp ? EPROC_CTTY : 0;
+               if (sess.s_leader == p)
+                       eproc.e_flag |= EPROC_SLEADER;
                if (proc.p_wmesg)
                        kvm_read(proc.p_wmesg, eproc.e_wmesg, WMESGLEN);
                if (proc.p_wmesg)
                        kvm_read(proc.p_wmesg, eproc.e_wmesg, WMESGLEN);
+#ifdef NEWVM
+               (void) kvm_read(proc.p_vmspace, &eproc.e_vm,
+                   sizeof (struct vmspace));
+               eproc.e_xsize = eproc.e_xrssize =
+                       eproc.e_xccount = eproc.e_xswrss = 0;
+#else
                if (proc.p_textp) {
                        kvm_read(proc.p_textp, &text, sizeof (text));
                        eproc.e_xsize = text.x_size;
                if (proc.p_textp) {
                        kvm_read(proc.p_textp, &text, sizeof (text));
                        eproc.e_xsize = text.x_size;
@@ -468,6 +527,7 @@ again:
                        eproc.e_xsize = eproc.e_xrssize =
                          eproc.e_xccount = eproc.e_xswrss = 0;
                }
                        eproc.e_xsize = eproc.e_xrssize =
                          eproc.e_xccount = eproc.e_xswrss = 0;
                }
+#endif
 
                switch(ki_op(what)) {
 
 
                switch(ki_op(what)) {
 
@@ -491,7 +551,7 @@ again:
        }
        if (!doingzomb) {
                /* zombproc */
        }
        if (!doingzomb) {
                /* zombproc */
-               if (kvm_read(nl[X_ZOMBPROC].n_value, &p, 
+               if (kvm_read((void *) nl[X_ZOMBPROC].n_value, &p, 
                    sizeof (struct proc *)) != sizeof (struct proc *)) {
                        seterr("can't read zombproc");
                        return (-1);
                    sizeof (struct proc *)) != sizeof (struct proc *)) {
                        seterr("can't read zombproc");
                        return (-1);
@@ -518,14 +578,13 @@ kvm_nextproc()
 
 struct eproc *
 kvm_geteproc(p)
 
 struct eproc *
 kvm_geteproc(p)
-       struct proc *p;
+       const struct proc *p;
 {
        return ((struct eproc *)(((char *)p) + sizeof (struct proc)));
 }
 
 kvm_setproc()
 {
 {
        return ((struct eproc *)(((char *)p) + sizeof (struct proc)));
 }
 
 kvm_setproc()
 {
-
        kvmprocptr = kvmprocbase;
 }
 
        kvmprocptr = kvmprocbase;
 }
 
@@ -538,9 +597,64 @@ kvm_freeprocs()
        }
 }
 
        }
 }
 
+#ifdef NEWVM
 struct user *
 kvm_getu(p)
 struct user *
 kvm_getu(p)
-       struct proc *p;
+       const struct proc *p;
+{
+       register struct kinfo_proc *kp = (struct kinfo_proc *)p;
+       register int i;
+       register char *up;
+
+       if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1)
+               return (NULL);
+       if (p->p_stat == SZOMB) {
+               seterr("zombie process");
+               return (NULL);
+       }
+       /*
+        * Read u-area one page at a time for the benefit of post-mortems
+        */
+       up = (char *) p->p_addr;
+       for (i = 0; i < UPAGES; i++) {
+               if (klseek(kmem, (long)up, 0) == -1)
+                       return (NULL);
+               if (read(kmem, user.upages[i], CLBYTES) != CLBYTES) {
+                       seterr("cant read page %x of u of pid %d from %s",
+                           up, p->p_pid, kmemf);
+                       return(NULL);
+               }
+               up += CLBYTES;
+       }
+       pcbpf = (int) btop(p->p_addr);  /* what should this be really? */
+       /*
+        * Conjure up a physical address for the arguments.
+        */
+       argaddr0 = argaddr1 = 0;
+#ifdef hp300
+       if (kp->kp_eproc.e_vm.vm_pmap.pm_ptab) {
+               struct pte pte[CLSIZE*2];
+
+               if (klseek(kmem,
+                   (long)&kp->kp_eproc.e_vm.vm_pmap.pm_ptab
+                   [btoc(USRSTACK-CLBYTES*2)], 0) == -1)
+                       return (NULL);
+               if (read(kmem, (char *)&pte, sizeof(pte)) == sizeof(pte)) {
+#if CLBYTES < 2048
+                       argaddr0 = ctob(pftoc(pte[CLSIZE*0].pg_pfnum));
+#endif
+                       argaddr1 = ctob(pftoc(pte[CLSIZE*1].pg_pfnum));
+               }
+       }
+       kp->kp_eproc.e_vm.vm_rssize =
+           kp->kp_eproc.e_vm.vm_pmap.pm_stats.resident_count; /* XXX */
+#endif
+       return(&user.user);
+}
+#else
+struct user *
+kvm_getu(p)
+       const struct proc *p;
 {
        struct pte *pteaddr, apte;
        struct pte arguutl[HIGHPAGES+(CLSIZE*2)];
 {
        struct pte *pteaddr, apte;
        struct pte arguutl[HIGHPAGES+(CLSIZE*2)];
@@ -561,7 +675,7 @@ kvm_getu(p)
                (void) lseek(swap, (long)dtob(p->p_swaddr), 0);
                if (read(swap, (char *)&user.user, sizeof (struct user)) != 
                    sizeof (struct user)) {
                (void) lseek(swap, (long)dtob(p->p_swaddr), 0);
                if (read(swap, (char *)&user.user, sizeof (struct user)) != 
                    sizeof (struct user)) {
-                       seterr("can't read u for pid %d from %s\n",
+                       seterr("can't read u for pid %d from %s",
                            p->p_pid, swapf);
                        return (NULL);
                }
                            p->p_pid, swapf);
                        return (NULL);
                }
@@ -571,7 +685,8 @@ kvm_getu(p)
                return (&user.user);
        }
        pteaddr = &Usrptmap[btokmx(p->p_p0br) + p->p_szpt - 1];
                return (&user.user);
        }
        pteaddr = &Usrptmap[btokmx(p->p_p0br) + p->p_szpt - 1];
-       klseek(kmem, (long)pteaddr, 0);
+       if (klseek(kmem, (long)pteaddr, 0) == -1)
+               return -1;
        if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) {
                seterr("can't read indir pte to get u for pid %d from %s",
                    p->p_pid, kmemf);
        if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) {
                seterr("can't read indir pte to get u for pid %d from %s",
                    p->p_pid, kmemf);
@@ -605,13 +720,14 @@ kvm_getu(p)
        }
        return (&user.user);
 }
        }
        return (&user.user);
 }
+#endif
 
 char *
 kvm_getargs(p, up)
 
 char *
 kvm_getargs(p, up)
-       struct proc *p;
-       struct user *up;
+       const struct proc *p;
+       const struct user *up;
 {
 {
-       char cmdbuf[CLBYTES*2];
+       static char cmdbuf[CLBYTES*2];
        union {
                char    argc[CLBYTES*2];
                int     argi[CLBYTES*2/sizeof (int)];
        union {
                char    argc[CLBYTES*2];
                int     argi[CLBYTES*2/sizeof (int)];
@@ -620,12 +736,21 @@ kvm_getargs(p, up)
        register int *ip;
        char c;
        int nbad;
        register int *ip;
        char c;
        int nbad;
+#ifndef NEWVM
        struct dblock db;
        struct dblock db;
-       char *file;
+#endif
+       const char *file;
+       int stkoff = 0;
 
 
+#if defined(NEWVM) && defined(hp300)
+       stkoff = 20;                    /* XXX for sigcode */
+#endif
        if (up == NULL || p->p_pid == 0 || p->p_pid == 2)
                goto retucomm;
        if ((p->p_flag & SLOAD) == 0 || argaddr1 == 0) {
        if (up == NULL || p->p_pid == 0 || p->p_pid == 2)
                goto retucomm;
        if ((p->p_flag & SLOAD) == 0 || argaddr1 == 0) {
+#ifdef NEWVM
+               goto retucomm;  /* XXX for now */
+#else
                if (swap < 0 || p->p_ssize == 0)
                        goto retucomm;
                vstodb(0, CLSIZE, &up->u_smap, &db, 1);
                if (swap < 0 || p->p_ssize == 0)
                        goto retucomm;
                vstodb(0, CLSIZE, &up->u_smap, &db, 1);
@@ -638,6 +763,7 @@ kvm_getargs(p, up)
                if (read(swap, (char *)&argspac.argc[0], CLBYTES) != CLBYTES)
                        goto bad;
                file = swapf;
                if (read(swap, (char *)&argspac.argc[0], CLBYTES) != CLBYTES)
                        goto bad;
                file = swapf;
+#endif
        } else {
                if (argaddr0) {
                        lseek(mem, (long)argaddr0, 0);
        } else {
                if (argaddr0) {
                        lseek(mem, (long)argaddr0, 0);
@@ -648,10 +774,11 @@ kvm_getargs(p, up)
                lseek(mem, (long)argaddr1, 0);
                if (read(mem, &argspac.argc[CLBYTES], CLBYTES) != CLBYTES)
                        goto bad;
                lseek(mem, (long)argaddr1, 0);
                if (read(mem, &argspac.argc[CLBYTES], CLBYTES) != CLBYTES)
                        goto bad;
-               file = memf;
+               file = (char *) memf;
        }
        ip = &argspac.argi[CLBYTES*2/sizeof (int)];
        }
        ip = &argspac.argi[CLBYTES*2/sizeof (int)];
-       ip -= 2;                /* last arg word and .long 0 */
+       ip -= 2;                /* last arg word and .long 0 */
+       ip -= stkoff / sizeof (int);
        while (*--ip) {
                if (ip == argspac.argi)
                        goto retucomm;
        while (*--ip) {
                if (ip == argspac.argi)
                        goto retucomm;
@@ -659,7 +786,7 @@ kvm_getargs(p, up)
        *(char *)ip = ' ';
        ip++;
        nbad = 0;
        *(char *)ip = ' ';
        ip++;
        nbad = 0;
-       for (cp = (char *)ip; cp < &argspac.argc[CLBYTES*2]; cp++) {
+       for (cp = (char *)ip; cp < &argspac.argc[CLBYTES*2-stkoff]; cp++) {
                c = *cp & 0177;
                if (c == 0)
                        *cp = ' ';
                c = *cp & 0177;
                if (c == 0)
                        *cp = ' ';
@@ -689,7 +816,7 @@ kvm_getargs(p, up)
        return (cmdbuf);
 
 bad:
        return (cmdbuf);
 
 bad:
-       seterr("error locating command name for pid %d from %s\n",
+       seterr("error locating command name for pid %d from %s",
            p->p_pid, file);
 retucomm:
        (void) strcpy(cmdbuf, " (");
            p->p_pid, file);
 retucomm:
        (void) strcpy(cmdbuf, " (");
@@ -702,28 +829,16 @@ retucomm:
 static
 getkvars()
 {
 static
 getkvars()
 {
+       int ret;
+       static nlisterr();
 
 
-       if (kvm_nlist(nl) == -1)
+       if ((ret = kvm_nlist(nl)) == -1)
                return (-1);
                return (-1);
+       else if (ret > 0)
+               nlisterr(nl);
        if (deadkernel) {
                /* We must do the sys map first because klseek uses it */
                long    addr;
        if (deadkernel) {
                /* We must do the sys map first because klseek uses it */
                long    addr;
-
-               Syssize = nl[X_SYSSIZE].n_value;
-               Sysmap = (struct pte *)
-                       calloc((unsigned) Syssize, sizeof (struct pte));
-               if (Sysmap == NULL) {
-                       seterr("out of space for Sysmap");
-                       return (-1);
-               }
-               addr = (long) nl[X_SYSMAP].n_value;
-               addr &= ~KERNBASE;
-               (void) lseek(kmem, addr, 0);
-               if (read(kmem, (char *) Sysmap, Syssize * sizeof (struct pte))
-                   != Syssize * sizeof (struct pte)) {
-                       seterr("can't read Sysmap");
-                       return (-1);
-               }
 #if defined(hp300)
                addr = (long) nl[X_LOWRAM].n_value;
                (void) lseek(kmem, addr, 0);
 #if defined(hp300)
                addr = (long) nl[X_LOWRAM].n_value;
                (void) lseek(kmem, addr, 0);
@@ -733,21 +848,32 @@ getkvars()
                        return (-1);
                }
                lowram = btop(lowram);
                        return (-1);
                }
                lowram = btop(lowram);
+               Sysseg = (struct ste *) malloc(NBPG);
+               if (Sysseg == NULL) {
+                       seterr("out of space for Sysseg");
+                       return (-1);
+               }
+               addr = (long) nl[X_SYSSEG].n_value;
+               (void) lseek(kmem, addr, 0);
+               read(kmem, (char *)&addr, sizeof(addr));
+               (void) lseek(kmem, (long)addr, 0);
+               if (read(kmem, (char *) Sysseg, NBPG) != NBPG) {
+                       seterr("can't read Sysseg");
+                       return (-1);
+               }
 #endif
        }
 #endif
        }
-       usrpt = (struct pte *)nl[X_USRPT].n_value;
-       Usrptmap = (struct pte *)nl[X_USRPTMAP].n_value;
-       if (kvm_read((long)nl[X_NSWAP].n_value, &nswap, sizeof (long)) !=
+       if (kvm_read((void *) nl[X_NSWAP].n_value, &nswap, sizeof (long)) !=
            sizeof (long)) {
                seterr("can't read nswap");
                return (-1);
        }
            sizeof (long)) {
                seterr("can't read nswap");
                return (-1);
        }
-       if (kvm_read((long)nl[X_DMMIN].n_value, &dmmin, sizeof (long)) !=
+       if (kvm_read((void *) nl[X_DMMIN].n_value, &dmmin, sizeof (long)) !=
            sizeof (long)) {
                seterr("can't read dmmin");
                return (-1);
        }
            sizeof (long)) {
                seterr("can't read dmmin");
                return (-1);
        }
-       if (kvm_read((long)nl[X_DMMAX].n_value, &dmmax, sizeof (long)) !=
+       if (kvm_read((void *) nl[X_DMMAX].n_value, &dmmax, sizeof (long)) !=
            sizeof (long)) {
                seterr("can't read dmmax");
                return (-1);
            sizeof (long)) {
                seterr("can't read dmmax");
                return (-1);
@@ -755,22 +881,37 @@ getkvars()
        return (0);
 }
 
        return (0);
 }
 
+static
+nlisterr(nl)
+       struct nlist nl[];
+{
+       int i;
+
+       fprintf(stderr, "kvm_nlist: can't find following names:");
+       for (i = 0; nl[i].n_name[0] != '\0'; i++)
+               if (nl[i].n_value == 0)
+                       fprintf(stderr, " %s", nl[i].n_name);
+       fprintf(stderr, ": continuing...\n");
+}
+
+
 kvm_read(loc, buf, len)
 kvm_read(loc, buf, len)
-       unsigned long loc;
-       char *buf;
+       void *loc;
+       void *buf;
 {
        if (kvmfilesopen == 0 && kvm_openfiles(NULL, NULL, NULL) == -1)
                return (-1);
        if (iskva(loc)) {
 {
        if (kvmfilesopen == 0 && kvm_openfiles(NULL, NULL, NULL) == -1)
                return (-1);
        if (iskva(loc)) {
-               klseek(kmem, loc, 0);
+               if (klseek(kmem, (off_t) loc, 0) == -1)
+                       return -1;
                if (read(kmem, buf, len) != len) {
                if (read(kmem, buf, len) != len) {
-                       seterr("error reading kmem at %x\n", loc);
+                       seterr("error reading kmem at %x", loc);
                        return (-1);
                }
        } else {
                        return (-1);
                }
        } else {
-               lseek(mem, loc, 0);
+               lseek(mem, (off_t) loc, 0);
                if (read(mem, buf, len) != len) {
                if (read(mem, buf, len) != len) {
-                       seterr("error reading mem at %x\n", loc);
+                       seterr("error reading mem at %x", loc);
                        return (-1);
                }
        }
                        return (-1);
                }
        }
@@ -785,20 +926,20 @@ klseek(fd, loc, off)
 {
 
        if (deadkernel) {
 {
 
        if (deadkernel) {
-               off_t vtophys();
-
                if ((loc = vtophys(loc)) == -1)
                if ((loc = vtophys(loc)) == -1)
-                       return;
+                       return -1;
        }
        }
-       (void) lseek(fd, (off_t)loc, off);
+       (void)lseek(fd, (off_t)loc, off);
+       return (0);
 }
 
 }
 
+#ifndef NEWVM
 /*
  * Given a base/size pair in virtual swap area,
  * return a physical base/size pair which is the
  * (largest) initial, physically contiguous block.
  */
 /*
  * Given a base/size pair in virtual swap area,
  * return a physical base/size pair which is the
  * (largest) initial, physically contiguous block.
  */
-static
+static void
 vstodb(vsbase, vssize, dmp, dbp, rev)
        register int vsbase;
        int vssize;
 vstodb(vsbase, vssize, dmp, dbp, rev)
        register int vsbase;
        int vssize;
@@ -823,7 +964,39 @@ vstodb(vsbase, vssize, dmp, dbp, rev)
        dbp->db_size = MIN(vssize, blk - vsbase);
        dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
 }
        dbp->db_size = MIN(vssize, blk - vsbase);
        dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
 }
+#endif
+
+#ifdef NEWVM
+static off_t
+vtophys(loc)
+       long    loc;
+{
+       off_t newloc = (off_t) -1;
+#ifdef hp300
+       int p, ste, pte;
 
 
+       ste = *(int *)&Sysseg[loc >> SG_ISHIFT];
+       if ((ste & SG_V) == 0) {
+               seterr("vtophys: segment not valid (%x)", ste);
+               return((off_t) -1);
+       }
+       p = btop(loc & SG_PMASK);
+       newloc = (ste & SG_FRAME) + (p * sizeof(struct pte));
+       (void) lseek(kmem, (long)(newloc-(off_t)ptob(lowram)), 0);
+       if (read(kmem, (char *)&pte, sizeof pte) != sizeof pte) {
+               seterr("vtophys: cannot locate pte");
+               return((off_t) -1);
+       }
+       newloc = pte & PG_FRAME;
+       if (pte == PG_NV || newloc < (off_t)ptob(lowram)) {
+               seterr("vtophys: page not valid");
+               return((off_t) -1);
+       }
+       newloc = (newloc - (off_t)ptob(lowram)) + (loc & PGOFSET);
+#endif
+       return((off_t) newloc);
+}
+#else
 static off_t
 vtophys(loc)
        long loc;
 static off_t
 vtophys(loc)
        long loc;
@@ -858,11 +1031,12 @@ vtophys(loc)
        loc = (long) (ptob(pftoc(pte->pg_pfnum)) + (loc & PGOFSET));
        return(loc);
 }
        loc = (long) (ptob(pftoc(pte->pg_pfnum)) + (loc & PGOFSET));
        return(loc);
 }
+#endif
 
 #include <varargs.h>
 static char errbuf[_POSIX2_LINE_MAX];
 
 
 #include <varargs.h>
 static char errbuf[_POSIX2_LINE_MAX];
 
-static
+static void
 seterr(va_alist)
        va_dcl
 {
 seterr(va_alist)
        va_dcl
 {
@@ -871,11 +1045,11 @@ seterr(va_alist)
 
        va_start(ap);
        fmt = va_arg(ap, char *);
 
        va_start(ap);
        fmt = va_arg(ap, char *);
-       (void) vsprintf(errbuf, fmt, ap);
+       (void) vsnprintf(errbuf, _POSIX2_LINE_MAX, fmt, ap);
        va_end(ap);
 }
 
        va_end(ap);
 }
 
-static
+static void
 setsyserr(va_alist)
        va_dcl
 {
 setsyserr(va_alist)
        va_dcl
 {
@@ -885,10 +1059,10 @@ setsyserr(va_alist)
 
        va_start(ap);
        fmt = va_arg(ap, char *);
 
        va_start(ap);
        fmt = va_arg(ap, char *);
-       (void) vsprintf(errbuf, fmt, ap);
+       (void) vsnprintf(errbuf, _POSIX2_LINE_MAX, fmt, ap);
        for (cp=errbuf; *cp; cp++)
                ;
        for (cp=errbuf; *cp; cp++)
                ;
-       sprintf(cp, ": %s", strerror(errno));
+       snprintf(cp, _POSIX2_LINE_MAX - (cp - errbuf), ": %s", strerror(errno));
        va_end(ap);
 }
 
        va_end(ap);
 }