xref: /openbmc/qemu/target/ppc/arch_dump.c (revision 44b1ff31) 
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         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 = &note->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 = &note->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 = &note->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(((Note *)0)->contents.prstatus),  ppc_write_elf_prstatus},
214     {sizeof(((Note *)0)->contents.fpregset),  ppc_write_elf_fpregset},
215     {sizeof(((Note *)0)->contents.vmxregset), ppc_write_elf_vmxregset},
216     {sizeof(((Note *)0)->contents.vsxregset), ppc_write_elf_vsxregset},
217     {sizeof(((Note *)0)->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