@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 296 lines 9.08 KB
Raw
1 /*
2 * S390x machine definitions and functions
3 *
4 * Copyright IBM Corp. 2014, 2018
5 *
6 * Authors:
7 * Thomas Huth <thuth@linux.vnet.ibm.com>
8 * Christian Borntraeger <borntraeger@de.ibm.com>
9 * Jason J. Herne <jjherne@us.ibm.com>
10 *
11 * This work is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published
13 * by the Free Software Foundation; either version 2 of the License,
14 * or (at your option) any later version.
15 */
16
17 #include "qemu/osdep.h"
18 #include "cpu.h"
19 #include "s390x-internal.h"
20 #include "kvm/kvm_s390x.h"
21 #include "migration/vmstate.h"
22 #include "tcg/tcg_s390x.h"
23 #include "system/kvm.h"
24 #include "system/tcg.h"
25
26 static int cpu_post_load(void *opaque, int version_id)
27 {
28 S390CPU *cpu = opaque;
29
30 /*
31 * As the cpu state is pushed to kvm via kvm_set_mp_state rather
32 * than via cpu_synchronize_state, we need update kvm here.
33 */
34 if (kvm_enabled()) {
35 kvm_s390_set_cpu_state(cpu, cpu->env.cpu_state);
36 return kvm_s390_vcpu_interrupt_post_load(cpu);
37 }
38
39 if (tcg_enabled()) {
40 /* Rearm the CKC timer if necessary */
41 tcg_s390_tod_updated(CPU(cpu), RUN_ON_CPU_NULL);
42 }
43
44 return 0;
45 }
46
47 static int cpu_pre_save(void *opaque)
48 {
49 S390CPU *cpu = opaque;
50
51 if (kvm_enabled()) {
52 kvm_s390_vcpu_interrupt_pre_save(cpu);
53 }
54
55 if (tcg_enabled()) {
56 tcg_s390_tod_updated(CPU(cpu), RUN_ON_CPU_NULL);
57 }
58
59 return 0;
60 }
61
62 static inline bool fpu_needed(void *opaque)
63 {
64 /* This looks odd, but we might want to NOT transfer fprs in the future */
65 return true;
66 }
67
68 static const VMStateDescription vmstate_fpu = {
69 .name = "cpu/fpu",
70 .version_id = 1,
71 .minimum_version_id = 1,
72 .needed = fpu_needed,
73 .fields = (const VMStateField[]) {
74 VMSTATE_UINT64(env.vregs[0][0], S390CPU),
75 VMSTATE_UINT64(env.vregs[1][0], S390CPU),
76 VMSTATE_UINT64(env.vregs[2][0], S390CPU),
77 VMSTATE_UINT64(env.vregs[3][0], S390CPU),
78 VMSTATE_UINT64(env.vregs[4][0], S390CPU),
79 VMSTATE_UINT64(env.vregs[5][0], S390CPU),
80 VMSTATE_UINT64(env.vregs[6][0], S390CPU),
81 VMSTATE_UINT64(env.vregs[7][0], S390CPU),
82 VMSTATE_UINT64(env.vregs[8][0], S390CPU),
83 VMSTATE_UINT64(env.vregs[9][0], S390CPU),
84 VMSTATE_UINT64(env.vregs[10][0], S390CPU),
85 VMSTATE_UINT64(env.vregs[11][0], S390CPU),
86 VMSTATE_UINT64(env.vregs[12][0], S390CPU),
87 VMSTATE_UINT64(env.vregs[13][0], S390CPU),
88 VMSTATE_UINT64(env.vregs[14][0], S390CPU),
89 VMSTATE_UINT64(env.vregs[15][0], S390CPU),
90 VMSTATE_UINT32(env.fpc, S390CPU),
91 VMSTATE_END_OF_LIST()
92 }
93 };
94
95 static bool vregs_needed(void *opaque)
96 {
97 return s390_has_feat(S390_FEAT_VECTOR);
98 }
99
100 static const VMStateDescription vmstate_vregs = {
101 .name = "cpu/vregs",
102 .version_id = 1,
103 .minimum_version_id = 1,
104 .needed = vregs_needed,
105 .fields = (const VMStateField[]) {
106 /* vregs[0][0] -> vregs[15][0] and fregs are overlays */
107 VMSTATE_UINT64(env.vregs[16][0], S390CPU),
108 VMSTATE_UINT64(env.vregs[17][0], S390CPU),
109 VMSTATE_UINT64(env.vregs[18][0], S390CPU),
110 VMSTATE_UINT64(env.vregs[19][0], S390CPU),
111 VMSTATE_UINT64(env.vregs[20][0], S390CPU),
112 VMSTATE_UINT64(env.vregs[21][0], S390CPU),
113 VMSTATE_UINT64(env.vregs[22][0], S390CPU),
114 VMSTATE_UINT64(env.vregs[23][0], S390CPU),
115 VMSTATE_UINT64(env.vregs[24][0], S390CPU),
116 VMSTATE_UINT64(env.vregs[25][0], S390CPU),
117 VMSTATE_UINT64(env.vregs[26][0], S390CPU),
118 VMSTATE_UINT64(env.vregs[27][0], S390CPU),
119 VMSTATE_UINT64(env.vregs[28][0], S390CPU),
120 VMSTATE_UINT64(env.vregs[29][0], S390CPU),
121 VMSTATE_UINT64(env.vregs[30][0], S390CPU),
122 VMSTATE_UINT64(env.vregs[31][0], S390CPU),
123 VMSTATE_UINT64(env.vregs[0][1], S390CPU),
124 VMSTATE_UINT64(env.vregs[1][1], S390CPU),
125 VMSTATE_UINT64(env.vregs[2][1], S390CPU),
126 VMSTATE_UINT64(env.vregs[3][1], S390CPU),
127 VMSTATE_UINT64(env.vregs[4][1], S390CPU),
128 VMSTATE_UINT64(env.vregs[5][1], S390CPU),
129 VMSTATE_UINT64(env.vregs[6][1], S390CPU),
130 VMSTATE_UINT64(env.vregs[7][1], S390CPU),
131 VMSTATE_UINT64(env.vregs[8][1], S390CPU),
132 VMSTATE_UINT64(env.vregs[9][1], S390CPU),
133 VMSTATE_UINT64(env.vregs[10][1], S390CPU),
134 VMSTATE_UINT64(env.vregs[11][1], S390CPU),
135 VMSTATE_UINT64(env.vregs[12][1], S390CPU),
136 VMSTATE_UINT64(env.vregs[13][1], S390CPU),
137 VMSTATE_UINT64(env.vregs[14][1], S390CPU),
138 VMSTATE_UINT64(env.vregs[15][1], S390CPU),
139 VMSTATE_UINT64(env.vregs[16][1], S390CPU),
140 VMSTATE_UINT64(env.vregs[17][1], S390CPU),
141 VMSTATE_UINT64(env.vregs[18][1], S390CPU),
142 VMSTATE_UINT64(env.vregs[19][1], S390CPU),
143 VMSTATE_UINT64(env.vregs[20][1], S390CPU),
144 VMSTATE_UINT64(env.vregs[21][1], S390CPU),
145 VMSTATE_UINT64(env.vregs[22][1], S390CPU),
146 VMSTATE_UINT64(env.vregs[23][1], S390CPU),
147 VMSTATE_UINT64(env.vregs[24][1], S390CPU),
148 VMSTATE_UINT64(env.vregs[25][1], S390CPU),
149 VMSTATE_UINT64(env.vregs[26][1], S390CPU),
150 VMSTATE_UINT64(env.vregs[27][1], S390CPU),
151 VMSTATE_UINT64(env.vregs[28][1], S390CPU),
152 VMSTATE_UINT64(env.vregs[29][1], S390CPU),
153 VMSTATE_UINT64(env.vregs[30][1], S390CPU),
154 VMSTATE_UINT64(env.vregs[31][1], S390CPU),
155 VMSTATE_END_OF_LIST()
156 }
157 };
158
159 static bool riccb_needed(void *opaque)
160 {
161 return s390_has_feat(S390_FEAT_RUNTIME_INSTRUMENTATION);
162 }
163
164 static const VMStateDescription vmstate_riccb = {
165 .name = "cpu/riccb",
166 .version_id = 1,
167 .minimum_version_id = 1,
168 .needed = riccb_needed,
169 .fields = (const VMStateField[]) {
170 VMSTATE_UINT8_ARRAY(env.riccb, S390CPU, 64),
171 VMSTATE_END_OF_LIST()
172 }
173 };
174
175 static bool exval_needed(void *opaque)
176 {
177 S390CPU *cpu = opaque;
178 return cpu->env.ex_value != 0;
179 }
180
181 static const VMStateDescription vmstate_exval = {
182 .name = "cpu/exval",
183 .version_id = 1,
184 .minimum_version_id = 1,
185 .needed = exval_needed,
186 .fields = (const VMStateField[]) {
187 VMSTATE_UINT64(env.ex_value, S390CPU),
188 VMSTATE_END_OF_LIST()
189 }
190 };
191
192 static bool gscb_needed(void *opaque)
193 {
194 return s390_has_feat(S390_FEAT_GUARDED_STORAGE);
195 }
196
197 static const VMStateDescription vmstate_gscb = {
198 .name = "cpu/gscb",
199 .version_id = 1,
200 .minimum_version_id = 1,
201 .needed = gscb_needed,
202 .fields = (const VMStateField[]) {
203 VMSTATE_UINT64_ARRAY(env.gscb, S390CPU, 4),
204 VMSTATE_END_OF_LIST()
205 }
206 };
207
208 static bool bpbc_needed(void *opaque)
209 {
210 return s390_has_feat(S390_FEAT_BPB);
211 }
212
213 static const VMStateDescription vmstate_bpbc = {
214 .name = "cpu/bpbc",
215 .version_id = 1,
216 .minimum_version_id = 1,
217 .needed = bpbc_needed,
218 .fields = (const VMStateField[]) {
219 VMSTATE_BOOL(env.bpbc, S390CPU),
220 VMSTATE_END_OF_LIST()
221 }
222 };
223
224 static bool etoken_needed(void *opaque)
225 {
226 return s390_has_feat(S390_FEAT_ETOKEN);
227 }
228
229 static const VMStateDescription vmstate_etoken = {
230 .name = "cpu/etoken",
231 .version_id = 1,
232 .minimum_version_id = 1,
233 .needed = etoken_needed,
234 .fields = (const VMStateField[]) {
235 VMSTATE_UINT64(env.etoken, S390CPU),
236 VMSTATE_UINT64(env.etoken_extension, S390CPU),
237 VMSTATE_END_OF_LIST()
238 }
239 };
240
241 static bool diag318_needed(void *opaque)
242 {
243 return s390_has_feat(S390_FEAT_DIAG_318);
244 }
245
246 static const VMStateDescription vmstate_diag318 = {
247 .name = "cpu/diag318",
248 .version_id = 1,
249 .minimum_version_id = 1,
250 .needed = diag318_needed,
251 .fields = (const VMStateField[]) {
252 VMSTATE_UINT64(env.diag318_info, S390CPU),
253 VMSTATE_END_OF_LIST()
254 }
255 };
256
257 const VMStateDescription vmstate_s390_cpu = {
258 .name = "cpu",
259 .post_load = cpu_post_load,
260 .pre_save = cpu_pre_save,
261 .version_id = 4,
262 .minimum_version_id = 3,
263 .fields = (const VMStateField[]) {
264 VMSTATE_UINT64_ARRAY(env.regs, S390CPU, 16),
265 VMSTATE_UINT64(env.psw.mask, S390CPU),
266 VMSTATE_UINT64(env.psw.addr, S390CPU),
267 VMSTATE_UINT64(env.psa, S390CPU),
268 VMSTATE_UINT32(env.todpr, S390CPU),
269 VMSTATE_UINT64(env.pfault_token, S390CPU),
270 VMSTATE_UINT64(env.pfault_compare, S390CPU),
271 VMSTATE_UINT64(env.pfault_select, S390CPU),
272 VMSTATE_UINT64(env.cputm, S390CPU),
273 VMSTATE_UINT64(env.ckc, S390CPU),
274 VMSTATE_UINT64(env.gbea, S390CPU),
275 VMSTATE_UINT64(env.pp, S390CPU),
276 VMSTATE_UINT32_ARRAY(env.aregs, S390CPU, 16),
277 VMSTATE_UINT64_ARRAY(env.cregs, S390CPU, 16),
278 VMSTATE_UINT8(env.cpu_state, S390CPU),
279 VMSTATE_UINT8(env.sigp_order, S390CPU),
280 VMSTATE_UINT32_V(irqstate_saved_size, S390CPU, 4),
281 VMSTATE_VBUFFER_UINT32(irqstate, S390CPU, 4, NULL,
282 irqstate_saved_size),
283 VMSTATE_END_OF_LIST()
284 },
285 .subsections = (const VMStateDescription * const []) {
286 &vmstate_fpu,
287 &vmstate_vregs,
288 &vmstate_riccb,
289 &vmstate_exval,
290 &vmstate_gscb,
291 &vmstate_bpbc,
292 &vmstate_etoken,
293 &vmstate_diag318,
294 NULL
295 },
296 };