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 NKPTEDIR(ps)            ((ps) >> 3)
  49 #define KPTE_PTE_INDEX(va,ps)   (((va)/(ps)) % NKPTEPG(ps))
  50 #define KPTE_DIR0_INDEX(va,ps)  ((((va)/(ps)) / NKPTEPG(ps)) / NKPTEDIR(ps))
  51 #define KPTE_DIR1_INDEX(va,ps)  ((((va)/(ps)) / NKPTEPG(ps)) % NKPTEDIR(ps))
  52
  53 struct vmstate {
  54         void    *mmapbase;
  55         size_t  mmapsize;
  56         size_t  pagesize;
  57         u_long  kptdir;
  58 };
  59
  60 /*
  61  * Map the ELF headers into the process' address space. We do this in two
  62  * steps: first the ELF header itself and using that information the whole
  63  * set of headers.
  64  */
  65 static int
  66 _kvm_maphdrs(kvm_t *kd, size_t sz)
  67 {
  68         struct vmstate *vm = kd->vmst;
  69
  70         /* munmap() previous mmap(). */
  71         if (vm->mmapbase != NULL) {
  72                 munmap(vm->mmapbase, vm->mmapsize);
  73                 vm->mmapbase = NULL;
  74         }
  75
  76         vm->mmapsize = sz;
  77         vm->mmapbase = mmap(NULL, sz, PROT_READ, MAP_PRIVATE, kd->pmfd, 0);
  78         if (vm->mmapbase == MAP_FAILED) {
  79                 _kvm_err(kd, kd->program, "cannot mmap corefile");
  80                 return (-1);
  81         }
  82
  83         return (0);
  84 }
  85
  86 /*
  87  * Translate a physical memory address to a file-offset in the crash-dump.
  88  */
  89 static size_t
  90 _kvm_pa2off(kvm_t *kd, uint64_t pa, off_t *ofs, size_t pgsz)
  91 {
  92         Elf64_Ehdr *e = kd->vmst->mmapbase;
  93         Elf64_Phdr *p = (Elf64_Phdr*)((char*)e + e->e_phoff);
  94         int n = e->e_phnum;
  95
  96         if (pa != REGION_ADDR(pa)) {
  97                 _kvm_err(kd, kd->program, "internal error");
  98                 return (0);
  99         }
 100
 101         while (n && (pa < p->p_paddr || pa >= p->p_paddr + p->p_memsz))
 102                 p++, n--;
 103         if (n == 0)
 104                 return (0);
 105
 106         *ofs = (pa - p->p_paddr) + p->p_offset;
 107         if (pgsz == 0)
 108                 return (p->p_memsz - (pa - p->p_paddr));
 109         return (pgsz - ((size_t)pa & (pgsz - 1)));
 110 }
 111
 112 void
 113 _kvm_freevtop(kvm_t *kd)
 114 {
 115         struct vmstate *vm = kd->vmst;
 116
 117         if (vm->mmapbase != NULL)
 118                 munmap(vm->mmapbase, vm->mmapsize);
 119         free(vm);
 120         kd->vmst = NULL;
 121 }
 122
 123 int
 124 _kvm_initvtop(kvm_t *kd)
 125 {
 126         struct nlist nlist[2];
 127         uint64_t va;
 128         Elf64_Ehdr *ehdr;
 129         size_t hdrsz;
 130
 131         kd->vmst = (struct vmstate *)_kvm_malloc(kd, sizeof(*kd->vmst));
 132         if (kd->vmst == NULL) {
 133                 _kvm_err(kd, kd->program, "cannot allocate vm");
 134                 return (-1);
 135         }
 136
 137         kd->vmst->pagesize = getpagesize();
 138
 139         if (_kvm_maphdrs(kd, sizeof(Elf64_Ehdr)) == -1)
 140                 return (-1);
 141
 142         ehdr = kd->vmst->mmapbase;
 143         hdrsz = ehdr->e_phoff + ehdr->e_phentsize * ehdr->e_phnum;
 144         if (_kvm_maphdrs(kd, hdrsz) == -1)
 145                 return (-1);
 146
 147         /*
 148          * At this point we've got enough information to use kvm_read() for
 149          * direct mapped (ie region 6 and region 7) address, such as symbol
 150          * addresses/values.
 151          */
 152
 153         nlist[0].n_name = "ia64_kptdir";
 154         nlist[1].n_name = 0;
 155
 156         if (kvm_nlist(kd, nlist) != 0) {
 157                 _kvm_err(kd, kd->program, "bad namelist");
 158                 return (-1);
 159         }
 160
 161         if (kvm_read(kd, (nlist[0].n_value), &va, sizeof(va)) != sizeof(va)) {
 162                 _kvm_err(kd, kd->program, "cannot read kptdir");
 163                 return (-1);
 164         }
 165
 166         if (va < REGION_BASE(6)) {
 167                 _kvm_err(kd, kd->program, "kptdir is itself virtual");
 168                 return (-1);
 169         }
 170
 171         kd->vmst->kptdir = va;
 172         return (0);
 173 }
 174
 175 int
 176 _kvm_kvatop(kvm_t *kd, u_long va, off_t *pa)
 177 {
 178         struct ia64_lpte pte;
 179         uint64_t pgaddr, pt0addr, pt1addr;
 180         size_t pgno, pgsz, pt0no, pt1no;
 181
 182         if (va >= REGION_BASE(6)) {
 183                 /* Regions 6 and 7: direct mapped. */
 184                 return (_kvm_pa2off(kd, REGION_ADDR(va), pa, 0));
 185         } else if (va >= REGION_BASE(5)) {
 186                 /* Region 5: virtual. */
 187                 va = REGION_ADDR(va);
 188                 pgsz = kd->vmst->pagesize;
 189                 pt0no = KPTE_DIR0_INDEX(va, pgsz);
 190                 pt1no = KPTE_DIR1_INDEX(va, pgsz);
 191                 pgno = KPTE_PTE_INDEX(va, pgsz);
 192                 if (pt0no >= NKPTEDIR(pgsz))
 193                         goto fail;
 194                 pt0addr = kd->vmst->kptdir + (pt0no << 3);
 195                 if (kvm_read(kd, pt0addr, &pt1addr, 8) != 8)
 196                         goto fail;
 197                 if (pt1addr == 0)
 198                         goto fail;
 199                 pt1addr += pt1no << 3;
 200                 if (kvm_read(kd, pt1addr, &pgaddr, 8) != 8)
 201                         goto fail;
 202                 if (pgaddr == 0)
 203                         goto fail;
 204                 pgaddr += pgno * sizeof(pte);
 205                 if (kvm_read(kd, pgaddr, &pte, sizeof(pte)) != sizeof(pte))
 206                         goto fail;
 207                 if (!(pte.pte & PTE_PRESENT))
 208                         goto fail;
 209                 va = (pte.pte & PTE_PPN_MASK) + (va & (pgsz - 1));
 210                 return (_kvm_pa2off(kd, va, pa, pgsz));
 211         }
 212
 213  fail:
 214         _kvm_err(kd, kd->program, "invalid kernel virtual address");
 215         *pa = ~0UL;
 216         return (0);
 217 }