lib/libkvm/kvm_sparc64.c

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