xref: /openbmc/qemu/target/i386/machine.c (revision 76bccf3c)
1 #include "qemu/osdep.h"
2 #include "cpu.h"
3 #include "exec/exec-all.h"
4 #include "hw/isa/isa.h"
5 #include "migration/cpu.h"
6 #include "kvm/hyperv.h"
7 #include "hw/i386/x86.h"
8 #include "kvm/kvm_i386.h"
9 #include "hw/xen/xen.h"
10 
11 #include "sysemu/kvm.h"
12 #include "sysemu/kvm_xen.h"
13 #include "sysemu/tcg.h"
14 
15 #include "qemu/error-report.h"
16 
17 static const VMStateDescription vmstate_segment = {
18     .name = "segment",
19     .version_id = 1,
20     .minimum_version_id = 1,
21     .fields = (const VMStateField[]) {
22         VMSTATE_UINT32(selector, SegmentCache),
23         VMSTATE_UINTTL(base, SegmentCache),
24         VMSTATE_UINT32(limit, SegmentCache),
25         VMSTATE_UINT32(flags, SegmentCache),
26         VMSTATE_END_OF_LIST()
27     }
28 };
29 
30 #define VMSTATE_SEGMENT(_field, _state) {                            \
31     .name       = (stringify(_field)),                               \
32     .size       = sizeof(SegmentCache),                              \
33     .vmsd       = &vmstate_segment,                                  \
34     .flags      = VMS_STRUCT,                                        \
35     .offset     = offsetof(_state, _field)                           \
36             + type_check(SegmentCache,typeof_field(_state, _field))  \
37 }
38 
39 #define VMSTATE_SEGMENT_ARRAY(_field, _state, _n)                    \
40     VMSTATE_STRUCT_ARRAY(_field, _state, _n, 0, vmstate_segment, SegmentCache)
41 
42 static const VMStateDescription vmstate_xmm_reg = {
43     .name = "xmm_reg",
44     .version_id = 1,
45     .minimum_version_id = 1,
46     .fields = (const VMStateField[]) {
47         VMSTATE_UINT64(ZMM_Q(0), ZMMReg),
48         VMSTATE_UINT64(ZMM_Q(1), ZMMReg),
49         VMSTATE_END_OF_LIST()
50     }
51 };
52 
53 #define VMSTATE_XMM_REGS(_field, _state, _start)                         \
54     VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0,     \
55                              vmstate_xmm_reg, ZMMReg)
56 
57 /* YMMH format is the same as XMM, but for bits 128-255 */
58 static const VMStateDescription vmstate_ymmh_reg = {
59     .name = "ymmh_reg",
60     .version_id = 1,
61     .minimum_version_id = 1,
62     .fields = (const VMStateField[]) {
63         VMSTATE_UINT64(ZMM_Q(2), ZMMReg),
64         VMSTATE_UINT64(ZMM_Q(3), ZMMReg),
65         VMSTATE_END_OF_LIST()
66     }
67 };
68 
69 #define VMSTATE_YMMH_REGS_VARS(_field, _state, _start, _v)               \
70     VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, _v,    \
71                              vmstate_ymmh_reg, ZMMReg)
72 
73 static const VMStateDescription vmstate_zmmh_reg = {
74     .name = "zmmh_reg",
75     .version_id = 1,
76     .minimum_version_id = 1,
77     .fields = (const VMStateField[]) {
78         VMSTATE_UINT64(ZMM_Q(4), ZMMReg),
79         VMSTATE_UINT64(ZMM_Q(5), ZMMReg),
80         VMSTATE_UINT64(ZMM_Q(6), ZMMReg),
81         VMSTATE_UINT64(ZMM_Q(7), ZMMReg),
82         VMSTATE_END_OF_LIST()
83     }
84 };
85 
86 #define VMSTATE_ZMMH_REGS_VARS(_field, _state, _start)                   \
87     VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0,     \
88                              vmstate_zmmh_reg, ZMMReg)
89 
90 #ifdef TARGET_X86_64
91 static const VMStateDescription vmstate_hi16_zmm_reg = {
92     .name = "hi16_zmm_reg",
93     .version_id = 1,
94     .minimum_version_id = 1,
95     .fields = (const VMStateField[]) {
96         VMSTATE_UINT64(ZMM_Q(0), ZMMReg),
97         VMSTATE_UINT64(ZMM_Q(1), ZMMReg),
98         VMSTATE_UINT64(ZMM_Q(2), ZMMReg),
99         VMSTATE_UINT64(ZMM_Q(3), ZMMReg),
100         VMSTATE_UINT64(ZMM_Q(4), ZMMReg),
101         VMSTATE_UINT64(ZMM_Q(5), ZMMReg),
102         VMSTATE_UINT64(ZMM_Q(6), ZMMReg),
103         VMSTATE_UINT64(ZMM_Q(7), ZMMReg),
104         VMSTATE_END_OF_LIST()
105     }
106 };
107 
108 #define VMSTATE_Hi16_ZMM_REGS_VARS(_field, _state, _start)               \
109     VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0,     \
110                              vmstate_hi16_zmm_reg, ZMMReg)
111 #endif
112 
113 static const VMStateDescription vmstate_bnd_regs = {
114     .name = "bnd_regs",
115     .version_id = 1,
116     .minimum_version_id = 1,
117     .fields = (const VMStateField[]) {
118         VMSTATE_UINT64(lb, BNDReg),
119         VMSTATE_UINT64(ub, BNDReg),
120         VMSTATE_END_OF_LIST()
121     }
122 };
123 
124 #define VMSTATE_BND_REGS(_field, _state, _n)          \
125     VMSTATE_STRUCT_ARRAY(_field, _state, _n, 0, vmstate_bnd_regs, BNDReg)
126 
127 static const VMStateDescription vmstate_mtrr_var = {
128     .name = "mtrr_var",
129     .version_id = 1,
130     .minimum_version_id = 1,
131     .fields = (const VMStateField[]) {
132         VMSTATE_UINT64(base, MTRRVar),
133         VMSTATE_UINT64(mask, MTRRVar),
134         VMSTATE_END_OF_LIST()
135     }
136 };
137 
138 #define VMSTATE_MTRR_VARS(_field, _state, _n, _v)                    \
139     VMSTATE_STRUCT_ARRAY(_field, _state, _n, _v, vmstate_mtrr_var, MTRRVar)
140 
141 static const VMStateDescription vmstate_lbr_records_var = {
142     .name = "lbr_records_var",
143     .version_id = 1,
144     .minimum_version_id = 1,
145     .fields = (const VMStateField[]) {
146         VMSTATE_UINT64(from, LBREntry),
147         VMSTATE_UINT64(to, LBREntry),
148         VMSTATE_UINT64(info, LBREntry),
149         VMSTATE_END_OF_LIST()
150     }
151 };
152 
153 #define VMSTATE_LBR_VARS(_field, _state, _n, _v)                    \
154     VMSTATE_STRUCT_ARRAY(_field, _state, _n, _v, vmstate_lbr_records_var, \
155                          LBREntry)
156 
157 typedef struct x86_FPReg_tmp {
158     FPReg *parent;
159     uint64_t tmp_mant;
160     uint16_t tmp_exp;
161 } x86_FPReg_tmp;
162 
163 static void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, floatx80 f)
164 {
165     CPU_LDoubleU temp;
166 
167     temp.d = f;
168     *pmant = temp.l.lower;
169     *pexp = temp.l.upper;
170 }
171 
172 static floatx80 cpu_set_fp80(uint64_t mant, uint16_t upper)
173 {
174     CPU_LDoubleU temp;
175 
176     temp.l.upper = upper;
177     temp.l.lower = mant;
178     return temp.d;
179 }
180 
181 static int fpreg_pre_save(void *opaque)
182 {
183     x86_FPReg_tmp *tmp = opaque;
184 
185     /* we save the real CPU data (in case of MMX usage only 'mant'
186        contains the MMX register */
187     cpu_get_fp80(&tmp->tmp_mant, &tmp->tmp_exp, tmp->parent->d);
188 
189     return 0;
190 }
191 
192 static int fpreg_post_load(void *opaque, int version)
193 {
194     x86_FPReg_tmp *tmp = opaque;
195 
196     tmp->parent->d = cpu_set_fp80(tmp->tmp_mant, tmp->tmp_exp);
197     return 0;
198 }
199 
200 static const VMStateDescription vmstate_fpreg_tmp = {
201     .name = "fpreg_tmp",
202     .post_load = fpreg_post_load,
203     .pre_save  = fpreg_pre_save,
204     .fields = (const VMStateField[]) {
205         VMSTATE_UINT64(tmp_mant, x86_FPReg_tmp),
206         VMSTATE_UINT16(tmp_exp, x86_FPReg_tmp),
207         VMSTATE_END_OF_LIST()
208     }
209 };
210 
211 static const VMStateDescription vmstate_fpreg = {
212     .name = "fpreg",
213     .fields = (const VMStateField[]) {
214         VMSTATE_WITH_TMP(FPReg, x86_FPReg_tmp, vmstate_fpreg_tmp),
215         VMSTATE_END_OF_LIST()
216     }
217 };
218 
219 static int cpu_pre_save(void *opaque)
220 {
221     X86CPU *cpu = opaque;
222     CPUX86State *env = &cpu->env;
223     int i;
224     env->v_tpr = env->int_ctl & V_TPR_MASK;
225     /* FPU */
226     env->fpus_vmstate = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
227     env->fptag_vmstate = 0;
228     for(i = 0; i < 8; i++) {
229         env->fptag_vmstate |= ((!env->fptags[i]) << i);
230     }
231 
232     env->fpregs_format_vmstate = 0;
233 
234     /*
235      * Real mode guest segments register DPL should be zero.
236      * Older KVM version were setting it wrongly.
237      * Fixing it will allow live migration to host with unrestricted guest
238      * support (otherwise the migration will fail with invalid guest state
239      * error).
240      */
241     if (!(env->cr[0] & CR0_PE_MASK) &&
242         (env->segs[R_CS].flags >> DESC_DPL_SHIFT & 3) != 0) {
243         env->segs[R_CS].flags &= ~(env->segs[R_CS].flags & DESC_DPL_MASK);
244         env->segs[R_DS].flags &= ~(env->segs[R_DS].flags & DESC_DPL_MASK);
245         env->segs[R_ES].flags &= ~(env->segs[R_ES].flags & DESC_DPL_MASK);
246         env->segs[R_FS].flags &= ~(env->segs[R_FS].flags & DESC_DPL_MASK);
247         env->segs[R_GS].flags &= ~(env->segs[R_GS].flags & DESC_DPL_MASK);
248         env->segs[R_SS].flags &= ~(env->segs[R_SS].flags & DESC_DPL_MASK);
249     }
250 
251 #ifdef CONFIG_KVM
252     /*
253      * In case vCPU may have enabled VMX, we need to make sure kernel have
254      * required capabilities in order to perform migration correctly:
255      *
256      * 1) We must be able to extract vCPU nested-state from KVM.
257      *
258      * 2) In case vCPU is running in guest-mode and it has a pending exception,
259      * we must be able to determine if it's in a pending or injected state.
260      * Note that in case KVM don't have required capability to do so,
261      * a pending/injected exception will always appear as an
262      * injected exception.
263      */
264     if (kvm_enabled() && cpu_vmx_maybe_enabled(env) &&
265         (!env->nested_state ||
266          (!kvm_has_exception_payload() && (env->hflags & HF_GUEST_MASK) &&
267           env->exception_injected))) {
268         error_report("Guest maybe enabled nested virtualization but kernel "
269                 "does not support required capabilities to save vCPU "
270                 "nested state");
271         return -EINVAL;
272     }
273 #endif
274 
275     /*
276      * When vCPU is running L2 and exception is still pending,
277      * it can potentially be intercepted by L1 hypervisor.
278      * In contrast to an injected exception which cannot be
279      * intercepted anymore.
280      *
281      * Furthermore, when a L2 exception is intercepted by L1
282      * hypervisor, its exception payload (CR2/DR6 on #PF/#DB)
283      * should not be set yet in the respective vCPU register.
284      * Thus, in case an exception is pending, it is
285      * important to save the exception payload separately.
286      *
287      * Therefore, if an exception is not in a pending state
288      * or vCPU is not in guest-mode, it is not important to
289      * distinguish between a pending and injected exception
290      * and we don't need to store separately the exception payload.
291      *
292      * In order to preserve better backwards-compatible migration,
293      * convert a pending exception to an injected exception in
294      * case it is not important to distinguish between them
295      * as described above.
296      */
297     if (env->exception_pending && !(env->hflags & HF_GUEST_MASK)) {
298         env->exception_pending = 0;
299         env->exception_injected = 1;
300 
301         if (env->exception_has_payload) {
302             if (env->exception_nr == EXCP01_DB) {
303                 env->dr[6] = env->exception_payload;
304             } else if (env->exception_nr == EXCP0E_PAGE) {
305                 env->cr[2] = env->exception_payload;
306             }
307         }
308     }
309 
310     return 0;
311 }
312 
313 static int cpu_post_load(void *opaque, int version_id)
314 {
315     X86CPU *cpu = opaque;
316     CPUState *cs = CPU(cpu);
317     CPUX86State *env = &cpu->env;
318     int i;
319 
320     if (env->tsc_khz && env->user_tsc_khz &&
321         env->tsc_khz != env->user_tsc_khz) {
322         error_report("Mismatch between user-specified TSC frequency and "
323                      "migrated TSC frequency");
324         return -EINVAL;
325     }
326 
327     if (env->fpregs_format_vmstate) {
328         error_report("Unsupported old non-softfloat CPU state");
329         return -EINVAL;
330     }
331     /*
332      * Real mode guest segments register DPL should be zero.
333      * Older KVM version were setting it wrongly.
334      * Fixing it will allow live migration from such host that don't have
335      * restricted guest support to a host with unrestricted guest support
336      * (otherwise the migration will fail with invalid guest state
337      * error).
338      */
339     if (!(env->cr[0] & CR0_PE_MASK) &&
340         (env->segs[R_CS].flags >> DESC_DPL_SHIFT & 3) != 0) {
341         env->segs[R_CS].flags &= ~(env->segs[R_CS].flags & DESC_DPL_MASK);
342         env->segs[R_DS].flags &= ~(env->segs[R_DS].flags & DESC_DPL_MASK);
343         env->segs[R_ES].flags &= ~(env->segs[R_ES].flags & DESC_DPL_MASK);
344         env->segs[R_FS].flags &= ~(env->segs[R_FS].flags & DESC_DPL_MASK);
345         env->segs[R_GS].flags &= ~(env->segs[R_GS].flags & DESC_DPL_MASK);
346         env->segs[R_SS].flags &= ~(env->segs[R_SS].flags & DESC_DPL_MASK);
347     }
348 
349     /* Older versions of QEMU incorrectly used CS.DPL as the CPL when
350      * running under KVM.  This is wrong for conforming code segments.
351      * Luckily, in our implementation the CPL field of hflags is redundant
352      * and we can get the right value from the SS descriptor privilege level.
353      */
354     env->hflags &= ~HF_CPL_MASK;
355     env->hflags |= (env->segs[R_SS].flags >> DESC_DPL_SHIFT) & HF_CPL_MASK;
356 
357 #ifdef CONFIG_KVM
358     if ((env->hflags & HF_GUEST_MASK) &&
359         (!env->nested_state ||
360         !(env->nested_state->flags & KVM_STATE_NESTED_GUEST_MODE))) {
361         error_report("vCPU set in guest-mode inconsistent with "
362                      "migrated kernel nested state");
363         return -EINVAL;
364     }
365 #endif
366 
367     /*
368      * There are cases that we can get valid exception_nr with both
369      * exception_pending and exception_injected being cleared.
370      * This can happen in one of the following scenarios:
371      * 1) Source is older QEMU without KVM_CAP_EXCEPTION_PAYLOAD support.
372      * 2) Source is running on kernel without KVM_CAP_EXCEPTION_PAYLOAD support.
373      * 3) "cpu/exception_info" subsection not sent because there is no exception
374      *    pending or guest wasn't running L2 (See comment in cpu_pre_save()).
375      *
376      * In those cases, we can just deduce that a valid exception_nr means
377      * we can treat the exception as already injected.
378      */
379     if ((env->exception_nr != -1) &&
380         !env->exception_pending && !env->exception_injected) {
381         env->exception_injected = 1;
382     }
383 
384     env->fpstt = (env->fpus_vmstate >> 11) & 7;
385     env->fpus = env->fpus_vmstate & ~0x3800;
386     env->fptag_vmstate ^= 0xff;
387     for(i = 0; i < 8; i++) {
388         env->fptags[i] = (env->fptag_vmstate >> i) & 1;
389     }
390     if (tcg_enabled()) {
391         target_ulong dr7;
392         update_fp_status(env);
393         update_mxcsr_status(env);
394 
395         cpu_breakpoint_remove_all(cs, BP_CPU);
396         cpu_watchpoint_remove_all(cs, BP_CPU);
397 
398         /* Indicate all breakpoints disabled, as they are, then
399            let the helper re-enable them.  */
400         dr7 = env->dr[7];
401         env->dr[7] = dr7 & ~(DR7_GLOBAL_BP_MASK | DR7_LOCAL_BP_MASK);
402         cpu_x86_update_dr7(env, dr7);
403     }
404     tlb_flush(cs);
405     return 0;
406 }
407 
408 static bool async_pf_msr_needed(void *opaque)
409 {
410     X86CPU *cpu = opaque;
411 
412     return cpu->env.async_pf_en_msr != 0;
413 }
414 
415 static bool async_pf_int_msr_needed(void *opaque)
416 {
417     X86CPU *cpu = opaque;
418 
419     return cpu->env.async_pf_int_msr != 0;
420 }
421 
422 static bool pv_eoi_msr_needed(void *opaque)
423 {
424     X86CPU *cpu = opaque;
425 
426     return cpu->env.pv_eoi_en_msr != 0;
427 }
428 
429 static bool steal_time_msr_needed(void *opaque)
430 {
431     X86CPU *cpu = opaque;
432 
433     return cpu->env.steal_time_msr != 0;
434 }
435 
436 static bool exception_info_needed(void *opaque)
437 {
438     X86CPU *cpu = opaque;
439     CPUX86State *env = &cpu->env;
440 
441     /*
442      * It is important to save exception-info only in case
443      * we need to distinguish between a pending and injected
444      * exception. Which is only required in case there is a
445      * pending exception and vCPU is running L2.
446      * For more info, refer to comment in cpu_pre_save().
447      */
448     return env->exception_pending && (env->hflags & HF_GUEST_MASK);
449 }
450 
451 static const VMStateDescription vmstate_exception_info = {
452     .name = "cpu/exception_info",
453     .version_id = 1,
454     .minimum_version_id = 1,
455     .needed = exception_info_needed,
456     .fields = (const VMStateField[]) {
457         VMSTATE_UINT8(env.exception_pending, X86CPU),
458         VMSTATE_UINT8(env.exception_injected, X86CPU),
459         VMSTATE_UINT8(env.exception_has_payload, X86CPU),
460         VMSTATE_UINT64(env.exception_payload, X86CPU),
461         VMSTATE_END_OF_LIST()
462     }
463 };
464 
465 /* Poll control MSR enabled by default */
466 static bool poll_control_msr_needed(void *opaque)
467 {
468     X86CPU *cpu = opaque;
469 
470     return cpu->env.poll_control_msr != 1;
471 }
472 
473 static const VMStateDescription vmstate_steal_time_msr = {
474     .name = "cpu/steal_time_msr",
475     .version_id = 1,
476     .minimum_version_id = 1,
477     .needed = steal_time_msr_needed,
478     .fields = (const VMStateField[]) {
479         VMSTATE_UINT64(env.steal_time_msr, X86CPU),
480         VMSTATE_END_OF_LIST()
481     }
482 };
483 
484 static const VMStateDescription vmstate_async_pf_msr = {
485     .name = "cpu/async_pf_msr",
486     .version_id = 1,
487     .minimum_version_id = 1,
488     .needed = async_pf_msr_needed,
489     .fields = (const VMStateField[]) {
490         VMSTATE_UINT64(env.async_pf_en_msr, X86CPU),
491         VMSTATE_END_OF_LIST()
492     }
493 };
494 
495 static const VMStateDescription vmstate_async_pf_int_msr = {
496     .name = "cpu/async_pf_int_msr",
497     .version_id = 1,
498     .minimum_version_id = 1,
499     .needed = async_pf_int_msr_needed,
500     .fields = (const VMStateField[]) {
501         VMSTATE_UINT64(env.async_pf_int_msr, X86CPU),
502         VMSTATE_END_OF_LIST()
503     }
504 };
505 
506 static const VMStateDescription vmstate_pv_eoi_msr = {
507     .name = "cpu/async_pv_eoi_msr",
508     .version_id = 1,
509     .minimum_version_id = 1,
510     .needed = pv_eoi_msr_needed,
511     .fields = (const VMStateField[]) {
512         VMSTATE_UINT64(env.pv_eoi_en_msr, X86CPU),
513         VMSTATE_END_OF_LIST()
514     }
515 };
516 
517 static const VMStateDescription vmstate_poll_control_msr = {
518     .name = "cpu/poll_control_msr",
519     .version_id = 1,
520     .minimum_version_id = 1,
521     .needed = poll_control_msr_needed,
522     .fields = (const VMStateField[]) {
523         VMSTATE_UINT64(env.poll_control_msr, X86CPU),
524         VMSTATE_END_OF_LIST()
525     }
526 };
527 
528 static bool fpop_ip_dp_needed(void *opaque)
529 {
530     X86CPU *cpu = opaque;
531     CPUX86State *env = &cpu->env;
532 
533     return env->fpop != 0 || env->fpip != 0 || env->fpdp != 0;
534 }
535 
536 static const VMStateDescription vmstate_fpop_ip_dp = {
537     .name = "cpu/fpop_ip_dp",
538     .version_id = 1,
539     .minimum_version_id = 1,
540     .needed = fpop_ip_dp_needed,
541     .fields = (const VMStateField[]) {
542         VMSTATE_UINT16(env.fpop, X86CPU),
543         VMSTATE_UINT64(env.fpip, X86CPU),
544         VMSTATE_UINT64(env.fpdp, X86CPU),
545         VMSTATE_END_OF_LIST()
546     }
547 };
548 
549 static bool tsc_adjust_needed(void *opaque)
550 {
551     X86CPU *cpu = opaque;
552     CPUX86State *env = &cpu->env;
553 
554     return env->tsc_adjust != 0;
555 }
556 
557 static const VMStateDescription vmstate_msr_tsc_adjust = {
558     .name = "cpu/msr_tsc_adjust",
559     .version_id = 1,
560     .minimum_version_id = 1,
561     .needed = tsc_adjust_needed,
562     .fields = (const VMStateField[]) {
563         VMSTATE_UINT64(env.tsc_adjust, X86CPU),
564         VMSTATE_END_OF_LIST()
565     }
566 };
567 
568 static bool msr_smi_count_needed(void *opaque)
569 {
570     X86CPU *cpu = opaque;
571     CPUX86State *env = &cpu->env;
572 
573     return cpu->migrate_smi_count && env->msr_smi_count != 0;
574 }
575 
576 static const VMStateDescription vmstate_msr_smi_count = {
577     .name = "cpu/msr_smi_count",
578     .version_id = 1,
579     .minimum_version_id = 1,
580     .needed = msr_smi_count_needed,
581     .fields = (const VMStateField[]) {
582         VMSTATE_UINT64(env.msr_smi_count, X86CPU),
583         VMSTATE_END_OF_LIST()
584     }
585 };
586 
587 static bool tscdeadline_needed(void *opaque)
588 {
589     X86CPU *cpu = opaque;
590     CPUX86State *env = &cpu->env;
591 
592     return env->tsc_deadline != 0;
593 }
594 
595 static const VMStateDescription vmstate_msr_tscdeadline = {
596     .name = "cpu/msr_tscdeadline",
597     .version_id = 1,
598     .minimum_version_id = 1,
599     .needed = tscdeadline_needed,
600     .fields = (const VMStateField[]) {
601         VMSTATE_UINT64(env.tsc_deadline, X86CPU),
602         VMSTATE_END_OF_LIST()
603     }
604 };
605 
606 static bool misc_enable_needed(void *opaque)
607 {
608     X86CPU *cpu = opaque;
609     CPUX86State *env = &cpu->env;
610 
611     return env->msr_ia32_misc_enable != MSR_IA32_MISC_ENABLE_DEFAULT;
612 }
613 
614 static bool feature_control_needed(void *opaque)
615 {
616     X86CPU *cpu = opaque;
617     CPUX86State *env = &cpu->env;
618 
619     return env->msr_ia32_feature_control != 0;
620 }
621 
622 static const VMStateDescription vmstate_msr_ia32_misc_enable = {
623     .name = "cpu/msr_ia32_misc_enable",
624     .version_id = 1,
625     .minimum_version_id = 1,
626     .needed = misc_enable_needed,
627     .fields = (const VMStateField[]) {
628         VMSTATE_UINT64(env.msr_ia32_misc_enable, X86CPU),
629         VMSTATE_END_OF_LIST()
630     }
631 };
632 
633 static const VMStateDescription vmstate_msr_ia32_feature_control = {
634     .name = "cpu/msr_ia32_feature_control",
635     .version_id = 1,
636     .minimum_version_id = 1,
637     .needed = feature_control_needed,
638     .fields = (const VMStateField[]) {
639         VMSTATE_UINT64(env.msr_ia32_feature_control, X86CPU),
640         VMSTATE_END_OF_LIST()
641     }
642 };
643 
644 static bool pmu_enable_needed(void *opaque)
645 {
646     X86CPU *cpu = opaque;
647     CPUX86State *env = &cpu->env;
648     int i;
649 
650     if (env->msr_fixed_ctr_ctrl || env->msr_global_ctrl ||
651         env->msr_global_status || env->msr_global_ovf_ctrl) {
652         return true;
653     }
654     for (i = 0; i < MAX_FIXED_COUNTERS; i++) {
655         if (env->msr_fixed_counters[i]) {
656             return true;
657         }
658     }
659     for (i = 0; i < MAX_GP_COUNTERS; i++) {
660         if (env->msr_gp_counters[i] || env->msr_gp_evtsel[i]) {
661             return true;
662         }
663     }
664 
665     return false;
666 }
667 
668 static const VMStateDescription vmstate_msr_architectural_pmu = {
669     .name = "cpu/msr_architectural_pmu",
670     .version_id = 1,
671     .minimum_version_id = 1,
672     .needed = pmu_enable_needed,
673     .fields = (const VMStateField[]) {
674         VMSTATE_UINT64(env.msr_fixed_ctr_ctrl, X86CPU),
675         VMSTATE_UINT64(env.msr_global_ctrl, X86CPU),
676         VMSTATE_UINT64(env.msr_global_status, X86CPU),
677         VMSTATE_UINT64(env.msr_global_ovf_ctrl, X86CPU),
678         VMSTATE_UINT64_ARRAY(env.msr_fixed_counters, X86CPU, MAX_FIXED_COUNTERS),
679         VMSTATE_UINT64_ARRAY(env.msr_gp_counters, X86CPU, MAX_GP_COUNTERS),
680         VMSTATE_UINT64_ARRAY(env.msr_gp_evtsel, X86CPU, MAX_GP_COUNTERS),
681         VMSTATE_END_OF_LIST()
682     }
683 };
684 
685 static bool mpx_needed(void *opaque)
686 {
687     X86CPU *cpu = opaque;
688     CPUX86State *env = &cpu->env;
689     unsigned int i;
690 
691     for (i = 0; i < 4; i++) {
692         if (env->bnd_regs[i].lb || env->bnd_regs[i].ub) {
693             return true;
694         }
695     }
696 
697     if (env->bndcs_regs.cfgu || env->bndcs_regs.sts) {
698         return true;
699     }
700 
701     return !!env->msr_bndcfgs;
702 }
703 
704 static const VMStateDescription vmstate_mpx = {
705     .name = "cpu/mpx",
706     .version_id = 1,
707     .minimum_version_id = 1,
708     .needed = mpx_needed,
709     .fields = (const VMStateField[]) {
710         VMSTATE_BND_REGS(env.bnd_regs, X86CPU, 4),
711         VMSTATE_UINT64(env.bndcs_regs.cfgu, X86CPU),
712         VMSTATE_UINT64(env.bndcs_regs.sts, X86CPU),
713         VMSTATE_UINT64(env.msr_bndcfgs, X86CPU),
714         VMSTATE_END_OF_LIST()
715     }
716 };
717 
718 static bool hyperv_hypercall_enable_needed(void *opaque)
719 {
720     X86CPU *cpu = opaque;
721     CPUX86State *env = &cpu->env;
722 
723     return env->msr_hv_hypercall != 0 || env->msr_hv_guest_os_id != 0;
724 }
725 
726 static const VMStateDescription vmstate_msr_hyperv_hypercall = {
727     .name = "cpu/msr_hyperv_hypercall",
728     .version_id = 1,
729     .minimum_version_id = 1,
730     .needed = hyperv_hypercall_enable_needed,
731     .fields = (const VMStateField[]) {
732         VMSTATE_UINT64(env.msr_hv_guest_os_id, X86CPU),
733         VMSTATE_UINT64(env.msr_hv_hypercall, X86CPU),
734         VMSTATE_END_OF_LIST()
735     }
736 };
737 
738 static bool hyperv_vapic_enable_needed(void *opaque)
739 {
740     X86CPU *cpu = opaque;
741     CPUX86State *env = &cpu->env;
742 
743     return env->msr_hv_vapic != 0;
744 }
745 
746 static const VMStateDescription vmstate_msr_hyperv_vapic = {
747     .name = "cpu/msr_hyperv_vapic",
748     .version_id = 1,
749     .minimum_version_id = 1,
750     .needed = hyperv_vapic_enable_needed,
751     .fields = (const VMStateField[]) {
752         VMSTATE_UINT64(env.msr_hv_vapic, X86CPU),
753         VMSTATE_END_OF_LIST()
754     }
755 };
756 
757 static bool hyperv_time_enable_needed(void *opaque)
758 {
759     X86CPU *cpu = opaque;
760     CPUX86State *env = &cpu->env;
761 
762     return env->msr_hv_tsc != 0;
763 }
764 
765 static const VMStateDescription vmstate_msr_hyperv_time = {
766     .name = "cpu/msr_hyperv_time",
767     .version_id = 1,
768     .minimum_version_id = 1,
769     .needed = hyperv_time_enable_needed,
770     .fields = (const VMStateField[]) {
771         VMSTATE_UINT64(env.msr_hv_tsc, X86CPU),
772         VMSTATE_END_OF_LIST()
773     }
774 };
775 
776 static bool hyperv_crash_enable_needed(void *opaque)
777 {
778     X86CPU *cpu = opaque;
779     CPUX86State *env = &cpu->env;
780     int i;
781 
782     for (i = 0; i < HV_CRASH_PARAMS; i++) {
783         if (env->msr_hv_crash_params[i]) {
784             return true;
785         }
786     }
787     return false;
788 }
789 
790 static const VMStateDescription vmstate_msr_hyperv_crash = {
791     .name = "cpu/msr_hyperv_crash",
792     .version_id = 1,
793     .minimum_version_id = 1,
794     .needed = hyperv_crash_enable_needed,
795     .fields = (const VMStateField[]) {
796         VMSTATE_UINT64_ARRAY(env.msr_hv_crash_params, X86CPU, HV_CRASH_PARAMS),
797         VMSTATE_END_OF_LIST()
798     }
799 };
800 
801 static bool hyperv_runtime_enable_needed(void *opaque)
802 {
803     X86CPU *cpu = opaque;
804     CPUX86State *env = &cpu->env;
805 
806     if (!hyperv_feat_enabled(cpu, HYPERV_FEAT_RUNTIME)) {
807         return false;
808     }
809 
810     return env->msr_hv_runtime != 0;
811 }
812 
813 static const VMStateDescription vmstate_msr_hyperv_runtime = {
814     .name = "cpu/msr_hyperv_runtime",
815     .version_id = 1,
816     .minimum_version_id = 1,
817     .needed = hyperv_runtime_enable_needed,
818     .fields = (const VMStateField[]) {
819         VMSTATE_UINT64(env.msr_hv_runtime, X86CPU),
820         VMSTATE_END_OF_LIST()
821     }
822 };
823 
824 static bool hyperv_synic_enable_needed(void *opaque)
825 {
826     X86CPU *cpu = opaque;
827     CPUX86State *env = &cpu->env;
828     int i;
829 
830     if (env->msr_hv_synic_control != 0 ||
831         env->msr_hv_synic_evt_page != 0 ||
832         env->msr_hv_synic_msg_page != 0) {
833         return true;
834     }
835 
836     for (i = 0; i < ARRAY_SIZE(env->msr_hv_synic_sint); i++) {
837         if (env->msr_hv_synic_sint[i] != 0) {
838             return true;
839         }
840     }
841 
842     return false;
843 }
844 
845 static int hyperv_synic_post_load(void *opaque, int version_id)
846 {
847     X86CPU *cpu = opaque;
848     hyperv_x86_synic_update(cpu);
849     return 0;
850 }
851 
852 static const VMStateDescription vmstate_msr_hyperv_synic = {
853     .name = "cpu/msr_hyperv_synic",
854     .version_id = 1,
855     .minimum_version_id = 1,
856     .needed = hyperv_synic_enable_needed,
857     .post_load = hyperv_synic_post_load,
858     .fields = (const VMStateField[]) {
859         VMSTATE_UINT64(env.msr_hv_synic_control, X86CPU),
860         VMSTATE_UINT64(env.msr_hv_synic_evt_page, X86CPU),
861         VMSTATE_UINT64(env.msr_hv_synic_msg_page, X86CPU),
862         VMSTATE_UINT64_ARRAY(env.msr_hv_synic_sint, X86CPU, HV_SINT_COUNT),
863         VMSTATE_END_OF_LIST()
864     }
865 };
866 
867 static bool hyperv_stimer_enable_needed(void *opaque)
868 {
869     X86CPU *cpu = opaque;
870     CPUX86State *env = &cpu->env;
871     int i;
872 
873     for (i = 0; i < ARRAY_SIZE(env->msr_hv_stimer_config); i++) {
874         if (env->msr_hv_stimer_config[i] || env->msr_hv_stimer_count[i]) {
875             return true;
876         }
877     }
878     return false;
879 }
880 
881 static const VMStateDescription vmstate_msr_hyperv_stimer = {
882     .name = "cpu/msr_hyperv_stimer",
883     .version_id = 1,
884     .minimum_version_id = 1,
885     .needed = hyperv_stimer_enable_needed,
886     .fields = (const VMStateField[]) {
887         VMSTATE_UINT64_ARRAY(env.msr_hv_stimer_config, X86CPU,
888                              HV_STIMER_COUNT),
889         VMSTATE_UINT64_ARRAY(env.msr_hv_stimer_count, X86CPU, HV_STIMER_COUNT),
890         VMSTATE_END_OF_LIST()
891     }
892 };
893 
894 static bool hyperv_reenlightenment_enable_needed(void *opaque)
895 {
896     X86CPU *cpu = opaque;
897     CPUX86State *env = &cpu->env;
898 
899     return env->msr_hv_reenlightenment_control != 0 ||
900         env->msr_hv_tsc_emulation_control != 0 ||
901         env->msr_hv_tsc_emulation_status != 0;
902 }
903 
904 static int hyperv_reenlightenment_post_load(void *opaque, int version_id)
905 {
906     X86CPU *cpu = opaque;
907     CPUX86State *env = &cpu->env;
908 
909     /*
910      * KVM doesn't fully support re-enlightenment notifications so we need to
911      * make sure TSC frequency doesn't change upon migration.
912      */
913     if ((env->msr_hv_reenlightenment_control & HV_REENLIGHTENMENT_ENABLE_BIT) &&
914         !env->user_tsc_khz) {
915         error_report("Guest enabled re-enlightenment notifications, "
916                      "'tsc-frequency=' has to be specified");
917         return -EINVAL;
918     }
919 
920     return 0;
921 }
922 
923 static const VMStateDescription vmstate_msr_hyperv_reenlightenment = {
924     .name = "cpu/msr_hyperv_reenlightenment",
925     .version_id = 1,
926     .minimum_version_id = 1,
927     .needed = hyperv_reenlightenment_enable_needed,
928     .post_load = hyperv_reenlightenment_post_load,
929     .fields = (const VMStateField[]) {
930         VMSTATE_UINT64(env.msr_hv_reenlightenment_control, X86CPU),
931         VMSTATE_UINT64(env.msr_hv_tsc_emulation_control, X86CPU),
932         VMSTATE_UINT64(env.msr_hv_tsc_emulation_status, X86CPU),
933         VMSTATE_END_OF_LIST()
934     }
935 };
936 
937 static bool avx512_needed(void *opaque)
938 {
939     X86CPU *cpu = opaque;
940     CPUX86State *env = &cpu->env;
941     unsigned int i;
942 
943     for (i = 0; i < NB_OPMASK_REGS; i++) {
944         if (env->opmask_regs[i]) {
945             return true;
946         }
947     }
948 
949     for (i = 0; i < CPU_NB_REGS; i++) {
950 #define ENV_XMM(reg, field) (env->xmm_regs[reg].ZMM_Q(field))
951         if (ENV_XMM(i, 4) || ENV_XMM(i, 6) ||
952             ENV_XMM(i, 5) || ENV_XMM(i, 7)) {
953             return true;
954         }
955 #ifdef TARGET_X86_64
956         if (ENV_XMM(i+16, 0) || ENV_XMM(i+16, 1) ||
957             ENV_XMM(i+16, 2) || ENV_XMM(i+16, 3) ||
958             ENV_XMM(i+16, 4) || ENV_XMM(i+16, 5) ||
959             ENV_XMM(i+16, 6) || ENV_XMM(i+16, 7)) {
960             return true;
961         }
962 #endif
963     }
964 
965     return false;
966 }
967 
968 static const VMStateDescription vmstate_avx512 = {
969     .name = "cpu/avx512",
970     .version_id = 1,
971     .minimum_version_id = 1,
972     .needed = avx512_needed,
973     .fields = (const VMStateField[]) {
974         VMSTATE_UINT64_ARRAY(env.opmask_regs, X86CPU, NB_OPMASK_REGS),
975         VMSTATE_ZMMH_REGS_VARS(env.xmm_regs, X86CPU, 0),
976 #ifdef TARGET_X86_64
977         VMSTATE_Hi16_ZMM_REGS_VARS(env.xmm_regs, X86CPU, 16),
978 #endif
979         VMSTATE_END_OF_LIST()
980     }
981 };
982 
983 static bool xss_needed(void *opaque)
984 {
985     X86CPU *cpu = opaque;
986     CPUX86State *env = &cpu->env;
987 
988     return env->xss != 0;
989 }
990 
991 static const VMStateDescription vmstate_xss = {
992     .name = "cpu/xss",
993     .version_id = 1,
994     .minimum_version_id = 1,
995     .needed = xss_needed,
996     .fields = (const VMStateField[]) {
997         VMSTATE_UINT64(env.xss, X86CPU),
998         VMSTATE_END_OF_LIST()
999     }
1000 };
1001 
1002 static bool umwait_needed(void *opaque)
1003 {
1004     X86CPU *cpu = opaque;
1005     CPUX86State *env = &cpu->env;
1006 
1007     return env->umwait != 0;
1008 }
1009 
1010 static const VMStateDescription vmstate_umwait = {
1011     .name = "cpu/umwait",
1012     .version_id = 1,
1013     .minimum_version_id = 1,
1014     .needed = umwait_needed,
1015     .fields = (const VMStateField[]) {
1016         VMSTATE_UINT32(env.umwait, X86CPU),
1017         VMSTATE_END_OF_LIST()
1018     }
1019 };
1020 
1021 static bool pkru_needed(void *opaque)
1022 {
1023     X86CPU *cpu = opaque;
1024     CPUX86State *env = &cpu->env;
1025 
1026     return env->pkru != 0;
1027 }
1028 
1029 static const VMStateDescription vmstate_pkru = {
1030     .name = "cpu/pkru",
1031     .version_id = 1,
1032     .minimum_version_id = 1,
1033     .needed = pkru_needed,
1034     .fields = (const VMStateField[]){
1035         VMSTATE_UINT32(env.pkru, X86CPU),
1036         VMSTATE_END_OF_LIST()
1037     }
1038 };
1039 
1040 static bool pkrs_needed(void *opaque)
1041 {
1042     X86CPU *cpu = opaque;
1043     CPUX86State *env = &cpu->env;
1044 
1045     return env->pkrs != 0;
1046 }
1047 
1048 static const VMStateDescription vmstate_pkrs = {
1049     .name = "cpu/pkrs",
1050     .version_id = 1,
1051     .minimum_version_id = 1,
1052     .needed = pkrs_needed,
1053     .fields = (const VMStateField[]){
1054         VMSTATE_UINT32(env.pkrs, X86CPU),
1055         VMSTATE_END_OF_LIST()
1056     }
1057 };
1058 
1059 static bool tsc_khz_needed(void *opaque)
1060 {
1061     X86CPU *cpu = opaque;
1062     CPUX86State *env = &cpu->env;
1063     MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
1064     X86MachineClass *x86mc = X86_MACHINE_CLASS(mc);
1065     return env->tsc_khz && x86mc->save_tsc_khz;
1066 }
1067 
1068 static const VMStateDescription vmstate_tsc_khz = {
1069     .name = "cpu/tsc_khz",
1070     .version_id = 1,
1071     .minimum_version_id = 1,
1072     .needed = tsc_khz_needed,
1073     .fields = (const VMStateField[]) {
1074         VMSTATE_INT64(env.tsc_khz, X86CPU),
1075         VMSTATE_END_OF_LIST()
1076     }
1077 };
1078 
1079 #ifdef CONFIG_KVM
1080 
1081 static bool vmx_vmcs12_needed(void *opaque)
1082 {
1083     struct kvm_nested_state *nested_state = opaque;
1084     return (nested_state->size >
1085             offsetof(struct kvm_nested_state, data.vmx[0].vmcs12));
1086 }
1087 
1088 static const VMStateDescription vmstate_vmx_vmcs12 = {
1089     .name = "cpu/kvm_nested_state/vmx/vmcs12",
1090     .version_id = 1,
1091     .minimum_version_id = 1,
1092     .needed = vmx_vmcs12_needed,
1093     .fields = (const VMStateField[]) {
1094         VMSTATE_UINT8_ARRAY(data.vmx[0].vmcs12,
1095                             struct kvm_nested_state,
1096                             KVM_STATE_NESTED_VMX_VMCS_SIZE),
1097         VMSTATE_END_OF_LIST()
1098     }
1099 };
1100 
1101 static bool vmx_shadow_vmcs12_needed(void *opaque)
1102 {
1103     struct kvm_nested_state *nested_state = opaque;
1104     return (nested_state->size >
1105             offsetof(struct kvm_nested_state, data.vmx[0].shadow_vmcs12));
1106 }
1107 
1108 static const VMStateDescription vmstate_vmx_shadow_vmcs12 = {
1109     .name = "cpu/kvm_nested_state/vmx/shadow_vmcs12",
1110     .version_id = 1,
1111     .minimum_version_id = 1,
1112     .needed = vmx_shadow_vmcs12_needed,
1113     .fields = (const VMStateField[]) {
1114         VMSTATE_UINT8_ARRAY(data.vmx[0].shadow_vmcs12,
1115                             struct kvm_nested_state,
1116                             KVM_STATE_NESTED_VMX_VMCS_SIZE),
1117         VMSTATE_END_OF_LIST()
1118     }
1119 };
1120 
1121 static bool vmx_nested_state_needed(void *opaque)
1122 {
1123     struct kvm_nested_state *nested_state = opaque;
1124 
1125     return (nested_state->format == KVM_STATE_NESTED_FORMAT_VMX &&
1126             nested_state->hdr.vmx.vmxon_pa != -1ull);
1127 }
1128 
1129 static const VMStateDescription vmstate_vmx_nested_state = {
1130     .name = "cpu/kvm_nested_state/vmx",
1131     .version_id = 1,
1132     .minimum_version_id = 1,
1133     .needed = vmx_nested_state_needed,
1134     .fields = (const VMStateField[]) {
1135         VMSTATE_U64(hdr.vmx.vmxon_pa, struct kvm_nested_state),
1136         VMSTATE_U64(hdr.vmx.vmcs12_pa, struct kvm_nested_state),
1137         VMSTATE_U16(hdr.vmx.smm.flags, struct kvm_nested_state),
1138         VMSTATE_END_OF_LIST()
1139     },
1140     .subsections = (const VMStateDescription * const []) {
1141         &vmstate_vmx_vmcs12,
1142         &vmstate_vmx_shadow_vmcs12,
1143         NULL,
1144     }
1145 };
1146 
1147 static bool svm_nested_state_needed(void *opaque)
1148 {
1149     struct kvm_nested_state *nested_state = opaque;
1150 
1151     /*
1152      * HF_GUEST_MASK and HF2_GIF_MASK are already serialized
1153      * via hflags and hflags2, all that's left is the opaque
1154      * nested state blob.
1155      */
1156     return (nested_state->format == KVM_STATE_NESTED_FORMAT_SVM &&
1157             nested_state->size > offsetof(struct kvm_nested_state, data));
1158 }
1159 
1160 static const VMStateDescription vmstate_svm_nested_state = {
1161     .name = "cpu/kvm_nested_state/svm",
1162     .version_id = 1,
1163     .minimum_version_id = 1,
1164     .needed = svm_nested_state_needed,
1165     .fields = (const VMStateField[]) {
1166         VMSTATE_U64(hdr.svm.vmcb_pa, struct kvm_nested_state),
1167         VMSTATE_UINT8_ARRAY(data.svm[0].vmcb12,
1168                             struct kvm_nested_state,
1169                             KVM_STATE_NESTED_SVM_VMCB_SIZE),
1170         VMSTATE_END_OF_LIST()
1171     }
1172 };
1173 
1174 static bool nested_state_needed(void *opaque)
1175 {
1176     X86CPU *cpu = opaque;
1177     CPUX86State *env = &cpu->env;
1178 
1179     return (env->nested_state &&
1180             (vmx_nested_state_needed(env->nested_state) ||
1181              svm_nested_state_needed(env->nested_state)));
1182 }
1183 
1184 static int nested_state_post_load(void *opaque, int version_id)
1185 {
1186     X86CPU *cpu = opaque;
1187     CPUX86State *env = &cpu->env;
1188     struct kvm_nested_state *nested_state = env->nested_state;
1189     int min_nested_state_len = offsetof(struct kvm_nested_state, data);
1190     int max_nested_state_len = kvm_max_nested_state_length();
1191 
1192     /*
1193      * If our kernel don't support setting nested state
1194      * and we have received nested state from migration stream,
1195      * we need to fail migration
1196      */
1197     if (max_nested_state_len <= 0) {
1198         error_report("Received nested state when kernel cannot restore it");
1199         return -EINVAL;
1200     }
1201 
1202     /*
1203      * Verify that the size of received nested_state struct
1204      * at least cover required header and is not larger
1205      * than the max size that our kernel support
1206      */
1207     if (nested_state->size < min_nested_state_len) {
1208         error_report("Received nested state size less than min: "
1209                      "len=%d, min=%d",
1210                      nested_state->size, min_nested_state_len);
1211         return -EINVAL;
1212     }
1213     if (nested_state->size > max_nested_state_len) {
1214         error_report("Received unsupported nested state size: "
1215                      "nested_state->size=%d, max=%d",
1216                      nested_state->size, max_nested_state_len);
1217         return -EINVAL;
1218     }
1219 
1220     /* Verify format is valid */
1221     if ((nested_state->format != KVM_STATE_NESTED_FORMAT_VMX) &&
1222         (nested_state->format != KVM_STATE_NESTED_FORMAT_SVM)) {
1223         error_report("Received invalid nested state format: %d",
1224                      nested_state->format);
1225         return -EINVAL;
1226     }
1227 
1228     return 0;
1229 }
1230 
1231 static const VMStateDescription vmstate_kvm_nested_state = {
1232     .name = "cpu/kvm_nested_state",
1233     .version_id = 1,
1234     .minimum_version_id = 1,
1235     .fields = (const VMStateField[]) {
1236         VMSTATE_U16(flags, struct kvm_nested_state),
1237         VMSTATE_U16(format, struct kvm_nested_state),
1238         VMSTATE_U32(size, struct kvm_nested_state),
1239         VMSTATE_END_OF_LIST()
1240     },
1241     .subsections = (const VMStateDescription * const []) {
1242         &vmstate_vmx_nested_state,
1243         &vmstate_svm_nested_state,
1244         NULL
1245     }
1246 };
1247 
1248 static const VMStateDescription vmstate_nested_state = {
1249     .name = "cpu/nested_state",
1250     .version_id = 1,
1251     .minimum_version_id = 1,
1252     .needed = nested_state_needed,
1253     .post_load = nested_state_post_load,
1254     .fields = (const VMStateField[]) {
1255         VMSTATE_STRUCT_POINTER(env.nested_state, X86CPU,
1256                 vmstate_kvm_nested_state,
1257                 struct kvm_nested_state),
1258         VMSTATE_END_OF_LIST()
1259     }
1260 };
1261 
1262 static bool xen_vcpu_needed(void *opaque)
1263 {
1264     return (xen_mode == XEN_EMULATE);
1265 }
1266 
1267 static const VMStateDescription vmstate_xen_vcpu = {
1268     .name = "cpu/xen_vcpu",
1269     .version_id = 1,
1270     .minimum_version_id = 1,
1271     .needed = xen_vcpu_needed,
1272     .fields = (const VMStateField[]) {
1273         VMSTATE_UINT64(env.xen_vcpu_info_gpa, X86CPU),
1274         VMSTATE_UINT64(env.xen_vcpu_info_default_gpa, X86CPU),
1275         VMSTATE_UINT64(env.xen_vcpu_time_info_gpa, X86CPU),
1276         VMSTATE_UINT64(env.xen_vcpu_runstate_gpa, X86CPU),
1277         VMSTATE_UINT8(env.xen_vcpu_callback_vector, X86CPU),
1278         VMSTATE_UINT16_ARRAY(env.xen_virq, X86CPU, XEN_NR_VIRQS),
1279         VMSTATE_UINT64(env.xen_singleshot_timer_ns, X86CPU),
1280         VMSTATE_UINT64(env.xen_periodic_timer_period, X86CPU),
1281         VMSTATE_END_OF_LIST()
1282     }
1283 };
1284 #endif
1285 
1286 static bool mcg_ext_ctl_needed(void *opaque)
1287 {
1288     X86CPU *cpu = opaque;
1289     CPUX86State *env = &cpu->env;
1290     return cpu->enable_lmce && env->mcg_ext_ctl;
1291 }
1292 
1293 static const VMStateDescription vmstate_mcg_ext_ctl = {
1294     .name = "cpu/mcg_ext_ctl",
1295     .version_id = 1,
1296     .minimum_version_id = 1,
1297     .needed = mcg_ext_ctl_needed,
1298     .fields = (const VMStateField[]) {
1299         VMSTATE_UINT64(env.mcg_ext_ctl, X86CPU),
1300         VMSTATE_END_OF_LIST()
1301     }
1302 };
1303 
1304 static bool spec_ctrl_needed(void *opaque)
1305 {
1306     X86CPU *cpu = opaque;
1307     CPUX86State *env = &cpu->env;
1308 
1309     return env->spec_ctrl != 0;
1310 }
1311 
1312 static const VMStateDescription vmstate_spec_ctrl = {
1313     .name = "cpu/spec_ctrl",
1314     .version_id = 1,
1315     .minimum_version_id = 1,
1316     .needed = spec_ctrl_needed,
1317     .fields = (const VMStateField[]){
1318         VMSTATE_UINT64(env.spec_ctrl, X86CPU),
1319         VMSTATE_END_OF_LIST()
1320     }
1321 };
1322 
1323 
1324 static bool amd_tsc_scale_msr_needed(void *opaque)
1325 {
1326     X86CPU *cpu = opaque;
1327     CPUX86State *env = &cpu->env;
1328 
1329     return (env->features[FEAT_SVM] & CPUID_SVM_TSCSCALE);
1330 }
1331 
1332 static const VMStateDescription amd_tsc_scale_msr_ctrl = {
1333     .name = "cpu/amd_tsc_scale_msr",
1334     .version_id = 1,
1335     .minimum_version_id = 1,
1336     .needed = amd_tsc_scale_msr_needed,
1337     .fields = (const VMStateField[]){
1338         VMSTATE_UINT64(env.amd_tsc_scale_msr, X86CPU),
1339         VMSTATE_END_OF_LIST()
1340     }
1341 };
1342 
1343 
1344 static bool intel_pt_enable_needed(void *opaque)
1345 {
1346     X86CPU *cpu = opaque;
1347     CPUX86State *env = &cpu->env;
1348     int i;
1349 
1350     if (env->msr_rtit_ctrl || env->msr_rtit_status ||
1351         env->msr_rtit_output_base || env->msr_rtit_output_mask ||
1352         env->msr_rtit_cr3_match) {
1353         return true;
1354     }
1355 
1356     for (i = 0; i < MAX_RTIT_ADDRS; i++) {
1357         if (env->msr_rtit_addrs[i]) {
1358             return true;
1359         }
1360     }
1361 
1362     return false;
1363 }
1364 
1365 static const VMStateDescription vmstate_msr_intel_pt = {
1366     .name = "cpu/intel_pt",
1367     .version_id = 1,
1368     .minimum_version_id = 1,
1369     .needed = intel_pt_enable_needed,
1370     .fields = (const VMStateField[]) {
1371         VMSTATE_UINT64(env.msr_rtit_ctrl, X86CPU),
1372         VMSTATE_UINT64(env.msr_rtit_status, X86CPU),
1373         VMSTATE_UINT64(env.msr_rtit_output_base, X86CPU),
1374         VMSTATE_UINT64(env.msr_rtit_output_mask, X86CPU),
1375         VMSTATE_UINT64(env.msr_rtit_cr3_match, X86CPU),
1376         VMSTATE_UINT64_ARRAY(env.msr_rtit_addrs, X86CPU, MAX_RTIT_ADDRS),
1377         VMSTATE_END_OF_LIST()
1378     }
1379 };
1380 
1381 static bool virt_ssbd_needed(void *opaque)
1382 {
1383     X86CPU *cpu = opaque;
1384     CPUX86State *env = &cpu->env;
1385 
1386     return env->virt_ssbd != 0;
1387 }
1388 
1389 static const VMStateDescription vmstate_msr_virt_ssbd = {
1390     .name = "cpu/virt_ssbd",
1391     .version_id = 1,
1392     .minimum_version_id = 1,
1393     .needed = virt_ssbd_needed,
1394     .fields = (const VMStateField[]){
1395         VMSTATE_UINT64(env.virt_ssbd, X86CPU),
1396         VMSTATE_END_OF_LIST()
1397     }
1398 };
1399 
1400 static bool svm_npt_needed(void *opaque)
1401 {
1402     X86CPU *cpu = opaque;
1403     CPUX86State *env = &cpu->env;
1404 
1405     return !!(env->hflags2 & HF2_NPT_MASK);
1406 }
1407 
1408 static const VMStateDescription vmstate_svm_npt = {
1409     .name = "cpu/svn_npt",
1410     .version_id = 1,
1411     .minimum_version_id = 1,
1412     .needed = svm_npt_needed,
1413     .fields = (const VMStateField[]){
1414         VMSTATE_UINT64(env.nested_cr3, X86CPU),
1415         VMSTATE_UINT32(env.nested_pg_mode, X86CPU),
1416         VMSTATE_END_OF_LIST()
1417     }
1418 };
1419 
1420 static bool svm_guest_needed(void *opaque)
1421 {
1422     X86CPU *cpu = opaque;
1423     CPUX86State *env = &cpu->env;
1424 
1425     return tcg_enabled() && env->int_ctl;
1426 }
1427 
1428 static const VMStateDescription vmstate_svm_guest = {
1429     .name = "cpu/svm_guest",
1430     .version_id = 1,
1431     .minimum_version_id = 1,
1432     .needed = svm_guest_needed,
1433     .fields = (const VMStateField[]){
1434         VMSTATE_UINT32(env.int_ctl, X86CPU),
1435         VMSTATE_END_OF_LIST()
1436     }
1437 };
1438 
1439 #ifndef TARGET_X86_64
1440 static bool intel_efer32_needed(void *opaque)
1441 {
1442     X86CPU *cpu = opaque;
1443     CPUX86State *env = &cpu->env;
1444 
1445     return env->efer != 0;
1446 }
1447 
1448 static const VMStateDescription vmstate_efer32 = {
1449     .name = "cpu/efer32",
1450     .version_id = 1,
1451     .minimum_version_id = 1,
1452     .needed = intel_efer32_needed,
1453     .fields = (const VMStateField[]) {
1454         VMSTATE_UINT64(env.efer, X86CPU),
1455         VMSTATE_END_OF_LIST()
1456     }
1457 };
1458 #endif
1459 
1460 static bool msr_tsx_ctrl_needed(void *opaque)
1461 {
1462     X86CPU *cpu = opaque;
1463     CPUX86State *env = &cpu->env;
1464 
1465     return env->features[FEAT_ARCH_CAPABILITIES] & ARCH_CAP_TSX_CTRL_MSR;
1466 }
1467 
1468 static const VMStateDescription vmstate_msr_tsx_ctrl = {
1469     .name = "cpu/msr_tsx_ctrl",
1470     .version_id = 1,
1471     .minimum_version_id = 1,
1472     .needed = msr_tsx_ctrl_needed,
1473     .fields = (const VMStateField[]) {
1474         VMSTATE_UINT32(env.tsx_ctrl, X86CPU),
1475         VMSTATE_END_OF_LIST()
1476     }
1477 };
1478 
1479 static bool intel_sgx_msrs_needed(void *opaque)
1480 {
1481     X86CPU *cpu = opaque;
1482     CPUX86State *env = &cpu->env;
1483 
1484     return !!(env->features[FEAT_7_0_ECX] & CPUID_7_0_ECX_SGX_LC);
1485 }
1486 
1487 static const VMStateDescription vmstate_msr_intel_sgx = {
1488     .name = "cpu/intel_sgx",
1489     .version_id = 1,
1490     .minimum_version_id = 1,
1491     .needed = intel_sgx_msrs_needed,
1492     .fields = (const VMStateField[]) {
1493         VMSTATE_UINT64_ARRAY(env.msr_ia32_sgxlepubkeyhash, X86CPU, 4),
1494                 VMSTATE_END_OF_LIST()
1495             }
1496         };
1497 
1498 static bool pdptrs_needed(void *opaque)
1499 {
1500     X86CPU *cpu = opaque;
1501     CPUX86State *env = &cpu->env;
1502     return env->pdptrs_valid;
1503 }
1504 
1505 static int pdptrs_post_load(void *opaque, int version_id)
1506 {
1507     X86CPU *cpu = opaque;
1508     CPUX86State *env = &cpu->env;
1509     env->pdptrs_valid = true;
1510     return 0;
1511 }
1512 
1513 
1514 static const VMStateDescription vmstate_pdptrs = {
1515     .name = "cpu/pdptrs",
1516     .version_id = 1,
1517     .minimum_version_id = 1,
1518     .needed = pdptrs_needed,
1519     .post_load = pdptrs_post_load,
1520     .fields = (const VMStateField[]) {
1521         VMSTATE_UINT64_ARRAY(env.pdptrs, X86CPU, 4),
1522         VMSTATE_END_OF_LIST()
1523     }
1524 };
1525 
1526 static bool xfd_msrs_needed(void *opaque)
1527 {
1528     X86CPU *cpu = opaque;
1529     CPUX86State *env = &cpu->env;
1530 
1531     return !!(env->features[FEAT_XSAVE] & CPUID_D_1_EAX_XFD);
1532 }
1533 
1534 static const VMStateDescription vmstate_msr_xfd = {
1535     .name = "cpu/msr_xfd",
1536     .version_id = 1,
1537     .minimum_version_id = 1,
1538     .needed = xfd_msrs_needed,
1539     .fields = (const VMStateField[]) {
1540         VMSTATE_UINT64(env.msr_xfd, X86CPU),
1541         VMSTATE_UINT64(env.msr_xfd_err, X86CPU),
1542         VMSTATE_END_OF_LIST()
1543     }
1544 };
1545 
1546 #ifdef TARGET_X86_64
1547 static bool intel_fred_msrs_needed(void *opaque)
1548 {
1549     X86CPU *cpu = opaque;
1550     CPUX86State *env = &cpu->env;
1551 
1552     return !!(env->features[FEAT_7_1_EAX] & CPUID_7_1_EAX_FRED);
1553 }
1554 
1555 static const VMStateDescription vmstate_msr_fred = {
1556     .name = "cpu/fred",
1557     .version_id = 1,
1558     .minimum_version_id = 1,
1559     .needed = intel_fred_msrs_needed,
1560     .fields = (VMStateField[]) {
1561         VMSTATE_UINT64(env.fred_rsp0, X86CPU),
1562         VMSTATE_UINT64(env.fred_rsp1, X86CPU),
1563         VMSTATE_UINT64(env.fred_rsp2, X86CPU),
1564         VMSTATE_UINT64(env.fred_rsp3, X86CPU),
1565         VMSTATE_UINT64(env.fred_stklvls, X86CPU),
1566         VMSTATE_UINT64(env.fred_ssp1, X86CPU),
1567         VMSTATE_UINT64(env.fred_ssp2, X86CPU),
1568         VMSTATE_UINT64(env.fred_ssp3, X86CPU),
1569         VMSTATE_UINT64(env.fred_config, X86CPU),
1570         VMSTATE_END_OF_LIST()
1571             }
1572         };
1573 
1574 static bool amx_xtile_needed(void *opaque)
1575 {
1576     X86CPU *cpu = opaque;
1577     CPUX86State *env = &cpu->env;
1578 
1579     return !!(env->features[FEAT_7_0_EDX] & CPUID_7_0_EDX_AMX_TILE);
1580 }
1581 
1582 static const VMStateDescription vmstate_amx_xtile = {
1583     .name = "cpu/intel_amx_xtile",
1584     .version_id = 1,
1585     .minimum_version_id = 1,
1586     .needed = amx_xtile_needed,
1587     .fields = (const VMStateField[]) {
1588         VMSTATE_UINT8_ARRAY(env.xtilecfg, X86CPU, 64),
1589         VMSTATE_UINT8_ARRAY(env.xtiledata, X86CPU, 8192),
1590         VMSTATE_END_OF_LIST()
1591     }
1592 };
1593 #endif
1594 
1595 static bool arch_lbr_needed(void *opaque)
1596 {
1597     X86CPU *cpu = opaque;
1598     CPUX86State *env = &cpu->env;
1599 
1600     return !!(env->features[FEAT_7_0_EDX] & CPUID_7_0_EDX_ARCH_LBR);
1601 }
1602 
1603 static const VMStateDescription vmstate_arch_lbr = {
1604     .name = "cpu/arch_lbr",
1605     .version_id = 1,
1606     .minimum_version_id = 1,
1607     .needed = arch_lbr_needed,
1608     .fields = (const VMStateField[]) {
1609         VMSTATE_UINT64(env.msr_lbr_ctl, X86CPU),
1610         VMSTATE_UINT64(env.msr_lbr_depth, X86CPU),
1611         VMSTATE_LBR_VARS(env.lbr_records, X86CPU, ARCH_LBR_NR_ENTRIES, 1),
1612         VMSTATE_END_OF_LIST()
1613     }
1614 };
1615 
1616 static bool triple_fault_needed(void *opaque)
1617 {
1618     X86CPU *cpu = opaque;
1619     CPUX86State *env = &cpu->env;
1620 
1621     return env->triple_fault_pending;
1622 }
1623 
1624 static const VMStateDescription vmstate_triple_fault = {
1625     .name = "cpu/triple_fault",
1626     .version_id = 1,
1627     .minimum_version_id = 1,
1628     .needed = triple_fault_needed,
1629     .fields = (const VMStateField[]) {
1630         VMSTATE_UINT8(env.triple_fault_pending, X86CPU),
1631         VMSTATE_END_OF_LIST()
1632     }
1633 };
1634 
1635 const VMStateDescription vmstate_x86_cpu = {
1636     .name = "cpu",
1637     .version_id = 12,
1638     .minimum_version_id = 11,
1639     .pre_save = cpu_pre_save,
1640     .post_load = cpu_post_load,
1641     .fields = (const VMStateField[]) {
1642         VMSTATE_UINTTL_ARRAY(env.regs, X86CPU, CPU_NB_REGS),
1643         VMSTATE_UINTTL(env.eip, X86CPU),
1644         VMSTATE_UINTTL(env.eflags, X86CPU),
1645         VMSTATE_UINT32(env.hflags, X86CPU),
1646         /* FPU */
1647         VMSTATE_UINT16(env.fpuc, X86CPU),
1648         VMSTATE_UINT16(env.fpus_vmstate, X86CPU),
1649         VMSTATE_UINT16(env.fptag_vmstate, X86CPU),
1650         VMSTATE_UINT16(env.fpregs_format_vmstate, X86CPU),
1651 
1652         VMSTATE_STRUCT_ARRAY(env.fpregs, X86CPU, 8, 0, vmstate_fpreg, FPReg),
1653 
1654         VMSTATE_SEGMENT_ARRAY(env.segs, X86CPU, 6),
1655         VMSTATE_SEGMENT(env.ldt, X86CPU),
1656         VMSTATE_SEGMENT(env.tr, X86CPU),
1657         VMSTATE_SEGMENT(env.gdt, X86CPU),
1658         VMSTATE_SEGMENT(env.idt, X86CPU),
1659 
1660         VMSTATE_UINT32(env.sysenter_cs, X86CPU),
1661         VMSTATE_UINTTL(env.sysenter_esp, X86CPU),
1662         VMSTATE_UINTTL(env.sysenter_eip, X86CPU),
1663 
1664         VMSTATE_UINTTL(env.cr[0], X86CPU),
1665         VMSTATE_UINTTL(env.cr[2], X86CPU),
1666         VMSTATE_UINTTL(env.cr[3], X86CPU),
1667         VMSTATE_UINTTL(env.cr[4], X86CPU),
1668         VMSTATE_UINTTL_ARRAY(env.dr, X86CPU, 8),
1669         /* MMU */
1670         VMSTATE_INT32(env.a20_mask, X86CPU),
1671         /* XMM */
1672         VMSTATE_UINT32(env.mxcsr, X86CPU),
1673         VMSTATE_XMM_REGS(env.xmm_regs, X86CPU, 0),
1674 
1675 #ifdef TARGET_X86_64
1676         VMSTATE_UINT64(env.efer, X86CPU),
1677         VMSTATE_UINT64(env.star, X86CPU),
1678         VMSTATE_UINT64(env.lstar, X86CPU),
1679         VMSTATE_UINT64(env.cstar, X86CPU),
1680         VMSTATE_UINT64(env.fmask, X86CPU),
1681         VMSTATE_UINT64(env.kernelgsbase, X86CPU),
1682 #endif
1683         VMSTATE_UINT32(env.smbase, X86CPU),
1684 
1685         VMSTATE_UINT64(env.pat, X86CPU),
1686         VMSTATE_UINT32(env.hflags2, X86CPU),
1687 
1688         VMSTATE_UINT64(env.vm_hsave, X86CPU),
1689         VMSTATE_UINT64(env.vm_vmcb, X86CPU),
1690         VMSTATE_UINT64(env.tsc_offset, X86CPU),
1691         VMSTATE_UINT64(env.intercept, X86CPU),
1692         VMSTATE_UINT16(env.intercept_cr_read, X86CPU),
1693         VMSTATE_UINT16(env.intercept_cr_write, X86CPU),
1694         VMSTATE_UINT16(env.intercept_dr_read, X86CPU),
1695         VMSTATE_UINT16(env.intercept_dr_write, X86CPU),
1696         VMSTATE_UINT32(env.intercept_exceptions, X86CPU),
1697         VMSTATE_UINT8(env.v_tpr, X86CPU),
1698         /* MTRRs */
1699         VMSTATE_UINT64_ARRAY(env.mtrr_fixed, X86CPU, 11),
1700         VMSTATE_UINT64(env.mtrr_deftype, X86CPU),
1701         VMSTATE_MTRR_VARS(env.mtrr_var, X86CPU, MSR_MTRRcap_VCNT, 8),
1702         /* KVM-related states */
1703         VMSTATE_INT32(env.interrupt_injected, X86CPU),
1704         VMSTATE_UINT32(env.mp_state, X86CPU),
1705         VMSTATE_UINT64(env.tsc, X86CPU),
1706         VMSTATE_INT32(env.exception_nr, X86CPU),
1707         VMSTATE_UINT8(env.soft_interrupt, X86CPU),
1708         VMSTATE_UINT8(env.nmi_injected, X86CPU),
1709         VMSTATE_UINT8(env.nmi_pending, X86CPU),
1710         VMSTATE_UINT8(env.has_error_code, X86CPU),
1711         VMSTATE_UINT32(env.sipi_vector, X86CPU),
1712         /* MCE */
1713         VMSTATE_UINT64(env.mcg_cap, X86CPU),
1714         VMSTATE_UINT64(env.mcg_status, X86CPU),
1715         VMSTATE_UINT64(env.mcg_ctl, X86CPU),
1716         VMSTATE_UINT64_ARRAY(env.mce_banks, X86CPU, MCE_BANKS_DEF * 4),
1717         /* rdtscp */
1718         VMSTATE_UINT64(env.tsc_aux, X86CPU),
1719         /* KVM pvclock msr */
1720         VMSTATE_UINT64(env.system_time_msr, X86CPU),
1721         VMSTATE_UINT64(env.wall_clock_msr, X86CPU),
1722         /* XSAVE related fields */
1723         VMSTATE_UINT64_V(env.xcr0, X86CPU, 12),
1724         VMSTATE_UINT64_V(env.xstate_bv, X86CPU, 12),
1725         VMSTATE_YMMH_REGS_VARS(env.xmm_regs, X86CPU, 0, 12),
1726         VMSTATE_END_OF_LIST()
1727         /* The above list is not sorted /wrt version numbers, watch out! */
1728     },
1729     .subsections = (const VMStateDescription * const []) {
1730         &vmstate_exception_info,
1731         &vmstate_async_pf_msr,
1732         &vmstate_async_pf_int_msr,
1733         &vmstate_pv_eoi_msr,
1734         &vmstate_steal_time_msr,
1735         &vmstate_poll_control_msr,
1736         &vmstate_fpop_ip_dp,
1737         &vmstate_msr_tsc_adjust,
1738         &vmstate_msr_tscdeadline,
1739         &vmstate_msr_ia32_misc_enable,
1740         &vmstate_msr_ia32_feature_control,
1741         &vmstate_msr_architectural_pmu,
1742         &vmstate_mpx,
1743         &vmstate_msr_hyperv_hypercall,
1744         &vmstate_msr_hyperv_vapic,
1745         &vmstate_msr_hyperv_time,
1746         &vmstate_msr_hyperv_crash,
1747         &vmstate_msr_hyperv_runtime,
1748         &vmstate_msr_hyperv_synic,
1749         &vmstate_msr_hyperv_stimer,
1750         &vmstate_msr_hyperv_reenlightenment,
1751         &vmstate_avx512,
1752         &vmstate_xss,
1753         &vmstate_umwait,
1754         &vmstate_tsc_khz,
1755         &vmstate_msr_smi_count,
1756         &vmstate_pkru,
1757         &vmstate_pkrs,
1758         &vmstate_spec_ctrl,
1759         &amd_tsc_scale_msr_ctrl,
1760         &vmstate_mcg_ext_ctl,
1761         &vmstate_msr_intel_pt,
1762         &vmstate_msr_virt_ssbd,
1763         &vmstate_svm_npt,
1764         &vmstate_svm_guest,
1765 #ifndef TARGET_X86_64
1766         &vmstate_efer32,
1767 #endif
1768 #ifdef CONFIG_KVM
1769         &vmstate_nested_state,
1770         &vmstate_xen_vcpu,
1771 #endif
1772         &vmstate_msr_tsx_ctrl,
1773         &vmstate_msr_intel_sgx,
1774         &vmstate_pdptrs,
1775         &vmstate_msr_xfd,
1776 #ifdef TARGET_X86_64
1777         &vmstate_msr_fred,
1778         &vmstate_amx_xtile,
1779 #endif
1780         &vmstate_arch_lbr,
1781         &vmstate_triple_fault,
1782         NULL
1783     }
1784 };
1785