lib/libkvm/kvm_ia64.c

   1 /* $FreeBSD$ */
   2 /*      $NetBSD: kvm_alpha.c,v 1.7.2.1 1997/11/02 20:34:26 mellon Exp $ */
   3
   4 /*
   5  * Copyright (c) 1994, 1995 Carnegie-Mellon University.
   6  * All rights reserved.
   7  *
   8  * Author: Chris G. Demetriou
   9  *
  10  * Permission to use, copy, modify and distribute this software and
  11  * its documentation is hereby granted, provided that both the copyright
  12  * notice and this permission notice appear in all copies of the
  13  * software, derivative works or modified versions, and any portions
  14  * thereof, and that both notices appear in supporting documentation.
  15  *
  16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  18  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  19  *
  20  * Carnegie Mellon requests users of this software to return to
  21  *
  22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  23  *  School of Computer Science
  24  *  Carnegie Mellon University
  25  *  Pittsburgh PA 15213-3890
  26  *
  27  * any improvements or extensions that they make and grant Carnegie the
  28  * rights to redistribute these changes.
  29  */
  30
  31 #include <sys/types.h>
  32 #include <sys/elf64.h>
  33 #include <sys/mman.h>
  34
  35 #include <machine/pte.h>
  36
  37 #include <kvm.h>
  38 #include <limits.h>
  39 #include <stdlib.h>
  40 #include <unistd.h>
  41
  42 #include "kvm_private.h"
  43
  44 #define REGION_BASE(n)          (((uint64_t)(n)) << 61)
  45 #define REGION_ADDR(x)          ((x) & ((1LL<<61)-1LL))
  46
  47 #define NKPTEPG(ps)             ((ps) / sizeof(struct ia64_lpte))
  48 #define KPTE_PTE_INDEX(va,ps)   (((va)/(ps)) % NKPTEPG(ps))
  49 #define KPTE_DIR_INDEX(va,ps)   (((va)/(ps)) / NKPTEPG(ps))
  50
  51 struct vmstate {
  52         void    *mmapbase;
  53         size_t  mmapsize;
  54         size_t  pagesize;
  55         u_long  kptdir;
  56 };
  57
  58 /*
  59  * Map the ELF headers into the process' address space. We do this in two
  60  * steps: first the ELF header itself and using that information the whole
  61  * set of headers.
  62  */
  63 static int
  64 _kvm_maphdrs(kvm_t *kd, size_t sz)
  65 {
  66         struct vmstate *vm = kd->vmst;
  67
  68         /* munmap() previous mmap(). */
  69         if (vm->mmapbase != NULL) {
  70                 munmap(vm->mmapbase, vm->mmapsize);
  71                 vm->mmapbase = NULL;
  72         }
  73
  74         vm->mmapsize = sz;
  75         vm->mmapbase = mmap(NULL, sz, PROT_READ, MAP_PRIVATE, kd->pmfd, 0);
  76         if (vm->mmapbase == MAP_FAILED) {
  77                 _kvm_err(kd, kd->program, "cannot mmap corefile");
  78                 return (-1);
  79         }
  80
  81         return (0);
  82 }
  83
  84 /*
  85  * Translate a physical memory address to a file-offset in the crash-dump.
  86  */
  87 static size_t
  88 _kvm_pa2off(kvm_t *kd, uint64_t pa, off_t *ofs, size_t pgsz)
  89 {
  90         Elf64_Ehdr *e = kd->vmst->mmapbase;
  91         Elf64_Phdr *p = (Elf64_Phdr*)((char*)e + e->e_phoff);
  92         int n = e->e_phnum;
  93
  94         if (pa != REGION_ADDR(pa)) {
  95                 _kvm_err(kd, kd->program, "internal error");
  96                 return (0);
  97         }
  98
  99         while (n && (pa < p->p_paddr || pa >= p->p_paddr + p->p_memsz))
 100                 p++, n--;
 101         if (n == 0)
 102                 return (0);
 103
 104         *ofs = (pa - p->p_paddr) + p->p_offset;
 105         if (pgsz == 0)
 106                 return (p->p_memsz - (pa - p->p_paddr));
 107         return (pgsz - ((size_t)pa & (pgsz - 1)));
 108 }
 109
 110 void
 111 _kvm_freevtop(kvm_t *kd)
 112 {
 113         struct vmstate *vm = kd->vmst;
 114
 115         if (vm->mmapbase != NULL)
 116                 munmap(vm->mmapbase, vm->mmapsize);
 117         free(vm);
 118         kd->vmst = NULL;
 119 }
 120
 121 int
 122 _kvm_initvtop(kvm_t *kd)
 123 {
 124         struct nlist nlist[2];
 125         uint64_t va;
 126         Elf64_Ehdr *ehdr;
 127         size_t hdrsz;
 128
 129         kd->vmst = (struct vmstate *)_kvm_malloc(kd, sizeof(*kd->vmst));
 130         if (kd->vmst == NULL) {
 131                 _kvm_err(kd, kd->program, "cannot allocate vm");
 132                 return (-1);
 133         }
 134
 135         kd->vmst->pagesize = getpagesize();
 136
 137         if (_kvm_maphdrs(kd, sizeof(Elf64_Ehdr)) == -1)
 138                 return (-1);
 139
 140         ehdr = kd->vmst->mmapbase;
 141         hdrsz = ehdr->e_phoff + ehdr->e_phentsize * ehdr->e_phnum;
 142         if (_kvm_maphdrs(kd, hdrsz) == -1)
 143                 return (-1);
 144
 145         /*
 146          * At this point we've got enough information to use kvm_read() for
 147          * direct mapped (ie region 6 and region 7) address, such as symbol
 148          * addresses/values.
 149          */
 150
 151         nlist[0].n_name = "ia64_kptdir";
 152         nlist[1].n_name = 0;
 153
 154         if (kvm_nlist(kd, nlist) != 0) {
 155                 _kvm_err(kd, kd->program, "bad namelist");
 156                 return (-1);
 157         }
 158
 159         if (kvm_read(kd, (nlist[0].n_value), &va, sizeof(va)) != sizeof(va)) {
 160                 _kvm_err(kd, kd->program, "cannot read kptdir");
 161                 return (-1);
 162         }
 163
 164         if (va < REGION_BASE(6)) {
 165                 _kvm_err(kd, kd->program, "kptdir is itself virtual");
 166                 return (-1);
 167         }
 168
 169         kd->vmst->kptdir = va;
 170         return (0);
 171 }
 172
 173 int
 174 _kvm_kvatop(kvm_t *kd, u_long va, off_t *pa)
 175 {
 176         struct ia64_lpte pte;
 177         uint64_t pgaddr, ptaddr;
 178         size_t pgno, pgsz, ptno;
 179
 180         if (va >= REGION_BASE(6)) {
 181                 /* Regions 6 and 7: direct mapped. */
 182                 return (_kvm_pa2off(kd, REGION_ADDR(va), pa, 0));
 183         } else if (va >= REGION_BASE(5)) {
 184                 /* Region 5: virtual. */
 185                 va = REGION_ADDR(va);
 186                 pgsz = kd->vmst->pagesize;
 187                 ptno = KPTE_DIR_INDEX(va, pgsz);
 188                 pgno = KPTE_PTE_INDEX(va, pgsz);
 189                 if (ptno >= (pgsz >> 3))
 190                         goto fail;
 191                 ptaddr = kd->vmst->kptdir + (ptno << 3);
 192                 if (kvm_read(kd, ptaddr, &pgaddr, 8) != 8)
 193                         goto fail;
 194                 if (pgaddr == 0)
 195                         goto fail;
 196                 pgaddr += (pgno * sizeof(pte));
 197                 if (kvm_read(kd, pgaddr, &pte, sizeof(pte)) != sizeof(pte))
 198                         goto fail;
 199                 if (!(pte.pte & PTE_PRESENT))
 200                         goto fail;
 201                 va = (pte.pte & PTE_PPN_MASK) + (va & (pgsz - 1));
 202                 return (_kvm_pa2off(kd, va, pa, pgsz));
 203         }
 204
 205  fail:
 206         _kvm_err(kd, kd->program, "invalid kernel virtual address");
 207         *pa = ~0UL;
 208         return (0);
 209 }