migration: do cleanup operation after completion
[kvmfornfv.git] / qemu / 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 "cpu.h"
15 #include "elf.h"
16 #include "exec/cpu-all.h"
17 #include "sysemu/dump.h"
18 #include "sysemu/kvm.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 typedef struct noteStruct {
60     Elf64_Nhdr hdr;
61     char name[5];
62     char pad3[3];
63     union {
64         S390xElfPrstatus prstatus;
65         S390xElfFpregset fpregset;
66         S390xElfVregsLo vregslo;
67         S390xElfVregsHi vregshi;
68         uint32_t prefix;
69         uint64_t timer;
70         uint64_t todcmp;
71         uint32_t todpreg;
72         uint64_t ctrs[16];
73     } contents;
74 } QEMU_PACKED Note;
75
76 static void s390x_write_elf64_prstatus(Note *note, S390CPU *cpu)
77 {
78     int i;
79     S390xUserRegs *regs;
80
81     note->hdr.n_type = cpu_to_be32(NT_PRSTATUS);
82
83     regs = &(note->contents.prstatus.regs);
84     regs->psw[0] = cpu_to_be64(cpu->env.psw.mask);
85     regs->psw[1] = cpu_to_be64(cpu->env.psw.addr);
86     for (i = 0; i <= 15; i++) {
87         regs->acrs[i] = cpu_to_be32(cpu->env.aregs[i]);
88         regs->gprs[i] = cpu_to_be64(cpu->env.regs[i]);
89     }
90 }
91
92 static void s390x_write_elf64_fpregset(Note *note, S390CPU *cpu)
93 {
94     int i;
95     CPUS390XState *cs = &cpu->env;
96
97     note->hdr.n_type = cpu_to_be32(NT_FPREGSET);
98     note->contents.fpregset.fpc = cpu_to_be32(cpu->env.fpc);
99     for (i = 0; i <= 15; i++) {
100         note->contents.fpregset.fprs[i] = cpu_to_be64(get_freg(cs, i)->ll);
101     }
102 }
103
104 static void s390x_write_elf64_vregslo(Note *note, S390CPU *cpu)
105 {
106     int i;
107
108     note->hdr.n_type = cpu_to_be32(NT_S390_VXRS_LOW);
109     for (i = 0; i <= 15; i++) {
110         note->contents.vregslo.vregs[i] = cpu_to_be64(cpu->env.vregs[i][1].ll);
111     }
112 }
113
114 static void s390x_write_elf64_vregshi(Note *note, S390CPU *cpu)
115 {
116     int i;
117     S390xElfVregsHi *temp_vregshi;
118
119     temp_vregshi = &note->contents.vregshi;
120
121     note->hdr.n_type = cpu_to_be32(NT_S390_VXRS_HIGH);
122     for (i = 0; i <= 15; i++) {
123         temp_vregshi->vregs[i][0] = cpu_to_be64(cpu->env.vregs[i + 16][0].ll);
124         temp_vregshi->vregs[i][1] = cpu_to_be64(cpu->env.vregs[i + 16][1].ll);
125     }
126 }
127
128 static void s390x_write_elf64_timer(Note *note, S390CPU *cpu)
129 {
130     note->hdr.n_type = cpu_to_be32(NT_S390_TIMER);
131     note->contents.timer = cpu_to_be64((uint64_t)(cpu->env.cputm));
132 }
133
134 static void s390x_write_elf64_todcmp(Note *note, S390CPU *cpu)
135 {
136     note->hdr.n_type = cpu_to_be32(NT_S390_TODCMP);
137     note->contents.todcmp = cpu_to_be64((uint64_t)(cpu->env.ckc));
138 }
139
140 static void s390x_write_elf64_todpreg(Note *note, S390CPU *cpu)
141 {
142     note->hdr.n_type = cpu_to_be32(NT_S390_TODPREG);
143     note->contents.todpreg = cpu_to_be32((uint32_t)(cpu->env.todpr));
144 }
145
146 static void s390x_write_elf64_ctrs(Note *note, S390CPU *cpu)
147 {
148     int i;
149
150     note->hdr.n_type = cpu_to_be32(NT_S390_CTRS);
151
152     for (i = 0; i <= 15; i++) {
153         note->contents.ctrs[i] = cpu_to_be64(cpu->env.cregs[i]);
154     }
155 }
156
157 static void s390x_write_elf64_prefix(Note *note, S390CPU *cpu)
158 {
159     note->hdr.n_type = cpu_to_be32(NT_S390_PREFIX);
160     note->contents.prefix = cpu_to_be32((uint32_t)(cpu->env.psa));
161 }
162
163
164 static const struct NoteFuncDescStruct {
165     int contents_size;
166     void (*note_contents_func)(Note *note, S390CPU *cpu);
167 } note_func[] = {
168     {sizeof(((Note *)0)->contents.prstatus), s390x_write_elf64_prstatus},
169     {sizeof(((Note *)0)->contents.prefix),   s390x_write_elf64_prefix},
170     {sizeof(((Note *)0)->contents.fpregset), s390x_write_elf64_fpregset},
171     {sizeof(((Note *)0)->contents.ctrs),     s390x_write_elf64_ctrs},
172     {sizeof(((Note *)0)->contents.timer),    s390x_write_elf64_timer},
173     {sizeof(((Note *)0)->contents.todcmp),   s390x_write_elf64_todcmp},
174     {sizeof(((Note *)0)->contents.todpreg),  s390x_write_elf64_todpreg},
175     {sizeof(((Note *)0)->contents.vregslo),  s390x_write_elf64_vregslo},
176     {sizeof(((Note *)0)->contents.vregshi),  s390x_write_elf64_vregshi},
177     { 0, NULL}
178 };
179
180 typedef struct NoteFuncDescStruct NoteFuncDesc;
181
182
183 static int s390x_write_all_elf64_notes(const char *note_name,
184                                        WriteCoreDumpFunction f,
185                                        S390CPU *cpu, int id,
186                                        void *opaque)
187 {
188     Note note;
189     const NoteFuncDesc *nf;
190     int note_size;
191     int ret = -1;
192
193     for (nf = note_func; nf->note_contents_func; nf++) {
194         memset(&note, 0, sizeof(note));
195         note.hdr.n_namesz = cpu_to_be32(sizeof(note.name));
196         note.hdr.n_descsz = cpu_to_be32(nf->contents_size);
197         strncpy(note.name, note_name, sizeof(note.name));
198         (*nf->note_contents_func)(&note, cpu);
199
200         note_size = sizeof(note) - sizeof(note.contents) + nf->contents_size;
201         ret = f(&note, note_size, opaque);
202
203         if (ret < 0) {
204             return -1;
205         }
206
207     }
208
209     return 0;
210 }
211
212
213 int s390_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
214                               int cpuid, void *opaque)
215 {
216     S390CPU *cpu = S390_CPU(cs);
217     return s390x_write_all_elf64_notes("CORE", f, cpu, cpuid, opaque);
218 }
219
220 int cpu_get_dump_info(ArchDumpInfo *info,
221                       const struct GuestPhysBlockList *guest_phys_blocks)
222 {
223     info->d_machine = EM_S390;
224     info->d_endian = ELFDATA2MSB;
225     info->d_class = ELFCLASS64;
226
227     return 0;
228 }
229
230 ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
231 {
232     int name_size = 8; /* "CORE" or "QEMU" rounded */
233     size_t elf_note_size = 0;
234     int note_head_size;
235     const NoteFuncDesc *nf;
236
237     assert(class == ELFCLASS64);
238     assert(machine == EM_S390);
239
240     note_head_size = sizeof(Elf64_Nhdr);
241
242     for (nf = note_func; nf->note_contents_func; nf++) {
243         elf_note_size = elf_note_size + note_head_size + name_size +
244                         nf->contents_size;
245     }
246
247     return (elf_note_size) * nr_cpus;
248 }
249
250 int s390_cpu_write_elf64_qemunote(WriteCoreDumpFunction f,
251                                   CPUState *cpu, void *opaque)
252 {
253     return 0;
254 }