d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Support crash dumps > 4GB in size on 32 bit platforms. _kvm_kvatop()

Browse Source 
returned an lseek offset in a "u_long *" value, which can't express >4GB
offsets on 32 bit machines (eg: PAE).  Change to "off_t *" for all.

Support ELF crashdumps on i386 and amd64.

Support PAE crashdumps on i386.  This is done by auto-detecting the
presence of the IdlePDPT which means that PAE is active.

I used Marcel's _kvm_pa2off strategy and ELF header reader for ELF support
on amd64.  Paul Saab ported the amd64 changes to i386 and we implemented
the PAE support from there.

Note that gdb6 in the src tree uses whatever libkvm supports.  If you want
to debug an old crash dump, you might want to keep an old libkvm.so handy
and use LD_PRELOAD or the like.  This does not detect the old raw dump
format.

Approved by: re
This commit is contained in:
Peter Wemm 2005-06-29 22:39:41 +00:00
parent 235a54de9d
commit e55a0cd805
9 changed files with 426 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/libkvm/kvm.c
View File

@ -369,7 +369,7 @@ kvm_read(kd, kva, buf, len)
} else {
cp = buf;
while (len > 0) {
u_long pa;
off_t pa;
cc = _kvm_kvatop(kd, kva, &pa);
if (cc == 0)
@ -377,7 +377,7 @@ kvm_read(kd, kva, buf, len)
if (cc > len)
cc = len;
errno = 0;
if (lseek(kd->pmfd, (off_t)pa, 0) == -1 && errno != 0) {
if (lseek(kd->pmfd, pa, 0) == -1 && errno != 0) {
_kvm_syserr(kd, 0, _PATH_MEM);
break;
}

176
lib/libkvm/kvm_amd64.c
View File

@ -53,6 +53,7 @@ static char sccsid[] = "@(#)kvm_hp300.c 8.1 (Berkeley) 6/4/93";
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <unistd.h>
#include <nlist.h>
@ -61,6 +62,8 @@ static char sccsid[] = "@(#)kvm_hp300.c 8.1 (Berkeley) 6/4/93";
#include <vm/vm.h>
#include <vm/vm_param.h>
#include <machine/elf.h>
#include <limits.h>
#include "kvm_private.h"
@ -71,36 +74,92 @@ static char sccsid[] = "@(#)kvm_hp300.c 8.1 (Berkeley) 6/4/93";
#endif
struct vmstate {
void *mmapbase;
size_t mmapsize;
pml4_entry_t *PML4;
};
/*
* 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. (Taken from kvm_ia64.c)
*/
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, 0);
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.
* (Taken from kvm_ia64.c)
*/
static size_t
_kvm_pa2off(kvm_t *kd, uint64_t pa, off_t *ofs)
{
Elf_Ehdr *e = kd->vmst->mmapbase;
Elf_Phdr *p = (Elf_Phdr*)((char*)e + e->e_phoff);
int n = e->e_phnum;
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;
return (PAGE_SIZE - ((size_t)pa & PAGE_MASK));
}
void
_kvm_freevtop(kvm_t *kd)
{
if (kd->vmst != 0) {
if (kd->vmst->PML4) {
free(kd->vmst->PML4);
}
free(kd->vmst);
}
struct vmstate *vm = kd->vmst;
if (vm->mmapbase != NULL)
munmap(vm->mmapbase, vm->mmapsize);
if (vm->PML4)
free(vm->PML4);
free(vm);
kd->vmst = NULL;
}
int
_kvm_initvtop(kvm_t *kd)
{
struct vmstate *vm;
struct nlist nlist[2];
u_long pa;
u_long kernbase;
pml4_entry_t *PML4;
Elf_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 == 0) {
_kvm_err(kd, kd->program, "cannot allocate vm");
return (-1);
}
kd->vmst = vm;
vm->PML4 = 0;
kd->vmst->PML4 = 0;
if (_kvm_maphdrs(kd, sizeof(Elf_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);
nlist[0].n_name = "kernbase";
nlist[1].n_name = 0;
@ -128,12 +187,12 @@ _kvm_initvtop(kvm_t *kd)
_kvm_err(kd, kd->program, "cannot read KPML4phys");
return (-1);
}
vm->PML4 = PML4;
kd->vmst->PML4 = PML4;
return (0);
}
static int
_kvm_vatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_vatop(kvm_t *kd, u_long va, off_t *pa)
{
struct vmstate *vm;
u_long offset;
@ -149,11 +208,9 @@ _kvm_vatop(kvm_t *kd, u_long va, u_long *pa)
u_long pdeindex;
u_long pteindex;
int i;
if (ISALIVE(kd)) {
_kvm_err(kd, 0, "kvm_vatop called in live kernel!");
return((off_t)0);
}
u_long a;
off_t ofs;
size_t s;
vm = kd->vmst;
offset = va & (PAGE_SIZE - 1);
@ -163,20 +220,32 @@ _kvm_vatop(kvm_t *kd, u_long va, u_long *pa)
* not yet set) then return pa == va to avoid infinite recursion.
*/
if (vm->PML4 == 0) {
*pa = va;
return (PAGE_SIZE - offset);
s = _kvm_pa2off(kd, va, pa);
if (s == 0) {
_kvm_err(kd, kd->program,
"_kvm_vatop: bootstrap data not in dump");
goto invalid;
} else
return (PAGE_SIZE - offset);
}
pml4eindex = (va >> PML4SHIFT) & (NPML4EPG - 1);
pml4e = vm->PML4[pml4eindex];
if (((u_long)pml4e & PG_V) == 0)
if (((u_long)pml4e & PG_V) == 0) {
_kvm_err(kd, kd->program, "_kvm_vatop: pml4e not valid");
goto invalid;
}
pdpeindex = (va >> PDPSHIFT) & (NPDPEPG-1);
pdpe_pa = ((u_long)pml4e & PG_FRAME) + (pdpeindex * sizeof(pdp_entry_t));
pdpe_pa = ((u_long)pml4e & PG_FRAME) +
(pdpeindex * sizeof(pdp_entry_t));
/* XXX This has to be a physical address read, kvm_read is virtual */
if (lseek(kd->pmfd, pdpe_pa, 0) == -1) {
s = _kvm_pa2off(kd, pdpe_pa, &ofs);
if (s <= sizeof pdpe) {
_kvm_err(kd, kd->program, "_kvm_vatop: pdpe_pa not found");
goto invalid;
}
if (lseek(kd->pmfd, ofs, 0) == -1) {
_kvm_syserr(kd, kd->program, "_kvm_vatop: lseek pdpe_pa");
goto invalid;
}
@ -184,24 +253,31 @@ _kvm_vatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_syserr(kd, kd->program, "_kvm_vatop: read pdpe");
goto invalid;
}
if (((u_long)pdpe & PG_V) == 0)
if (((u_long)pdpe & PG_V) == 0) {
_kvm_err(kd, kd->program, "_kvm_vatop: pdpe not valid");
goto invalid;
}
pdeindex = (va >> PDRSHIFT) & (NPDEPG-1);
pde_pa = ((u_long)pdpe & PG_FRAME) + (pdeindex * sizeof(pd_entry_t));
/* XXX This has to be a physical address read, kvm_read is virtual */
if (lseek(kd->pmfd, pde_pa, 0) == -1) {
_kvm_syserr(kd, kd->program, "_kvm_vatop: lseek pde_pa");
s = _kvm_pa2off(kd, pde_pa, &ofs);
if (s <= sizeof pde) {
_kvm_syserr(kd, kd->program, "_kvm_vatop: pde_pa not found");
goto invalid;
}
if (lseek(kd->pmfd, ofs, 0) == -1) {
_kvm_err(kd, kd->program, "_kvm_vatop: lseek pde_pa");
goto invalid;
}
if (read(kd->pmfd, &pde, sizeof pde) != sizeof pde) {
_kvm_syserr(kd, kd->program, "_kvm_vatop: read pde");
goto invalid;
}
if (((u_long)pde & PG_V) == 0)
if (((u_long)pde & PG_V) == 0) {
_kvm_err(kd, kd->program, "_kvm_vatop: pde not valid");
goto invalid;
}
if ((u_long)pde & PG_PS) {
/*
@ -209,15 +285,25 @@ _kvm_vatop(kvm_t *kd, u_long va, u_long *pa)
*/
#define PAGE2M_MASK (NBPDR - 1)
#define PG_FRAME2M (~PAGE2M_MASK)
*pa = ((u_long)pde & PG_FRAME2M) + (va & PAGE2M_MASK);
return (NBPDR - (va & PAGE2M_MASK));
a = ((u_long)pde & PG_FRAME2M) + (va & PAGE2M_MASK);
s = _kvm_pa2off(kd, a, pa);
if (s == 0) {
_kvm_err(kd, kd->program,
"_kvm_vatop: 2MB page address not in dump");
goto invalid;
} else
return (NBPDR - (va & PAGE2M_MASK));
}
pteindex = (va >> PAGE_SHIFT) & (NPTEPG-1);
pte_pa = ((u_long)pde & PG_FRAME) + (pteindex * sizeof(pt_entry_t));
/* XXX This has to be a physical address read, kvm_read is virtual */
if (lseek(kd->pmfd, pte_pa, 0) == -1) {
s = _kvm_pa2off(kd, pte_pa, &ofs);
if (s <= sizeof pte) {
_kvm_err(kd, kd->program, "_kvm_vatop: pte_pa not found");
goto invalid;
}
if (lseek(kd->pmfd, ofs, 0) == -1) {
_kvm_syserr(kd, kd->program, "_kvm_vatop: lseek");
goto invalid;
}
@ -225,19 +311,31 @@ _kvm_vatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_syserr(kd, kd->program, "_kvm_vatop: read");
goto invalid;
}
if (((u_long)pte & PG_V) == 0)
if (((u_long)pte & PG_V) == 0) {
_kvm_err(kd, kd->program, "_kvm_vatop: pte not valid");
goto invalid;
}
*pa = ((u_long)pte & PG_FRAME) + offset;
return (PAGE_SIZE - offset);
a = ((u_long)pte & PG_FRAME) + offset;
s = _kvm_pa2off(kd, a, pa);
if (s == 0) {
_kvm_err(kd, kd->program, "_kvm_vatop: address not in dump");
goto invalid;
} else
return (PAGE_SIZE - offset);
invalid:
_kvm_err(kd, 0, "invalid address (%x)", va);
_kvm_err(kd, 0, "invalid address (0x%lx)", va);
return (0);
}
int
_kvm_kvatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_kvatop(kvm_t *kd, u_long va, off_t *pa)
{
if (ISALIVE(kd)) {
_kvm_err(kd, 0, "kvm_kvatop called in live kernel!");
return (0);
}
return (_kvm_vatop(kd, va, pa));
}

2
lib/libkvm/kvm_arm.c
View File

@ -68,7 +68,7 @@ int
_kvm_kvatop(kd, va, pa)
kvm_t *kd;
u_long va;
u_long *pa;
off_t *pa;
{
_kvm_err(kd, 0, "vatop not yet implemented!");
return 0;

331
lib/libkvm/kvm_i386.c
View File

@ -53,6 +53,7 @@ static char sccsid[] = "@(#)kvm_hp300.c 8.1 (Berkeley) 6/4/93";
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <unistd.h>
#include <nlist.h>
@ -61,6 +62,8 @@ static char sccsid[] = "@(#)kvm_hp300.c 8.1 (Berkeley) 6/4/93";
#include <vm/vm.h>
#include <vm/vm_param.h>
#include <machine/elf.h>
#include <limits.h>
#include "kvm_private.h"
@ -70,37 +73,100 @@ static char sccsid[] = "@(#)kvm_hp300.c 8.1 (Berkeley) 6/4/93";
#define ptob(x) (i386_ptob(x))
#endif
#define PG_FRAME_PAE (~((uint64_t)PAGE_MASK))
#define PDRSHIFT_PAE 21
#define NPTEPG_PAE (PAGE_SIZE/sizeof(uint64_t))
#define NBPDR_PAE (1<<PDRSHIFT_PAE)
struct vmstate {
pd_entry_t *PTD;
void *mmapbase;
size_t mmapsize;
void *PTD;
int pae;
};
/*
* 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. (Taken from kvm_ia64.c)
*/
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, 0);
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.
* (Taken from kvm_ia64.c)
*/
static size_t
_kvm_pa2off(kvm_t *kd, uint64_t pa, off_t *ofs)
{
Elf_Ehdr *e = kd->vmst->mmapbase;
Elf_Phdr *p = (Elf_Phdr*)((char*)e + e->e_phoff);
int n = e->e_phnum;
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;
return (PAGE_SIZE - ((size_t)pa & PAGE_MASK));
}
void
_kvm_freevtop(kvm_t *kd)
{
if (kd->vmst != 0) {
if (kd->vmst->PTD) {
free(kd->vmst->PTD);
}
free(kd->vmst);
}
struct vmstate *vm = kd->vmst;
if (vm->mmapbase != NULL)
munmap(vm->mmapbase, vm->mmapsize);
if (vm->PTD)
free(vm->PTD);
free(vm);
kd->vmst = NULL;
}
int
_kvm_initvtop(kvm_t *kd)
{
struct vmstate *vm;
struct nlist nlist[2];
u_long pa;
u_long kernbase;
pd_entry_t *PTD;
char *PTD;
Elf_Ehdr *ehdr;
size_t hdrsz;
int i;
vm = (struct vmstate *)_kvm_malloc(kd, sizeof(*vm));
if (vm == 0) {
kd->vmst = (struct vmstate *)_kvm_malloc(kd, sizeof(*kd->vmst));
if (kd->vmst == 0) {
_kvm_err(kd, kd->program, "cannot allocate vm");
return (-1);
}
kd->vmst = vm;
vm->PTD = 0;
kd->vmst->PTD = 0;
if (_kvm_maphdrs(kd, sizeof(Elf_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);
nlist[0].n_name = "kernbase";
nlist[1].n_name = 0;
@ -110,79 +176,130 @@ _kvm_initvtop(kvm_t *kd)
else
kernbase = nlist[0].n_value;
nlist[0].n_name = "IdlePTD";
nlist[0].n_name = "IdlePDPT";
nlist[1].n_name = 0;
if (kvm_nlist(kd, nlist) != 0) {
_kvm_err(kd, kd->program, "bad namelist");
return (-1);
if (kvm_nlist(kd, nlist) == 0) {
uint64_t pa64;
if (kvm_read(kd, (nlist[0].n_value - kernbase), &pa,
sizeof(pa)) != sizeof(pa)) {
_kvm_err(kd, kd->program, "cannot read IdlePDPT");
return (-1);
}
PTD = _kvm_malloc(kd, 4 * PAGE_SIZE);
for (i = 0; i < 4; i++) {
if (kvm_read(kd, pa + (i * sizeof(pa64)), &pa64,
sizeof(pa64)) != sizeof(pa64)) {
_kvm_err(kd, kd->program, "Cannot read PDPT");
free(PTD);
return (-1);
}
if (kvm_read(kd, pa64 & PG_FRAME_PAE,
PTD + (i * PAGE_SIZE), PAGE_SIZE) != (PAGE_SIZE)) {
_kvm_err(kd, kd->program, "cannot read PDPT");
free(PTD);
return (-1);
}
}
kd->vmst->PTD = PTD;
kd->vmst->pae = 1;
} else {
nlist[0].n_name = "IdlePTD";
nlist[1].n_name = 0;
if (kvm_nlist(kd, nlist) != 0) {
_kvm_err(kd, kd->program, "bad namelist");
return (-1);
}
if (kvm_read(kd, (nlist[0].n_value - kernbase), &pa,
sizeof(pa)) != sizeof(pa)) {
_kvm_err(kd, kd->program, "cannot read IdlePTD");
return (-1);
}
PTD = _kvm_malloc(kd, PAGE_SIZE);
if (kvm_read(kd, pa, PTD, PAGE_SIZE) != PAGE_SIZE) {
_kvm_err(kd, kd->program, "cannot read PTD");
return (-1);
}
kd->vmst->PTD = PTD;
return (0);
kd->vmst->pae = 0;
}
if (kvm_read(kd, (nlist[0].n_value - kernbase), &pa, sizeof(pa)) !=
sizeof(pa)) {
_kvm_err(kd, kd->program, "cannot read IdlePTD");
return (-1);
}
PTD = _kvm_malloc(kd, PAGE_SIZE);
if (kvm_read(kd, pa, PTD, PAGE_SIZE) != PAGE_SIZE) {
_kvm_err(kd, kd->program, "cannot read PTD");
return (-1);
}
vm->PTD = PTD;
return (0);
}
static int
_kvm_vatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_vatop(kvm_t *kd, u_long va, off_t *pa)
{
struct vmstate *vm;
u_long offset;
u_long pte_pa;
u_long pde_pa;
pd_entry_t pde;
pt_entry_t pte;
u_long pdeindex;
u_long pteindex;
int i;
if (ISALIVE(kd)) {
_kvm_err(kd, 0, "vatop called in live kernel!");
return((off_t)0);
}
size_t s;
u_long a;
off_t ofs;
uint32_t *PTD;
vm = kd->vmst;
PTD = (uint32_t *)vm->PTD;
offset = va & (PAGE_SIZE - 1);
/*
* If we are initializing (kernel page table descriptor pointer
* not yet set) then return pa == va to avoid infinite recursion.
*/
if (vm->PTD == 0) {
*pa = va;
return (PAGE_SIZE - offset);
if (PTD == 0) {
s = _kvm_pa2off(kd, va, pa);
if (s == 0) {
_kvm_err(kd, kd->program,
"_kvm_vatop: bootstrap data not in dump");
goto invalid;
} else
return (PAGE_SIZE - offset);
}
pdeindex = va >> PDRSHIFT;
pde = vm->PTD[pdeindex];
if (((u_long)pde & PG_V) == 0)
pde = PTD[pdeindex];
if (((u_long)pde & PG_V) == 0) {
_kvm_err(kd, kd->program, "_kvm_vatop: pde not valid");
goto invalid;
}
if ((u_long)pde & PG_PS) {
/*
* No second-level page table; ptd describes one 4MB page.
* (We assume that the kernel wouldn't set PG_PS without enabling
* it cr0, and that the kernel doesn't support 36-bit physical
* addresses).
* it cr0).
*/
#define PAGE4M_MASK (NBPDR - 1)
#define PG_FRAME4M (~PAGE4M_MASK)
*pa = ((u_long)pde & PG_FRAME4M) + (va & PAGE4M_MASK);
pde_pa = ((u_long)pde & PG_FRAME4M) + (va & PAGE4M_MASK);
s = _kvm_pa2off(kd, pde_pa, &ofs);
if (s <= sizeof pde) {
_kvm_syserr(kd, kd->program,
"_kvm_vatop: pde_pa not found");
goto invalid;
}
*pa = ofs;
return (NBPDR - (va & PAGE4M_MASK));
}
pteindex = (va >> PAGE_SHIFT) & (NPTEPG-1);
pte_pa = ((u_long)pde & PG_FRAME) + (pteindex * sizeof(pt_entry_t));
pte_pa = ((u_long)pde & PG_FRAME) + (pteindex * sizeof(pde));
s = _kvm_pa2off(kd, pte_pa, &ofs);
if (s <= sizeof pte) {
_kvm_err(kd, kd->program, "_kvm_vatop: pdpe_pa not found");
goto invalid;
}
/* XXX This has to be a physical address read, kvm_read is virtual */
if (lseek(kd->pmfd, pte_pa, 0) == -1) {
if (lseek(kd->pmfd, ofs, 0) == -1) {
_kvm_syserr(kd, kd->program, "_kvm_vatop: lseek");
goto invalid;
}
@ -190,19 +307,131 @@ _kvm_vatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_syserr(kd, kd->program, "_kvm_vatop: read");
goto invalid;
}
if (((u_long)pte & PG_V) == 0)
if (((u_long)pte & PG_V) == 0) {
_kvm_err(kd, kd->program, "_kvm_kvatop: pte not valid");
goto invalid;
}
*pa = ((u_long)pte & PG_FRAME) + offset;
return (PAGE_SIZE - offset);
a = ((u_long)pte & PG_FRAME) + offset;
s =_kvm_pa2off(kd, a, pa);
if (s == 0) {
_kvm_err(kd, kd->program, "_kvm_vatop: address not in dump");
goto invalid;
} else
return (PAGE_SIZE - offset);
invalid:
_kvm_err(kd, 0, "invalid address (%x)", va);
_kvm_err(kd, 0, "invalid address (0x%lx)", va);
return (0);
}
static int
_kvm_vatop_pae(kvm_t *kd, u_long va, off_t *pa)
{
struct vmstate *vm;
uint64_t offset;
uint64_t pte_pa;
uint64_t pde_pa;
uint64_t pde;
uint64_t pte;
u_long pdeindex;
u_long pteindex;
size_t s;
uint64_t a;
off_t ofs;
uint64_t *PTD;
vm = kd->vmst;
PTD = (uint64_t *)vm->PTD;
offset = va & (PAGE_SIZE - 1);
/*
* If we are initializing (kernel page table descriptor pointer
* not yet set) then return pa == va to avoid infinite recursion.
*/
if (PTD == 0) {
s = _kvm_pa2off(kd, va, pa);
if (s == 0) {
_kvm_err(kd, kd->program,
"_kvm_vatop_pae: bootstrap data not in dump");
goto invalid;
} else
return (PAGE_SIZE - offset);
}
pdeindex = va >> PDRSHIFT_PAE;
pde = PTD[pdeindex];
if (((u_long)pde & PG_V) == 0) {
_kvm_err(kd, kd->program, "_kvm_kvatop_pae: pde not valid");
goto invalid;
}
if ((u_long)pde & PG_PS) {
/*
* No second-level page table; ptd describes one 2MB page.
* (We assume that the kernel wouldn't set PG_PS without enabling
* it cr0).
*/
#define PAGE2M_MASK (NBPDR_PAE - 1)
#define PG_FRAME2M (~PAGE2M_MASK)
pde_pa = ((u_long)pde & PG_FRAME2M) + (va & PAGE2M_MASK);
s = _kvm_pa2off(kd, pde_pa, &ofs);
if (s <= sizeof pde) {
_kvm_syserr(kd, kd->program,
"_kvm_vatop_pae: pde_pa not found");
goto invalid;
}
*pa = ofs;
return (NBPDR_PAE - (va & PAGE2M_MASK));
}
pteindex = (va >> PAGE_SHIFT) & (NPTEPG_PAE-1);
pte_pa = ((uint64_t)pde & PG_FRAME_PAE) + (pteindex * sizeof(pde));
s = _kvm_pa2off(kd, pte_pa, &ofs);
if (s <= sizeof pte) {
_kvm_err(kd, kd->program, "_kvm_vatop_pae: pdpe_pa not found");
goto invalid;
}
/* XXX This has to be a physical address read, kvm_read is virtual */
if (lseek(kd->pmfd, ofs, 0) == -1) {
_kvm_syserr(kd, kd->program, "_kvm_vatop_pae: lseek");
goto invalid;
}
if (read(kd->pmfd, &pte, sizeof pte) != sizeof pte) {
_kvm_syserr(kd, kd->program, "_kvm_vatop_pae: read");
goto invalid;
}
if (((uint64_t)pte & PG_V) == 0) {
_kvm_err(kd, kd->program, "_kvm_vatop_pae: pte not valid");
goto invalid;
}
a = ((uint64_t)pte & PG_FRAME_PAE) + offset;
s =_kvm_pa2off(kd, a, pa);
if (s == 0) {
_kvm_err(kd, kd->program,
"_kvm_vatop_pae: address not in dump");
goto invalid;
} else
return (PAGE_SIZE - offset);
invalid:
_kvm_err(kd, 0, "invalid address (0x%lx)", va);
return (0);
}
int
_kvm_kvatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_kvatop(kvm_t *kd, u_long va, uint64_t *pa)
{
return (_kvm_vatop(kd, va, pa));
if (ISALIVE(kd)) {
_kvm_err(kd, 0, "vatop called in live kernel!");
return (0);
}
if (kd->vmst->pae)
return (_kvm_vatop_pae(kd, va, pa));
else
return (_kvm_vatop(kd, va, pa));
}

4
lib/libkvm/kvm_ia64.c
View File

@ -85,7 +85,7 @@ _kvm_maphdrs(kvm_t *kd, size_t sz)
* 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)
_kvm_pa2off(kvm_t *kd, uint64_t pa, off_t *ofs, size_t pgsz)
{
Elf64_Ehdr *e = kd->vmst->mmapbase;
Elf64_Phdr *p = (Elf64_Phdr*)((char*)e + e->e_phoff);
@ -171,7 +171,7 @@ _kvm_initvtop(kvm_t *kd)
}
int
_kvm_kvatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_kvatop(kvm_t *kd, u_long va, off_t *pa)
{
struct ia64_lpte pte;
uint64_t pgaddr, ptaddr;

2
lib/libkvm/kvm_powerpc.c
View File

@ -68,7 +68,7 @@ int
_kvm_kvatop(kd, va, pa)
kvm_t *kd;
u_long va;
u_long *pa;
off_t *pa;
{
_kvm_err(kd, 0, "vatop not yet implemented!");
return 0;

2
lib/libkvm/kvm_private.h
View File

@ -75,7 +75,7 @@ void _kvm_err(kvm_t *kd, const char *program, const char *fmt, ...)
void _kvm_freeprocs(kvm_t *kd);
void _kvm_freevtop(kvm_t *);
int _kvm_initvtop(kvm_t *);
int _kvm_kvatop(kvm_t *, u_long, u_long *);
int _kvm_kvatop(kvm_t *, u_long, off_t *);
void *_kvm_malloc(kvm_t *kd, size_t);
void *_kvm_realloc(kvm_t *kd, void *, size_t);
void _kvm_syserr (kvm_t *kd, const char *program, const char *fmt, ...)

2
lib/libkvm/kvm_sparc.c
View File

@ -216,7 +216,7 @@ int
_kvm_kvatop(kd, va, pa)
kvm_t *kd;
u_long va;
u_long *pa;
uint64_t *pa;
{
struct vmstate *vm;
int s;

2
lib/libkvm/kvm_sparc64.c
View File

@ -191,7 +191,7 @@ fail_vm:
}
int
_kvm_kvatop(kvm_t *kd, u_long va, u_long *pa)
_kvm_kvatop(kvm_t *kd, u_long va, off_t *pa)
{
struct vmstate *vm;
struct tte tte;