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[32]; /* 32 == offsetof(struct elf_prstatus, pr_pid) */
  51     uint32_t pid;
  52     char pad2[76]; /* 76 == offsetof(struct elf_prstatus, pr_reg) -
  53                             offsetof(struct elf_prstatus, pr_ppid) */
  54     struct PPCUserRegStruct pr_reg;
  55     char pad3[40]; /* 40 == sizeof(struct elf_prstatus) -
  56                             offsetof(struct elf_prstatus, pr_reg) -
  57                             sizeof(struct user_pt_regs) */
  58 } QEMU_PACKED;
  59
  60
  61 struct PPCElfFpregset {
  62     uint64_t fpr[32];
  63     reg_t fpscr;
  64 }  QEMU_PACKED;
  65
  66
  67 struct PPCElfVmxregset {
  68     ppc_avr_t avr[32];
  69     ppc_avr_t vscr;
  70     union {
  71         ppc_avr_t unused;
  72         uint32_t value;
  73     } vrsave;
  74 }  QEMU_PACKED;
  75
  76 struct PPCElfVsxregset {
  77     uint64_t vsr[32];
  78 }  QEMU_PACKED;
  79
  80 struct PPCElfSperegset {
  81     uint32_t evr[32];
  82     uint64_t spe_acc;
  83     uint32_t spe_fscr;
  84 }  QEMU_PACKED;
  85
  86 typedef struct noteStruct {
  87     Elf_Nhdr hdr;
  88     char name[5];
  89     char pad3[3];
  90     union {
  91         struct PPCElfPrstatus  prstatus;
  92         struct PPCElfFpregset  fpregset;
  93         struct PPCElfVmxregset vmxregset;
  94         struct PPCElfVsxregset vsxregset;
  95         struct PPCElfSperegset speregset;
  96     } contents;
  97 } QEMU_PACKED Note;
  98
  99 typedef struct NoteFuncArg {
 100     Note note;
 101     DumpState *state;
 102 } NoteFuncArg;
 103
 104 static void ppc_write_elf_prstatus(NoteFuncArg *arg, PowerPCCPU *cpu, int id)
 105 {
 106     int i;
 107     reg_t cr;
 108     struct PPCElfPrstatus *prstatus;
 109     struct PPCUserRegStruct *reg;
 110     Note *note = &arg->note;
 111     DumpState *s = arg->state;
 112
 113     note->hdr.n_type = cpu_to_dump32(s, NT_PRSTATUS);
 114
 115     prstatus = &note->contents.prstatus;
 116     memset(prstatus, 0, sizeof(*prstatus));
 117     prstatus->pid = cpu_to_dump32(s, id);
 118     reg = &prstatus->pr_reg;
 119
 120     for (i = 0; i < 32; i++) {
 121         reg->gpr[i] = cpu_to_dump_reg(s, cpu->env.gpr[i]);
 122     }
 123     reg->nip = cpu_to_dump_reg(s, cpu->env.nip);
 124     reg->msr = cpu_to_dump_reg(s, cpu->env.msr);
 125     reg->ctr = cpu_to_dump_reg(s, cpu->env.ctr);
 126     reg->link = cpu_to_dump_reg(s, cpu->env.lr);
 127     reg->xer = cpu_to_dump_reg(s, cpu_read_xer(&cpu->env));
 128
 129     cr = 0;
 130     for (i = 0; i < 8; i++) {
 131         cr |= (cpu->env.crf[i] & 15) << (4 * (7 - i));
 132     }
 133     reg->ccr = cpu_to_dump_reg(s, cr);
 134 }
 135
 136 static void ppc_write_elf_fpregset(NoteFuncArg *arg, PowerPCCPU *cpu, int id)
 137 {
 138     int i;
 139     struct PPCElfFpregset  *fpregset;
 140     Note *note = &arg->note;
 141     DumpState *s = arg->state;
 142
 143     note->hdr.n_type = cpu_to_dump32(s, NT_PRFPREG);
 144
 145     fpregset = &note->contents.fpregset;
 146     memset(fpregset, 0, sizeof(*fpregset));
 147
 148     for (i = 0; i < 32; i++) {
 149         uint64_t *fpr = cpu_fpr_ptr(&cpu->env, i);
 150         fpregset->fpr[i] = cpu_to_dump64(s, *fpr);
 151     }
 152     fpregset->fpscr = cpu_to_dump_reg(s, cpu->env.fpscr);
 153 }
 154
 155 static void ppc_write_elf_vmxregset(NoteFuncArg *arg, PowerPCCPU *cpu, int id)
 156 {
 157     int i;
 158     struct PPCElfVmxregset *vmxregset;
 159     Note *note = &arg->note;
 160     DumpState *s = arg->state;
 161
 162     note->hdr.n_type = cpu_to_dump32(s, NT_PPC_VMX);
 163     vmxregset = &note->contents.vmxregset;
 164     memset(vmxregset, 0, sizeof(*vmxregset));
 165
 166     for (i = 0; i < 32; i++) {
 167         bool needs_byteswap;
 168         ppc_avr_t *avr = cpu_avr_ptr(&cpu->env, i);
 169
 170 #if HOST_BIG_ENDIAN
 171         needs_byteswap = s->dump_info.d_endian == ELFDATA2LSB;
 172 #else
 173         needs_byteswap = s->dump_info.d_endian == ELFDATA2MSB;
 174 #endif
 175
 176         if (needs_byteswap) {
 177             vmxregset->avr[i].u64[0] = bswap64(avr->u64[1]);
 178             vmxregset->avr[i].u64[1] = bswap64(avr->u64[0]);
 179         } else {
 180             vmxregset->avr[i].u64[0] = avr->u64[0];
 181             vmxregset->avr[i].u64[1] = avr->u64[1];
 182         }
 183     }
 184     vmxregset->vscr.u32[3] = cpu_to_dump32(s, ppc_get_vscr(&cpu->env));
 185 }
 186
 187 static void ppc_write_elf_vsxregset(NoteFuncArg *arg, PowerPCCPU *cpu, int id)
 188 {
 189     int i;
 190     struct PPCElfVsxregset *vsxregset;
 191     Note *note = &arg->note;
 192     DumpState *s = arg->state;
 193
 194     note->hdr.n_type = cpu_to_dump32(s, NT_PPC_VSX);
 195     vsxregset = &note->contents.vsxregset;
 196     memset(vsxregset, 0, sizeof(*vsxregset));
 197
 198     for (i = 0; i < 32; i++) {
 199         uint64_t *vsrl = cpu_vsrl_ptr(&cpu->env, i);
 200         vsxregset->vsr[i] = cpu_to_dump64(s, *vsrl);
 201     }
 202 }
 203
 204 static void ppc_write_elf_speregset(NoteFuncArg *arg, PowerPCCPU *cpu, int id)
 205 {
 206     struct PPCElfSperegset *speregset;
 207     Note *note = &arg->note;
 208     DumpState *s = arg->state;
 209
 210     note->hdr.n_type = cpu_to_dump32(s, NT_PPC_SPE);
 211     speregset = &note->contents.speregset;
 212     memset(speregset, 0, sizeof(*speregset));
 213
 214     speregset->spe_acc = cpu_to_dump64(s, cpu->env.spe_acc);
 215     speregset->spe_fscr = cpu_to_dump32(s, cpu->env.spe_fscr);
 216 }
 217
 218 static const struct NoteFuncDescStruct {
 219     int contents_size;
 220     void (*note_contents_func)(NoteFuncArg *arg, PowerPCCPU *cpu, int id);
 221 } note_func[] = {
 222     {sizeof_field(Note, contents.prstatus),  ppc_write_elf_prstatus},
 223     {sizeof_field(Note, contents.fpregset),  ppc_write_elf_fpregset},
 224     {sizeof_field(Note, contents.vmxregset), ppc_write_elf_vmxregset},
 225     {sizeof_field(Note, contents.vsxregset), ppc_write_elf_vsxregset},
 226     {sizeof_field(Note, contents.speregset), ppc_write_elf_speregset},
 227     { 0, NULL}
 228 };
 229
 230 typedef struct NoteFuncDescStruct NoteFuncDesc;
 231
 232 int cpu_get_dump_info(ArchDumpInfo *info,
 233                       const struct GuestPhysBlockList *guest_phys_blocks)
 234 {
 235     PowerPCCPU *cpu;
 236
 237     if (first_cpu == NULL) {
 238         return -1;
 239     }
 240
 241     cpu = POWERPC_CPU(first_cpu);
 242
 243     info->d_machine = PPC_ELF_MACHINE;
 244     info->d_class = ELFCLASS;
 245
 246     if (ppc_interrupts_little_endian(cpu, !!(cpu->env.msr_mask & MSR_HVB))) {
 247         info->d_endian = ELFDATA2LSB;
 248     } else {
 249         info->d_endian = ELFDATA2MSB;
 250     }
 251     /* 64KB is the max page size for pseries kernel */
 252     if (strncmp(object_get_typename(qdev_get_machine()),
 253                 "pseries-", 8) == 0) {
 254         info->page_size = (1U << 16);
 255     }
 256
 257     return 0;
 258 }
 259
 260 ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
 261 {
 262     int name_size = 8; /* "CORE" or "QEMU" rounded */
 263     size_t elf_note_size = 0;
 264     int note_head_size;
 265     const NoteFuncDesc *nf;
 266
 267     note_head_size = sizeof(Elf_Nhdr);
 268     for (nf = note_func; nf->note_contents_func; nf++) {
 269         elf_note_size = elf_note_size + note_head_size + name_size +
 270             nf->contents_size;
 271     }
 272
 273     return (elf_note_size) * nr_cpus;
 274 }
 275
 276 static int ppc_write_all_elf_notes(const char *note_name,
 277                                    WriteCoreDumpFunction f,
 278                                    PowerPCCPU *cpu, int id,
 279                                    DumpState *s)
 280 {
 281     NoteFuncArg arg = { .state = s };
 282     int ret = -1;
 283     int note_size;
 284     const NoteFuncDesc *nf;
 285
 286     for (nf = note_func; nf->note_contents_func; nf++) {
 287         arg.note.hdr.n_namesz = cpu_to_dump32(s, sizeof(arg.note.name));
 288         arg.note.hdr.n_descsz = cpu_to_dump32(s, nf->contents_size);
 289         strncpy(arg.note.name, note_name, sizeof(arg.note.name));
 290
 291         (*nf->note_contents_func)(&arg, cpu, id);
 292
 293         note_size =
 294             sizeof(arg.note) - sizeof(arg.note.contents) + nf->contents_size;
 295         ret = f(&arg.note, note_size, s);
 296         if (ret < 0) {
 297             return -1;
 298         }
 299     }
 300     return 0;
 301 }
 302
 303 int ppc64_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
 304                                int cpuid, DumpState *s)
 305 {
 306     PowerPCCPU *cpu = POWERPC_CPU(cs);
 307     return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, s);
 308 }
 309
 310 int ppc32_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs,
 311                                int cpuid, DumpState *s)
 312 {
 313     PowerPCCPU *cpu = POWERPC_CPU(cs);
 314     return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, s);
 315 }