Home | History | Annotate | Line # | Download | only in libkvm
kvm.c revision 1.26
      1 /*-
      2  * Copyright (c) 1994 Charles Hannum.
      3  * Copyright (c) 1993 Christopher G. Demetriou
      4  * Copyright (c) 1989 The Regents of the University of California.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *	This product includes software developed by the University of
     18  *	California, Berkeley and its contributors.
     19  * 4. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  */
     35 
     36 #if defined(LIBC_SCCS) && !defined(lint)
     37 /*static char sccsid[] = "from: @(#)kvm.c	5.18 (Berkeley) 5/7/91";*/
     38 static char rcsid[] = "$Id: kvm.c,v 1.26 1994/02/14 13:46:01 pk Exp $";
     39 #endif /* LIBC_SCCS and not lint */
     40 
     41 #include <sys/param.h>
     42 #include <sys/user.h>
     43 #include <sys/proc.h>
     44 #include <sys/ioctl.h>
     45 #include <sys/kinfo.h>
     46 #include <sys/tty.h>
     47 #include <sys/exec.h>
     48 #include <machine/vmparam.h>
     49 #include <fcntl.h>
     50 #include <nlist.h>
     51 #include <kvm.h>
     52 #include <ndbm.h>
     53 #include <limits.h>
     54 #include <paths.h>
     55 #include <stdio.h>
     56 #include <string.h>
     57 
     58 #define	btop(x)		(((unsigned)(x)) >> PGSHIFT)	/* XXX */
     59 #define	ptob(x)		((caddr_t)((x) << PGSHIFT))	/* XXX */
     60 #include <vm/vm.h>	/* ??? kinfo_proc currently includes this*/
     61 #include <vm/vm_page.h>
     62 #include <vm/swap_pager.h>
     63 #include <sys/kinfo_proc.h>
     64 #if defined(m68k)
     65 #include <machine/pte.h>
     66 #define	btos(x)		(((unsigned)(x)) >> SEGSHIFT)	/* XXX */
     67 #endif
     68 
     69 /*
     70  * files
     71  */
     72 static	const char *unixf, *memf, *kmemf, *swapf;
     73 static	int unixx, mem, kmem, swap;
     74 static	DBM *db;
     75 /*
     76  * flags
     77  */
     78 static	int deadkernel;
     79 static	int kvminit = 0;
     80 static	int kvmfilesopen = 0;
     81 /*
     82  * state
     83  */
     84 static	struct kinfo_proc *kvmprocbase, *kvmprocptr;
     85 static	int kvmnprocs;
     86 /*
     87  * u. buffer
     88  */
     89 static union {
     90 	struct	user user;
     91 	char	upages[UPAGES][NBPG];
     92 } user;
     93 
     94 struct swapblk {
     95 	long	offset;		/* offset in swap device */
     96 	long	size;		/* remaining size of block in swap device */
     97 };
     98 
     99 /*
    100  * random other stuff
    101  */
    102 static	int	dmmin, dmmax;
    103 static	int	pcbpf;
    104 static	int	nswap;
    105 static	long	vm_page_hash_mask;
    106 static	long	vm_page_buckets;
    107 static	long	page_shift;
    108 static	char	*tmp;
    109 #if defined(m68k)
    110 #if defined(amiga)
    111 static  int	cpu040;
    112 #endif
    113 static	int	lowram;
    114 static	struct ste *Sysseg;
    115 #endif
    116 #if defined(i386)
    117 static	struct pde *PTD;
    118 #endif
    119 
    120 #define atop(x)		(((unsigned)(x)) >> page_shift)
    121 #define vm_page_hash(object, offset) \
    122         (((unsigned)object+(unsigned)atop(offset))&vm_page_hash_mask)
    123 
    124 #define basename(cp)	((tmp=rindex((cp), '/')) ? tmp+1 : (cp))
    125 #define	MAXSYMSIZE	256
    126 
    127 static struct nlist nl[] = {
    128 	{ "_Usrptmap" },
    129 #define	X_USRPTMAP	0
    130 	{ "_usrpt" },
    131 #define	X_USRPT		1
    132 	{ "_nswap" },
    133 #define	X_NSWAP		2
    134 	{ "_dmmin" },
    135 #define	X_DMMIN		3
    136 	{ "_dmmax" },
    137 #define	X_DMMAX		4
    138 	{ "_vm_page_buckets" },
    139 #define X_VM_PAGE_BUCKETS	5
    140 	{ "_vm_page_hash_mask" },
    141 #define X_VM_PAGE_HASH_MASK	6
    142 	{ "_page_shift" },
    143 #define X_PAGE_SHIFT	7
    144 
    145 #if defined(m68k)
    146 #define	X_DEADKERNEL	8
    147 #endif
    148 
    149 #if defined(i386)
    150 #define	X_DEADKERNEL	8
    151 #endif
    152 
    153 #if defined(sparc)
    154 	{ "_pmap_dtos" },
    155 #define	X_PMAP_DTOS	8
    156 #define	X_DEADKERNEL	9
    157 #endif
    158 
    159 	/*
    160 	 * everything here and down, only if a dead kernel
    161 	 */
    162 	{ "_Sysmap" },
    163 #define	X_SYSMAP	(X_DEADKERNEL + 0)
    164 	{ "_Syssize" },
    165 #define	X_SYSSIZE	(X_DEADKERNEL + 1)
    166 	{ "_allproc" },
    167 #define X_ALLPROC	(X_DEADKERNEL + 2)
    168 	{ "_zombproc" },
    169 #define X_ZOMBPROC	(X_DEADKERNEL + 3)
    170 	{ "_nproc" },
    171 #define	X_NPROC		(X_DEADKERNEL + 4)
    172 #define	X_LAST		(X_DEADKERNEL + 5)
    173 
    174 #if defined(m68k)
    175 	{ "_Sysseg" },
    176 #define	X_SYSSEG	(X_LAST+0)
    177 	{ "_lowram" },
    178 #define	X_LOWRAM	(X_LAST+1)
    179 #if defined(amiga)
    180 	{ "_cpu040" },
    181 #define X_CPU040	(X_LAST+2)
    182 #endif
    183 #endif
    184 
    185 #if defined(i386)
    186 	{ "_IdlePTD" },
    187 #define	X_IdlePTD	(X_LAST+0)
    188 #endif
    189 
    190 	{ "" },
    191 };
    192 
    193 static off_t Vtophys();
    194 static void klseek(), seterr(), setsyserr(), vstodb();
    195 static int getkvars(), kvm_doprocs(), kvm_init();
    196 static int vatosw();
    197 static int pager_get();
    198 static int findpage();
    199 #if defined(sparc)
    200 static vm_offset_t phys2realphys();
    201 #endif
    202 
    203 /*
    204  * returns 	0 if files were opened now,
    205  * 		1 if files were already opened,
    206  *		-1 if files could not be opened.
    207  */
    208 kvm_openfiles(uf, mf, sf)
    209 	const char *uf, *mf, *sf;
    210 {
    211 	if (kvmfilesopen)
    212 		return (1);
    213 	unixx = mem = kmem = swap = -1;
    214 	unixf = (uf == NULL) ? _PATH_UNIX : uf;
    215 	memf = (mf == NULL) ? _PATH_MEM : mf;
    216 
    217 	if ((unixx = open(unixf, O_RDONLY, 0)) == -1) {
    218 		setsyserr("can't open %s", unixf);
    219 		goto failed;
    220 	}
    221 	if ((mem = open(memf, O_RDONLY, 0)) == -1) {
    222 		setsyserr("can't open %s", memf);
    223 		goto failed;
    224 	}
    225 	if (sf != NULL)
    226 		swapf = sf;
    227 	if (mf != NULL) {
    228 		deadkernel++;
    229 		kmemf = mf;
    230 		kmem = mem;
    231 		swap = -1;
    232 	} else {
    233 		kmemf = _PATH_KMEM;
    234 		if ((kmem = open(kmemf, O_RDONLY, 0)) == -1) {
    235 			setsyserr("can't open %s", kmemf);
    236 			goto failed;
    237 		}
    238 		swapf = (sf == NULL) ?  _PATH_DRUM : sf;
    239 		/*
    240 		 * live kernel - avoid looking up nlist entries
    241 		 * past X_DEADKERNEL.
    242 		 */
    243 		nl[X_DEADKERNEL].n_name = "";
    244 	}
    245 	if (swapf != NULL && ((swap = open(swapf, O_RDONLY, 0)) == -1)) {
    246 		seterr("can't open %s", swapf);
    247 		goto failed;
    248 	}
    249 	kvmfilesopen++;
    250 	if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1) /*XXX*/
    251 		return (-1);
    252 	return (0);
    253 failed:
    254 	kvm_close();
    255 	return (-1);
    256 }
    257 
    258 static
    259 kvm_init(uf, mf, sf)
    260 	char *uf, *mf, *sf;
    261 {
    262 	if (kvmfilesopen == 0 && kvm_openfiles(NULL, NULL, NULL) == -1)
    263 		return (-1);
    264 	if (getkvars() == -1)
    265 		return (-1);
    266 	kvminit = 1;
    267 
    268 	return (0);
    269 }
    270 
    271 kvm_close()
    272 {
    273 	if (unixx != -1) {
    274 		close(unixx);
    275 		unixx = -1;
    276 	}
    277 	if (kmem != -1) {
    278 		if (kmem != mem)
    279 			close(kmem);
    280 		/* otherwise kmem is a copy of mem, and will be closed below */
    281 		kmem = -1;
    282 	}
    283 	if (mem != -1) {
    284 		close(mem);
    285 		mem = -1;
    286 	}
    287 	if (swap != -1) {
    288 		close(swap);
    289 		swap = -1;
    290 	}
    291 	if (db != NULL) {
    292 		dbm_close(db);
    293 		db = NULL;
    294 	}
    295 	kvminit = 0;
    296 	kvmfilesopen = 0;
    297 	deadkernel = 0;
    298 }
    299 
    300 kvm_nlist(nl)
    301 	struct nlist *nl;
    302 {
    303 	datum key, data;
    304 	char dbname[MAXPATHLEN];
    305 	char dbversion[_POSIX2_LINE_MAX];
    306 	char kversion[_POSIX2_LINE_MAX];
    307 	int dbversionlen;
    308 	char symbuf[MAXSYMSIZE];
    309 	struct nlist nbuf, *n;
    310 	int num, did;
    311 
    312 	if (kvmfilesopen == 0 && kvm_openfiles(NULL, NULL, NULL) == -1)
    313 		return (-1);
    314 	if (deadkernel)
    315 		goto hard2;
    316 	/*
    317 	 * initialize key datum
    318 	 */
    319 	key.dptr = symbuf;
    320 
    321 	if (db != NULL)
    322 		goto win;	/* off to the races */
    323 	/*
    324 	 * open database
    325 	 */
    326 	sprintf(dbname, "%s/kvm_%s", _PATH_VARRUN, basename(unixf));
    327 	if ((db = dbm_open(dbname, O_RDONLY, 0)) == NULL)
    328 		goto hard2;
    329 	/*
    330 	 * read version out of database
    331 	 */
    332 	bcopy("VERSION", symbuf, sizeof ("VERSION")-1);
    333 	key.dsize = (sizeof ("VERSION") - 1);
    334 	data = dbm_fetch(db, key);
    335 	if (data.dptr == NULL)
    336 		goto hard1;
    337 	bcopy(data.dptr, dbversion, data.dsize);
    338 	dbversionlen = data.dsize;
    339 	/*
    340 	 * read version string from kernel memory
    341 	 */
    342 	bcopy("_version", symbuf, sizeof ("_version")-1);
    343 	key.dsize = (sizeof ("_version")-1);
    344 	data = dbm_fetch(db, key);
    345 	if (data.dptr == NULL)
    346 		goto hard1;
    347 	if (data.dsize != sizeof (struct nlist))
    348 		goto hard1;
    349 	bcopy(data.dptr, &nbuf, sizeof (struct nlist));
    350 	lseek(kmem, nbuf.n_value, 0);
    351 	if (read(kmem, kversion, dbversionlen) != dbversionlen)
    352 		goto hard1;
    353 	/*
    354 	 * if they match, we win - otherwise do it the hard way
    355 	 */
    356 	if (bcmp(dbversion, kversion, dbversionlen) != 0)
    357 		goto hard1;
    358 	/*
    359 	 * getem from the database.
    360 	 */
    361 win:
    362 	num = did = 0;
    363 	for (n = nl; n->n_name && n->n_name[0]; n++, num++) {
    364 		int len;
    365 		/*
    366 		 * clear out fields from users buffer
    367 		 */
    368 		n->n_type = 0;
    369 		n->n_other = 0;
    370 		n->n_desc = 0;
    371 		n->n_value = 0;
    372 		/*
    373 		 * query db
    374 		 */
    375 		if ((len = strlen(n->n_name)) > MAXSYMSIZE) {
    376 			seterr("symbol too large");
    377 			return (-1);
    378 		}
    379 		(void)strcpy(symbuf, n->n_name);
    380 		key.dsize = len;
    381 		data = dbm_fetch(db, key);
    382 		if (data.dptr == NULL || data.dsize != sizeof (struct nlist))
    383 			continue;
    384 		bcopy(data.dptr, &nbuf, sizeof (struct nlist));
    385 		n->n_value = nbuf.n_value;
    386 		n->n_type = nbuf.n_type;
    387 		n->n_desc = nbuf.n_desc;
    388 		n->n_other = nbuf.n_other;
    389 		did++;
    390 	}
    391 	return (num - did);
    392 hard1:
    393 	dbm_close(db);
    394 	db = NULL;
    395 hard2:
    396 	num = nlist(unixf, nl);
    397 	if (num == -1)
    398 		seterr("nlist (hard way) failed");
    399 	return (num);
    400 }
    401 
    402 kvm_getprocs(what, arg)
    403 	int what, arg;
    404 {
    405 	static int	ocopysize = -1;
    406 
    407 	if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1)
    408 		return (NULL);
    409 	if (!deadkernel) {
    410 		int ret, copysize;
    411 
    412 		if ((ret = getkerninfo(what, NULL, NULL, arg)) == -1) {
    413 			setsyserr("can't get estimate for kerninfo");
    414 			return (-1);
    415 		}
    416 		copysize = ret;
    417 		if (copysize > ocopysize || !kvmprocbase) {
    418 			if (ocopysize == -1 || !kvmprocbase)
    419 				kvmprocbase =
    420 					(struct kinfo_proc *)malloc(copysize);
    421 			else
    422 				kvmprocbase =
    423 					(struct kinfo_proc *)realloc(kvmprocbase,
    424 								copysize);
    425 			if (!kvmprocbase) {
    426 				seterr("out of memory");
    427 				return (-1);
    428 			}
    429 		}
    430 		ocopysize = copysize;
    431 		if ((ret = getkerninfo(what, kvmprocbase, &copysize,
    432 		     arg)) == -1) {
    433 			setsyserr("can't get proc list");
    434 			return (-1);
    435 		}
    436 		if (copysize % sizeof (struct kinfo_proc)) {
    437 			seterr("proc size mismatch (got %d total, kinfo_proc: %d)",
    438 				copysize, sizeof (struct kinfo_proc));
    439 			return (-1);
    440 		}
    441 		kvmnprocs = copysize / sizeof (struct kinfo_proc);
    442 	} else {
    443 		int nproc;
    444 
    445 		if (kvm_read((void *) nl[X_NPROC].n_value, &nproc,
    446 		    sizeof (int)) == -1) {
    447 			seterr("can't read nproc");
    448 			return (-1);
    449 		}
    450 		if ((kvmprocbase = (struct kinfo_proc *)
    451 		     malloc(nproc * sizeof (struct kinfo_proc))) == NULL) {
    452 			seterr("out of memory (addr: %x nproc = %d)",
    453 				nl[X_NPROC].n_value, nproc);
    454 			return (-1);
    455 		}
    456 		kvmnprocs = kvm_doprocs(what, arg, kvmprocbase);
    457 		realloc(kvmprocbase, kvmnprocs * sizeof (struct kinfo_proc));
    458 	}
    459 	kvmprocptr = kvmprocbase;
    460 
    461 	return (kvmnprocs);
    462 }
    463 
    464 /*
    465  * XXX - should NOT give up so easily - especially since the kernel
    466  * may be corrupt (it died).  Should gather as much information as possible.
    467  * Follows proc ptrs instead of reading table since table may go
    468  * away soon.
    469  */
    470 static
    471 kvm_doprocs(what, arg, buff)
    472 	int what, arg;
    473 	char *buff;
    474 {
    475 	struct proc *p, proc;
    476 	register char *bp = buff;
    477 	int i = 0;
    478 	int doingzomb = 0;
    479 	struct eproc eproc;
    480 	struct pgrp pgrp;
    481 	struct session sess;
    482 	struct tty tty;
    483 
    484 	/* allproc */
    485 	if (kvm_read((void *) nl[X_ALLPROC].n_value, &p,
    486 	    sizeof (struct proc *)) == -1) {
    487 		seterr("can't read allproc");
    488 		return (-1);
    489 	}
    490 
    491 again:
    492 	for (; p; p = proc.p_nxt) {
    493 		if (kvm_read(p, &proc, sizeof (struct proc)) == -1) {
    494 			seterr("can't read proc at %x", p);
    495 			return (-1);
    496 		}
    497 		if (kvm_read(proc.p_cred, &eproc.e_pcred,
    498 		    sizeof (struct pcred)) != -1)
    499 			(void) kvm_read(eproc.e_pcred.pc_ucred, &eproc.e_ucred,
    500 			    sizeof (struct ucred));
    501 
    502 		switch(ki_op(what)) {
    503 
    504 		case KINFO_PROC_PID:
    505 			if (proc.p_pid != (pid_t)arg)
    506 				continue;
    507 			break;
    508 
    509 
    510 		case KINFO_PROC_UID:
    511 			if (eproc.e_ucred.cr_uid != (uid_t)arg)
    512 				continue;
    513 			break;
    514 
    515 		case KINFO_PROC_RUID:
    516 			if (eproc.e_pcred.p_ruid != (uid_t)arg)
    517 				continue;
    518 			break;
    519 		}
    520 		/*
    521 		 * gather eproc
    522 		 */
    523 		eproc.e_paddr = p;
    524 		if (kvm_read(proc.p_pgrp, &pgrp, sizeof (struct pgrp)) == -1) {
    525 			seterr("can't read pgrp at %x", proc.p_pgrp);
    526 			return (-1);
    527 		}
    528 		eproc.e_sess = pgrp.pg_session;
    529 		eproc.e_pgid = pgrp.pg_id;
    530 		eproc.e_jobc = pgrp.pg_jobc;
    531 		if (kvm_read(pgrp.pg_session, &sess, sizeof (struct session))
    532 		    == -1) {
    533 			seterr("can't read session at %x", pgrp.pg_session);
    534 			return (-1);
    535 		}
    536 		if ((proc.p_flag&SCTTY) && sess.s_ttyp != NULL) {
    537 			if (kvm_read(sess.s_ttyp, &tty, sizeof (struct tty))
    538 			    == -1) {
    539 				seterr("can't read tty at %x", sess.s_ttyp);
    540 				return (-1);
    541 			}
    542 			eproc.e_tdev = tty.t_dev;
    543 			eproc.e_tsess = tty.t_session;
    544 			if (tty.t_pgrp != NULL) {
    545 				if (kvm_read(tty.t_pgrp, &pgrp, sizeof (struct
    546 				    pgrp)) == -1) {
    547 					seterr("can't read tpgrp at &x",
    548 						tty.t_pgrp);
    549 					return (-1);
    550 				}
    551 				eproc.e_tpgid = pgrp.pg_id;
    552 			} else
    553 				eproc.e_tpgid = -1;
    554 		} else
    555 			eproc.e_tdev = NODEV;
    556 		if (proc.p_wmesg)
    557 			(void) kvm_read(proc.p_wmesg, eproc.e_wmesg, WMESGLEN);
    558 		(void) kvm_read(proc.p_vmspace, &eproc.e_vm,
    559 		    sizeof (struct vmspace));
    560 		eproc.e_xsize = eproc.e_xrssize =
    561 			eproc.e_xccount = eproc.e_xswrss = 0;
    562 
    563 		switch(ki_op(what)) {
    564 
    565 		case KINFO_PROC_PGRP:
    566 			if (eproc.e_pgid != (pid_t)arg)
    567 				continue;
    568 			break;
    569 
    570 		case KINFO_PROC_TTY:
    571 			if ((proc.p_flag&SCTTY) == 0 ||
    572 			     eproc.e_tdev != (dev_t)arg)
    573 				continue;
    574 			break;
    575 		}
    576 
    577 		i++;
    578 		bcopy(&proc, bp, sizeof (struct proc));
    579 		bp += sizeof (struct proc);
    580 		bcopy(&eproc, bp, sizeof (struct eproc));
    581 		bp+= sizeof (struct eproc);
    582 	}
    583 	if (!doingzomb) {
    584 		/* zombproc */
    585 		if (kvm_read((void *) nl[X_ZOMBPROC].n_value, &p,
    586 		    sizeof (struct proc *)) == -1) {
    587 			seterr("can't read zombproc");
    588 			return (-1);
    589 		}
    590 		doingzomb = 1;
    591 		goto again;
    592 	}
    593 
    594 	return (i);
    595 }
    596 
    597 struct proc *
    598 kvm_nextproc()
    599 {
    600 
    601 	if (!kvmprocbase && kvm_getprocs(0, 0) == -1)
    602 		return (NULL);
    603 	if (kvmprocptr >= (kvmprocbase + kvmnprocs)) {
    604 		seterr("end of proc list");
    605 		return (NULL);
    606 	}
    607 	return((struct proc *)(kvmprocptr++));
    608 }
    609 
    610 struct eproc *
    611 kvm_geteproc(p)
    612 	const struct proc *p;
    613 {
    614 	return ((struct eproc *)(((char *)p) + sizeof (struct proc)));
    615 }
    616 
    617 kvm_setproc()
    618 {
    619 	kvmprocptr = kvmprocbase;
    620 }
    621 
    622 kvm_freeprocs()
    623 {
    624 
    625 	if (kvmprocbase) {
    626 		free(kvmprocbase);
    627 		kvmprocbase = NULL;
    628 	}
    629 }
    630 
    631 struct user *
    632 kvm_getu(p)
    633 	const struct proc *p;
    634 {
    635 	register struct kinfo_proc *kp = (struct kinfo_proc *)p;
    636 	register int i;
    637 	register char *up;
    638 	u_int vaddr;
    639 	struct swapblk swb;
    640 
    641 	if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1)
    642 		return (NULL);
    643 	if (p->p_stat == SZOMB) {
    644 		seterr("zombie process");
    645 		return (NULL);
    646 	}
    647 
    648 	if ((p->p_flag & SLOAD) == 0) {
    649 		vm_offset_t	maddr;
    650 
    651 		if (swap < 0) {
    652 			seterr("no swap");
    653 			return (NULL);
    654 		}
    655 		/*
    656 		 * Costly operation, better set enable_swap to zero
    657 		 * in vm/vm_glue.c, since paging of user pages isn't
    658 		 * done yet anyway.
    659 		 */
    660 		if (vatosw(&kp->kp_eproc.e_vm.vm_map, USRSTACK + i * NBPG,
    661 			   &maddr, &swb) == 0)
    662 			return NULL;
    663 
    664 		if (maddr == 0 && swb.size < UPAGES * NBPG)
    665 			return NULL;
    666 
    667 		for (i = 0; i < UPAGES; i++) {
    668 			if (maddr) {
    669 				(void) lseek(mem, maddr + i * NBPG, 0);
    670 				if (read(mem,
    671 				    (char *)user.upages[i], NBPG) != NBPG) {
    672 					setsyserr(
    673 					    "can't read u for pid %d from %s",
    674 					    p->p_pid, swapf);
    675 					return NULL;
    676 				}
    677 			} else {
    678 				(void) lseek(swap, swb.offset + i * NBPG, 0);
    679 				if (read(swap,
    680 				    (char *)user.upages[i], NBPG) != NBPG) {
    681 					setsyserr(
    682 					    "can't read u for pid %d from %s",
    683 					    p->p_pid, swapf);
    684 					return NULL;
    685 				}
    686 			}
    687 		}
    688 		return(&user.user);
    689 	}
    690 	/*
    691 	 * Read u-area one page at a time for the benefit of post-mortems
    692 	 */
    693 	up = (char *) p->p_addr;
    694 	for (i = 0; i < UPAGES; i++) {
    695 		klseek(kmem, (long)up, 0);
    696 		if (read(kmem, user.upages[i], CLBYTES) != CLBYTES) {
    697 			setsyserr("cant read page %x of u of pid %d from %s",
    698 			    up, p->p_pid, kmemf);
    699 			return(NULL);
    700 		}
    701 		up += CLBYTES;
    702 	}
    703 	pcbpf = (int) btop(p->p_addr);	/* what should this be really? */
    704 
    705 	return(&user.user);
    706 }
    707 
    708 int
    709 kvm_procread(p, addr, buf, len)
    710 	const struct proc *p;
    711 	const unsigned addr;
    712 	unsigned len;
    713 	char *buf;
    714 {
    715 	register struct kinfo_proc *kp = (struct kinfo_proc *) p;
    716 	struct swapblk swb;
    717 	vm_offset_t swaddr = 0, memaddr = 0;
    718 	unsigned real_len;
    719 	static int last_pid = -1;
    720 	static vm_offset_t last_addr;
    721 	static char bouncebuf[CLBYTES];
    722 
    723 	real_len = len < (CLBYTES - (addr & CLOFSET)) ? len : (CLBYTES - (addr & CLOFSET));
    724 
    725 	if (p->p_pid != last_pid || last_addr != (addr & ~CLOFSET)) {
    726         	if (vatosw(&kp->kp_eproc.e_vm.vm_map, addr & ~CLOFSET, &memaddr,
    727 		    &swb) == 0)
    728 			return 0;
    729 
    730 		if (memaddr) {
    731 #if defined(sparc)
    732 			memaddr = phys2realphys(memaddr);
    733 #endif
    734 			if (lseek(mem, memaddr, 0) == -1) {
    735 				setsyserr("kvm_procread: lseek mem");
    736 				return 0;
    737 			}
    738 			len = read(mem, bouncebuf, CLBYTES);
    739 			if (len == -1 || len < CLBYTES) {
    740 				last_pid = -1;
    741 				setsyserr("kvm_procread: read mem");
    742 				return 0;
    743 			}
    744 		} else {
    745 			swaddr = swb.offset;
    746 			if (lseek(swap, swaddr, 0) == -1) {
    747 				setsyserr("kvm_procread: lseek swap");
    748 				return 0;
    749 			}
    750 			len = read(swap, bouncebuf, CLBYTES);
    751 			if (len == -1 || len < CLBYTES) {
    752 				last_pid = -1;
    753 				setsyserr("kvm_procread: read swap");
    754 				return 0;
    755 			}
    756 		}
    757 	}
    758 
    759 	memcpy(buf, &bouncebuf[addr & CLOFSET], real_len);
    760 	last_pid = p->p_pid;
    761 	last_addr = addr & ~CLOFSET;
    762 	return real_len;
    763 }
    764 
    765 int
    766 kvm_procreadstr(p, addr, buf, len)
    767         const struct proc *p;
    768         const unsigned addr;
    769 	char *buf;
    770 	unsigned len;
    771 {
    772 	int	done, little;
    773 	char	copy[200], *pb;
    774 	char	a;
    775 
    776 	done = 0;
    777 	copy[0] = '\0';
    778 	while (len) {
    779 		little = kvm_procread(p, addr+done, copy, MIN(len, sizeof copy));
    780 		if (little<1)
    781 			break;
    782 		pb = copy;
    783 		while (little--) {
    784 			len--;
    785 			if( (*buf++ = *pb++) == '\0' )
    786 				return done;
    787 			done++;
    788 		}
    789 	}
    790 	return done;
    791 }
    792 
    793 char *
    794 kvm_getargs(p, up)
    795 	const struct proc *p;
    796 	const struct user *up;
    797 {
    798 	static char *cmdbuf = NULL, ucomm[sizeof(p->p_comm) + 4];
    799 	register char *cp, *acp;
    800 	int left, rv;
    801 	struct ps_strings arginfo;
    802 
    803 	if (cmdbuf == NULL) {
    804 		cmdbuf = (char *)malloc(ARG_MAX + sizeof(p->p_comm) + 5);
    805 		if (cmdbuf == NULL)
    806 			cmdbuf = ucomm;
    807 	}
    808 
    809 	if (cmdbuf == ucomm || up == NULL || p->p_pid == 0 || p->p_pid == 2)
    810 		goto retucomm;
    811 
    812 	if (kvm_procread(p, PS_STRINGS, (char *)&arginfo, sizeof(arginfo)) !=
    813 		sizeof(arginfo))
    814 		goto bad;
    815 
    816 	cmdbuf[0] = '\0';
    817 	cp = cmdbuf;
    818 	acp = arginfo.ps_argvstr;
    819 	left = ARG_MAX + 1;
    820 	while (arginfo.ps_nargvstr--) {
    821 		if ((rv = kvm_procreadstr(p, acp, cp, left)) >= 0) {
    822 			acp += rv + 1;
    823 			left -= rv + 1;
    824 			cp += rv;
    825 			*cp++ = ' ';
    826 			*cp = '\0';
    827 		} else
    828 			goto bad;
    829 	}
    830 	cp-- ; *cp = '\0';
    831 
    832 	if (cmdbuf[0] == '-' || cmdbuf[0] == '?' || cmdbuf[0] <= ' ') {
    833 		(void) strcat(cmdbuf, " (");
    834 		(void) strncat(cmdbuf, p->p_comm, sizeof(p->p_comm));
    835 		(void) strcat(cmdbuf, ")");
    836 	}
    837 	return (cmdbuf);
    838 
    839 bad:
    840 	seterr("error locating command name for pid %d", p->p_pid);
    841 retucomm:
    842 	(void) strcpy(cmdbuf, "(");
    843 	(void) strncat(cmdbuf, p->p_comm, sizeof (p->p_comm));
    844 	(void) strcat(cmdbuf, ")");
    845 	return (cmdbuf);
    846 }
    847 
    848 char *
    849 kvm_getenv(p, up)
    850 	const struct proc *p;
    851 	const struct user *up;
    852 {
    853 	static char *envbuf = NULL, emptyenv[1];
    854 	register char *cp, *acp;
    855 	int left, rv;
    856 	struct ps_strings arginfo;
    857 
    858 	if (envbuf == NULL) {
    859 		envbuf = (char *)malloc(ARG_MAX + 1);
    860 		if (envbuf == NULL)
    861 			envbuf = emptyenv;
    862 	}
    863 
    864 	if (envbuf == emptyenv || up == NULL || p->p_pid == 0 || p->p_pid == 2)
    865 		goto retemptyenv;
    866 
    867 	if (kvm_procread(p, PS_STRINGS, (char *)&arginfo, sizeof(arginfo)) !=
    868 		sizeof(arginfo))
    869 		goto bad;
    870 
    871 	cp = envbuf;
    872 	acp = arginfo.ps_envstr;
    873 	left = ARG_MAX + 1;
    874 	while (arginfo.ps_nenvstr--) {
    875 		if ((rv = kvm_procreadstr(p, acp, cp, left)) >= 0) {
    876 			acp += rv + 1;
    877 			left -= rv + 1;
    878 			cp += rv;
    879 			*cp++ = ' ';
    880 			*cp = '\0';
    881 		} else
    882 			goto bad;
    883 	}
    884 	cp-- ; *cp = '\0';
    885 	return (envbuf);
    886 
    887 bad:
    888 	seterr("error locating environment for pid %d", p->p_pid);
    889 retemptyenv:
    890 	envbuf[0] = '\0';
    891 	return (envbuf);
    892 }
    893 
    894 static
    895 getkvars()
    896 {
    897 	if (kvm_nlist(nl) == -1)
    898 		return (-1);
    899 	if (deadkernel) {
    900 		/* We must do the sys map first because klseek uses it */
    901 		long	addr;
    902 
    903 #if defined(m68k)
    904 #if defined(amiga)
    905 		addr = (long) nl[X_CPU040].n_value;
    906 		(void) lseek(kmem, addr, 0);
    907 		if (read(kmem, (char *) &cpu040, sizeof (cpu040))
    908 		    != sizeof (cpu040)) {
    909 			seterr("can't read cpu040");
    910 			return (-1);
    911 		}
    912 #endif
    913 		addr = (long) nl[X_LOWRAM].n_value;
    914 		(void) lseek(kmem, addr, 0);
    915 		if (read(kmem, (char *) &lowram, sizeof (lowram))
    916 		    != sizeof (lowram)) {
    917 			seterr("can't read lowram");
    918 			return (-1);
    919 		}
    920 		lowram = btop(lowram);
    921 		Sysseg = (struct ste *) malloc(NBPG);
    922 		if (Sysseg == NULL) {
    923 			seterr("out of space for Sysseg");
    924 			return (-1);
    925 		}
    926 		addr = (long) nl[X_SYSSEG].n_value;
    927 		(void) lseek(kmem, addr, 0);
    928 		read(kmem, (char *)&addr, sizeof(addr));
    929 		(void) lseek(kmem, (long)addr, 0);
    930 		if (read(kmem, (char *) Sysseg, NBPG) != NBPG) {
    931 			seterr("can't read Sysseg");
    932 			return (-1);
    933 		}
    934 #endif
    935 #if defined(i386)
    936 		PTD = (struct pde *) malloc(NBPG);
    937 		if (PTD == NULL) {
    938 			seterr("out of space for PTD");
    939 			return (-1);
    940 		}
    941 		addr = (long) nl[X_IdlePTD].n_value;
    942 		(void) lseek(kmem, addr, 0);
    943 		read(kmem, (char *)&addr, sizeof(addr));
    944 		(void) lseek(kmem, (long)addr, 0);
    945 		if (read(kmem, (char *) PTD, NBPG) != NBPG) {
    946 			seterr("can't read PTD");
    947 			return (-1);
    948 		}
    949 #endif
    950 	}
    951 	if (kvm_read((void *) nl[X_NSWAP].n_value, &nswap, sizeof (long)) == -1) {
    952 		seterr("can't read nswap");
    953 		return (-1);
    954 	}
    955 	if (kvm_read((void *) nl[X_DMMIN].n_value, &dmmin, sizeof (long)) == -1) {
    956 		seterr("can't read dmmin");
    957 		return (-1);
    958 	}
    959 	if (kvm_read((void *) nl[X_DMMAX].n_value, &dmmax, sizeof (long)) == -1) {
    960 		seterr("can't read dmmax");
    961 		return (-1);
    962 	}
    963 	if (kvm_read((void *) nl[X_VM_PAGE_HASH_MASK].n_value,
    964 		     &vm_page_hash_mask, sizeof (long)) == -1) {
    965 		seterr("can't read vm_page_hash_mask");
    966 		return (-1);
    967 	}
    968 	if (kvm_read((void *) nl[X_VM_PAGE_BUCKETS].n_value,
    969 		     &vm_page_buckets, sizeof (long)) == -1) {
    970 		seterr("can't read vm_page_buckets");
    971 		return (-1);
    972 	}
    973 	if (kvm_read((void *) nl[X_PAGE_SHIFT].n_value,
    974 		     &page_shift, sizeof (long)) == -1) {
    975 		seterr("can't read page_shift");
    976 		return (-1);
    977 	}
    978 
    979 	return (0);
    980 }
    981 
    982 int
    983 kvm_read(loc, buf, len)
    984 	void *loc;
    985 	void *buf;
    986 {
    987 	int n;
    988 
    989 	if (kvmfilesopen == 0 && kvm_openfiles(NULL, NULL, NULL) == -1)
    990 		return (-1);
    991 	klseek(kmem, (off_t) loc, 0);
    992 	if ((n = read(kmem, buf, len)) != len) {
    993 		if (n == -1)
    994 			setsyserr("error reading kmem at %#x", loc);
    995 		else
    996 			seterr("short read on kmem at %#x", loc);
    997 		return (-1);
    998 	}
    999 	return (len);
   1000 }
   1001 
   1002 static void
   1003 klseek(fd, loc, off)
   1004 	int fd;
   1005 	off_t loc;
   1006 	int off;
   1007 {
   1008 
   1009 	if (deadkernel) {
   1010 		if ((loc = Vtophys(loc)) == -1)
   1011 			return;
   1012 	}
   1013 	(void) lseek(fd, (off_t)loc, off);
   1014 }
   1015 
   1016 static off_t
   1017 Vtophys(loc)
   1018 	u_long	loc;
   1019 {
   1020 	off_t newloc = (off_t) -1;
   1021 #if defined(m68k)
   1022 	int p, ste, pte;
   1023 
   1024 	ste = *(int *)&Sysseg[btos(loc)];
   1025 	if ((ste & SG_V) == 0) {
   1026 		seterr("vtophys: segment not valid");
   1027 		return((off_t) -1);
   1028 	}
   1029 	p = btop(loc & SG_PMASK);
   1030 	newloc = (ste & SG_FRAME) + (p * sizeof(struct pte));
   1031 	(void) lseek(mem, newloc, 0);
   1032 	if (read(mem, (char *)&pte, sizeof pte) != sizeof pte) {
   1033 		seterr("vtophys: cannot locate pte");
   1034 		return((off_t) -1);
   1035 	}
   1036 	newloc = pte & PG_FRAME;
   1037 	if (pte == PG_NV || newloc < (off_t)ptob(lowram)) {
   1038 		seterr("vtophys: page not valid");
   1039 		return((off_t) -1);
   1040 	}
   1041 	newloc = (newloc - (off_t)ptob(lowram)) + (loc & PGOFSET);
   1042 #endif
   1043 #if defined(i386)
   1044 	struct pde pde;
   1045 	struct pte pte;
   1046 	int p;
   1047 
   1048 	pde = PTD[loc >> PDSHIFT];
   1049 	if (pde.pd_v == 0) {
   1050 		seterr("vtophys: page directory entry not valid");
   1051 		return((off_t) -1);
   1052 	}
   1053 	p = btop(loc & PT_MASK);
   1054 	newloc = pde.pd_pfnum + (p * sizeof(struct pte));
   1055 	(void) lseek(kmem, (long)newloc, 0);
   1056 	if (read(kmem, (char *)&pte, sizeof pte) != sizeof pte) {
   1057 		seterr("vtophys: cannot obtain desired pte");
   1058 		return((off_t) -1);
   1059 	}
   1060 	newloc = pte.pg_pfnum;
   1061 	if (pte.pg_v == 0) {
   1062 		seterr("vtophys: page table entry not valid");
   1063 		return((off_t) -1);
   1064 	}
   1065 	newloc += (loc & PGOFSET);
   1066 #endif
   1067 	return((off_t) newloc);
   1068 }
   1069 
   1070 /*
   1071  * locate address of unwired or swapped page
   1072  */
   1073 
   1074 static int
   1075 vatosw(mp, vaddr, maddr, swb)
   1076 vm_map_t	mp;
   1077 vm_offset_t	vaddr;
   1078 vm_offset_t	*maddr;
   1079 struct swapblk	*swb;
   1080 {
   1081 	struct vm_object	vm_object;
   1082 	struct vm_map_entry	vm_entry;
   1083 	long			saddr, addr, off;
   1084 	int			i;
   1085 
   1086 	saddr = addr = (long)mp->header.next;
   1087 #ifdef DEBUG
   1088 	fprintf(stderr, "vatosw: head=%x\n", &mp->header);
   1089 #endif
   1090 	for (i = 0; ; i++) {
   1091 		/* Weed through map entries until vaddr in range */
   1092 		if (kvm_read((void *) addr, &vm_entry, sizeof(vm_entry)) == -1) {
   1093 			seterr("vatosw: can't read vm_map_entry");
   1094 			return 0;
   1095 		}
   1096 #ifdef DEBUG
   1097 		fprintf(stderr, "vatosw: %d/%d, vaddr=%x, start=%x, end=%x ",
   1098 			i, mp->nentries, vaddr, vm_entry.start, vm_entry.end);
   1099 		fprintf(stderr, "addr=%x, next=%x\n", addr, vm_entry.next);
   1100 #endif
   1101 		if ((vaddr >= vm_entry.start) && (vaddr < vm_entry.end))
   1102 			if (vm_entry.object.vm_object != 0)
   1103 				break;
   1104 			else {
   1105 				seterr("vatosw: no object\n");
   1106 				return 0;
   1107 			}
   1108 
   1109 		addr = (long)vm_entry.next;
   1110 
   1111 		if (addr == saddr) {
   1112 			seterr("vatosw: map not found\n");
   1113 			return 0;
   1114 		}
   1115 	}
   1116 
   1117 	if (vm_entry.is_a_map || vm_entry.is_sub_map) {
   1118 #ifdef DEBUG
   1119 		fprintf(stderr, "vatosw: is a %smap\n",
   1120 			vm_entry.is_sub_map ? "sub " : "");
   1121 #endif
   1122 		seterr("vatosw: is a %smap\n",
   1123 		       vm_entry.is_sub_map ? "sub " : "");
   1124 		return 0;
   1125 	}
   1126 
   1127 	/* Locate memory object */
   1128 	off = (vaddr - vm_entry.start) + vm_entry.offset;
   1129 	addr = (long)vm_entry.object.vm_object;
   1130 	while (1) {
   1131 		if (kvm_read((void *) addr, &vm_object, sizeof (vm_object)) == -1) {
   1132 			seterr("vatosw: can't read vm_object");
   1133 			return 0;
   1134 		}
   1135 
   1136 #ifdef DEBUG
   1137 		fprintf(stderr, "vatosw: find page: object %#x offset %x\n",
   1138 			addr, off);
   1139 #endif
   1140 
   1141 		/* Lookup in page queue */
   1142 		if ((i = findpage(addr, off, maddr)) != -1)
   1143 			return i;
   1144 
   1145 		if (vm_object.pager != 0 &&
   1146 		    (i = pager_get(&vm_object, off, swb)) != -1)
   1147 			return i;
   1148 
   1149 		if (vm_object.shadow == 0)
   1150 			break;
   1151 
   1152 #ifdef DEBUG
   1153 		fprintf(stderr, "vatosw: shadow obj at %x: offset %x+%x\n",
   1154 			addr, off, vm_object.shadow_offset);
   1155 #endif
   1156 
   1157 		addr = (long)vm_object.shadow;
   1158 		off += vm_object.shadow_offset;
   1159 	}
   1160 
   1161 	seterr("vatosw: page not found\n");
   1162 	return 0;
   1163 }
   1164 
   1165 
   1166 int
   1167 pager_get(object, off, swb)
   1168 struct vm_object *object;
   1169 long off;
   1170 struct swapblk	*swb;
   1171 {
   1172 	struct pager_struct	pager;
   1173 	struct swpager		swpager;
   1174 	struct swblock		swblock;
   1175 
   1176 	/* Find address in swap space */
   1177 	if (kvm_read(object->pager, &pager, sizeof (pager)) == -1) {
   1178 		seterr("pager_get: can't read pager");
   1179 		return 0;
   1180 	}
   1181 	if (pager.pg_type != PG_SWAP) {
   1182 		seterr("pager_get: weird pager\n");
   1183 		return 0;
   1184 	}
   1185 
   1186 	/* Get swap pager data */
   1187 	if (kvm_read(pager.pg_data, &swpager, sizeof (swpager)) == -1) {
   1188 		seterr("pager_get: can't read swpager");
   1189 		return 0;
   1190 	}
   1191 
   1192 	off += object->paging_offset;
   1193 
   1194 	/* Read swap block array */
   1195 	if (kvm_read((void *) swpager.sw_blocks +
   1196 			(off/dbtob(swpager.sw_bsize)) * sizeof swblock,
   1197 			&swblock, sizeof (swblock)) == -1) {
   1198 		seterr("pager_get: can't read swblock");
   1199 		return 0;
   1200 	}
   1201 
   1202 	off %= dbtob(swpager.sw_bsize);
   1203 
   1204 	if (swblock.swb_mask & (1 << atop(off))) {
   1205 		swb->offset = dbtob(swblock.swb_block) + off;
   1206 		swb->size = dbtob(swpager.sw_bsize) - off;
   1207 		return 1;
   1208 	}
   1209 
   1210 	return -1;
   1211 }
   1212 
   1213 static int
   1214 findpage(object, offset, maddr)
   1215 long			object;
   1216 long			offset;
   1217 vm_offset_t		*maddr;
   1218 {
   1219 	queue_head_t	bucket;
   1220 	struct vm_page	mem;
   1221 	long		addr, baddr;
   1222 
   1223 	baddr = vm_page_buckets +
   1224 		vm_page_hash(object,offset) * sizeof(queue_head_t);
   1225 
   1226 	if (kvm_read((void *) baddr, &bucket, sizeof (bucket)) == -1) {
   1227 		seterr("can't read vm_page_bucket");
   1228 		return 0;
   1229 	}
   1230 
   1231 	addr = (long)bucket.next;
   1232 
   1233 	while (addr != baddr) {
   1234 		if (kvm_read((void *) addr, &mem, sizeof (mem)) == -1) {
   1235 			seterr("can't read vm_page");
   1236 			return 0;
   1237 		}
   1238 
   1239 		if ((long)mem.object == object && mem.offset == offset) {
   1240 			*maddr = (long)mem.phys_addr;
   1241 			return 1;
   1242 		}
   1243 
   1244 		addr = (long)mem.hashq.next;
   1245 	}
   1246 
   1247 	return -1;
   1248 }
   1249 
   1250 #if defined(sparc)
   1251 /*
   1252  * This comes from the bowels of pmap.c
   1253  */
   1254 #define MAXMEM 	(128 * 1024 * 1024)	/* no more than 128 MB phys mem */
   1255 #define NPGBANK	16			/* 2^4 pages per bank (64K / bank) */
   1256 #define	BSHIFT	4			/* log2(NPGBANK) */
   1257 #define BOFFSET	(NPGBANK - 1)
   1258 #define BTSIZE 	(MAXMEM / NBPG / NPGBANK)
   1259 
   1260 static int	pmap_dtos[BTSIZE];		/* dense to sparse */
   1261 static int	pmap_stod[BTSIZE];		/* sparse to dense */
   1262 
   1263 #define	HWTOSW(pg) (pmap_stod[(pg) >> BSHIFT] | ((pg) & BOFFSET))
   1264 #define	SWTOHW(pg) (pmap_dtos[(pg) >> BSHIFT] | ((pg) & BOFFSET))
   1265 /* -- */
   1266 
   1267 static int pmap_dtos_valid;
   1268 
   1269 /*
   1270  * Translate a VM physical address to a hardware physical address.
   1271  */
   1272 static vm_offset_t
   1273 phys2realphys(memaddr)
   1274 vm_offset_t memaddr;
   1275 {
   1276 	if (nl[X_PMAP_DTOS].n_value == 0)
   1277 		/* This is possibly a sun4 */
   1278 		return memaddr;
   1279 
   1280 	if (!pmap_dtos_valid) {
   1281 		if (kvm_read((void *)nl[X_PMAP_DTOS].n_value,
   1282 					pmap_dtos, sizeof (pmap_dtos)) == -1) {
   1283 			seterr("can't read pmap_dtos table");
   1284 			return -1;
   1285 		}
   1286 		pmap_dtos_valid = 1;
   1287 	}
   1288 	return (SWTOHW(atop(memaddr)) << PGSHIFT) | (memaddr & PGOFSET);
   1289 }
   1290 #endif
   1291 
   1292 #include <varargs.h>
   1293 static char errbuf[_POSIX2_LINE_MAX];
   1294 
   1295 static void
   1296 seterr(va_alist)
   1297 	va_dcl
   1298 {
   1299 	char *fmt;
   1300 	va_list ap;
   1301 
   1302 	va_start(ap);
   1303 	fmt = va_arg(ap, char *);
   1304 	(void) vsnprintf(errbuf, _POSIX2_LINE_MAX, fmt, ap);
   1305 #ifdef DEBUG
   1306 	(void) fprintf(stderr, "%s\n", errbuf);
   1307 #endif
   1308 	va_end(ap);
   1309 }
   1310 
   1311 static void
   1312 setsyserr(va_alist)
   1313 	va_dcl
   1314 {
   1315 	char *fmt, *cp;
   1316 	va_list ap;
   1317 	extern int errno;
   1318 
   1319 	va_start(ap);
   1320 	fmt = va_arg(ap, char *);
   1321 	(void) vsnprintf(cp = errbuf, _POSIX2_LINE_MAX, fmt, ap);
   1322 	cp += strlen(cp);
   1323 	(void) snprintf(cp, _POSIX2_LINE_MAX - (cp - errbuf), ": %s",
   1324 			strerror(errno));
   1325 #ifdef DEBUG
   1326 	(void) fprintf(stderr, "%s\n", errbuf);
   1327 #endif
   1328 	va_end(ap);
   1329 }
   1330 
   1331 char *
   1332 kvm_geterr()
   1333 {
   1334 	return (errbuf);
   1335 }
   1336