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 = ¬e->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 = ¬e->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 = ¬e->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 = ¬e->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 = ¬e->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 } 316