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