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, ©size,
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