]>
Commit | Line | Data |
---|---|---|
e62fbc54 | 1 | /* |
356bb70e | 2 | * writing ELF notes for ppc{64,} arch |
e62fbc54 AK |
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 | ||
0d75590d | 15 | #include "qemu/osdep.h" |
e62fbc54 AK |
16 | #include "cpu.h" |
17 | #include "elf.h" | |
18 | #include "exec/cpu-all.h" | |
19 | #include "sysemu/dump.h" | |
20 | #include "sysemu/kvm.h" | |
21 | ||
356bb70e MN |
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; | |
e62fbc54 AK |
48 | } QEMU_PACKED; |
49 | ||
356bb70e | 50 | struct PPCElfPrstatus { |
e62fbc54 | 51 | char pad1[112]; |
356bb70e MN |
52 | struct PPCUserRegStruct pr_reg; |
53 | reg_t pad2[4]; | |
e62fbc54 AK |
54 | } QEMU_PACKED; |
55 | ||
56 | ||
356bb70e | 57 | struct PPCElfFpregset { |
e62fbc54 | 58 | uint64_t fpr[32]; |
356bb70e | 59 | reg_t fpscr; |
e62fbc54 AK |
60 | } QEMU_PACKED; |
61 | ||
62 | ||
356bb70e | 63 | struct PPCElfVmxregset { |
e62fbc54 AK |
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 | ||
356bb70e | 72 | struct PPCElfVsxregset { |
e62fbc54 AK |
73 | uint64_t vsr[32]; |
74 | } QEMU_PACKED; | |
75 | ||
356bb70e | 76 | struct PPCElfSperegset { |
e62fbc54 AK |
77 | uint32_t evr[32]; |
78 | uint64_t spe_acc; | |
79 | uint32_t spe_fscr; | |
80 | } QEMU_PACKED; | |
81 | ||
82 | typedef struct noteStruct { | |
356bb70e | 83 | Elf_Nhdr hdr; |
e62fbc54 AK |
84 | char name[5]; |
85 | char pad3[3]; | |
86 | union { | |
356bb70e MN |
87 | struct PPCElfPrstatus prstatus; |
88 | struct PPCElfFpregset fpregset; | |
89 | struct PPCElfVmxregset vmxregset; | |
90 | struct PPCElfVsxregset vsxregset; | |
91 | struct PPCElfSperegset speregset; | |
e62fbc54 AK |
92 | } contents; |
93 | } QEMU_PACKED Note; | |
94 | ||
0c967de9 BR |
95 | typedef struct NoteFuncArg { |
96 | Note note; | |
97 | DumpState *state; | |
98 | } NoteFuncArg; | |
e62fbc54 | 99 | |
356bb70e | 100 | static void ppc_write_elf_prstatus(NoteFuncArg *arg, PowerPCCPU *cpu) |
e62fbc54 AK |
101 | { |
102 | int i; | |
356bb70e MN |
103 | reg_t cr; |
104 | struct PPCElfPrstatus *prstatus; | |
105 | struct PPCUserRegStruct *reg; | |
0c967de9 BR |
106 | Note *note = &arg->note; |
107 | DumpState *s = arg->state; | |
e62fbc54 | 108 | |
0c967de9 | 109 | note->hdr.n_type = cpu_to_dump32(s, NT_PRSTATUS); |
e62fbc54 AK |
110 | |
111 | prstatus = ¬e->contents.prstatus; | |
112 | memset(prstatus, 0, sizeof(*prstatus)); | |
113 | reg = &prstatus->pr_reg; | |
114 | ||
115 | for (i = 0; i < 32; i++) { | |
356bb70e | 116 | reg->gpr[i] = cpu_to_dump_reg(s, cpu->env.gpr[i]); |
e62fbc54 | 117 | } |
356bb70e MN |
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)); | |
e62fbc54 AK |
123 | |
124 | cr = 0; | |
125 | for (i = 0; i < 8; i++) { | |
126 | cr |= (cpu->env.crf[i] & 15) << (4 * (7 - i)); | |
127 | } | |
356bb70e | 128 | reg->ccr = cpu_to_dump_reg(s, cr); |
e62fbc54 AK |
129 | } |
130 | ||
356bb70e | 131 | static void ppc_write_elf_fpregset(NoteFuncArg *arg, PowerPCCPU *cpu) |
e62fbc54 AK |
132 | { |
133 | int i; | |
356bb70e | 134 | struct PPCElfFpregset *fpregset; |
0c967de9 BR |
135 | Note *note = &arg->note; |
136 | DumpState *s = arg->state; | |
e62fbc54 | 137 | |
0c967de9 | 138 | note->hdr.n_type = cpu_to_dump32(s, NT_PRFPREG); |
e62fbc54 AK |
139 | |
140 | fpregset = ¬e->contents.fpregset; | |
141 | memset(fpregset, 0, sizeof(*fpregset)); | |
142 | ||
143 | for (i = 0; i < 32; i++) { | |
0c967de9 | 144 | fpregset->fpr[i] = cpu_to_dump64(s, cpu->env.fpr[i]); |
e62fbc54 | 145 | } |
356bb70e | 146 | fpregset->fpscr = cpu_to_dump_reg(s, cpu->env.fpscr); |
e62fbc54 AK |
147 | } |
148 | ||
356bb70e | 149 | static void ppc_write_elf_vmxregset(NoteFuncArg *arg, PowerPCCPU *cpu) |
e62fbc54 AK |
150 | { |
151 | int i; | |
356bb70e | 152 | struct PPCElfVmxregset *vmxregset; |
0c967de9 BR |
153 | Note *note = &arg->note; |
154 | DumpState *s = arg->state; | |
e62fbc54 | 155 | |
0c967de9 | 156 | note->hdr.n_type = cpu_to_dump32(s, NT_PPC_VMX); |
e62fbc54 AK |
157 | vmxregset = ¬e->contents.vmxregset; |
158 | memset(vmxregset, 0, sizeof(*vmxregset)); | |
159 | ||
160 | for (i = 0; i < 32; i++) { | |
0c967de9 BR |
161 | bool needs_byteswap; |
162 | ||
163 | #ifdef HOST_WORDS_BIGENDIAN | |
164 | needs_byteswap = s->dump_info.d_endian == ELFDATA2LSB; | |
165 | #else | |
166 | needs_byteswap = s->dump_info.d_endian == ELFDATA2MSB; | |
167 | #endif | |
168 | ||
169 | if (needs_byteswap) { | |
170 | vmxregset->avr[i].u64[0] = bswap64(cpu->env.avr[i].u64[1]); | |
171 | vmxregset->avr[i].u64[1] = bswap64(cpu->env.avr[i].u64[0]); | |
172 | } else { | |
173 | vmxregset->avr[i].u64[0] = cpu->env.avr[i].u64[0]; | |
174 | vmxregset->avr[i].u64[1] = cpu->env.avr[i].u64[1]; | |
175 | } | |
e62fbc54 | 176 | } |
0c967de9 | 177 | vmxregset->vscr.u32[3] = cpu_to_dump32(s, cpu->env.vscr); |
e62fbc54 | 178 | } |
356bb70e MN |
179 | |
180 | static void ppc_write_elf_vsxregset(NoteFuncArg *arg, PowerPCCPU *cpu) | |
e62fbc54 AK |
181 | { |
182 | int i; | |
356bb70e | 183 | struct PPCElfVsxregset *vsxregset; |
0c967de9 BR |
184 | Note *note = &arg->note; |
185 | DumpState *s = arg->state; | |
e62fbc54 | 186 | |
0c967de9 | 187 | note->hdr.n_type = cpu_to_dump32(s, NT_PPC_VSX); |
e62fbc54 AK |
188 | vsxregset = ¬e->contents.vsxregset; |
189 | memset(vsxregset, 0, sizeof(*vsxregset)); | |
190 | ||
191 | for (i = 0; i < 32; i++) { | |
0c967de9 | 192 | vsxregset->vsr[i] = cpu_to_dump64(s, cpu->env.vsr[i]); |
e62fbc54 AK |
193 | } |
194 | } | |
356bb70e MN |
195 | |
196 | static void ppc_write_elf_speregset(NoteFuncArg *arg, PowerPCCPU *cpu) | |
e62fbc54 | 197 | { |
356bb70e | 198 | struct PPCElfSperegset *speregset; |
0c967de9 BR |
199 | Note *note = &arg->note; |
200 | DumpState *s = arg->state; | |
201 | ||
202 | note->hdr.n_type = cpu_to_dump32(s, NT_PPC_SPE); | |
e62fbc54 AK |
203 | speregset = ¬e->contents.speregset; |
204 | memset(speregset, 0, sizeof(*speregset)); | |
205 | ||
0c967de9 BR |
206 | speregset->spe_acc = cpu_to_dump64(s, cpu->env.spe_acc); |
207 | speregset->spe_fscr = cpu_to_dump32(s, cpu->env.spe_fscr); | |
e62fbc54 AK |
208 | } |
209 | ||
cfd54a04 | 210 | static const struct NoteFuncDescStruct { |
e62fbc54 | 211 | int contents_size; |
0c967de9 | 212 | void (*note_contents_func)(NoteFuncArg *arg, PowerPCCPU *cpu); |
e62fbc54 | 213 | } note_func[] = { |
356bb70e MN |
214 | {sizeof(((Note *)0)->contents.prstatus), ppc_write_elf_prstatus}, |
215 | {sizeof(((Note *)0)->contents.fpregset), ppc_write_elf_fpregset}, | |
216 | {sizeof(((Note *)0)->contents.vmxregset), ppc_write_elf_vmxregset}, | |
217 | {sizeof(((Note *)0)->contents.vsxregset), ppc_write_elf_vsxregset}, | |
218 | {sizeof(((Note *)0)->contents.speregset), ppc_write_elf_speregset}, | |
e62fbc54 AK |
219 | { 0, NULL} |
220 | }; | |
221 | ||
222 | typedef struct NoteFuncDescStruct NoteFuncDesc; | |
223 | ||
224 | int cpu_get_dump_info(ArchDumpInfo *info, | |
225 | const struct GuestPhysBlockList *guest_phys_blocks) | |
226 | { | |
1e6ed54e BR |
227 | PowerPCCPU *cpu = POWERPC_CPU(first_cpu); |
228 | PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu); | |
229 | ||
356bb70e MN |
230 | info->d_machine = PPC_ELF_MACHINE; |
231 | info->d_class = ELFCLASS; | |
232 | ||
1e6ed54e BR |
233 | if ((*pcc->interrupts_big_endian)(cpu)) { |
234 | info->d_endian = ELFDATA2MSB; | |
235 | } else { | |
236 | info->d_endian = ELFDATA2LSB; | |
237 | } | |
760d88d1 LV |
238 | /* 64KB is the max page size for pseries kernel */ |
239 | if (strncmp(object_get_typename(qdev_get_machine()), | |
240 | "pseries-", 8) == 0) { | |
241 | info->page_size = (1U << 16); | |
242 | } | |
e62fbc54 AK |
243 | |
244 | return 0; | |
245 | } | |
246 | ||
247 | ssize_t cpu_get_note_size(int class, int machine, int nr_cpus) | |
248 | { | |
249 | int name_size = 8; /* "CORE" or "QEMU" rounded */ | |
250 | size_t elf_note_size = 0; | |
251 | int note_head_size; | |
cfd54a04 | 252 | const NoteFuncDesc *nf; |
e62fbc54 | 253 | |
356bb70e | 254 | note_head_size = sizeof(Elf_Nhdr); |
e62fbc54 AK |
255 | for (nf = note_func; nf->note_contents_func; nf++) { |
256 | elf_note_size = elf_note_size + note_head_size + name_size + | |
356bb70e | 257 | nf->contents_size; |
e62fbc54 AK |
258 | } |
259 | ||
260 | return (elf_note_size) * nr_cpus; | |
261 | } | |
262 | ||
356bb70e MN |
263 | static int ppc_write_all_elf_notes(const char *note_name, |
264 | WriteCoreDumpFunction f, | |
265 | PowerPCCPU *cpu, int id, | |
266 | void *opaque) | |
e62fbc54 | 267 | { |
0c967de9 | 268 | NoteFuncArg arg = { .state = opaque }; |
e62fbc54 AK |
269 | int ret = -1; |
270 | int note_size; | |
cfd54a04 | 271 | const NoteFuncDesc *nf; |
e62fbc54 AK |
272 | |
273 | for (nf = note_func; nf->note_contents_func; nf++) { | |
0c967de9 BR |
274 | arg.note.hdr.n_namesz = cpu_to_dump32(opaque, sizeof(arg.note.name)); |
275 | arg.note.hdr.n_descsz = cpu_to_dump32(opaque, nf->contents_size); | |
276 | strncpy(arg.note.name, note_name, sizeof(arg.note.name)); | |
e62fbc54 | 277 | |
0c967de9 | 278 | (*nf->note_contents_func)(&arg, cpu); |
e62fbc54 | 279 | |
0c967de9 BR |
280 | note_size = |
281 | sizeof(arg.note) - sizeof(arg.note.contents) + nf->contents_size; | |
282 | ret = f(&arg.note, note_size, opaque); | |
e62fbc54 AK |
283 | if (ret < 0) { |
284 | return -1; | |
285 | } | |
286 | } | |
287 | return 0; | |
288 | } | |
289 | ||
290 | int ppc64_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs, | |
291 | int cpuid, void *opaque) | |
292 | { | |
293 | PowerPCCPU *cpu = POWERPC_CPU(cs); | |
356bb70e MN |
294 | return ppc_write_all_elf_notes("CORE", f, cpu, cpuid, opaque); |
295 | } | |
296 | ||
297 | int ppc32_cpu_write_elf32_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); | |
e62fbc54 | 302 | } |