target/ppc/arch_dump.c

   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
  24 typedef uint64_t reg_t;
  25 typedef Elf64_Nhdr Elf_Nhdr;
  26 #else
  27 #define ELFCLASS ELFCLASS32
  28 #define cpu_to_dump_reg cpu_to_dump32
  29 typedef uint32_t reg_t;
  30 typedef Elf32_Nhdr Elf_Nhdr;
  31 #endif /* TARGET_PPC64 */
  32
  33 struct 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
  49 struct PPCElfPrstatus {
  50     char pad1[112];
  51     struct PPCUserRegStruct pr_reg;
  52     char pad2[40];
  53 } QEMU_PACKED;
  54
  55
  56 struct PPCElfFpregset {
  57     uint64_t fpr[32];
  58     reg_t fpscr;
  59 }  QEMU_PACKED;
  60
  61
  62 struct 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
  71 struct PPCElfVsxregset {
  72     uint64_t vsr[32];
  73 }  QEMU_PACKED;
  74
  75 struct PPCElfSperegset {
  76     uint32_t evr[32];
  77     uint64_t spe_acc;
  78     uint32_t spe_fscr;
  79 }  QEMU_PACKED;
  80
  81 typedef 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
  94 typedef struct NoteFuncArg {
  95     Note note;
  96     DumpState *state;
  97 } NoteFuncArg;
  98
  99 static 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
 130 static 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         fpregset->fpr[i] = cpu_to_dump64(s, cpu->env.fpr[i]);
 144     }
 145     fpregset->fpscr = cpu_to_dump_reg(s, cpu->env.fpscr);
 146 }
 147
 148 static void ppc_write_elf_vmxregset(NoteFuncArg *arg, PowerPCCPU *cpu)
 149 {
 150     int i;
 151     struct PPCElfVmxregset *vmxregset;
 152     Note *note = &arg->note;
 153     DumpState *s = arg->state;
 154
 155     note->hdr.n_type = cpu_to_dump32(s, NT_PPC_VMX);
 156     vmxregset = &note->contents.vmxregset;
 157     memset(vmxregset, 0, sizeof(*vmxregset));
 158
 159     for (i = 0; i < 32; i++) {
 160         bool needs_byteswap;
 161
 162 #ifdef HOST_WORDS_BIGENDIAN
 163         needs_byteswap = s->dump_info.d_endian == ELFDATA2LSB;
 164 #else
 165         needs_byteswap = s->dump_info.d_endian == ELFDATA2MSB;
 166 #endif
 167
 168         if (needs_byteswap) {
 169             vmxregset->avr[i].u64[0] = bswap64(cpu->env.avr[i].u64[1]);
 170             vmxregset->avr[i].u64[1] = bswap64(cpu->env.avr[i].u64[0]);
 171         } else {
 172             vmxregset->avr[i].u64[0] = cpu->env.avr[i].u64[0];
 173             vmxregset->avr[i].u64[1] = cpu->env.avr[i].u64[1];
 174         }
 175     }
 176     vmxregset->vscr.u32[3] = cpu_to_dump32(s, cpu->env.vscr);
 177 }
 178
 179 static void ppc_write_elf_vsxregset(NoteFuncArg *arg, PowerPCCPU *cpu)
 180 {
 181     int i;
 182     struct PPCElfVsxregset *vsxregset;
 183     Note *note = &arg->note;
 184     DumpState *s = arg->state;
 185
 186     note->hdr.n_type = cpu_to_dump32(s, NT_PPC_VSX);
 187     vsxregset = &note->contents.vsxregset;
 188     memset(vsxregset, 0, sizeof(*vsxregset));
 189
 190     for (i = 0; i < 32; i++) {
 191         vsxregset->vsr[i] = cpu_to_dump64(s, cpu->env.vsr[i]);
 192     }
 193 }
 194
 195 static void ppc_write_elf_speregset(NoteFuncArg *arg, PowerPCCPU *cpu)
 196 {
 197     struct PPCElfSperegset *speregset;
 198     Note *note = &arg->note;
 199     DumpState *s = arg->state;
 200
 201     note->hdr.n_type = cpu_to_dump32(s, NT_PPC_SPE);
 202     speregset = &note->contents.speregset;
 203     memset(speregset, 0, sizeof(*speregset));
 204
 205     speregset->spe_acc = cpu_to_dump64(s, cpu->env.spe_acc);
 206     speregset->spe_fscr = cpu_to_dump32(s, cpu->env.spe_fscr);
 207 }
 208
 209 static const struct NoteFuncDescStruct {
 210     int contents_size;
 211     void (*note_contents_func)(NoteFuncArg *arg, PowerPCCPU *cpu);
 212 } note_func[] = {
 213     {sizeof(((Note *)0)->contents.prstatus),  ppc_write_elf_prstatus},
 214     {sizeof(((Note *)0)->contents.fpregset),  ppc_write_elf_fpregset},
 215     {sizeof(((Note *)0)->contents.vmxregset), ppc_write_elf_vmxregset},
 216     {sizeof(((Note *)0)->contents.vsxregset), ppc_write_elf_vsxregset},
 217     {sizeof(((Note *)0)->contents.speregset), ppc_write_elf_speregset},
 218     { 0, NULL}
 219 };
 220
 221 typedef struct NoteFuncDescStruct NoteFuncDesc;
 222
 223 int cpu_get_dump_info(ArchDumpInfo *info,
 224                       const struct GuestPhysBlockList *guest_phys_blocks)
 225 {
 226     PowerPCCPU *cpu;
 227     PowerPCCPUClass *pcc;
 228
 229     if (first_cpu == NULL) {
 230         return -1;
 231     }
 232
 233     cpu = POWERPC_CPU(first_cpu);
 234     pcc = POWERPC_CPU_GET_CLASS(cpu);
 235
 236     info->d_machine = PPC_ELF_MACHINE;
 237     info->d_class = ELFCLASS;
 238
 239     if ((*pcc->interrupts_big_endian)(cpu)) {
 240         info->d_endian = ELFDATA2MSB;
 241     } else {
 242         info->d_endian = ELFDATA2LSB;
 243     }
 244     /* 64KB is the max page size for pseries kernel */
 245     if (strncmp(object_get_typename(qdev_get_machine()),
 246                 "pseries-", 8) == 0) {
 247         info->page_size = (1U << 16);
 248     }
 249
 250     return 0;
 251 }
 252
 253 ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
 254 {
 255     int name_size = 8; /* "CORE" or "QEMU" rounded */
 256     size_t elf_note_size = 0;
 257     int note_head_size;
 258     const NoteFuncDesc *nf;
 259
 260     note_head_size = sizeof(Elf_Nhdr);
 261     for (nf = note_func; nf->note_contents_func; nf++) {
 262         elf_note_size = elf_note_size + note_head_size + name_size +
 263             nf->contents_size;
 264     }
 265
 266     return (elf_note_size) * nr_cpus;
 267 }
 268
 269 static int ppc_write_all_elf_notes(const char *note_name,
 270                                    WriteCoreDumpFunction f,
 271                                    PowerPCCPU *cpu, int id,
 272                                    void *opaque)
 273 {
 274     NoteFuncArg arg = { .state = opaque };
 275     int ret = -1;
 276     int note_size;
 277     const NoteFuncDesc *nf;
 278
 279     for (nf = note_func; nf->note_contents_func; nf++) {
 280         arg.note.hdr.n_namesz = cpu_to_dump32(opaque, sizeof(arg.note.name));
 281         arg.note.hdr.n_descsz = cpu_to_dump32(opaque, nf->contents_size);
 282         strncpy(arg.note.name, note_name, sizeof(arg.note.name));
 283
 284         (*nf->note_contents_func)(&arg, cpu);
 285
 286         note_size =
 287             sizeof(arg.note) - sizeof(arg.note.contents) + nf->contents_size;
 288         ret = f(&arg.note, note_size, opaque);
 289         if (ret < 0) {
 290             return -1;
 291         }
 292     }
 293     return 0;
 294 }
 295
 296 int ppc64_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
 297                                int cpuid, void *opaque)
 298 {
 299     PowerPCCPU *cpu = POWERPC_CPU(cs);
 300     return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, opaque);
 301 }
 302
 303 int ppc32_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs,
 304                                int cpuid, void *opaque)
 305 {
 306     PowerPCCPU *cpu = POWERPC_CPU(cs);
 307     return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, opaque);
 308 }