qemu/target/ppc/arch_dump.c
<<
>>
Prefs
   1/*
   2 * writing ELF notes for ppc{64,} arch
   3 *
   4 *
   5 * Copyright IBM, Corp. 2013
   6 *
   7 * Authors:
   8 * Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
   9 *
  10 * This work is licensed under the terms of the GNU GPL, version 2.  See
  11 * the COPYING file in the top-level directory.
  12 *
  13 */
  14
  15#include "qemu/osdep.h"
  16#include "cpu.h"
  17#include "elf.h"
  18#include "sysemu/dump.h"
  19#include "sysemu/kvm.h"
  20
  21#ifdef TARGET_PPC64
  22#define ELFCLASS ELFCLASS64
  23#define cpu_to_dump_reg cpu_to_dump64
  24typedef uint64_t reg_t;
  25typedef Elf64_Nhdr Elf_Nhdr;
  26#else
  27#define ELFCLASS ELFCLASS32
  28#define cpu_to_dump_reg cpu_to_dump32
  29typedef uint32_t reg_t;
  30typedef Elf32_Nhdr Elf_Nhdr;
  31#endif /* TARGET_PPC64 */
  32
  33struct PPCUserRegStruct {
  34    reg_t gpr[32];
  35    reg_t nip;
  36    reg_t msr;
  37    reg_t orig_gpr3;
  38    reg_t ctr;
  39    reg_t link;
  40    reg_t xer;
  41    reg_t ccr;
  42    reg_t softe;
  43    reg_t trap;
  44    reg_t dar;
  45    reg_t dsisr;
  46    reg_t result;
  47} QEMU_PACKED;
  48
  49struct PPCElfPrstatus {
  50    char pad1[112];
  51    struct PPCUserRegStruct pr_reg;
  52    char pad2[40];
  53} QEMU_PACKED;
  54
  55
  56struct PPCElfFpregset {
  57    uint64_t fpr[32];
  58    reg_t fpscr;
  59}  QEMU_PACKED;
  60
  61
  62struct PPCElfVmxregset {
  63    ppc_avr_t avr[32];
  64    ppc_avr_t vscr;
  65    union {
  66        ppc_avr_t unused;
  67        uint32_t value;
  68    } vrsave;
  69}  QEMU_PACKED;
  70
  71struct PPCElfVsxregset {
  72    uint64_t vsr[32];
  73}  QEMU_PACKED;
  74
  75struct PPCElfSperegset {
  76    uint32_t evr[32];
  77    uint64_t spe_acc;
  78    uint32_t spe_fscr;
  79}  QEMU_PACKED;
  80
  81typedef struct noteStruct {
  82    Elf_Nhdr hdr;
  83    char name[5];
  84    char pad3[3];
  85    union {
  86        struct PPCElfPrstatus  prstatus;
  87        struct PPCElfFpregset  fpregset;
  88        struct PPCElfVmxregset vmxregset;
  89        struct PPCElfVsxregset vsxregset;
  90        struct PPCElfSperegset speregset;
  91    } contents;
  92} QEMU_PACKED Note;
  93
  94typedef struct NoteFuncArg {
  95    Note note;
  96    DumpState *state;
  97} NoteFuncArg;
  98
  99static void ppc_write_elf_prstatus(NoteFuncArg *arg, PowerPCCPU *cpu)
 100{
 101    int i;
 102    reg_t cr;
 103    struct PPCElfPrstatus *prstatus;
 104    struct PPCUserRegStruct *reg;
 105    Note *note = &arg->note;
 106    DumpState *s = arg->state;
 107
 108    note->hdr.n_type = cpu_to_dump32(s, NT_PRSTATUS);
 109
 110    prstatus = &note->contents.prstatus;
 111    memset(prstatus, 0, sizeof(*prstatus));
 112    reg = &prstatus->pr_reg;
 113
 114    for (i = 0; i < 32; i++) {
 115        reg->gpr[i] = cpu_to_dump_reg(s, cpu->env.gpr[i]);
 116    }
 117    reg->nip = cpu_to_dump_reg(s, cpu->env.nip);
 118    reg->msr = cpu_to_dump_reg(s, cpu->env.msr);
 119    reg->ctr = cpu_to_dump_reg(s, cpu->env.ctr);
 120    reg->link = cpu_to_dump_reg(s, cpu->env.lr);
 121    reg->xer = cpu_to_dump_reg(s, cpu_read_xer(&cpu->env));
 122
 123    cr = 0;
 124    for (i = 0; i < 8; i++) {
 125        cr |= (cpu->env.crf[i] & 15) << (4 * (7 - i));
 126    }
 127    reg->ccr = cpu_to_dump_reg(s, cr);
 128}
 129
 130static void ppc_write_elf_fpregset(NoteFuncArg *arg, PowerPCCPU *cpu)
 131{
 132    int i;
 133    struct PPCElfFpregset  *fpregset;
 134    Note *note = &arg->note;
 135    DumpState *s = arg->state;
 136
 137    note->hdr.n_type = cpu_to_dump32(s, NT_PRFPREG);
 138
 139    fpregset = &note->contents.fpregset;
 140    memset(fpregset, 0, sizeof(*fpregset));
 141
 142    for (i = 0; i < 32; i++) {
 143        uint64_t *fpr = cpu_fpr_ptr(&cpu->env, i);
 144        fpregset->fpr[i] = cpu_to_dump64(s, *fpr);
 145    }
 146    fpregset->fpscr = cpu_to_dump_reg(s, cpu->env.fpscr);
 147}
 148
 149static void ppc_write_elf_vmxregset(NoteFuncArg *arg, PowerPCCPU *cpu)
 150{
 151    int i;
 152    struct PPCElfVmxregset *vmxregset;
 153    Note *note = &arg->note;
 154    DumpState *s = arg->state;
 155
 156    note->hdr.n_type = cpu_to_dump32(s, NT_PPC_VMX);
 157    vmxregset = &note->contents.vmxregset;
 158    memset(vmxregset, 0, sizeof(*vmxregset));
 159
 160    for (i = 0; i < 32; i++) {
 161        bool needs_byteswap;
 162        ppc_avr_t *avr = cpu_avr_ptr(&cpu->env, i);
 163
 164#if HOST_BIG_ENDIAN
 165        needs_byteswap = s->dump_info.d_endian == ELFDATA2LSB;
 166#else
 167        needs_byteswap = s->dump_info.d_endian == ELFDATA2MSB;
 168#endif
 169
 170        if (needs_byteswap) {
 171            vmxregset->avr[i].u64[0] = bswap64(avr->u64[1]);
 172            vmxregset->avr[i].u64[1] = bswap64(avr->u64[0]);
 173        } else {
 174            vmxregset->avr[i].u64[0] = avr->u64[0];
 175            vmxregset->avr[i].u64[1] = avr->u64[1];
 176        }
 177    }
 178    vmxregset->vscr.u32[3] = cpu_to_dump32(s, ppc_get_vscr(&cpu->env));
 179}
 180
 181static void ppc_write_elf_vsxregset(NoteFuncArg *arg, PowerPCCPU *cpu)
 182{
 183    int i;
 184    struct PPCElfVsxregset *vsxregset;
 185    Note *note = &arg->note;
 186    DumpState *s = arg->state;
 187
 188    note->hdr.n_type = cpu_to_dump32(s, NT_PPC_VSX);
 189    vsxregset = &note->contents.vsxregset;
 190    memset(vsxregset, 0, sizeof(*vsxregset));
 191
 192    for (i = 0; i < 32; i++) {
 193        uint64_t *vsrl = cpu_vsrl_ptr(&cpu->env, i);
 194        vsxregset->vsr[i] = cpu_to_dump64(s, *vsrl);
 195    }
 196}
 197
 198static void ppc_write_elf_speregset(NoteFuncArg *arg, PowerPCCPU *cpu)
 199{
 200    struct PPCElfSperegset *speregset;
 201    Note *note = &arg->note;
 202    DumpState *s = arg->state;
 203
 204    note->hdr.n_type = cpu_to_dump32(s, NT_PPC_SPE);
 205    speregset = &note->contents.speregset;
 206    memset(speregset, 0, sizeof(*speregset));
 207
 208    speregset->spe_acc = cpu_to_dump64(s, cpu->env.spe_acc);
 209    speregset->spe_fscr = cpu_to_dump32(s, cpu->env.spe_fscr);
 210}
 211
 212static const struct NoteFuncDescStruct {
 213    int contents_size;
 214    void (*note_contents_func)(NoteFuncArg *arg, PowerPCCPU *cpu);
 215} note_func[] = {
 216    {sizeof_field(Note, contents.prstatus),  ppc_write_elf_prstatus},
 217    {sizeof_field(Note, contents.fpregset),  ppc_write_elf_fpregset},
 218    {sizeof_field(Note, contents.vmxregset), ppc_write_elf_vmxregset},
 219    {sizeof_field(Note, contents.vsxregset), ppc_write_elf_vsxregset},
 220    {sizeof_field(Note, contents.speregset), ppc_write_elf_speregset},
 221    { 0, NULL}
 222};
 223
 224typedef struct NoteFuncDescStruct NoteFuncDesc;
 225
 226int cpu_get_dump_info(ArchDumpInfo *info,
 227                      const struct GuestPhysBlockList *guest_phys_blocks)
 228{
 229    PowerPCCPU *cpu;
 230
 231    if (first_cpu == NULL) {
 232        return -1;
 233    }
 234
 235    cpu = POWERPC_CPU(first_cpu);
 236
 237    info->d_machine = PPC_ELF_MACHINE;
 238    info->d_class = ELFCLASS;
 239
 240    if (ppc_interrupts_little_endian(cpu, cpu->env.has_hv_mode)) {
 241        info->d_endian = ELFDATA2LSB;
 242    } else {
 243        info->d_endian = ELFDATA2MSB;
 244    }
 245    /* 64KB is the max page size for pseries kernel */
 246    if (strncmp(object_get_typename(qdev_get_machine()),
 247                "pseries-", 8) == 0) {
 248        info->page_size = (1U << 16);
 249    }
 250
 251    return 0;
 252}
 253
 254ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
 255{
 256    int name_size = 8; /* "CORE" or "QEMU" rounded */
 257    size_t elf_note_size = 0;
 258    int note_head_size;
 259    const NoteFuncDesc *nf;
 260
 261    note_head_size = sizeof(Elf_Nhdr);
 262    for (nf = note_func; nf->note_contents_func; nf++) {
 263        elf_note_size = elf_note_size + note_head_size + name_size +
 264            nf->contents_size;
 265    }
 266
 267    return (elf_note_size) * nr_cpus;
 268}
 269
 270static int ppc_write_all_elf_notes(const char *note_name,
 271                                   WriteCoreDumpFunction f,
 272                                   PowerPCCPU *cpu, int id,
 273                                   DumpState *s)
 274{
 275    NoteFuncArg arg = { .state = s };
 276    int ret = -1;
 277    int note_size;
 278    const NoteFuncDesc *nf;
 279
 280    for (nf = note_func; nf->note_contents_func; nf++) {
 281        arg.note.hdr.n_namesz = cpu_to_dump32(s, sizeof(arg.note.name));
 282        arg.note.hdr.n_descsz = cpu_to_dump32(s, nf->contents_size);
 283        strncpy(arg.note.name, note_name, sizeof(arg.note.name));
 284
 285        (*nf->note_contents_func)(&arg, cpu);
 286
 287        note_size =
 288            sizeof(arg.note) - sizeof(arg.note.contents) + nf->contents_size;
 289        ret = f(&arg.note, note_size, s);
 290        if (ret < 0) {
 291            return -1;
 292        }
 293    }
 294    return 0;
 295}
 296
 297int ppc64_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
 298                               int cpuid, DumpState *s)
 299{
 300    PowerPCCPU *cpu = POWERPC_CPU(cs);
 301    return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, s);
 302}
 303
 304int ppc32_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs,
 305                               int cpuid, DumpState *s)
 306{
 307    PowerPCCPU *cpu = POWERPC_CPU(cs);
 308    return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, s);
 309}
 310