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 = ¬e->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 = ¬e->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 = ¬e->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 = ¬e->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 = ¬e->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_field(Note, contents.prstatus), ppc_write_elf_prstatus}, 214 {sizeof_field(Note, contents.fpregset), ppc_write_elf_fpregset}, 215 {sizeof_field(Note, contents.vmxregset), ppc_write_elf_vmxregset}, 216 {sizeof_field(Note, contents.vsxregset), ppc_write_elf_vsxregset}, 217 {sizeof_field(Note, 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 } 309