]>
Commit | Line | Data |
---|---|---|
b6a0aa05 | 1 | #include "qemu/osdep.h" |
33c11879 PB |
2 | #include "qemu-common.h" |
3 | #include "cpu.h" | |
63c91552 | 4 | #include "exec/exec-all.h" |
8dd3dca3 AJ |
5 | #include "hw/hw.h" |
6 | #include "hw/boards.h" | |
0d09e41a PB |
7 | #include "hw/i386/pc.h" |
8 | #include "hw/isa/isa.h" | |
1e00b8d5 | 9 | #include "migration/cpu.h" |
8dd3dca3 | 10 | |
9c17d615 | 11 | #include "sysemu/kvm.h" |
8dd3dca3 | 12 | |
36f96c4b HZ |
13 | #include "qemu/error-report.h" |
14 | ||
66e6d55b JQ |
15 | static const VMStateDescription vmstate_segment = { |
16 | .name = "segment", | |
17 | .version_id = 1, | |
18 | .minimum_version_id = 1, | |
d49805ae | 19 | .fields = (VMStateField[]) { |
66e6d55b JQ |
20 | VMSTATE_UINT32(selector, SegmentCache), |
21 | VMSTATE_UINTTL(base, SegmentCache), | |
22 | VMSTATE_UINT32(limit, SegmentCache), | |
23 | VMSTATE_UINT32(flags, SegmentCache), | |
24 | VMSTATE_END_OF_LIST() | |
25 | } | |
26 | }; | |
27 | ||
0cb892aa JQ |
28 | #define VMSTATE_SEGMENT(_field, _state) { \ |
29 | .name = (stringify(_field)), \ | |
30 | .size = sizeof(SegmentCache), \ | |
31 | .vmsd = &vmstate_segment, \ | |
32 | .flags = VMS_STRUCT, \ | |
33 | .offset = offsetof(_state, _field) \ | |
34 | + type_check(SegmentCache,typeof_field(_state, _field)) \ | |
8dd3dca3 AJ |
35 | } |
36 | ||
0cb892aa JQ |
37 | #define VMSTATE_SEGMENT_ARRAY(_field, _state, _n) \ |
38 | VMSTATE_STRUCT_ARRAY(_field, _state, _n, 0, vmstate_segment, SegmentCache) | |
8dd3dca3 | 39 | |
fc3b0aa2 JQ |
40 | static const VMStateDescription vmstate_xmm_reg = { |
41 | .name = "xmm_reg", | |
42 | .version_id = 1, | |
43 | .minimum_version_id = 1, | |
d49805ae | 44 | .fields = (VMStateField[]) { |
19cbd87c EH |
45 | VMSTATE_UINT64(ZMM_Q(0), ZMMReg), |
46 | VMSTATE_UINT64(ZMM_Q(1), ZMMReg), | |
fc3b0aa2 JQ |
47 | VMSTATE_END_OF_LIST() |
48 | } | |
49 | }; | |
50 | ||
a03c3e90 PB |
51 | #define VMSTATE_XMM_REGS(_field, _state, _start) \ |
52 | VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0, \ | |
fa451874 | 53 | vmstate_xmm_reg, ZMMReg) |
fc3b0aa2 | 54 | |
b7711471 | 55 | /* YMMH format is the same as XMM, but for bits 128-255 */ |
f1665b21 SY |
56 | static const VMStateDescription vmstate_ymmh_reg = { |
57 | .name = "ymmh_reg", | |
58 | .version_id = 1, | |
59 | .minimum_version_id = 1, | |
d49805ae | 60 | .fields = (VMStateField[]) { |
19cbd87c EH |
61 | VMSTATE_UINT64(ZMM_Q(2), ZMMReg), |
62 | VMSTATE_UINT64(ZMM_Q(3), ZMMReg), | |
f1665b21 SY |
63 | VMSTATE_END_OF_LIST() |
64 | } | |
65 | }; | |
66 | ||
a03c3e90 PB |
67 | #define VMSTATE_YMMH_REGS_VARS(_field, _state, _start, _v) \ |
68 | VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, _v, \ | |
fa451874 | 69 | vmstate_ymmh_reg, ZMMReg) |
f1665b21 | 70 | |
9aecd6f8 CP |
71 | static const VMStateDescription vmstate_zmmh_reg = { |
72 | .name = "zmmh_reg", | |
73 | .version_id = 1, | |
74 | .minimum_version_id = 1, | |
75 | .fields = (VMStateField[]) { | |
19cbd87c EH |
76 | VMSTATE_UINT64(ZMM_Q(4), ZMMReg), |
77 | VMSTATE_UINT64(ZMM_Q(5), ZMMReg), | |
78 | VMSTATE_UINT64(ZMM_Q(6), ZMMReg), | |
79 | VMSTATE_UINT64(ZMM_Q(7), ZMMReg), | |
9aecd6f8 CP |
80 | VMSTATE_END_OF_LIST() |
81 | } | |
82 | }; | |
83 | ||
a03c3e90 PB |
84 | #define VMSTATE_ZMMH_REGS_VARS(_field, _state, _start) \ |
85 | VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0, \ | |
fa451874 | 86 | vmstate_zmmh_reg, ZMMReg) |
9aecd6f8 CP |
87 | |
88 | #ifdef TARGET_X86_64 | |
89 | static const VMStateDescription vmstate_hi16_zmm_reg = { | |
90 | .name = "hi16_zmm_reg", | |
91 | .version_id = 1, | |
92 | .minimum_version_id = 1, | |
93 | .fields = (VMStateField[]) { | |
19cbd87c EH |
94 | VMSTATE_UINT64(ZMM_Q(0), ZMMReg), |
95 | VMSTATE_UINT64(ZMM_Q(1), ZMMReg), | |
96 | VMSTATE_UINT64(ZMM_Q(2), ZMMReg), | |
97 | VMSTATE_UINT64(ZMM_Q(3), ZMMReg), | |
98 | VMSTATE_UINT64(ZMM_Q(4), ZMMReg), | |
99 | VMSTATE_UINT64(ZMM_Q(5), ZMMReg), | |
100 | VMSTATE_UINT64(ZMM_Q(6), ZMMReg), | |
101 | VMSTATE_UINT64(ZMM_Q(7), ZMMReg), | |
9aecd6f8 CP |
102 | VMSTATE_END_OF_LIST() |
103 | } | |
104 | }; | |
105 | ||
a03c3e90 PB |
106 | #define VMSTATE_Hi16_ZMM_REGS_VARS(_field, _state, _start) \ |
107 | VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0, \ | |
fa451874 | 108 | vmstate_hi16_zmm_reg, ZMMReg) |
9aecd6f8 CP |
109 | #endif |
110 | ||
79e9ebeb LJ |
111 | static const VMStateDescription vmstate_bnd_regs = { |
112 | .name = "bnd_regs", | |
113 | .version_id = 1, | |
114 | .minimum_version_id = 1, | |
d49805ae | 115 | .fields = (VMStateField[]) { |
79e9ebeb LJ |
116 | VMSTATE_UINT64(lb, BNDReg), |
117 | VMSTATE_UINT64(ub, BNDReg), | |
118 | VMSTATE_END_OF_LIST() | |
119 | } | |
120 | }; | |
121 | ||
122 | #define VMSTATE_BND_REGS(_field, _state, _n) \ | |
123 | VMSTATE_STRUCT_ARRAY(_field, _state, _n, 0, vmstate_bnd_regs, BNDReg) | |
124 | ||
216c07c3 JQ |
125 | static const VMStateDescription vmstate_mtrr_var = { |
126 | .name = "mtrr_var", | |
127 | .version_id = 1, | |
128 | .minimum_version_id = 1, | |
d49805ae | 129 | .fields = (VMStateField[]) { |
216c07c3 JQ |
130 | VMSTATE_UINT64(base, MTRRVar), |
131 | VMSTATE_UINT64(mask, MTRRVar), | |
132 | VMSTATE_END_OF_LIST() | |
133 | } | |
134 | }; | |
135 | ||
0cb892aa JQ |
136 | #define VMSTATE_MTRR_VARS(_field, _state, _n, _v) \ |
137 | VMSTATE_STRUCT_ARRAY(_field, _state, _n, _v, vmstate_mtrr_var, MTRRVar) | |
216c07c3 | 138 | |
ab808276 DDAG |
139 | typedef struct x86_FPReg_tmp { |
140 | FPReg *parent; | |
141 | uint64_t tmp_mant; | |
142 | uint16_t tmp_exp; | |
143 | } x86_FPReg_tmp; | |
144 | ||
db573d2c YZ |
145 | static void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, floatx80 f) |
146 | { | |
147 | CPU_LDoubleU temp; | |
148 | ||
149 | temp.d = f; | |
150 | *pmant = temp.l.lower; | |
151 | *pexp = temp.l.upper; | |
152 | } | |
153 | ||
154 | static floatx80 cpu_set_fp80(uint64_t mant, uint16_t upper) | |
155 | { | |
156 | CPU_LDoubleU temp; | |
157 | ||
158 | temp.l.upper = upper; | |
159 | temp.l.lower = mant; | |
160 | return temp.d; | |
161 | } | |
162 | ||
44b1ff31 | 163 | static int fpreg_pre_save(void *opaque) |
3c8ce630 | 164 | { |
ab808276 | 165 | x86_FPReg_tmp *tmp = opaque; |
3c8ce630 | 166 | |
ab808276 DDAG |
167 | /* we save the real CPU data (in case of MMX usage only 'mant' |
168 | contains the MMX register */ | |
169 | cpu_get_fp80(&tmp->tmp_mant, &tmp->tmp_exp, tmp->parent->d); | |
44b1ff31 DDAG |
170 | |
171 | return 0; | |
3c8ce630 JQ |
172 | } |
173 | ||
ab808276 | 174 | static int fpreg_post_load(void *opaque, int version) |
3c8ce630 | 175 | { |
ab808276 | 176 | x86_FPReg_tmp *tmp = opaque; |
2c21ee76 | 177 | |
ab808276 | 178 | tmp->parent->d = cpu_set_fp80(tmp->tmp_mant, tmp->tmp_exp); |
2c21ee76 | 179 | return 0; |
3c8ce630 JQ |
180 | } |
181 | ||
ab808276 DDAG |
182 | static const VMStateDescription vmstate_fpreg_tmp = { |
183 | .name = "fpreg_tmp", | |
184 | .post_load = fpreg_post_load, | |
185 | .pre_save = fpreg_pre_save, | |
186 | .fields = (VMStateField[]) { | |
187 | VMSTATE_UINT64(tmp_mant, x86_FPReg_tmp), | |
188 | VMSTATE_UINT16(tmp_exp, x86_FPReg_tmp), | |
189 | VMSTATE_END_OF_LIST() | |
190 | } | |
191 | }; | |
192 | ||
193 | static const VMStateDescription vmstate_fpreg = { | |
0cb892aa | 194 | .name = "fpreg", |
ab808276 DDAG |
195 | .fields = (VMStateField[]) { |
196 | VMSTATE_WITH_TMP(FPReg, x86_FPReg_tmp, vmstate_fpreg_tmp), | |
197 | VMSTATE_END_OF_LIST() | |
198 | } | |
0cb892aa JQ |
199 | }; |
200 | ||
44b1ff31 | 201 | static int cpu_pre_save(void *opaque) |
8dd3dca3 | 202 | { |
f56e3a14 AF |
203 | X86CPU *cpu = opaque; |
204 | CPUX86State *env = &cpu->env; | |
0e607a80 | 205 | int i; |
8dd3dca3 | 206 | |
8dd3dca3 | 207 | /* FPU */ |
67b8f419 | 208 | env->fpus_vmstate = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11; |
cdc0c58f | 209 | env->fptag_vmstate = 0; |
8dd3dca3 | 210 | for(i = 0; i < 8; i++) { |
cdc0c58f | 211 | env->fptag_vmstate |= ((!env->fptags[i]) << i); |
8dd3dca3 AJ |
212 | } |
213 | ||
60a902f1 | 214 | env->fpregs_format_vmstate = 0; |
3e47c249 OW |
215 | |
216 | /* | |
217 | * Real mode guest segments register DPL should be zero. | |
218 | * Older KVM version were setting it wrongly. | |
219 | * Fixing it will allow live migration to host with unrestricted guest | |
220 | * support (otherwise the migration will fail with invalid guest state | |
221 | * error). | |
222 | */ | |
223 | if (!(env->cr[0] & CR0_PE_MASK) && | |
224 | (env->segs[R_CS].flags >> DESC_DPL_SHIFT & 3) != 0) { | |
225 | env->segs[R_CS].flags &= ~(env->segs[R_CS].flags & DESC_DPL_MASK); | |
226 | env->segs[R_DS].flags &= ~(env->segs[R_DS].flags & DESC_DPL_MASK); | |
227 | env->segs[R_ES].flags &= ~(env->segs[R_ES].flags & DESC_DPL_MASK); | |
228 | env->segs[R_FS].flags &= ~(env->segs[R_FS].flags & DESC_DPL_MASK); | |
229 | env->segs[R_GS].flags &= ~(env->segs[R_GS].flags & DESC_DPL_MASK); | |
230 | env->segs[R_SS].flags &= ~(env->segs[R_SS].flags & DESC_DPL_MASK); | |
231 | } | |
232 | ||
44b1ff31 | 233 | return 0; |
c4c38c8c JQ |
234 | } |
235 | ||
468f6581 JQ |
236 | static int cpu_post_load(void *opaque, int version_id) |
237 | { | |
f56e3a14 | 238 | X86CPU *cpu = opaque; |
75a34036 | 239 | CPUState *cs = CPU(cpu); |
f56e3a14 | 240 | CPUX86State *env = &cpu->env; |
468f6581 JQ |
241 | int i; |
242 | ||
36f96c4b HZ |
243 | if (env->tsc_khz && env->user_tsc_khz && |
244 | env->tsc_khz != env->user_tsc_khz) { | |
245 | error_report("Mismatch between user-specified TSC frequency and " | |
246 | "migrated TSC frequency"); | |
247 | return -EINVAL; | |
248 | } | |
249 | ||
46baa900 DDAG |
250 | if (env->fpregs_format_vmstate) { |
251 | error_report("Unsupported old non-softfloat CPU state"); | |
252 | return -EINVAL; | |
253 | } | |
444ba679 OW |
254 | /* |
255 | * Real mode guest segments register DPL should be zero. | |
256 | * Older KVM version were setting it wrongly. | |
257 | * Fixing it will allow live migration from such host that don't have | |
258 | * restricted guest support to a host with unrestricted guest support | |
259 | * (otherwise the migration will fail with invalid guest state | |
260 | * error). | |
261 | */ | |
262 | if (!(env->cr[0] & CR0_PE_MASK) && | |
263 | (env->segs[R_CS].flags >> DESC_DPL_SHIFT & 3) != 0) { | |
264 | env->segs[R_CS].flags &= ~(env->segs[R_CS].flags & DESC_DPL_MASK); | |
265 | env->segs[R_DS].flags &= ~(env->segs[R_DS].flags & DESC_DPL_MASK); | |
266 | env->segs[R_ES].flags &= ~(env->segs[R_ES].flags & DESC_DPL_MASK); | |
267 | env->segs[R_FS].flags &= ~(env->segs[R_FS].flags & DESC_DPL_MASK); | |
268 | env->segs[R_GS].flags &= ~(env->segs[R_GS].flags & DESC_DPL_MASK); | |
269 | env->segs[R_SS].flags &= ~(env->segs[R_SS].flags & DESC_DPL_MASK); | |
270 | } | |
271 | ||
7125c937 PB |
272 | /* Older versions of QEMU incorrectly used CS.DPL as the CPL when |
273 | * running under KVM. This is wrong for conforming code segments. | |
274 | * Luckily, in our implementation the CPL field of hflags is redundant | |
275 | * and we can get the right value from the SS descriptor privilege level. | |
276 | */ | |
277 | env->hflags &= ~HF_CPL_MASK; | |
278 | env->hflags |= (env->segs[R_SS].flags >> DESC_DPL_SHIFT) & HF_CPL_MASK; | |
279 | ||
468f6581 JQ |
280 | env->fpstt = (env->fpus_vmstate >> 11) & 7; |
281 | env->fpus = env->fpus_vmstate & ~0x3800; | |
282 | env->fptag_vmstate ^= 0xff; | |
283 | for(i = 0; i < 8; i++) { | |
284 | env->fptags[i] = (env->fptag_vmstate >> i) & 1; | |
285 | } | |
1d8ad165 | 286 | if (tcg_enabled()) { |
79c664f6 | 287 | target_ulong dr7; |
1d8ad165 YZ |
288 | update_fp_status(env); |
289 | update_mxcsr_status(env); | |
468f6581 | 290 | |
79c664f6 YZ |
291 | cpu_breakpoint_remove_all(cs, BP_CPU); |
292 | cpu_watchpoint_remove_all(cs, BP_CPU); | |
293 | ||
93d00d0f RH |
294 | /* Indicate all breakpoints disabled, as they are, then |
295 | let the helper re-enable them. */ | |
79c664f6 | 296 | dr7 = env->dr[7]; |
93d00d0f RH |
297 | env->dr[7] = dr7 & ~(DR7_GLOBAL_BP_MASK | DR7_LOCAL_BP_MASK); |
298 | cpu_x86_update_dr7(env, dr7); | |
428065ce | 299 | } |
d10eb08f | 300 | tlb_flush(cs); |
1e7fbc6d | 301 | return 0; |
468f6581 JQ |
302 | } |
303 | ||
f6584ee2 GN |
304 | static bool async_pf_msr_needed(void *opaque) |
305 | { | |
f56e3a14 | 306 | X86CPU *cpu = opaque; |
f6584ee2 | 307 | |
f56e3a14 | 308 | return cpu->env.async_pf_en_msr != 0; |
f6584ee2 GN |
309 | } |
310 | ||
bc9a839d MT |
311 | static bool pv_eoi_msr_needed(void *opaque) |
312 | { | |
f56e3a14 | 313 | X86CPU *cpu = opaque; |
bc9a839d | 314 | |
f56e3a14 | 315 | return cpu->env.pv_eoi_en_msr != 0; |
bc9a839d MT |
316 | } |
317 | ||
917367aa MT |
318 | static bool steal_time_msr_needed(void *opaque) |
319 | { | |
0e503577 | 320 | X86CPU *cpu = opaque; |
917367aa | 321 | |
0e503577 | 322 | return cpu->env.steal_time_msr != 0; |
917367aa MT |
323 | } |
324 | ||
325 | static const VMStateDescription vmstate_steal_time_msr = { | |
326 | .name = "cpu/steal_time_msr", | |
327 | .version_id = 1, | |
328 | .minimum_version_id = 1, | |
5cd8cada | 329 | .needed = steal_time_msr_needed, |
d49805ae | 330 | .fields = (VMStateField[]) { |
0e503577 | 331 | VMSTATE_UINT64(env.steal_time_msr, X86CPU), |
917367aa MT |
332 | VMSTATE_END_OF_LIST() |
333 | } | |
334 | }; | |
335 | ||
f6584ee2 GN |
336 | static const VMStateDescription vmstate_async_pf_msr = { |
337 | .name = "cpu/async_pf_msr", | |
338 | .version_id = 1, | |
339 | .minimum_version_id = 1, | |
5cd8cada | 340 | .needed = async_pf_msr_needed, |
d49805ae | 341 | .fields = (VMStateField[]) { |
f56e3a14 | 342 | VMSTATE_UINT64(env.async_pf_en_msr, X86CPU), |
f6584ee2 GN |
343 | VMSTATE_END_OF_LIST() |
344 | } | |
345 | }; | |
346 | ||
bc9a839d MT |
347 | static const VMStateDescription vmstate_pv_eoi_msr = { |
348 | .name = "cpu/async_pv_eoi_msr", | |
349 | .version_id = 1, | |
350 | .minimum_version_id = 1, | |
5cd8cada | 351 | .needed = pv_eoi_msr_needed, |
d49805ae | 352 | .fields = (VMStateField[]) { |
f56e3a14 | 353 | VMSTATE_UINT64(env.pv_eoi_en_msr, X86CPU), |
bc9a839d MT |
354 | VMSTATE_END_OF_LIST() |
355 | } | |
356 | }; | |
357 | ||
42cc8fa6 JK |
358 | static bool fpop_ip_dp_needed(void *opaque) |
359 | { | |
f56e3a14 AF |
360 | X86CPU *cpu = opaque; |
361 | CPUX86State *env = &cpu->env; | |
42cc8fa6 JK |
362 | |
363 | return env->fpop != 0 || env->fpip != 0 || env->fpdp != 0; | |
364 | } | |
365 | ||
366 | static const VMStateDescription vmstate_fpop_ip_dp = { | |
367 | .name = "cpu/fpop_ip_dp", | |
368 | .version_id = 1, | |
369 | .minimum_version_id = 1, | |
5cd8cada | 370 | .needed = fpop_ip_dp_needed, |
d49805ae | 371 | .fields = (VMStateField[]) { |
f56e3a14 AF |
372 | VMSTATE_UINT16(env.fpop, X86CPU), |
373 | VMSTATE_UINT64(env.fpip, X86CPU), | |
374 | VMSTATE_UINT64(env.fpdp, X86CPU), | |
42cc8fa6 JK |
375 | VMSTATE_END_OF_LIST() |
376 | } | |
377 | }; | |
378 | ||
f28558d3 WA |
379 | static bool tsc_adjust_needed(void *opaque) |
380 | { | |
f56e3a14 AF |
381 | X86CPU *cpu = opaque; |
382 | CPUX86State *env = &cpu->env; | |
f28558d3 WA |
383 | |
384 | return env->tsc_adjust != 0; | |
385 | } | |
386 | ||
387 | static const VMStateDescription vmstate_msr_tsc_adjust = { | |
388 | .name = "cpu/msr_tsc_adjust", | |
389 | .version_id = 1, | |
390 | .minimum_version_id = 1, | |
5cd8cada | 391 | .needed = tsc_adjust_needed, |
d49805ae | 392 | .fields = (VMStateField[]) { |
f56e3a14 | 393 | VMSTATE_UINT64(env.tsc_adjust, X86CPU), |
f28558d3 WA |
394 | VMSTATE_END_OF_LIST() |
395 | } | |
396 | }; | |
397 | ||
aa82ba54 LJ |
398 | static bool tscdeadline_needed(void *opaque) |
399 | { | |
f56e3a14 AF |
400 | X86CPU *cpu = opaque; |
401 | CPUX86State *env = &cpu->env; | |
aa82ba54 LJ |
402 | |
403 | return env->tsc_deadline != 0; | |
404 | } | |
405 | ||
406 | static const VMStateDescription vmstate_msr_tscdeadline = { | |
407 | .name = "cpu/msr_tscdeadline", | |
408 | .version_id = 1, | |
409 | .minimum_version_id = 1, | |
5cd8cada | 410 | .needed = tscdeadline_needed, |
d49805ae | 411 | .fields = (VMStateField[]) { |
f56e3a14 | 412 | VMSTATE_UINT64(env.tsc_deadline, X86CPU), |
aa82ba54 LJ |
413 | VMSTATE_END_OF_LIST() |
414 | } | |
415 | }; | |
416 | ||
21e87c46 AK |
417 | static bool misc_enable_needed(void *opaque) |
418 | { | |
f56e3a14 AF |
419 | X86CPU *cpu = opaque; |
420 | CPUX86State *env = &cpu->env; | |
21e87c46 AK |
421 | |
422 | return env->msr_ia32_misc_enable != MSR_IA32_MISC_ENABLE_DEFAULT; | |
423 | } | |
424 | ||
0779caeb ACL |
425 | static bool feature_control_needed(void *opaque) |
426 | { | |
427 | X86CPU *cpu = opaque; | |
428 | CPUX86State *env = &cpu->env; | |
429 | ||
430 | return env->msr_ia32_feature_control != 0; | |
431 | } | |
432 | ||
21e87c46 AK |
433 | static const VMStateDescription vmstate_msr_ia32_misc_enable = { |
434 | .name = "cpu/msr_ia32_misc_enable", | |
435 | .version_id = 1, | |
436 | .minimum_version_id = 1, | |
5cd8cada | 437 | .needed = misc_enable_needed, |
d49805ae | 438 | .fields = (VMStateField[]) { |
f56e3a14 | 439 | VMSTATE_UINT64(env.msr_ia32_misc_enable, X86CPU), |
21e87c46 AK |
440 | VMSTATE_END_OF_LIST() |
441 | } | |
442 | }; | |
443 | ||
0779caeb ACL |
444 | static const VMStateDescription vmstate_msr_ia32_feature_control = { |
445 | .name = "cpu/msr_ia32_feature_control", | |
446 | .version_id = 1, | |
447 | .minimum_version_id = 1, | |
5cd8cada | 448 | .needed = feature_control_needed, |
d49805ae | 449 | .fields = (VMStateField[]) { |
0779caeb ACL |
450 | VMSTATE_UINT64(env.msr_ia32_feature_control, X86CPU), |
451 | VMSTATE_END_OF_LIST() | |
452 | } | |
453 | }; | |
454 | ||
0d894367 PB |
455 | static bool pmu_enable_needed(void *opaque) |
456 | { | |
457 | X86CPU *cpu = opaque; | |
458 | CPUX86State *env = &cpu->env; | |
459 | int i; | |
460 | ||
461 | if (env->msr_fixed_ctr_ctrl || env->msr_global_ctrl || | |
462 | env->msr_global_status || env->msr_global_ovf_ctrl) { | |
463 | return true; | |
464 | } | |
465 | for (i = 0; i < MAX_FIXED_COUNTERS; i++) { | |
466 | if (env->msr_fixed_counters[i]) { | |
467 | return true; | |
468 | } | |
469 | } | |
470 | for (i = 0; i < MAX_GP_COUNTERS; i++) { | |
471 | if (env->msr_gp_counters[i] || env->msr_gp_evtsel[i]) { | |
472 | return true; | |
473 | } | |
474 | } | |
475 | ||
476 | return false; | |
477 | } | |
478 | ||
479 | static const VMStateDescription vmstate_msr_architectural_pmu = { | |
480 | .name = "cpu/msr_architectural_pmu", | |
481 | .version_id = 1, | |
482 | .minimum_version_id = 1, | |
5cd8cada | 483 | .needed = pmu_enable_needed, |
d49805ae | 484 | .fields = (VMStateField[]) { |
0d894367 PB |
485 | VMSTATE_UINT64(env.msr_fixed_ctr_ctrl, X86CPU), |
486 | VMSTATE_UINT64(env.msr_global_ctrl, X86CPU), | |
487 | VMSTATE_UINT64(env.msr_global_status, X86CPU), | |
488 | VMSTATE_UINT64(env.msr_global_ovf_ctrl, X86CPU), | |
489 | VMSTATE_UINT64_ARRAY(env.msr_fixed_counters, X86CPU, MAX_FIXED_COUNTERS), | |
490 | VMSTATE_UINT64_ARRAY(env.msr_gp_counters, X86CPU, MAX_GP_COUNTERS), | |
491 | VMSTATE_UINT64_ARRAY(env.msr_gp_evtsel, X86CPU, MAX_GP_COUNTERS), | |
492 | VMSTATE_END_OF_LIST() | |
493 | } | |
494 | }; | |
495 | ||
79e9ebeb LJ |
496 | static bool mpx_needed(void *opaque) |
497 | { | |
498 | X86CPU *cpu = opaque; | |
499 | CPUX86State *env = &cpu->env; | |
500 | unsigned int i; | |
501 | ||
502 | for (i = 0; i < 4; i++) { | |
503 | if (env->bnd_regs[i].lb || env->bnd_regs[i].ub) { | |
504 | return true; | |
505 | } | |
506 | } | |
507 | ||
508 | if (env->bndcs_regs.cfgu || env->bndcs_regs.sts) { | |
509 | return true; | |
510 | } | |
511 | ||
512 | return !!env->msr_bndcfgs; | |
513 | } | |
514 | ||
515 | static const VMStateDescription vmstate_mpx = { | |
516 | .name = "cpu/mpx", | |
517 | .version_id = 1, | |
518 | .minimum_version_id = 1, | |
5cd8cada | 519 | .needed = mpx_needed, |
d49805ae | 520 | .fields = (VMStateField[]) { |
79e9ebeb LJ |
521 | VMSTATE_BND_REGS(env.bnd_regs, X86CPU, 4), |
522 | VMSTATE_UINT64(env.bndcs_regs.cfgu, X86CPU), | |
523 | VMSTATE_UINT64(env.bndcs_regs.sts, X86CPU), | |
524 | VMSTATE_UINT64(env.msr_bndcfgs, X86CPU), | |
525 | VMSTATE_END_OF_LIST() | |
526 | } | |
527 | }; | |
528 | ||
1c90ef26 VR |
529 | static bool hyperv_hypercall_enable_needed(void *opaque) |
530 | { | |
531 | X86CPU *cpu = opaque; | |
532 | CPUX86State *env = &cpu->env; | |
533 | ||
534 | return env->msr_hv_hypercall != 0 || env->msr_hv_guest_os_id != 0; | |
535 | } | |
536 | ||
537 | static const VMStateDescription vmstate_msr_hypercall_hypercall = { | |
538 | .name = "cpu/msr_hyperv_hypercall", | |
539 | .version_id = 1, | |
540 | .minimum_version_id = 1, | |
5cd8cada | 541 | .needed = hyperv_hypercall_enable_needed, |
d49805ae | 542 | .fields = (VMStateField[]) { |
1c90ef26 | 543 | VMSTATE_UINT64(env.msr_hv_guest_os_id, X86CPU), |
466e6e9d | 544 | VMSTATE_UINT64(env.msr_hv_hypercall, X86CPU), |
1c90ef26 VR |
545 | VMSTATE_END_OF_LIST() |
546 | } | |
547 | }; | |
548 | ||
5ef68987 VR |
549 | static bool hyperv_vapic_enable_needed(void *opaque) |
550 | { | |
551 | X86CPU *cpu = opaque; | |
552 | CPUX86State *env = &cpu->env; | |
553 | ||
554 | return env->msr_hv_vapic != 0; | |
555 | } | |
556 | ||
557 | static const VMStateDescription vmstate_msr_hyperv_vapic = { | |
558 | .name = "cpu/msr_hyperv_vapic", | |
559 | .version_id = 1, | |
560 | .minimum_version_id = 1, | |
5cd8cada | 561 | .needed = hyperv_vapic_enable_needed, |
d49805ae | 562 | .fields = (VMStateField[]) { |
5ef68987 VR |
563 | VMSTATE_UINT64(env.msr_hv_vapic, X86CPU), |
564 | VMSTATE_END_OF_LIST() | |
565 | } | |
566 | }; | |
567 | ||
48a5f3bc VR |
568 | static bool hyperv_time_enable_needed(void *opaque) |
569 | { | |
570 | X86CPU *cpu = opaque; | |
571 | CPUX86State *env = &cpu->env; | |
572 | ||
573 | return env->msr_hv_tsc != 0; | |
574 | } | |
575 | ||
576 | static const VMStateDescription vmstate_msr_hyperv_time = { | |
577 | .name = "cpu/msr_hyperv_time", | |
578 | .version_id = 1, | |
579 | .minimum_version_id = 1, | |
5cd8cada | 580 | .needed = hyperv_time_enable_needed, |
d49805ae | 581 | .fields = (VMStateField[]) { |
48a5f3bc VR |
582 | VMSTATE_UINT64(env.msr_hv_tsc, X86CPU), |
583 | VMSTATE_END_OF_LIST() | |
584 | } | |
585 | }; | |
586 | ||
f2a53c9e AS |
587 | static bool hyperv_crash_enable_needed(void *opaque) |
588 | { | |
589 | X86CPU *cpu = opaque; | |
590 | CPUX86State *env = &cpu->env; | |
591 | int i; | |
592 | ||
5e953812 | 593 | for (i = 0; i < HV_CRASH_PARAMS; i++) { |
f2a53c9e AS |
594 | if (env->msr_hv_crash_params[i]) { |
595 | return true; | |
596 | } | |
597 | } | |
598 | return false; | |
599 | } | |
600 | ||
601 | static const VMStateDescription vmstate_msr_hyperv_crash = { | |
602 | .name = "cpu/msr_hyperv_crash", | |
603 | .version_id = 1, | |
604 | .minimum_version_id = 1, | |
605 | .needed = hyperv_crash_enable_needed, | |
606 | .fields = (VMStateField[]) { | |
5e953812 | 607 | VMSTATE_UINT64_ARRAY(env.msr_hv_crash_params, X86CPU, HV_CRASH_PARAMS), |
f2a53c9e AS |
608 | VMSTATE_END_OF_LIST() |
609 | } | |
610 | }; | |
611 | ||
46eb8f98 AS |
612 | static bool hyperv_runtime_enable_needed(void *opaque) |
613 | { | |
614 | X86CPU *cpu = opaque; | |
615 | CPUX86State *env = &cpu->env; | |
616 | ||
51227875 ZY |
617 | if (!cpu->hyperv_runtime) { |
618 | return false; | |
619 | } | |
620 | ||
46eb8f98 AS |
621 | return env->msr_hv_runtime != 0; |
622 | } | |
623 | ||
624 | static const VMStateDescription vmstate_msr_hyperv_runtime = { | |
625 | .name = "cpu/msr_hyperv_runtime", | |
626 | .version_id = 1, | |
627 | .minimum_version_id = 1, | |
628 | .needed = hyperv_runtime_enable_needed, | |
629 | .fields = (VMStateField[]) { | |
630 | VMSTATE_UINT64(env.msr_hv_runtime, X86CPU), | |
631 | VMSTATE_END_OF_LIST() | |
632 | } | |
633 | }; | |
634 | ||
866eea9a AS |
635 | static bool hyperv_synic_enable_needed(void *opaque) |
636 | { | |
637 | X86CPU *cpu = opaque; | |
638 | CPUX86State *env = &cpu->env; | |
639 | int i; | |
640 | ||
641 | if (env->msr_hv_synic_control != 0 || | |
642 | env->msr_hv_synic_evt_page != 0 || | |
643 | env->msr_hv_synic_msg_page != 0) { | |
644 | return true; | |
645 | } | |
646 | ||
647 | for (i = 0; i < ARRAY_SIZE(env->msr_hv_synic_sint); i++) { | |
648 | if (env->msr_hv_synic_sint[i] != 0) { | |
649 | return true; | |
650 | } | |
651 | } | |
652 | ||
653 | return false; | |
654 | } | |
655 | ||
656 | static const VMStateDescription vmstate_msr_hyperv_synic = { | |
657 | .name = "cpu/msr_hyperv_synic", | |
658 | .version_id = 1, | |
659 | .minimum_version_id = 1, | |
660 | .needed = hyperv_synic_enable_needed, | |
661 | .fields = (VMStateField[]) { | |
662 | VMSTATE_UINT64(env.msr_hv_synic_control, X86CPU), | |
663 | VMSTATE_UINT64(env.msr_hv_synic_evt_page, X86CPU), | |
664 | VMSTATE_UINT64(env.msr_hv_synic_msg_page, X86CPU), | |
5e953812 | 665 | VMSTATE_UINT64_ARRAY(env.msr_hv_synic_sint, X86CPU, HV_SINT_COUNT), |
866eea9a AS |
666 | VMSTATE_END_OF_LIST() |
667 | } | |
668 | }; | |
669 | ||
ff99aa64 AS |
670 | static bool hyperv_stimer_enable_needed(void *opaque) |
671 | { | |
672 | X86CPU *cpu = opaque; | |
673 | CPUX86State *env = &cpu->env; | |
674 | int i; | |
675 | ||
676 | for (i = 0; i < ARRAY_SIZE(env->msr_hv_stimer_config); i++) { | |
677 | if (env->msr_hv_stimer_config[i] || env->msr_hv_stimer_count[i]) { | |
678 | return true; | |
679 | } | |
680 | } | |
681 | return false; | |
682 | } | |
683 | ||
684 | static const VMStateDescription vmstate_msr_hyperv_stimer = { | |
685 | .name = "cpu/msr_hyperv_stimer", | |
686 | .version_id = 1, | |
687 | .minimum_version_id = 1, | |
688 | .needed = hyperv_stimer_enable_needed, | |
689 | .fields = (VMStateField[]) { | |
5e953812 RK |
690 | VMSTATE_UINT64_ARRAY(env.msr_hv_stimer_config, X86CPU, |
691 | HV_STIMER_COUNT), | |
692 | VMSTATE_UINT64_ARRAY(env.msr_hv_stimer_count, X86CPU, HV_STIMER_COUNT), | |
ff99aa64 AS |
693 | VMSTATE_END_OF_LIST() |
694 | } | |
695 | }; | |
696 | ||
9aecd6f8 CP |
697 | static bool avx512_needed(void *opaque) |
698 | { | |
699 | X86CPU *cpu = opaque; | |
700 | CPUX86State *env = &cpu->env; | |
701 | unsigned int i; | |
702 | ||
703 | for (i = 0; i < NB_OPMASK_REGS; i++) { | |
704 | if (env->opmask_regs[i]) { | |
705 | return true; | |
706 | } | |
707 | } | |
708 | ||
709 | for (i = 0; i < CPU_NB_REGS; i++) { | |
19cbd87c | 710 | #define ENV_XMM(reg, field) (env->xmm_regs[reg].ZMM_Q(field)) |
b7711471 PB |
711 | if (ENV_XMM(i, 4) || ENV_XMM(i, 6) || |
712 | ENV_XMM(i, 5) || ENV_XMM(i, 7)) { | |
9aecd6f8 CP |
713 | return true; |
714 | } | |
715 | #ifdef TARGET_X86_64 | |
b7711471 PB |
716 | if (ENV_XMM(i+16, 0) || ENV_XMM(i+16, 1) || |
717 | ENV_XMM(i+16, 2) || ENV_XMM(i+16, 3) || | |
718 | ENV_XMM(i+16, 4) || ENV_XMM(i+16, 5) || | |
719 | ENV_XMM(i+16, 6) || ENV_XMM(i+16, 7)) { | |
9aecd6f8 CP |
720 | return true; |
721 | } | |
722 | #endif | |
723 | } | |
724 | ||
725 | return false; | |
726 | } | |
727 | ||
728 | static const VMStateDescription vmstate_avx512 = { | |
729 | .name = "cpu/avx512", | |
730 | .version_id = 1, | |
731 | .minimum_version_id = 1, | |
5cd8cada | 732 | .needed = avx512_needed, |
9aecd6f8 CP |
733 | .fields = (VMStateField[]) { |
734 | VMSTATE_UINT64_ARRAY(env.opmask_regs, X86CPU, NB_OPMASK_REGS), | |
b7711471 | 735 | VMSTATE_ZMMH_REGS_VARS(env.xmm_regs, X86CPU, 0), |
9aecd6f8 | 736 | #ifdef TARGET_X86_64 |
b7711471 | 737 | VMSTATE_Hi16_ZMM_REGS_VARS(env.xmm_regs, X86CPU, 16), |
9aecd6f8 CP |
738 | #endif |
739 | VMSTATE_END_OF_LIST() | |
740 | } | |
741 | }; | |
742 | ||
18cd2c17 WL |
743 | static bool xss_needed(void *opaque) |
744 | { | |
745 | X86CPU *cpu = opaque; | |
746 | CPUX86State *env = &cpu->env; | |
747 | ||
748 | return env->xss != 0; | |
749 | } | |
750 | ||
751 | static const VMStateDescription vmstate_xss = { | |
752 | .name = "cpu/xss", | |
753 | .version_id = 1, | |
754 | .minimum_version_id = 1, | |
5cd8cada | 755 | .needed = xss_needed, |
18cd2c17 WL |
756 | .fields = (VMStateField[]) { |
757 | VMSTATE_UINT64(env.xss, X86CPU), | |
758 | VMSTATE_END_OF_LIST() | |
759 | } | |
760 | }; | |
761 | ||
f74eefe0 HH |
762 | #ifdef TARGET_X86_64 |
763 | static bool pkru_needed(void *opaque) | |
764 | { | |
765 | X86CPU *cpu = opaque; | |
766 | CPUX86State *env = &cpu->env; | |
767 | ||
768 | return env->pkru != 0; | |
769 | } | |
770 | ||
771 | static const VMStateDescription vmstate_pkru = { | |
772 | .name = "cpu/pkru", | |
773 | .version_id = 1, | |
774 | .minimum_version_id = 1, | |
775 | .needed = pkru_needed, | |
776 | .fields = (VMStateField[]){ | |
777 | VMSTATE_UINT32(env.pkru, X86CPU), | |
778 | VMSTATE_END_OF_LIST() | |
779 | } | |
780 | }; | |
781 | #endif | |
782 | ||
36f96c4b HZ |
783 | static bool tsc_khz_needed(void *opaque) |
784 | { | |
785 | X86CPU *cpu = opaque; | |
786 | CPUX86State *env = &cpu->env; | |
787 | MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); | |
788 | PCMachineClass *pcmc = PC_MACHINE_CLASS(mc); | |
789 | return env->tsc_khz && pcmc->save_tsc_khz; | |
790 | } | |
791 | ||
792 | static const VMStateDescription vmstate_tsc_khz = { | |
793 | .name = "cpu/tsc_khz", | |
794 | .version_id = 1, | |
795 | .minimum_version_id = 1, | |
796 | .needed = tsc_khz_needed, | |
797 | .fields = (VMStateField[]) { | |
798 | VMSTATE_INT64(env.tsc_khz, X86CPU), | |
799 | VMSTATE_END_OF_LIST() | |
800 | } | |
801 | }; | |
802 | ||
87f8b626 AR |
803 | static bool mcg_ext_ctl_needed(void *opaque) |
804 | { | |
805 | X86CPU *cpu = opaque; | |
806 | CPUX86State *env = &cpu->env; | |
807 | return cpu->enable_lmce && env->mcg_ext_ctl; | |
808 | } | |
809 | ||
810 | static const VMStateDescription vmstate_mcg_ext_ctl = { | |
811 | .name = "cpu/mcg_ext_ctl", | |
812 | .version_id = 1, | |
813 | .minimum_version_id = 1, | |
814 | .needed = mcg_ext_ctl_needed, | |
815 | .fields = (VMStateField[]) { | |
816 | VMSTATE_UINT64(env.mcg_ext_ctl, X86CPU), | |
817 | VMSTATE_END_OF_LIST() | |
818 | } | |
819 | }; | |
820 | ||
a33a2cfe PB |
821 | static bool spec_ctrl_needed(void *opaque) |
822 | { | |
823 | X86CPU *cpu = opaque; | |
824 | CPUX86State *env = &cpu->env; | |
825 | ||
826 | return env->spec_ctrl != 0; | |
827 | } | |
828 | ||
829 | static const VMStateDescription vmstate_spec_ctrl = { | |
830 | .name = "cpu/spec_ctrl", | |
831 | .version_id = 1, | |
832 | .minimum_version_id = 1, | |
833 | .needed = spec_ctrl_needed, | |
834 | .fields = (VMStateField[]){ | |
835 | VMSTATE_UINT64(env.spec_ctrl, X86CPU), | |
836 | VMSTATE_END_OF_LIST() | |
837 | } | |
838 | }; | |
839 | ||
b77146e9 CP |
840 | static bool intel_pt_enable_needed(void *opaque) |
841 | { | |
842 | X86CPU *cpu = opaque; | |
843 | CPUX86State *env = &cpu->env; | |
844 | int i; | |
845 | ||
846 | if (env->msr_rtit_ctrl || env->msr_rtit_status || | |
847 | env->msr_rtit_output_base || env->msr_rtit_output_mask || | |
848 | env->msr_rtit_cr3_match) { | |
849 | return true; | |
850 | } | |
851 | ||
852 | for (i = 0; i < MAX_RTIT_ADDRS; i++) { | |
853 | if (env->msr_rtit_addrs[i]) { | |
854 | return true; | |
855 | } | |
856 | } | |
857 | ||
858 | return false; | |
859 | } | |
860 | ||
861 | static const VMStateDescription vmstate_msr_intel_pt = { | |
862 | .name = "cpu/intel_pt", | |
863 | .version_id = 1, | |
864 | .minimum_version_id = 1, | |
865 | .needed = intel_pt_enable_needed, | |
866 | .fields = (VMStateField[]) { | |
867 | VMSTATE_UINT64(env.msr_rtit_ctrl, X86CPU), | |
868 | VMSTATE_UINT64(env.msr_rtit_status, X86CPU), | |
869 | VMSTATE_UINT64(env.msr_rtit_output_base, X86CPU), | |
870 | VMSTATE_UINT64(env.msr_rtit_output_mask, X86CPU), | |
871 | VMSTATE_UINT64(env.msr_rtit_cr3_match, X86CPU), | |
872 | VMSTATE_UINT64_ARRAY(env.msr_rtit_addrs, X86CPU, MAX_RTIT_ADDRS), | |
873 | VMSTATE_END_OF_LIST() | |
874 | } | |
875 | }; | |
876 | ||
68bfd0ad | 877 | VMStateDescription vmstate_x86_cpu = { |
0cb892aa | 878 | .name = "cpu", |
f56e3a14 | 879 | .version_id = 12, |
08b277ac | 880 | .minimum_version_id = 11, |
0cb892aa | 881 | .pre_save = cpu_pre_save, |
0cb892aa | 882 | .post_load = cpu_post_load, |
d49805ae | 883 | .fields = (VMStateField[]) { |
f56e3a14 AF |
884 | VMSTATE_UINTTL_ARRAY(env.regs, X86CPU, CPU_NB_REGS), |
885 | VMSTATE_UINTTL(env.eip, X86CPU), | |
886 | VMSTATE_UINTTL(env.eflags, X86CPU), | |
887 | VMSTATE_UINT32(env.hflags, X86CPU), | |
0cb892aa | 888 | /* FPU */ |
f56e3a14 AF |
889 | VMSTATE_UINT16(env.fpuc, X86CPU), |
890 | VMSTATE_UINT16(env.fpus_vmstate, X86CPU), | |
891 | VMSTATE_UINT16(env.fptag_vmstate, X86CPU), | |
892 | VMSTATE_UINT16(env.fpregs_format_vmstate, X86CPU), | |
46baa900 DDAG |
893 | |
894 | VMSTATE_STRUCT_ARRAY(env.fpregs, X86CPU, 8, 0, vmstate_fpreg, FPReg), | |
f56e3a14 AF |
895 | |
896 | VMSTATE_SEGMENT_ARRAY(env.segs, X86CPU, 6), | |
897 | VMSTATE_SEGMENT(env.ldt, X86CPU), | |
898 | VMSTATE_SEGMENT(env.tr, X86CPU), | |
899 | VMSTATE_SEGMENT(env.gdt, X86CPU), | |
900 | VMSTATE_SEGMENT(env.idt, X86CPU), | |
901 | ||
902 | VMSTATE_UINT32(env.sysenter_cs, X86CPU), | |
f56e3a14 AF |
903 | VMSTATE_UINTTL(env.sysenter_esp, X86CPU), |
904 | VMSTATE_UINTTL(env.sysenter_eip, X86CPU), | |
8dd3dca3 | 905 | |
f56e3a14 AF |
906 | VMSTATE_UINTTL(env.cr[0], X86CPU), |
907 | VMSTATE_UINTTL(env.cr[2], X86CPU), | |
908 | VMSTATE_UINTTL(env.cr[3], X86CPU), | |
909 | VMSTATE_UINTTL(env.cr[4], X86CPU), | |
910 | VMSTATE_UINTTL_ARRAY(env.dr, X86CPU, 8), | |
0cb892aa | 911 | /* MMU */ |
f56e3a14 | 912 | VMSTATE_INT32(env.a20_mask, X86CPU), |
0cb892aa | 913 | /* XMM */ |
f56e3a14 | 914 | VMSTATE_UINT32(env.mxcsr, X86CPU), |
a03c3e90 | 915 | VMSTATE_XMM_REGS(env.xmm_regs, X86CPU, 0), |
8dd3dca3 AJ |
916 | |
917 | #ifdef TARGET_X86_64 | |
f56e3a14 AF |
918 | VMSTATE_UINT64(env.efer, X86CPU), |
919 | VMSTATE_UINT64(env.star, X86CPU), | |
920 | VMSTATE_UINT64(env.lstar, X86CPU), | |
921 | VMSTATE_UINT64(env.cstar, X86CPU), | |
922 | VMSTATE_UINT64(env.fmask, X86CPU), | |
923 | VMSTATE_UINT64(env.kernelgsbase, X86CPU), | |
8dd3dca3 | 924 | #endif |
08b277ac DDAG |
925 | VMSTATE_UINT32(env.smbase, X86CPU), |
926 | ||
927 | VMSTATE_UINT64(env.pat, X86CPU), | |
928 | VMSTATE_UINT32(env.hflags2, X86CPU), | |
929 | ||
930 | VMSTATE_UINT64(env.vm_hsave, X86CPU), | |
931 | VMSTATE_UINT64(env.vm_vmcb, X86CPU), | |
932 | VMSTATE_UINT64(env.tsc_offset, X86CPU), | |
933 | VMSTATE_UINT64(env.intercept, X86CPU), | |
934 | VMSTATE_UINT16(env.intercept_cr_read, X86CPU), | |
935 | VMSTATE_UINT16(env.intercept_cr_write, X86CPU), | |
936 | VMSTATE_UINT16(env.intercept_dr_read, X86CPU), | |
937 | VMSTATE_UINT16(env.intercept_dr_write, X86CPU), | |
938 | VMSTATE_UINT32(env.intercept_exceptions, X86CPU), | |
939 | VMSTATE_UINT8(env.v_tpr, X86CPU), | |
dd5e3b17 | 940 | /* MTRRs */ |
08b277ac DDAG |
941 | VMSTATE_UINT64_ARRAY(env.mtrr_fixed, X86CPU, 11), |
942 | VMSTATE_UINT64(env.mtrr_deftype, X86CPU), | |
d8b5c67b | 943 | VMSTATE_MTRR_VARS(env.mtrr_var, X86CPU, MSR_MTRRcap_VCNT, 8), |
0cb892aa | 944 | /* KVM-related states */ |
08b277ac DDAG |
945 | VMSTATE_INT32(env.interrupt_injected, X86CPU), |
946 | VMSTATE_UINT32(env.mp_state, X86CPU), | |
947 | VMSTATE_UINT64(env.tsc, X86CPU), | |
948 | VMSTATE_INT32(env.exception_injected, X86CPU), | |
949 | VMSTATE_UINT8(env.soft_interrupt, X86CPU), | |
950 | VMSTATE_UINT8(env.nmi_injected, X86CPU), | |
951 | VMSTATE_UINT8(env.nmi_pending, X86CPU), | |
952 | VMSTATE_UINT8(env.has_error_code, X86CPU), | |
953 | VMSTATE_UINT32(env.sipi_vector, X86CPU), | |
0cb892aa | 954 | /* MCE */ |
08b277ac DDAG |
955 | VMSTATE_UINT64(env.mcg_cap, X86CPU), |
956 | VMSTATE_UINT64(env.mcg_status, X86CPU), | |
957 | VMSTATE_UINT64(env.mcg_ctl, X86CPU), | |
958 | VMSTATE_UINT64_ARRAY(env.mce_banks, X86CPU, MCE_BANKS_DEF * 4), | |
0cb892aa | 959 | /* rdtscp */ |
08b277ac | 960 | VMSTATE_UINT64(env.tsc_aux, X86CPU), |
1a03675d | 961 | /* KVM pvclock msr */ |
08b277ac DDAG |
962 | VMSTATE_UINT64(env.system_time_msr, X86CPU), |
963 | VMSTATE_UINT64(env.wall_clock_msr, X86CPU), | |
f1665b21 | 964 | /* XSAVE related fields */ |
f56e3a14 AF |
965 | VMSTATE_UINT64_V(env.xcr0, X86CPU, 12), |
966 | VMSTATE_UINT64_V(env.xstate_bv, X86CPU, 12), | |
b7711471 | 967 | VMSTATE_YMMH_REGS_VARS(env.xmm_regs, X86CPU, 0, 12), |
0cb892aa | 968 | VMSTATE_END_OF_LIST() |
a0fb002c | 969 | /* The above list is not sorted /wrt version numbers, watch out! */ |
f6584ee2 | 970 | }, |
5cd8cada JQ |
971 | .subsections = (const VMStateDescription*[]) { |
972 | &vmstate_async_pf_msr, | |
973 | &vmstate_pv_eoi_msr, | |
974 | &vmstate_steal_time_msr, | |
975 | &vmstate_fpop_ip_dp, | |
976 | &vmstate_msr_tsc_adjust, | |
977 | &vmstate_msr_tscdeadline, | |
978 | &vmstate_msr_ia32_misc_enable, | |
979 | &vmstate_msr_ia32_feature_control, | |
980 | &vmstate_msr_architectural_pmu, | |
981 | &vmstate_mpx, | |
982 | &vmstate_msr_hypercall_hypercall, | |
983 | &vmstate_msr_hyperv_vapic, | |
984 | &vmstate_msr_hyperv_time, | |
f2a53c9e | 985 | &vmstate_msr_hyperv_crash, |
46eb8f98 | 986 | &vmstate_msr_hyperv_runtime, |
866eea9a | 987 | &vmstate_msr_hyperv_synic, |
ff99aa64 | 988 | &vmstate_msr_hyperv_stimer, |
5cd8cada JQ |
989 | &vmstate_avx512, |
990 | &vmstate_xss, | |
36f96c4b | 991 | &vmstate_tsc_khz, |
f74eefe0 HH |
992 | #ifdef TARGET_X86_64 |
993 | &vmstate_pkru, | |
994 | #endif | |
a33a2cfe | 995 | &vmstate_spec_ctrl, |
87f8b626 | 996 | &vmstate_mcg_ext_ctl, |
b77146e9 | 997 | &vmstate_msr_intel_pt, |
5cd8cada | 998 | NULL |
79c4f6b0 | 999 | } |
0cb892aa | 1000 | }; |