Implement working on ELF corefiles. Use kvm_read() when reading

memory while mapping a virtual address to a physical address.
This allows us to work with virtual addresses for page tables,
provided it doesn't cause infinite recursion. Currently all
page tables are direct mapped.

1 files changed, 135 insertions, 122 deletions

diff --git a/lib/libkvm/kvm_ia64.c b/lib/libkvm/kvm_ia64.c
index dbdc67b..b0bdeee 100644
--- a/lib/libkvm/kvm_ia64.c
+++ b/lib/libkvm/kvm_ia64.c
@@ -28,56 +28,125 @@
  * rights to redistribute these changes.
  */
 
-#include <sys/param.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/user.h>
-#include <sys/proc.h>
-#include <sys/stat.h>
 #include <sys/types.h>
-#include <sys/uio.h>
-#include <unistd.h>
-#include <nlist.h>
-#include <kvm.h>
+#include <sys/elf64.h>
+#include <sys/mman.h>
 
-#include <vm/vm.h>
-#include <vm/vm_param.h>
+#include <machine/pte.h>
 
+#include <kvm.h>
 #include <limits.h>
 #include <stdlib.h>
-#include <machine/pmap.h>
+#include <unistd.h>
+
 #include "kvm_private.h"
 
-static off_t   _kvm_pa2off(kvm_t *kd, u_long pa);
+#define	REGION_BASE(n)		(((uint64_t)(n)) << 61)
+#define	REGION_ADDR(x)		((x) & ((1LL<<61)-1LL))
+
+#define	NKPTEPG(ps)		((ps) / sizeof(struct ia64_lpte))
+#define	KPTE_PTE_INDEX(va,ps)	(((va)/(ps)) % NKPTEPG(ps))
+#define	KPTE_DIR_INDEX(va,ps)	(((va)/(ps)) / NKPTEPG(ps))
 
 struct vmstate {
-	u_int64_t       kptdir;		/* PA of page table directory */
-        u_int64_t	page_size;	/* Page size */
+	void	*mmapbase;
+	size_t	mmapsize;
+	size_t	pagesize;
+	u_long	kptdir;
 };
 
+/*
+ * Map the ELF headers into the process' address space. We do this in two
+ * steps: first the ELF header itself and using that information the whole
+ * set of headers.
+ */
+static int
+_kvm_maphdrs(kvm_t *kd, size_t sz)
+{
+	struct vmstate *vm = kd->vmst;
+
+	/* munmap() previous mmap(). */
+	if (vm->mmapbase != NULL) {
+		munmap(vm->mmapbase, vm->mmapsize);
+		vm->mmapbase = NULL;
+	}
+
+	vm->mmapsize = sz;
+	vm->mmapbase = mmap(NULL, sz, PROT_READ, MAP_PRIVATE, kd->pmfd, NULL);
+	if (vm->mmapbase == MAP_FAILED) {
+		_kvm_err(kd, kd->program, "cannot mmap corefile");
+		return (-1);
+	}
+
+	return (0);
+}
+
+/*
+ * Translate a physical memory address to a file-offset in the crash-dump.
+ */
+static size_t
+_kvm_pa2off(kvm_t *kd, uint64_t pa, u_long *ofs, size_t pgsz)
+{
+	Elf64_Ehdr *e = kd->vmst->mmapbase;
+	Elf64_Phdr *p = (Elf64_Phdr*)((char*)e + e->e_phoff);
+	int n = e->e_phnum;
+
+	if (pa != REGION_ADDR(pa)) {
+		_kvm_err(kd, kd->program, "internal error");
+		return (0);
+	}
+
+	while (n && (pa < p->p_paddr || pa >= p->p_paddr + p->p_memsz))
+		p++, n--;
+	if (n == 0)
+		return (0);
+
+	*ofs = (pa - p->p_paddr) + p->p_offset;
+	if (pgsz == 0)
+		return (p->p_memsz - (pa - p->p_paddr));
+	return (pgsz - ((size_t)pa & (pgsz - 1)));
+}
+
 void
 _kvm_freevtop(kvm_t *kd)
 {
+	struct vmstate *vm = kd->vmst;
 
-	/* Not actually used for anything right now, but safe. */
-	if (kd->vmst != 0)
-		free(kd->vmst);
+	if (vm->mmapbase != NULL)
+		munmap(vm->mmapbase, vm->mmapsize);
+	free(vm);
+	kd->vmst = NULL;
 }
 
 int
 _kvm_initvtop(kvm_t *kd)
 {
-	struct vmstate *vm;
 	struct nlist nlist[2];
-	u_int64_t va;
+	uint64_t va;
+	Elf64_Ehdr *ehdr;
+	size_t hdrsz;
 
-	vm = (struct vmstate *)_kvm_malloc(kd, sizeof(*vm));
-	if (vm == 0) {
+	kd->vmst = (struct vmstate *)_kvm_malloc(kd, sizeof(*kd->vmst));
+	if (kd->vmst == NULL) {
 		_kvm_err(kd, kd->program, "cannot allocate vm");
 		return (-1);
 	}
-	kd->vmst = vm;
-	vm->page_size = getpagesize(); /* XXX wrong for crashdumps */
+
+	kd->vmst->pagesize = getpagesize();
+
+	if (_kvm_maphdrs(kd, sizeof(Elf64_Ehdr)) == -1)
+		return (-1);
+
+	ehdr = kd->vmst->mmapbase;
+	hdrsz = ehdr->e_phoff + ehdr->e_phentsize * ehdr->e_phnum;
+	if (_kvm_maphdrs(kd, hdrsz) == -1)
+		return (-1);
+
+	/*
+	 * At this point we've got enough information to use kvm_read() for
+	 * direct mapped (ie region 6 and region 7) address, such as symbol
+	 * addresses/values.
+	 */
 
 	nlist[0].n_name = "kptdir";
 	nlist[1].n_name = 0;
@@ -87,110 +156,54 @@ _kvm_initvtop(kvm_t *kd)
 		return (-1);
 	}
 
-	if(!ISALIVE(kd)) {
-		if (kvm_read(kd, (nlist[0].n_value), &va, sizeof(va)) != sizeof(va)) {
-			_kvm_err(kd, kd->program, "cannot read kptdir");
-			return (-1);
-		}
-	} else 
-		if (kvm_read(kd, (nlist[0].n_value), &va, sizeof(va)) != sizeof(va)) {
-			_kvm_err(kd, kd->program, "cannot read kptdir");
-			return (-1);
-		}
-	vm->kptdir = IA64_RR_MASK(va);
-	return (0);
+	if (kvm_read(kd, (nlist[0].n_value), &va, sizeof(va)) != sizeof(va)) {
+		_kvm_err(kd, kd->program, "cannot read kptdir");
+		return (-1);
+	}
 
+	if (va < REGION_BASE(6)) {
+		_kvm_err(kd, kd->program, "kptdir is itself virtual");
+		return (-1);
+	}
+
+	kd->vmst->kptdir = va;
+	return (0);
 }
 
 int
 _kvm_kvatop(kvm_t *kd, u_long va, u_long *pa)
 {
-	u_int64_t	kptdir;			/* PA of kptdir */
-        u_int64_t	page_size;
-	int		rv, page_off;
 	struct ia64_lpte pte;
-	off_t		pteoff;
-	struct vmstate	*vm;
-
-	vm = kd->vmst;
-	
-        if (ISALIVE(kd)) {
-                _kvm_err(kd, 0, "vatop called in live kernel!");
-                return(0);
-        }
-	kptdir = vm->kptdir;
-	page_size = vm->page_size;
-
-	page_off = va & (page_size - 1);
-	if (va >= IA64_RR_BASE(6) && va <= IA64_RR_BASE(7) + ((1L<<61)-1)) {
-		/*
-		 * Direct-mapped address: just convert it.
-		 */
-
-		*pa = IA64_RR_MASK(va);
-		rv = page_size - page_off;
-	} else if (va >= IA64_RR_BASE(5) && va < IA64_RR_BASE(6)) {
-		/*
-		 * Real kernel virtual address: do the translation.
-		 */
-#define KPTE_DIR_INDEX(va, ps) \
-	(IA64_RR_MASK(va) / ((ps) * (ps) * sizeof(struct ia64_lpte)))
-#define KPTE_PTE_INDEX(va, ps) \
-	(((va) / (ps)) % (ps / sizeof(struct ia64_lpte)))
-
-		int maxpt = page_size / sizeof(u_int64_t);
-		int ptno = KPTE_DIR_INDEX(va, page_size);
-		int pgno = KPTE_PTE_INDEX(va, page_size);
-		u_int64_t ptoff, pgoff;
-
-		if (ptno >= maxpt) {
-			_kvm_err(kd, 0, "invalid translation (va too large)");
-			goto lose;
-		}
-		ptoff = kptdir + ptno * sizeof(u_int64_t);
-		if (lseek(kd->pmfd, _kvm_pa2off(kd, ptoff), 0) == -1 ||
-		    read(kd->pmfd, &pgoff, sizeof(pgoff)) != sizeof(pgoff)) {
-			_kvm_syserr(kd, 0, "could not read page table address");
-			goto lose;
-		}
-		pgoff = IA64_RR_MASK(pgoff);
-		if (!pgoff) {
-			_kvm_err(kd, 0, "invalid translation (no page table)");
-			goto lose;
-		}
-		if (lseek(kd->pmfd, _kvm_pa2off(kd, pgoff), 0) == -1 ||
-		    read(kd->pmfd, &pte, sizeof(pte)) != sizeof(pte)) {
-			_kvm_syserr(kd, 0, "could not read PTE");
-			goto lose;
-		}
-		if (!pte.pte_p) {
-			_kvm_err(kd, 0, "invalid translation (invalid PTE)");
-			goto lose;
-		}
-		*pa = pte.pte_ppn << 12;
-		rv = page_size - page_off;
-	} else {
-		/*
-		 * Bogus address (not in KV space): punt.
-		 */
-
-		_kvm_err(kd, 0, "invalid kernel virtual address");
-lose:
-		*pa = -1;
-		rv = 0;
+	uint64_t pgaddr, ptaddr;
+	size_t pgno, pgsz, ptno;
+
+	if (va >= REGION_BASE(6)) {
+		/* Regions 6 and 7: direct mapped. */
+		return (_kvm_pa2off(kd, REGION_ADDR(va), pa, 0));
+	} else if (va >= REGION_BASE(5)) {
+		/* Region 5: virtual. */
+		va = REGION_ADDR(va);
+		pgsz = kd->vmst->pagesize;
+		ptno = KPTE_DIR_INDEX(va, pgsz);
+		pgno = KPTE_PTE_INDEX(va, pgsz);
+		if (ptno >= (pgsz >> 3))
+			goto fail;
+		ptaddr = kd->vmst->kptdir + (ptno << 3);
+		if (kvm_read(kd, ptaddr, &pgaddr, 8) != 8)
+			goto fail;
+		if (pgaddr == 0)
+			goto fail;
+		pgaddr += (pgno * sizeof(pte));
+		if (kvm_read(kd, pgaddr, &pte, sizeof(pte)) != sizeof(pte))
+			goto fail;
+		if (!pte.pte_p)
+			goto fail;
+		va = ((u_long)pte.pte_ppn << 12) + (va & (pgsz - 1));
+		return (_kvm_pa2off(kd, va, pa, pgsz));
 	}
 
-	return (rv);
-}
-
-/*
- * Translate a physical address to a file-offset in the crash-dump.
- */
-off_t   
-_kvm_pa2off(kd, pa)
-	kvm_t *kd;
-	u_long pa;
-{
-	return IA64_PHYS_TO_RR7(pa);
+ fail:
+	_kvm_err(kd, kd->program, "invalid kernel virtual address");
+	*pa = ~0UL;
+	return (0);
 }
-