1 /*
2 * writing ELF notes for s390x arch
3 *
4 *
5 * Copyright IBM Corp. 2012, 2013
6 *
7 * Ekaterina Tumanova <tumanova@linux.vnet.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 *
12 */
13
14 #include "qemu/osdep.h"
15 #include "qemu/units.h"
16 #include "cpu.h"
17 #include "s390x-internal.h"
18 #include "elf.h"
19 #include "sysemu/dump.h"
20 #include "kvm/kvm_s390x.h"
21 #include "target/s390x/kvm/pv.h"
22
23 struct S390xUserRegsStruct {
24 uint64_t psw[2];
25 uint64_t gprs[16];
26 uint32_t acrs[16];
27 } QEMU_PACKED;
28
29 typedef struct S390xUserRegsStruct S390xUserRegs;
30
31 struct S390xElfPrstatusStruct {
32 uint8_t pad1[32];
33 uint32_t pid;
34 uint8_t pad2[76];
35 S390xUserRegs regs;
36 uint8_t pad3[16];
37 } QEMU_PACKED;
38
39 typedef struct S390xElfPrstatusStruct S390xElfPrstatus;
40
41 struct S390xElfFpregsetStruct {
42 uint32_t fpc;
43 uint32_t pad;
44 uint64_t fprs[16];
45 } QEMU_PACKED;
46
47 typedef struct S390xElfFpregsetStruct S390xElfFpregset;
48
49 struct S390xElfVregsLoStruct {
50 uint64_t vregs[16];
51 } QEMU_PACKED;
52
53 typedef struct S390xElfVregsLoStruct S390xElfVregsLo;
54
55 struct S390xElfVregsHiStruct {
56 uint64_t vregs[16][2];
57 } QEMU_PACKED;
58
59 typedef struct S390xElfVregsHiStruct S390xElfVregsHi;
60
61 struct S390xElfGSCBStruct {
62 uint64_t gsregs[4];
63 } QEMU_PACKED;
64
65 typedef struct S390xElfGSCBStruct S390xElfGSCB;
66
67 typedef struct noteStruct {
68 Elf64_Nhdr hdr;
69 char name[8];
70 union {
71 S390xElfPrstatus prstatus;
72 S390xElfFpregset fpregset;
73 S390xElfVregsLo vregslo;
74 S390xElfVregsHi vregshi;
75 S390xElfGSCB gscb;
76 uint32_t prefix;
77 uint64_t timer;
78 uint64_t todcmp;
79 uint32_t todpreg;
80 uint64_t ctrs[16];
81 uint8_t dynamic[1]; /*
82 * Would be a flexible array member, if
83 * that was legal inside a union. Real
84 * size comes from PV info interface.
85 */
86 } contents;
87 } QEMU_PACKED Note;
88
89 static bool pv_dump_initialized;
90
s390x_write_elf64_prstatus(Note * note,S390CPU * cpu,int id)91 static void s390x_write_elf64_prstatus(Note *note, S390CPU *cpu, int id)
92 {
93 int i;
94 S390xUserRegs *regs;
95
96 note->hdr.n_type = cpu_to_be32(NT_PRSTATUS);
97
98 regs = &(note->contents.prstatus.regs);
99 regs->psw[0] = cpu_to_be64(cpu->env.psw.mask);
100 regs->psw[1] = cpu_to_be64(cpu->env.psw.addr);
101 for (i = 0; i <= 15; i++) {
102 regs->acrs[i] = cpu_to_be32(cpu->env.aregs[i]);
103 regs->gprs[i] = cpu_to_be64(cpu->env.regs[i]);
104 }
105 note->contents.prstatus.pid = cpu_to_be32(id);
106 }
107
s390x_write_elf64_fpregset(Note * note,S390CPU * cpu,int id)108 static void s390x_write_elf64_fpregset(Note *note, S390CPU *cpu, int id)
109 {
110 int i;
111 CPUS390XState *cs = &cpu->env;
112
113 note->hdr.n_type = cpu_to_be32(NT_FPREGSET);
114 note->contents.fpregset.fpc = cpu_to_be32(cpu->env.fpc);
115 for (i = 0; i <= 15; i++) {
116 note->contents.fpregset.fprs[i] = cpu_to_be64(*get_freg(cs, i));
117 }
118 }
119
s390x_write_elf64_vregslo(Note * note,S390CPU * cpu,int id)120 static void s390x_write_elf64_vregslo(Note *note, S390CPU *cpu, int id)
121 {
122 int i;
123
124 note->hdr.n_type = cpu_to_be32(NT_S390_VXRS_LOW);
125 for (i = 0; i <= 15; i++) {
126 note->contents.vregslo.vregs[i] = cpu_to_be64(cpu->env.vregs[i][1]);
127 }
128 }
129
s390x_write_elf64_vregshi(Note * note,S390CPU * cpu,int id)130 static void s390x_write_elf64_vregshi(Note *note, S390CPU *cpu, int id)
131 {
132 int i;
133 S390xElfVregsHi *temp_vregshi;
134
135 temp_vregshi = ¬e->contents.vregshi;
136
137 note->hdr.n_type = cpu_to_be32(NT_S390_VXRS_HIGH);
138 for (i = 0; i <= 15; i++) {
139 temp_vregshi->vregs[i][0] = cpu_to_be64(cpu->env.vregs[i + 16][0]);
140 temp_vregshi->vregs[i][1] = cpu_to_be64(cpu->env.vregs[i + 16][1]);
141 }
142 }
143
s390x_write_elf64_gscb(Note * note,S390CPU * cpu,int id)144 static void s390x_write_elf64_gscb(Note *note, S390CPU *cpu, int id)
145 {
146 int i;
147
148 note->hdr.n_type = cpu_to_be32(NT_S390_GS_CB);
149 for (i = 0; i < 4; i++) {
150 note->contents.gscb.gsregs[i] = cpu_to_be64(cpu->env.gscb[i]);
151 }
152 }
153
s390x_write_elf64_timer(Note * note,S390CPU * cpu,int id)154 static void s390x_write_elf64_timer(Note *note, S390CPU *cpu, int id)
155 {
156 note->hdr.n_type = cpu_to_be32(NT_S390_TIMER);
157 note->contents.timer = cpu_to_be64((uint64_t)(cpu->env.cputm));
158 }
159
s390x_write_elf64_todcmp(Note * note,S390CPU * cpu,int id)160 static void s390x_write_elf64_todcmp(Note *note, S390CPU *cpu, int id)
161 {
162 note->hdr.n_type = cpu_to_be32(NT_S390_TODCMP);
163 note->contents.todcmp = cpu_to_be64((uint64_t)(cpu->env.ckc));
164 }
165
s390x_write_elf64_todpreg(Note * note,S390CPU * cpu,int id)166 static void s390x_write_elf64_todpreg(Note *note, S390CPU *cpu, int id)
167 {
168 note->hdr.n_type = cpu_to_be32(NT_S390_TODPREG);
169 note->contents.todpreg = cpu_to_be32((uint32_t)(cpu->env.todpr));
170 }
171
s390x_write_elf64_ctrs(Note * note,S390CPU * cpu,int id)172 static void s390x_write_elf64_ctrs(Note *note, S390CPU *cpu, int id)
173 {
174 int i;
175
176 note->hdr.n_type = cpu_to_be32(NT_S390_CTRS);
177
178 for (i = 0; i <= 15; i++) {
179 note->contents.ctrs[i] = cpu_to_be64(cpu->env.cregs[i]);
180 }
181 }
182
s390x_write_elf64_prefix(Note * note,S390CPU * cpu,int id)183 static void s390x_write_elf64_prefix(Note *note, S390CPU *cpu, int id)
184 {
185 note->hdr.n_type = cpu_to_be32(NT_S390_PREFIX);
186 note->contents.prefix = cpu_to_be32((uint32_t)(cpu->env.psa));
187 }
188
s390x_write_elf64_pv(Note * note,S390CPU * cpu,int id)189 static void s390x_write_elf64_pv(Note *note, S390CPU *cpu, int id)
190 {
191 note->hdr.n_type = cpu_to_be32(NT_S390_PV_CPU_DATA);
192 if (!pv_dump_initialized) {
193 return;
194 }
195 kvm_s390_dump_cpu(cpu, ¬e->contents.dynamic);
196 }
197
198 typedef struct NoteFuncDescStruct {
199 int contents_size;
200 uint64_t (*note_size_func)(void); /* NULL for non-dynamic sized contents */
201 void (*note_contents_func)(Note *note, S390CPU *cpu, int id);
202 bool pvonly;
203 } NoteFuncDesc;
204
205 static const NoteFuncDesc note_core[] = {
206 {sizeof_field(Note, contents.prstatus), NULL, s390x_write_elf64_prstatus, false},
207 {sizeof_field(Note, contents.fpregset), NULL, s390x_write_elf64_fpregset, false},
208 { 0, NULL, NULL, false}
209 };
210
211 static const NoteFuncDesc note_linux[] = {
212 {sizeof_field(Note, contents.prefix), NULL, s390x_write_elf64_prefix, false},
213 {sizeof_field(Note, contents.ctrs), NULL, s390x_write_elf64_ctrs, false},
214 {sizeof_field(Note, contents.timer), NULL, s390x_write_elf64_timer, false},
215 {sizeof_field(Note, contents.todcmp), NULL, s390x_write_elf64_todcmp, false},
216 {sizeof_field(Note, contents.todpreg), NULL, s390x_write_elf64_todpreg, false},
217 {sizeof_field(Note, contents.vregslo), NULL, s390x_write_elf64_vregslo, false},
218 {sizeof_field(Note, contents.vregshi), NULL, s390x_write_elf64_vregshi, false},
219 {sizeof_field(Note, contents.gscb), NULL, s390x_write_elf64_gscb, false},
220 {0, kvm_s390_pv_dmp_get_size_cpu, s390x_write_elf64_pv, true},
221 { 0, NULL, NULL, false}
222 };
223
s390x_write_elf64_notes(const char * note_name,WriteCoreDumpFunction f,S390CPU * cpu,int id,DumpState * s,const NoteFuncDesc * funcs)224 static int s390x_write_elf64_notes(const char *note_name,
225 WriteCoreDumpFunction f,
226 S390CPU *cpu, int id,
227 DumpState *s,
228 const NoteFuncDesc *funcs)
229 {
230 g_autofree Note *notep = NULL;
231 const NoteFuncDesc *nf;
232 int note_size, prev_size = 0, content_size;
233 int ret = -1;
234
235 assert(strlen(note_name) < sizeof(notep->name));
236
237 for (nf = funcs; nf->note_contents_func; nf++) {
238 if (nf->pvonly && !s390_is_pv()) {
239 continue;
240 }
241
242 content_size = nf->note_size_func ? nf->note_size_func() : nf->contents_size;
243 note_size = sizeof(Note) - sizeof(notep->contents) + content_size;
244
245 if (prev_size < note_size) {
246 g_free(notep);
247 notep = g_malloc(note_size);
248 prev_size = note_size;
249 }
250
251 memset(notep, 0, note_size);
252
253 /* Setup note header data */
254 notep->hdr.n_descsz = cpu_to_be32(content_size);
255 notep->hdr.n_namesz = cpu_to_be32(strlen(note_name) + 1);
256 g_strlcpy(notep->name, note_name, sizeof(notep->name));
257
258 /* Get contents and write them out */
259 (*nf->note_contents_func)(notep, cpu, id);
260 ret = f(notep, note_size, s);
261 if (ret < 0) {
262 return -1;
263 }
264 }
265
266 return 0;
267 }
268
269
s390_cpu_write_elf64_note(WriteCoreDumpFunction f,CPUState * cs,int cpuid,DumpState * s)270 int s390_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
271 int cpuid, DumpState *s)
272 {
273 S390CPU *cpu = S390_CPU(cs);
274 int r;
275
276 r = s390x_write_elf64_notes("CORE", f, cpu, cpuid, s, note_core);
277 if (r) {
278 return r;
279 }
280 return s390x_write_elf64_notes("LINUX", f, cpu, cpuid, s, note_linux);
281 }
282
283 /* PV dump section size functions */
get_mem_state_size_from_len(uint64_t len)284 static uint64_t get_mem_state_size_from_len(uint64_t len)
285 {
286 return (len / (MiB)) * kvm_s390_pv_dmp_get_size_mem_state();
287 }
288
get_size_mem_state(DumpState * s)289 static uint64_t get_size_mem_state(DumpState *s)
290 {
291 return get_mem_state_size_from_len(s->total_size);
292 }
293
get_size_completion_data(DumpState * s)294 static uint64_t get_size_completion_data(DumpState *s)
295 {
296 return kvm_s390_pv_dmp_get_size_completion_data();
297 }
298
299 /* PV dump section data functions*/
get_data_completion(DumpState * s,uint8_t * buff)300 static int get_data_completion(DumpState *s, uint8_t *buff)
301 {
302 int rc;
303
304 if (!pv_dump_initialized) {
305 return 0;
306 }
307 rc = kvm_s390_dump_completion_data(buff);
308 if (!rc) {
309 pv_dump_initialized = false;
310 }
311 return rc;
312 }
313
get_mem_state(DumpState * s,uint8_t * buff)314 static int get_mem_state(DumpState *s, uint8_t *buff)
315 {
316 int64_t memblock_size, memblock_start;
317 GuestPhysBlock *block;
318 uint64_t off;
319 int rc;
320
321 QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
322 memblock_start = dump_filtered_memblock_start(block, s->filter_area_begin,
323 s->filter_area_length);
324 if (memblock_start == -1) {
325 continue;
326 }
327
328 memblock_size = dump_filtered_memblock_size(block, s->filter_area_begin,
329 s->filter_area_length);
330
331 off = get_mem_state_size_from_len(block->target_start);
332
333 rc = kvm_s390_dump_mem_state(block->target_start,
334 get_mem_state_size_from_len(memblock_size),
335 buff + off);
336 if (rc) {
337 return rc;
338 }
339 }
340
341 return 0;
342 }
343
344 static struct sections {
345 uint64_t (*sections_size_func)(DumpState *s);
346 int (*sections_contents_func)(DumpState *s, uint8_t *buff);
347 char sctn_str[12];
348 } sections[] = {
349 { get_size_mem_state, get_mem_state, "pv_mem_meta"},
350 { get_size_completion_data, get_data_completion, "pv_compl"},
351 {NULL , NULL, ""}
352 };
353
arch_sections_write_hdr(DumpState * s,uint8_t * buff)354 static uint64_t arch_sections_write_hdr(DumpState *s, uint8_t *buff)
355 {
356 Elf64_Shdr *shdr = (void *)buff;
357 struct sections *sctn = sections;
358 uint64_t off = s->section_offset;
359
360 if (!pv_dump_initialized) {
361 return 0;
362 }
363
364 for (; sctn->sections_size_func; off += shdr->sh_size, sctn++, shdr++) {
365 memset(shdr, 0, sizeof(*shdr));
366 shdr->sh_type = SHT_PROGBITS;
367 shdr->sh_offset = off;
368 shdr->sh_size = sctn->sections_size_func(s);
369 shdr->sh_name = s->string_table_buf->len;
370 g_array_append_vals(s->string_table_buf, sctn->sctn_str, sizeof(sctn->sctn_str));
371 }
372
373 return (uintptr_t)shdr - (uintptr_t)buff;
374 }
375
376
377 /* Add arch specific number of sections and their respective sizes */
arch_sections_add(DumpState * s)378 static void arch_sections_add(DumpState *s)
379 {
380 struct sections *sctn = sections;
381
382 /*
383 * We only do a PV dump if we are running a PV guest, KVM supports
384 * the dump API and we got valid dump length information.
385 */
386 if (!s390_is_pv() || !kvm_s390_get_protected_dump() ||
387 !kvm_s390_pv_info_basic_valid()) {
388 return;
389 }
390
391 /*
392 * Start the UV dump process by doing the initialize dump call via
393 * KVM as the proxy.
394 */
395 if (!kvm_s390_dump_init()) {
396 pv_dump_initialized = true;
397 } else {
398 /*
399 * Dump init failed, maybe the guest owner disabled dumping.
400 * We'll continue the non-PV dump process since this is no
401 * reason to crash qemu.
402 */
403 return;
404 }
405
406 for (; sctn->sections_size_func; sctn++) {
407 s->shdr_num += 1;
408 s->elf_section_data_size += sctn->sections_size_func(s);
409 }
410 }
411
412 /*
413 * After the PV dump has been initialized, the CPU data has been
414 * fetched and memory has been dumped, we need to grab the tweak data
415 * and the completion data.
416 */
arch_sections_write(DumpState * s,uint8_t * buff)417 static int arch_sections_write(DumpState *s, uint8_t *buff)
418 {
419 struct sections *sctn = sections;
420 int rc;
421
422 if (!pv_dump_initialized) {
423 return -EINVAL;
424 }
425
426 for (; sctn->sections_size_func; sctn++) {
427 rc = sctn->sections_contents_func(s, buff);
428 buff += sctn->sections_size_func(s);
429 if (rc) {
430 return rc;
431 }
432 }
433 return 0;
434 }
435
arch_cleanup(DumpState * s)436 static void arch_cleanup(DumpState *s)
437 {
438 g_autofree uint8_t *buff = NULL;
439 int rc;
440
441 if (!pv_dump_initialized) {
442 return;
443 }
444
445 buff = g_malloc(kvm_s390_pv_dmp_get_size_completion_data());
446 rc = kvm_s390_dump_completion_data(buff);
447 if (!rc) {
448 pv_dump_initialized = false;
449 }
450 }
451
cpu_get_dump_info(ArchDumpInfo * info,const struct GuestPhysBlockList * guest_phys_blocks)452 int cpu_get_dump_info(ArchDumpInfo *info,
453 const struct GuestPhysBlockList *guest_phys_blocks)
454 {
455 info->d_machine = EM_S390;
456 info->d_endian = ELFDATA2MSB;
457 info->d_class = ELFCLASS64;
458 /*
459 * This is evaluated for each dump so we can freely switch
460 * between PV and non-PV.
461 */
462 if (s390_is_pv() && kvm_s390_get_protected_dump() &&
463 kvm_s390_pv_info_basic_valid()) {
464 info->arch_sections_add_fn = *arch_sections_add;
465 info->arch_sections_write_hdr_fn = *arch_sections_write_hdr;
466 info->arch_sections_write_fn = *arch_sections_write;
467 info->arch_cleanup_fn = *arch_cleanup;
468 }
469 return 0;
470 }
471
cpu_get_note_size(int class,int machine,int nr_cpus)472 ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
473 {
474 int name_size = 8; /* "LINUX" or "CORE" + pad */
475 size_t elf_note_size = 0;
476 int note_head_size, content_size;
477 const NoteFuncDesc *nf;
478
479 assert(class == ELFCLASS64);
480 assert(machine == EM_S390);
481
482 note_head_size = sizeof(Elf64_Nhdr);
483
484 for (nf = note_core; nf->note_contents_func; nf++) {
485 elf_note_size = elf_note_size + note_head_size + name_size + nf->contents_size;
486 }
487 for (nf = note_linux; nf->note_contents_func; nf++) {
488 if (nf->pvonly && !s390_is_pv()) {
489 continue;
490 }
491 content_size = nf->contents_size ? nf->contents_size : nf->note_size_func();
492 elf_note_size = elf_note_size + note_head_size + name_size +
493 content_size;
494 }
495
496 return (elf_note_size) * nr_cpus;
497 }
498