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         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
 149 static 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 #ifdef HOST_WORDS_BIGENDIAN
 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
 181 static 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
 198 static 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
 212 static 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
 224 typedef struct NoteFuncDescStruct NoteFuncDesc;
 225
 226 int 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)) {
 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
 254 ssize_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
 270 static int ppc_write_all_elf_notes(const char *note_name,
 271                                    WriteCoreDumpFunction f,
 272                                    PowerPCCPU *cpu, int id,
 273                                    void *opaque)
 274 {
 275     NoteFuncArg arg = { .state = opaque };
 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(opaque, sizeof(arg.note.name));
 282         arg.note.hdr.n_descsz = cpu_to_dump32(opaque, 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, opaque);
 290         if (ret < 0) {
 291             return -1;
 292         }
 293     }
 294     return 0;
 295 }
 296
 297 int ppc64_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
 298                                int cpuid, void *opaque)
 299 {
 300     PowerPCCPU *cpu = POWERPC_CPU(cs);
 301     return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, opaque);
 302 }
 303
 304 int ppc32_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs,
 305                                int cpuid, void *opaque)
 306 {
 307     PowerPCCPU *cpu = POWERPC_CPU(cs);
 308     return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, opaque);
 309 }