lib/libkvm/kvm_sparc64.c

   1 /*-
   2  * Copyright (c) 1989, 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software developed by the Computer Systems
   6  * Engineering group at Lawrence Berkeley Laboratory under DARPA contract
   7  * BG 91-66 and contributed to Berkeley.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      from: FreeBSD: src/lib/libkvm/kvm_i386.c,v 1.15 2001/10/10 17:48:43
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #if defined(LIBC_SCCS) && !defined(lint)
  40 #if 0
  41 static char sccsid[] = "@(#)kvm_hp300.c 8.1 (Berkeley) 6/4/93";
  42 #endif
  43 #endif /* LIBC_SCCS and not lint */
  44
  45 /*
  46  * sparc64 machine dependent routines for kvm.
  47  */
  48
  49 #include <sys/param.h>
  50 #include <kvm.h>
  51 #include <limits.h>
  52 #include <stdint.h>
  53 #include <stdlib.h>
  54 #include <unistd.h>
  55
  56 #include "../../sys/sparc64/include/kerneldump.h"
  57
  58 #include "kvm_private.h"
  59 #include "kvm_sparc64.h"
  60
  61 struct vmstate {
  62         off_t           vm_tsb_off;
  63         uint64_t        vm_tsb_mask;
  64         int             vm_nregions;
  65         struct sparc64_dump_reg *vm_regions;
  66 };
  67
  68 static int
  69 _sparc64_probe(kvm_t *kd)
  70 {
  71
  72         return (_kvm_probe_elf_kernel(kd, ELFCLASS64, EM_SPARCV9));
  73 }
  74
  75 static void
  76 _sparc64_freevtop(kvm_t *kd)
  77 {
  78
  79         free(kd->vmst->vm_regions);
  80         free(kd->vmst);
  81         kd->vmst = NULL;
  82 }
  83
  84 static int
  85 _sparc64_read_phys(kvm_t *kd, off_t pos, void *buf, size_t size)
  86 {
  87
  88         /* XXX This has to be a raw file read, kvm_read is virtual. */
  89         if (pread(kd->pmfd, buf, size, pos) != (ssize_t)size) {
  90                 _kvm_syserr(kd, kd->program, "_sparc64_read_phys: pread");
  91                 return (0);
  92         }
  93         return (1);
  94 }
  95
  96 static int
  97 _sparc64_reg_cmp(const void *a, const void *b)
  98 {
  99         const struct sparc64_dump_reg *ra, *rb;
 100
 101         ra = a;
 102         rb = b;
 103         if (ra->dr_pa < rb->dr_pa)
 104                 return (-1);
 105         else if (ra->dr_pa >= rb->dr_pa + rb->dr_size)
 106                 return (1);
 107         else
 108                 return (0);
 109 }
 110
 111 #define KVM_OFF_NOTFOUND        0
 112
 113 static off_t
 114 _sparc64_find_off(struct vmstate *vm, uint64_t pa, uint64_t size)
 115 {
 116         struct sparc64_dump_reg *reg, key;
 117         vm_offset_t o;
 118
 119         key.dr_pa = pa;
 120         reg = bsearch(&key, vm->vm_regions, vm->vm_nregions,
 121             sizeof(*vm->vm_regions), _sparc64_reg_cmp);
 122         if (reg == NULL)
 123                 return (KVM_OFF_NOTFOUND);
 124         o = pa - reg->dr_pa;
 125         if (o + size > reg->dr_size)
 126                 return (KVM_OFF_NOTFOUND);
 127         return (reg->dr_offs + o);
 128 }
 129
 130 static int
 131 _sparc64_initvtop(kvm_t *kd)
 132 {
 133         struct sparc64_dump_hdr hdr;
 134         struct sparc64_dump_reg *regs;
 135         struct vmstate *vm;
 136         size_t regsz;
 137         uint64_t pa;
 138         int i;
 139
 140         vm = (struct vmstate *)_kvm_malloc(kd, sizeof(*vm));
 141         if (vm == NULL) {
 142                 _kvm_err(kd, kd->program, "cannot allocate vm");
 143                 return (-1);
 144         }
 145         kd->vmst = vm;
 146
 147         if (!_sparc64_read_phys(kd, 0, &hdr, sizeof(hdr)))
 148                 goto fail_vm;
 149         hdr.dh_hdr_size = be64toh(hdr.dh_hdr_size);
 150         hdr.dh_tsb_pa = be64toh(hdr.dh_tsb_pa);
 151         hdr.dh_tsb_size = be64toh(hdr.dh_tsb_size);
 152         hdr.dh_tsb_mask = be64toh(hdr.dh_tsb_mask);
 153         hdr.dh_nregions = be32toh(hdr.dh_nregions);
 154         pa = hdr.dh_tsb_pa;
 155
 156         regsz = hdr.dh_nregions * sizeof(*regs);
 157         regs = _kvm_malloc(kd, regsz);
 158         if (regs == NULL) {
 159                 _kvm_err(kd, kd->program, "cannot allocate regions");
 160                 goto fail_vm;
 161         }
 162         if (!_sparc64_read_phys(kd, sizeof(hdr), regs, regsz))
 163                 goto fail_regs;
 164         for (i = 0; i < hdr.dh_nregions; i++) {
 165                 regs[i].dr_pa = be64toh(regs[i].dr_pa);
 166                 regs[i].dr_size = be64toh(regs[i].dr_size);
 167                 regs[i].dr_offs = be64toh(regs[i].dr_offs);
 168         }
 169         qsort(regs, hdr.dh_nregions, sizeof(*regs), _sparc64_reg_cmp);
 170
 171         vm->vm_tsb_mask = hdr.dh_tsb_mask;
 172         vm->vm_regions = regs;
 173         vm->vm_nregions = hdr.dh_nregions;
 174         vm->vm_tsb_off = _sparc64_find_off(vm, hdr.dh_tsb_pa, hdr.dh_tsb_size);
 175         if (vm->vm_tsb_off == KVM_OFF_NOTFOUND) {
 176                 _kvm_err(kd, kd->program, "tsb not found in dump");
 177                 goto fail_regs;
 178         }
 179         return (0);
 180
 181 fail_regs:
 182         free(regs);
 183 fail_vm:
 184         free(vm);
 185         return (-1);
 186 }
 187
 188 static int
 189 _sparc64_kvatop(kvm_t *kd, kvaddr_t va, off_t *pa)
 190 {
 191         struct sparc64_tte tte;
 192         off_t tte_off;
 193         kvaddr_t vpn;
 194         off_t pa_off;
 195         kvaddr_t pg_off;
 196         int rest;
 197
 198         pg_off = va & SPARC64_PAGE_MASK;
 199         if (va >= SPARC64_MIN_DIRECT_ADDRESS)
 200                 pa_off = SPARC64_DIRECT_TO_PHYS(va) & ~SPARC64_PAGE_MASK;
 201         else {
 202                 vpn = va >> SPARC64_PAGE_SHIFT;
 203                 tte_off = kd->vmst->vm_tsb_off +
 204                     ((vpn & kd->vmst->vm_tsb_mask) << SPARC64_TTE_SHIFT);
 205                 if (!_sparc64_read_phys(kd, tte_off, &tte, sizeof(tte)))
 206                         goto invalid;
 207                 tte.tte_vpn = be64toh(tte.tte_vpn);
 208                 tte.tte_data = be64toh(tte.tte_data);
 209                 if (!sparc64_tte_match(&tte, va))
 210                         goto invalid;
 211                 pa_off = SPARC64_TTE_GET_PA(&tte);
 212         }
 213         rest = SPARC64_PAGE_SIZE - pg_off;
 214         pa_off = _sparc64_find_off(kd->vmst, pa_off, rest);
 215         if (pa_off == KVM_OFF_NOTFOUND)
 216                 goto invalid;
 217         *pa = pa_off + pg_off;
 218         return (rest);
 219
 220 invalid:
 221         _kvm_err(kd, 0, "invalid address (%jx)", (uintmax_t)va);
 222         return (0);
 223 }
 224
 225 static int
 226 _sparc64_native(kvm_t *kd)
 227 {
 228
 229 #ifdef __sparc64__
 230         return (1);
 231 #else
 232         return (0);
 233 #endif
 234 }
 235
 236 struct kvm_arch kvm_sparc64 = {
 237         .ka_probe = _sparc64_probe,
 238         .ka_initvtop = _sparc64_initvtop,
 239         .ka_freevtop = _sparc64_freevtop,
 240         .ka_kvatop = _sparc64_kvatop,
 241         .ka_native = _sparc64_native,
 242 };
 243
 244 KVM_ARCH(kvm_sparc64);