1
2
3
4
5
6
7
8
9
10
11
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
24typedef uint64_t reg_t;
25typedef Elf64_Nhdr Elf_Nhdr;
26#else
27#define ELFCLASS ELFCLASS32
28#define cpu_to_dump_reg cpu_to_dump32
29typedef uint32_t reg_t;
30typedef Elf32_Nhdr Elf_Nhdr;
31#endif
32
33struct 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
49struct PPCElfPrstatus {
50 char pad1[112];
51 struct PPCUserRegStruct pr_reg;
52 char pad2[40];
53} QEMU_PACKED;
54
55
56struct PPCElfFpregset {
57 uint64_t fpr[32];
58 reg_t fpscr;
59} QEMU_PACKED;
60
61
62struct 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
71struct PPCElfVsxregset {
72 uint64_t vsr[32];
73} QEMU_PACKED;
74
75struct PPCElfSperegset {
76 uint32_t evr[32];
77 uint64_t spe_acc;
78 uint32_t spe_fscr;
79} QEMU_PACKED;
80
81typedef 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
94typedef struct NoteFuncArg {
95 Note note;
96 DumpState *state;
97} NoteFuncArg;
98
99static 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
130static 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
148static 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
179static 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
195static 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
209static 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
221typedef struct NoteFuncDescStruct NoteFuncDesc;
222
223int 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
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
253ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
254{
255 int name_size = 8;
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
269static 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
296int 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
303int 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
