migration: increase max-bandwidth to 128 MiB/s (1 Gib/s)
[qemu.git] / target / s390x / arch_dump.c
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 "cpu.h"
16 #include "internal.h"
17 #include "elf.h"
18 #include "sysemu/dump.h"
19
20
21 struct S390xUserRegsStruct {
22 uint64_t psw[2];
23 uint64_t gprs[16];
24 uint32_t acrs[16];
25 } QEMU_PACKED;
26
27 typedef struct S390xUserRegsStruct S390xUserRegs;
28
29 struct S390xElfPrstatusStruct {
30 uint8_t pad1[32];
31 uint32_t pid;
32 uint8_t pad2[76];
33 S390xUserRegs regs;
34 uint8_t pad3[16];
35 } QEMU_PACKED;
36
37 typedef struct S390xElfPrstatusStruct S390xElfPrstatus;
38
39 struct S390xElfFpregsetStruct {
40 uint32_t fpc;
41 uint32_t pad;
42 uint64_t fprs[16];
43 } QEMU_PACKED;
44
45 typedef struct S390xElfFpregsetStruct S390xElfFpregset;
46
47 struct S390xElfVregsLoStruct {
48 uint64_t vregs[16];
49 } QEMU_PACKED;
50
51 typedef struct S390xElfVregsLoStruct S390xElfVregsLo;
52
53 struct S390xElfVregsHiStruct {
54 uint64_t vregs[16][2];
55 } QEMU_PACKED;
56
57 typedef struct S390xElfVregsHiStruct S390xElfVregsHi;
58
59 struct S390xElfGSCBStruct {
60 uint64_t gsregs[4];
61 } QEMU_PACKED;
62
63 typedef struct S390xElfGSCBStruct S390xElfGSCB;
64
65 typedef struct noteStruct {
66 Elf64_Nhdr hdr;
67 char name[8];
68 union {
69 S390xElfPrstatus prstatus;
70 S390xElfFpregset fpregset;
71 S390xElfVregsLo vregslo;
72 S390xElfVregsHi vregshi;
73 S390xElfGSCB gscb;
74 uint32_t prefix;
75 uint64_t timer;
76 uint64_t todcmp;
77 uint32_t todpreg;
78 uint64_t ctrs[16];
79 } contents;
80 } QEMU_PACKED Note;
81
82 static void s390x_write_elf64_prstatus(Note *note, S390CPU *cpu, int id)
83 {
84 int i;
85 S390xUserRegs *regs;
86
87 note->hdr.n_type = cpu_to_be32(NT_PRSTATUS);
88
89 regs = &(note->contents.prstatus.regs);
90 regs->psw[0] = cpu_to_be64(cpu->env.psw.mask);
91 regs->psw[1] = cpu_to_be64(cpu->env.psw.addr);
92 for (i = 0; i <= 15; i++) {
93 regs->acrs[i] = cpu_to_be32(cpu->env.aregs[i]);
94 regs->gprs[i] = cpu_to_be64(cpu->env.regs[i]);
95 }
96 note->contents.prstatus.pid = id;
97 }
98
99 static void s390x_write_elf64_fpregset(Note *note, S390CPU *cpu, int id)
100 {
101 int i;
102 CPUS390XState *cs = &cpu->env;
103
104 note->hdr.n_type = cpu_to_be32(NT_FPREGSET);
105 note->contents.fpregset.fpc = cpu_to_be32(cpu->env.fpc);
106 for (i = 0; i <= 15; i++) {
107 note->contents.fpregset.fprs[i] = cpu_to_be64(*get_freg(cs, i));
108 }
109 }
110
111 static void s390x_write_elf64_vregslo(Note *note, S390CPU *cpu, int id)
112 {
113 int i;
114
115 note->hdr.n_type = cpu_to_be32(NT_S390_VXRS_LOW);
116 for (i = 0; i <= 15; i++) {
117 note->contents.vregslo.vregs[i] = cpu_to_be64(cpu->env.vregs[i][1]);
118 }
119 }
120
121 static void s390x_write_elf64_vregshi(Note *note, S390CPU *cpu, int id)
122 {
123 int i;
124 S390xElfVregsHi *temp_vregshi;
125
126 temp_vregshi = &note->contents.vregshi;
127
128 note->hdr.n_type = cpu_to_be32(NT_S390_VXRS_HIGH);
129 for (i = 0; i <= 15; i++) {
130 temp_vregshi->vregs[i][0] = cpu_to_be64(cpu->env.vregs[i + 16][0]);
131 temp_vregshi->vregs[i][1] = cpu_to_be64(cpu->env.vregs[i + 16][1]);
132 }
133 }
134
135 static void s390x_write_elf64_gscb(Note *note, S390CPU *cpu, int id)
136 {
137 int i;
138
139 note->hdr.n_type = cpu_to_be32(NT_S390_GS_CB);
140 for (i = 0; i < 4; i++) {
141 note->contents.gscb.gsregs[i] = cpu_to_be64(cpu->env.gscb[i]);
142 }
143 }
144
145 static void s390x_write_elf64_timer(Note *note, S390CPU *cpu, int id)
146 {
147 note->hdr.n_type = cpu_to_be32(NT_S390_TIMER);
148 note->contents.timer = cpu_to_be64((uint64_t)(cpu->env.cputm));
149 }
150
151 static void s390x_write_elf64_todcmp(Note *note, S390CPU *cpu, int id)
152 {
153 note->hdr.n_type = cpu_to_be32(NT_S390_TODCMP);
154 note->contents.todcmp = cpu_to_be64((uint64_t)(cpu->env.ckc));
155 }
156
157 static void s390x_write_elf64_todpreg(Note *note, S390CPU *cpu, int id)
158 {
159 note->hdr.n_type = cpu_to_be32(NT_S390_TODPREG);
160 note->contents.todpreg = cpu_to_be32((uint32_t)(cpu->env.todpr));
161 }
162
163 static void s390x_write_elf64_ctrs(Note *note, S390CPU *cpu, int id)
164 {
165 int i;
166
167 note->hdr.n_type = cpu_to_be32(NT_S390_CTRS);
168
169 for (i = 0; i <= 15; i++) {
170 note->contents.ctrs[i] = cpu_to_be64(cpu->env.cregs[i]);
171 }
172 }
173
174 static void s390x_write_elf64_prefix(Note *note, S390CPU *cpu, int id)
175 {
176 note->hdr.n_type = cpu_to_be32(NT_S390_PREFIX);
177 note->contents.prefix = cpu_to_be32((uint32_t)(cpu->env.psa));
178 }
179
180
181 typedef struct NoteFuncDescStruct {
182 int contents_size;
183 void (*note_contents_func)(Note *note, S390CPU *cpu, int id);
184 } NoteFuncDesc;
185
186 static const NoteFuncDesc note_core[] = {
187 {sizeof_field(Note, contents.prstatus), s390x_write_elf64_prstatus},
188 {sizeof_field(Note, contents.fpregset), s390x_write_elf64_fpregset},
189 { 0, NULL}
190 };
191
192 static const NoteFuncDesc note_linux[] = {
193 {sizeof_field(Note, contents.prefix), s390x_write_elf64_prefix},
194 {sizeof_field(Note, contents.ctrs), s390x_write_elf64_ctrs},
195 {sizeof_field(Note, contents.timer), s390x_write_elf64_timer},
196 {sizeof_field(Note, contents.todcmp), s390x_write_elf64_todcmp},
197 {sizeof_field(Note, contents.todpreg), s390x_write_elf64_todpreg},
198 {sizeof_field(Note, contents.vregslo), s390x_write_elf64_vregslo},
199 {sizeof_field(Note, contents.vregshi), s390x_write_elf64_vregshi},
200 {sizeof_field(Note, contents.gscb), s390x_write_elf64_gscb},
201 { 0, NULL}
202 };
203
204 static int s390x_write_elf64_notes(const char *note_name,
205 WriteCoreDumpFunction f,
206 S390CPU *cpu, int id,
207 void *opaque,
208 const NoteFuncDesc *funcs)
209 {
210 Note note;
211 const NoteFuncDesc *nf;
212 int note_size;
213 int ret = -1;
214
215 for (nf = funcs; nf->note_contents_func; nf++) {
216 memset(&note, 0, sizeof(note));
217 note.hdr.n_namesz = cpu_to_be32(strlen(note_name) + 1);
218 note.hdr.n_descsz = cpu_to_be32(nf->contents_size);
219 strncpy(note.name, note_name, sizeof(note.name));
220 (*nf->note_contents_func)(&note, cpu, id);
221
222 note_size = sizeof(note) - sizeof(note.contents) + nf->contents_size;
223 ret = f(&note, note_size, opaque);
224
225 if (ret < 0) {
226 return -1;
227 }
228
229 }
230
231 return 0;
232 }
233
234
235 int s390_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
236 int cpuid, void *opaque)
237 {
238 S390CPU *cpu = S390_CPU(cs);
239 int r;
240
241 r = s390x_write_elf64_notes("CORE", f, cpu, cpuid, opaque, note_core);
242 if (r) {
243 return r;
244 }
245 return s390x_write_elf64_notes("LINUX", f, cpu, cpuid, opaque, note_linux);
246 }
247
248 int cpu_get_dump_info(ArchDumpInfo *info,
249 const struct GuestPhysBlockList *guest_phys_blocks)
250 {
251 info->d_machine = EM_S390;
252 info->d_endian = ELFDATA2MSB;
253 info->d_class = ELFCLASS64;
254
255 return 0;
256 }
257
258 ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
259 {
260 int name_size = 8; /* "LINUX" or "CORE" + pad */
261 size_t elf_note_size = 0;
262 int note_head_size;
263 const NoteFuncDesc *nf;
264
265 assert(class == ELFCLASS64);
266 assert(machine == EM_S390);
267
268 note_head_size = sizeof(Elf64_Nhdr);
269
270 for (nf = note_core; nf->note_contents_func; nf++) {
271 elf_note_size = elf_note_size + note_head_size + name_size +
272 nf->contents_size;
273 }
274 for (nf = note_linux; nf->note_contents_func; nf++) {
275 elf_note_size = elf_note_size + note_head_size + name_size +
276 nf->contents_size;
277 }
278
279 return (elf_note_size) * nr_cpus;
280 }