lib/libkvm/kvm_alpha.c

   1 /* $Id$ */
   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/param.h>
  32 #include <sys/user.h>
  33 #include <sys/proc.h>
  34 #include <sys/stat.h>
  35 #include <unistd.h>
  36 #include <nlist.h>
  37 #include <kvm.h>
  38
  39 #include <vm/vm.h>
  40 #include <vm/vm_param.h>
  41
  42 #include <limits.h>
  43 #include <db.h>
  44 #include <stdlib.h>
  45
  46 #include "kvm_private.h"
  47
  48 void
  49 _kvm_freevtop(kd)
  50         kvm_t *kd;
  51 {
  52
  53         /* Not actually used for anything right now, but safe. */
  54         if (kd->vmst != 0)
  55                 free(kd->vmst);
  56 }
  57
  58 int
  59 _kvm_initvtop(kd)
  60         kvm_t *kd;
  61 {
  62
  63         return (0);
  64 }
  65
  66 int
  67 _kvm_kvatop(kd, va, pa)
  68         kvm_t *kd;
  69         u_long va;
  70         u_long *pa;
  71 {
  72 #if 0
  73         cpu_kcore_hdr_t *cpu_kh;
  74         int rv, page_off;
  75         alpha_pt_entry_t pte;
  76         off_t pteoff;
  77
  78         if (ISALIVE(kd)) {
  79                 _kvm_err(kd, 0, "vatop called in live kernel!");
  80                 return(0);
  81         }
  82
  83         cpu_kh = kd->cpu_data;
  84         page_off = va & (cpu_kh->page_size - 1);
  85
  86         if (va >= ALPHA_K0SEG_BASE && va <= ALPHA_K0SEG_END) {
  87                 /*
  88                  * Direct-mapped address: just convert it.
  89                  */
  90
  91                 *pa = ALPHA_K0SEG_TO_PHYS(va);
  92                 rv = cpu_kh->page_size - page_off;
  93         } else if (va >= ALPHA_K1SEG_BASE && va <= ALPHA_K1SEG_END) {
  94                 /*
  95                  * Real kernel virtual address: do the translation.
  96                  */
  97
  98                 /* Find and read the L1 PTE. */
  99                 pteoff = cpu_kh->lev1map_pa +
 100                     kvtol1pte(va) * sizeof(alpha_pt_entry_t);
 101                 if (lseek(kd->pmfd, _kvm_pa2off(kd, pteoff), 0) == -1 ||
 102                     read(kd->pmfd, (char *)&pte, sizeof(pte)) != sizeof(pte)) {
 103                         _kvm_syserr(kd, 0, "could not read L1 PTE");
 104                         goto lose;
 105                 }
 106
 107                 /* Find and read the L2 PTE. */
 108                 if ((pte & ALPHA_PTE_VALID) == 0) {
 109                         _kvm_err(kd, 0, "invalid translation (invalid L1 PTE)");
 110                         goto lose;
 111                 }
 112                 pteoff = ALPHA_PTE_TO_PFN(pte) * cpu_kh->page_size +
 113                     vatoste(va) * sizeof(alpha_pt_entry_t);
 114                 if (lseek(kd->pmfd, _kvm_pa2off(kd, pteoff), 0) == -1 ||
 115                     read(kd->pmfd, (char *)&pte, sizeof(pte)) != sizeof(pte)) {
 116                         _kvm_syserr(kd, 0, "could not read L2 PTE");
 117                         goto lose;
 118                 }
 119
 120                 /* Find and read the L3 PTE. */
 121                 if ((pte & ALPHA_PTE_VALID) == 0) {
 122                         _kvm_err(kd, 0, "invalid translation (invalid L2 PTE)");
 123                         goto lose;
 124                 }
 125                 pteoff = ALPHA_PTE_TO_PFN(pte) * cpu_kh->page_size +
 126                     vatopte(va) * sizeof(alpha_pt_entry_t);
 127                 if (lseek(kd->pmfd, _kvm_pa2off(kd, pteoff), 0) == -1 ||
 128                     read(kd->pmfd, (char *)&pte, sizeof(pte)) != sizeof(pte)) {
 129                         _kvm_syserr(kd, 0, "could not read L3 PTE");
 130                         goto lose;
 131                 }
 132
 133                 /* Fill in the PA. */
 134                 if ((pte & ALPHA_PTE_VALID) == 0) {
 135                         _kvm_err(kd, 0, "invalid translation (invalid L3 PTE)");
 136                         goto lose;
 137                 }
 138                 *pa = ALPHA_PTE_TO_PFN(pte) * cpu_kh->page_size + page_off;
 139                 rv = cpu_kh->page_size - page_off;
 140         } else {
 141                 /*
 142                  * Bogus address (not in KV space): punt.
 143                  */
 144
 145                 _kvm_err(kd, 0, "invalid kernel virtual address");
 146 lose:
 147                 *pa = -1;
 148                 rv = 0;
 149         }
 150
 151         return (rv);
 152 #else
 153         return (0);
 154 #endif
 155 }
 156
 157 /*
 158  * Translate a physical address to a file-offset in the crash-dump.
 159  */
 160 off_t
 161 _kvm_pa2off(kd, pa)
 162         kvm_t *kd;
 163         u_long pa;
 164 {
 165 #if 0
 166         off_t off;
 167         cpu_kcore_hdr_t *cpu_kh;
 168
 169         cpu_kh = kd->cpu_data;
 170
 171         off = 0;
 172         pa -= cpu_kh->core_seg.start;
 173
 174         return (kd->dump_off + off + pa);
 175 #else
 176         return 0;               /* XXX fixme */
 177 #endif
 178 }
 179
 180 /*
 181  * Machine-dependent initialization for ALL open kvm descriptors,
 182  * not just those for a kernel crash dump.  Some architectures
 183  * have to deal with these NOT being constants!  (i.e. m68k)
 184  */
 185 int
 186 _kvm_mdopen(kd)
 187         kvm_t   *kd;
 188 {
 189
 190 #if 0                           /* XXX fixme */
 191         kd->usrstack = USRSTACK;
 192         kd->min_uva = VM_MIN_ADDRESS;
 193         kd->max_uva = VM_MAXUSER_ADDRESS;
 194 #endif
 195
 196         return (0);
 197 }