Index: head/lib/libkvm/kvm_powerpc64.c =================================================================== --- head/lib/libkvm/kvm_powerpc64.c (revision 366054) +++ head/lib/libkvm/kvm_powerpc64.c (revision 366055) @@ -1,238 +1,270 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 2008, Juniper Networks, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include "kvm_private.h" struct vmstate { void *map; size_t mapsz; size_t dmphdrsz; Elf64_Ehdr *eh; Elf64_Phdr *ph; }; static int -valid_elf_header(Elf64_Ehdr *eh) +valid_elf_header(kvm_t *kd, Elf64_Ehdr *eh) { if (!IS_ELF(*eh)) return (0); if (eh->e_ident[EI_CLASS] != ELFCLASS64) return (0); - if (eh->e_ident[EI_DATA] != ELFDATA2MSB) + if (eh->e_ident[EI_DATA] != ELFDATA2MSB && + eh->e_ident[EI_DATA] != ELFDATA2LSB) return (0); if (eh->e_ident[EI_VERSION] != EV_CURRENT) return (0); if (eh->e_ident[EI_OSABI] != ELFOSABI_STANDALONE) return (0); - if (be16toh(eh->e_type) != ET_CORE) + if (_kvm16toh(kd, eh->e_type) != ET_CORE) return (0); - if (be16toh(eh->e_machine) != EM_PPC64) + if (_kvm16toh(kd, eh->e_machine) != EM_PPC64) return (0); /* Can't think of anything else to check... */ return (1); } static size_t dump_header_size(struct kerneldumpheader *dh) { if (strcmp(dh->magic, KERNELDUMPMAGIC) != 0) return (0); - if (strcmp(dh->architecture, "powerpc64") != 0) + if (strcmp(dh->architecture, "powerpc64") != 0 && + strcmp(dh->architecture, "powerpc64le") != 0) return (0); /* That should do it... */ return (sizeof(*dh)); } /* * Map the ELF headers into the process' address space. We do this in two * steps: first the ELF header itself and using that information the whole * set of headers. */ static int powerpc_maphdrs(kvm_t *kd) { struct vmstate *vm; size_t mapsz; vm = kd->vmst; vm->mapsz = sizeof(*vm->eh) + sizeof(struct kerneldumpheader); vm->map = mmap(NULL, vm->mapsz, PROT_READ, MAP_PRIVATE, kd->pmfd, 0); if (vm->map == MAP_FAILED) { _kvm_err(kd, kd->program, "cannot map corefile"); return (-1); } vm->dmphdrsz = 0; vm->eh = vm->map; - if (!valid_elf_header(vm->eh)) { + if (!valid_elf_header(kd, vm->eh)) { /* * Hmmm, no ELF header. Maybe we still have a dump header. * This is normal when the core file wasn't created by * savecore(8), but instead was dumped over TFTP. We can * easily skip the dump header... */ vm->dmphdrsz = dump_header_size(vm->map); if (vm->dmphdrsz == 0) goto inval; vm->eh = (void *)((uintptr_t)vm->map + vm->dmphdrsz); - if (!valid_elf_header(vm->eh)) + if (!valid_elf_header(kd, vm->eh)) goto inval; } - mapsz = be16toh(vm->eh->e_phentsize) * be16toh(vm->eh->e_phnum) + - be64toh(vm->eh->e_phoff); + mapsz = _kvm16toh(kd, vm->eh->e_phentsize) * + _kvm16toh(kd, vm->eh->e_phnum) + _kvm64toh(kd, vm->eh->e_phoff); munmap(vm->map, vm->mapsz); /* Map all headers. */ vm->mapsz = vm->dmphdrsz + mapsz; vm->map = mmap(NULL, vm->mapsz, PROT_READ, MAP_PRIVATE, kd->pmfd, 0); if (vm->map == MAP_FAILED) { _kvm_err(kd, kd->program, "cannot map corefile headers"); return (-1); } vm->eh = (void *)((uintptr_t)vm->map + vm->dmphdrsz); vm->ph = (void *)((uintptr_t)vm->eh + - (uintptr_t)be64toh(vm->eh->e_phoff)); + (uintptr_t)_kvm64toh(kd, vm->eh->e_phoff)); return (0); inval: _kvm_err(kd, kd->program, "invalid corefile"); return (-1); } /* * Determine the offset within the corefile corresponding the virtual * address. Return the number of contiguous bytes in the corefile or * 0 when the virtual address is invalid. */ static size_t powerpc64_va2off(kvm_t *kd, kvaddr_t va, off_t *ofs) { struct vmstate *vm = kd->vmst; Elf64_Phdr *ph; int nph; ph = vm->ph; - nph = be16toh(vm->eh->e_phnum); - while (nph && (va < be64toh(ph->p_vaddr) || - va >= be64toh(ph->p_vaddr) + be64toh(ph->p_memsz))) { + nph = _kvm16toh(kd, vm->eh->e_phnum); + while (nph && (va < _kvm64toh(kd, ph->p_vaddr) || + va >= _kvm64toh(kd, ph->p_vaddr) + _kvm64toh(kd, ph->p_memsz))) { nph--; - ph = (void *)((uintptr_t)ph + be16toh(vm->eh->e_phentsize)); + ph = (void *)((uintptr_t)ph + + _kvm16toh(kd, vm->eh->e_phentsize)); } if (nph == 0) return (0); /* Segment found. Return file offset and range. */ - *ofs = vm->dmphdrsz + be64toh(ph->p_offset) + - (va - be64toh(ph->p_vaddr)); - return (be64toh(ph->p_memsz) - (va - be64toh(ph->p_vaddr))); + *ofs = vm->dmphdrsz + _kvm64toh(kd, ph->p_offset) + + (va - _kvm64toh(kd, ph->p_vaddr)); + return (_kvm64toh(kd, ph->p_memsz) - + (va - _kvm64toh(kd, ph->p_vaddr))); } static void _powerpc64_freevtop(kvm_t *kd) { struct vmstate *vm = kd->vmst; if (vm->eh != MAP_FAILED) munmap(vm->eh, vm->mapsz); free(vm); kd->vmst = NULL; } static int _powerpc64_probe(kvm_t *kd) { return (_kvm_probe_elf_kernel(kd, ELFCLASS64, EM_PPC64) && kd->nlehdr.e_ident[EI_DATA] == ELFDATA2MSB); } static int +_powerpc64le_probe(kvm_t *kd) +{ + + return (_kvm_probe_elf_kernel(kd, ELFCLASS64, EM_PPC64) && + kd->nlehdr.e_ident[EI_DATA] == ELFDATA2LSB); +} + +static int _powerpc64_initvtop(kvm_t *kd) { kd->vmst = (struct vmstate *)_kvm_malloc(kd, sizeof(*kd->vmst)); if (kd->vmst == NULL) return (-1); if (powerpc_maphdrs(kd) == -1) return (-1); return (0); } static int _powerpc64_kvatop(kvm_t *kd, kvaddr_t va, off_t *ofs) { struct vmstate *vm; vm = kd->vmst; - if (be64toh(vm->ph->p_paddr) == 0xffffffffffffffff) + if (_kvm64toh(kd, vm->ph->p_paddr) == 0xffffffffffffffff) return ((int)powerpc64_va2off(kd, va, ofs)); _kvm_err(kd, kd->program, "Raw corefile not supported"); return (0); } static int _powerpc64_native(kvm_t *kd __unused) { -#ifdef __powerpc64__ +#if defined(__powerpc64__) && BYTE_ORDER == BIG_ENDIAN return (1); #else return (0); #endif } +static int +_powerpc64le_native(kvm_t *kd __unused) +{ + +#if defined(__powerpc64__) && BYTE_ORDER == LITTLE_ENDIAN + return (1); +#else + return (0); +#endif +} + static struct kvm_arch kvm_powerpc64 = { .ka_probe = _powerpc64_probe, .ka_initvtop = _powerpc64_initvtop, .ka_freevtop = _powerpc64_freevtop, .ka_kvatop = _powerpc64_kvatop, .ka_native = _powerpc64_native, }; +static struct kvm_arch kvm_powerpc64le = { + .ka_probe = _powerpc64le_probe, + .ka_initvtop = _powerpc64_initvtop, + .ka_freevtop = _powerpc64_freevtop, + .ka_kvatop = _powerpc64_kvatop, + .ka_native = _powerpc64le_native, +}; + KVM_ARCH(kvm_powerpc64); +KVM_ARCH(kvm_powerpc64le); Index: head/lib/libkvm/kvm_private.h =================================================================== --- head/lib/libkvm/kvm_private.h (revision 366054) +++ head/lib/libkvm/kvm_private.h (revision 366055) @@ -1,189 +1,199 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1992, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software developed by the Computer Systems * Engineering group at Lawrence Berkeley Laboratory under DARPA contract * BG 91-66 and contributed to Berkeley. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)kvm_private.h 8.1 (Berkeley) 6/4/93 * $FreeBSD$ */ #include #include #include struct kvm_arch { int (*ka_probe)(kvm_t *); int (*ka_initvtop)(kvm_t *); void (*ka_freevtop)(kvm_t *); int (*ka_kvatop)(kvm_t *, kvaddr_t, off_t *); int (*ka_native)(kvm_t *); int (*ka_walk_pages)(kvm_t *, kvm_walk_pages_cb_t *, void *); kssize_t (*ka_kerndisp)(kvm_t *); }; #define KVM_ARCH(ka) DATA_SET(kvm_arch, ka) struct __kvm { struct kvm_arch *arch; /* * a string to be prepended to error messages * provided for compatibility with sun's interface * if this value is null, errors are saved in errbuf[] */ const char *program; char *errp; /* XXX this can probably go away */ char errbuf[_POSIX2_LINE_MAX]; #define ISALIVE(kd) ((kd)->vmfd >= 0) int pmfd; /* physical memory file (or crashdump) */ int vmfd; /* virtual memory file (-1 if crashdump) */ int nlfd; /* namelist file (e.g., /kernel) */ GElf_Ehdr nlehdr; /* ELF file header for namelist file */ int (*resolve_symbol)(const char *, kvaddr_t *); struct kinfo_proc *procbase; char *argspc; /* (dynamic) storage for argv strings */ int arglen; /* length of the above */ char **argv; /* (dynamic) storage for argv pointers */ int argc; /* length of above (not actual # present) */ char *argbuf; /* (dynamic) temporary storage */ /* * Kernel virtual address translation state. This only gets filled * in for dead kernels; otherwise, the running kernel (i.e. kmem) * will do the translations for us. It could be big, so we * only allocate it if necessary. */ struct vmstate *vmst; int rawdump; /* raw dump format */ int writable; /* physical memory is writable */ int vnet_initialized; /* vnet fields set up */ kvaddr_t vnet_start; /* start of kernel's vnet region */ kvaddr_t vnet_stop; /* stop of kernel's vnet region */ kvaddr_t vnet_current; /* vnet we're working with */ kvaddr_t vnet_base; /* vnet base of current vnet */ /* * Dynamic per-CPU kernel memory. We translate symbols, on-demand, * to the data associated with dpcpu_curcpu, set with * kvm_dpcpu_setcpu(). */ int dpcpu_initialized; /* dpcpu fields set up */ kvaddr_t dpcpu_start; /* start of kernel's dpcpu region */ kvaddr_t dpcpu_stop; /* stop of kernel's dpcpu region */ u_int dpcpu_maxcpus; /* size of base array */ uintptr_t *dpcpu_off; /* base array, indexed by CPU ID */ u_int dpcpu_curcpu; /* CPU we're currently working with */ kvaddr_t dpcpu_curoff; /* dpcpu base of current CPU */ /* Page table lookup structures. */ uint64_t *pt_map; size_t pt_map_size; uint64_t *dump_avail; /* actually word sized */ size_t dump_avail_size; off_t pt_sparse_off; uint64_t pt_sparse_size; uint32_t *pt_popcounts; unsigned int pt_page_size; unsigned int pt_word_size; /* Page & sparse map structures. */ void *page_map; uint32_t page_map_size; off_t page_map_off; void *sparse_map; }; struct kvm_bitmap { uint8_t *map; u_long size; }; /* Page table lookup constants. */ #define POPCOUNT_BITS 1024 #define BITS_IN(v) (sizeof(v) * NBBY) #define POPCOUNTS_IN(v) (POPCOUNT_BITS / BITS_IN(v)) /* * Functions used internally by kvm, but across kvm modules. */ +static inline uint16_t +_kvm16toh(kvm_t *kd, uint16_t val) +{ + + if (kd->nlehdr.e_ident[EI_DATA] == ELFDATA2LSB) + return (le16toh(val)); + else + return (be16toh(val)); +} + static inline uint32_t _kvm32toh(kvm_t *kd, uint32_t val) { if (kd->nlehdr.e_ident[EI_DATA] == ELFDATA2LSB) return (le32toh(val)); else return (be32toh(val)); } static inline uint64_t _kvm64toh(kvm_t *kd, uint64_t val) { if (kd->nlehdr.e_ident[EI_DATA] == ELFDATA2LSB) return (le64toh(val)); else return (be64toh(val)); } uint64_t _kvm_pa_bit_id(kvm_t *kd, uint64_t pa, unsigned int page_size); uint64_t _kvm_bit_id_pa(kvm_t *kd, uint64_t bit_id, unsigned int page_size); #define _KVM_PA_INVALID ULONG_MAX #define _KVM_BIT_ID_INVALID ULONG_MAX int _kvm_bitmap_init(struct kvm_bitmap *, u_long, u_long *); void _kvm_bitmap_set(struct kvm_bitmap *, u_long); int _kvm_bitmap_next(struct kvm_bitmap *, u_long *); void _kvm_bitmap_deinit(struct kvm_bitmap *); void _kvm_err(kvm_t *kd, const char *program, const char *fmt, ...) __printflike(3, 4); void _kvm_freeprocs(kvm_t *kd); void *_kvm_malloc(kvm_t *kd, size_t); int _kvm_nlist(kvm_t *, struct kvm_nlist *, int); void *_kvm_realloc(kvm_t *kd, void *, size_t); void _kvm_syserr (kvm_t *kd, const char *program, const char *fmt, ...) __printflike(3, 4); int _kvm_vnet_selectpid(kvm_t *, pid_t); int _kvm_vnet_initialized(kvm_t *, int); kvaddr_t _kvm_vnet_validaddr(kvm_t *, kvaddr_t); int _kvm_dpcpu_initialized(kvm_t *, int); kvaddr_t _kvm_dpcpu_validaddr(kvm_t *, kvaddr_t); int _kvm_probe_elf_kernel(kvm_t *, int, int); int _kvm_is_minidump(kvm_t *); int _kvm_read_core_phdrs(kvm_t *, size_t *, GElf_Phdr **); int _kvm_pt_init(kvm_t *, size_t, off_t, size_t, off_t, off_t, int, int); off_t _kvm_pt_find(kvm_t *, uint64_t, unsigned int); int _kvm_visit_cb(kvm_t *, kvm_walk_pages_cb_t *, void *, u_long, u_long, u_long, vm_prot_t, size_t, unsigned int); int _kvm_pmap_init(kvm_t *, uint32_t, off_t); void * _kvm_pmap_get(kvm_t *, u_long, size_t); void * _kvm_map_get(kvm_t *, u_long, unsigned int);