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