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
  41 #if defined(LIBC_SCCS) && !defined(lint)
  42 #if 0
  43 static char sccsid[] = "@(#)kvm_hp300.c 8.1 (Berkeley) 6/4/93";
  44 #endif
  45 #endif /* LIBC_SCCS and not lint */
  46
  47 /*
  48  * sparc64 machine dependent routines for kvm.
  49  */
  50
  51 #include <sys/param.h>
  52 #include <kvm.h>
  53 #include <limits.h>
  54 #include <stdint.h>
  55 #include <stdlib.h>
  56 #include <unistd.h>
  57
  58 #include "../../sys/sparc64/include/kerneldump.h"
  59
  60 #include "kvm_private.h"
  61 #include "kvm_sparc64.h"
  62
  63 struct vmstate {
  64         off_t           vm_tsb_off;
  65         uint64_t        vm_tsb_mask;
  66         int             vm_nregions;
  67         struct sparc64_dump_reg *vm_regions;
  68 };
  69
  70 static int
  71 _sparc64_probe(kvm_t *kd)
  72 {
  73
  74         return (_kvm_probe_elf_kernel(kd, ELFCLASS64, EM_SPARCV9));
  75 }
  76
  77 static void
  78 _sparc64_freevtop(kvm_t *kd)
  79 {
  80
  81         free(kd->vmst->vm_regions);
  82         free(kd->vmst);
  83         kd->vmst = NULL;
  84 }
  85
  86 static int
  87 _sparc64_read_phys(kvm_t *kd, off_t pos, void *buf, size_t size)
  88 {
  89
  90         /* XXX This has to be a raw file read, kvm_read is virtual. */
  91         if (pread(kd->pmfd, buf, size, pos) != (ssize_t)size) {
  92                 _kvm_syserr(kd, kd->program, "_sparc64_read_phys: pread");
  93                 return (0);
  94         }
  95         return (1);
  96 }
  97
  98 static int
  99 _sparc64_reg_cmp(const void *a, const void *b)
 100 {
 101         const struct sparc64_dump_reg *ra, *rb;
 102
 103         ra = a;
 104         rb = b;
 105         if (ra->dr_pa < rb->dr_pa)
 106                 return (-1);
 107         else if (ra->dr_pa >= rb->dr_pa + rb->dr_size)
 108                 return (1);
 109         else
 110                 return (0);
 111 }
 112
 113 #define KVM_OFF_NOTFOUND        0
 114
 115 static off_t
 116 _sparc64_find_off(struct vmstate *vm, uint64_t pa, uint64_t size)
 117 {
 118         struct sparc64_dump_reg *reg, key;
 119         vm_offset_t o;
 120
 121         key.dr_pa = pa;
 122         reg = bsearch(&key, vm->vm_regions, vm->vm_nregions,
 123             sizeof(*vm->vm_regions), _sparc64_reg_cmp);
 124         if (reg == NULL)
 125                 return (KVM_OFF_NOTFOUND);
 126         o = pa - reg->dr_pa;
 127         if (o + size > reg->dr_size)
 128                 return (KVM_OFF_NOTFOUND);
 129         return (reg->dr_offs + o);
 130 }
 131
 132 static int
 133 _sparc64_initvtop(kvm_t *kd)
 134 {
 135         struct sparc64_dump_hdr hdr;
 136         struct sparc64_dump_reg *regs;
 137         struct vmstate *vm;
 138         size_t regsz;
 139         int i;
 140
 141         vm = (struct vmstate *)_kvm_malloc(kd, sizeof(*vm));
 142         if (vm == NULL) {
 143                 _kvm_err(kd, kd->program, "cannot allocate vm");
 144                 return (-1);
 145         }
 146         kd->vmst = vm;
 147
 148         if (!_sparc64_read_phys(kd, 0, &hdr, sizeof(hdr)))
 149                 goto fail_vm;
 150         hdr.dh_hdr_size = be64toh(hdr.dh_hdr_size);
 151         hdr.dh_tsb_pa = be64toh(hdr.dh_tsb_pa);
 152         hdr.dh_tsb_size = be64toh(hdr.dh_tsb_size);
 153         hdr.dh_tsb_mask = be64toh(hdr.dh_tsb_mask);
 154         hdr.dh_nregions = be32toh(hdr.dh_nregions);
 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 __unused)
 227 {
 228
 229 #ifdef __sparc64__
 230         return (1);
 231 #else
 232         return (0);
 233 #endif
 234 }
 235
 236 static 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);