target-i386/machine.c

   1 #include "hw/hw.h"
   2 #include "hw/boards.h"
   3 #include "hw/pc.h"
   4 #include "hw/isa.h"
   5
   6 #include "exec-all.h"
   7 #include "kvm.h"
   8 #include "qemu-kvm.h"
   9
  10 static const VMStateDescription vmstate_segment = {
  11     .name = "segment",
  12     .version_id = 1,
  13     .minimum_version_id = 1,
  14     .minimum_version_id_old = 1,
  15     .fields      = (VMStateField []) {
  16         VMSTATE_UINT32(selector, SegmentCache),
  17         VMSTATE_UINTTL(base, SegmentCache),
  18         VMSTATE_UINT32(limit, SegmentCache),
  19         VMSTATE_UINT32(flags, SegmentCache),
  20         VMSTATE_END_OF_LIST()
  21     }
  22 };
  23
  24 #define VMSTATE_SEGMENT(_field, _state) {                            \
  25     .name       = (stringify(_field)),                               \
  26     .size       = sizeof(SegmentCache),                              \
  27     .vmsd       = &vmstate_segment,                                  \
  28     .flags      = VMS_STRUCT,                                        \
  29     .offset     = offsetof(_state, _field)                           \
  30             + type_check(SegmentCache,typeof_field(_state, _field))  \
  31 }
  32
  33 #define VMSTATE_SEGMENT_ARRAY(_field, _state, _n)                    \
  34     VMSTATE_STRUCT_ARRAY(_field, _state, _n, 0, vmstate_segment, SegmentCache)
  35
  36 static const VMStateDescription vmstate_xmm_reg = {
  37     .name = "xmm_reg",
  38     .version_id = 1,
  39     .minimum_version_id = 1,
  40     .minimum_version_id_old = 1,
  41     .fields      = (VMStateField []) {
  42         VMSTATE_UINT64(XMM_Q(0), XMMReg),
  43         VMSTATE_UINT64(XMM_Q(1), XMMReg),
  44         VMSTATE_END_OF_LIST()
  45     }
  46 };
  47
  48 #define VMSTATE_XMM_REGS(_field, _state, _n)                         \
  49     VMSTATE_STRUCT_ARRAY(_field, _state, _n, 0, vmstate_xmm_reg, XMMReg)
  50
  51 static const VMStateDescription vmstate_mtrr_var = {
  52     .name = "mtrr_var",
  53     .version_id = 1,
  54     .minimum_version_id = 1,
  55     .minimum_version_id_old = 1,
  56     .fields      = (VMStateField []) {
  57         VMSTATE_UINT64(base, MTRRVar),
  58         VMSTATE_UINT64(mask, MTRRVar),
  59         VMSTATE_END_OF_LIST()
  60     }
  61 };
  62
  63 #define VMSTATE_MTRR_VARS(_field, _state, _n, _v)                    \
  64     VMSTATE_STRUCT_ARRAY(_field, _state, _n, _v, vmstate_mtrr_var, MTRRVar)
  65
  66 static void put_fpreg_error(QEMUFile *f, void *opaque, size_t size)
  67 {
  68     fprintf(stderr, "call put_fpreg() with invalid arguments\n");
  69     exit(0);
  70 }
  71
  72 #ifdef USE_X86LDOUBLE
  73 /* XXX: add that in a FPU generic layer */
  74 union x86_longdouble {
  75     uint64_t mant;
  76     uint16_t exp;
  77 };
  78
  79 #define MANTD1(fp)      (fp & ((1LL << 52) - 1))
  80 #define EXPBIAS1 1023
  81 #define EXPD1(fp)       ((fp >> 52) & 0x7FF)
  82 #define SIGND1(fp)      ((fp >> 32) & 0x80000000)
  83
  84 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
  85 {
  86     int e;
  87     /* mantissa */
  88     p->mant = (MANTD1(temp) << 11) | (1LL << 63);
  89     /* exponent + sign */
  90     e = EXPD1(temp) - EXPBIAS1 + 16383;
  91     e |= SIGND1(temp) >> 16;
  92     p->exp = e;
  93 }
  94
  95 static int get_fpreg(QEMUFile *f, void *opaque, size_t size)
  96 {
  97     FPReg *fp_reg = opaque;
  98     uint64_t mant;
  99     uint16_t exp;
 100
 101     qemu_get_be64s(f, &mant);
 102     qemu_get_be16s(f, &exp);
 103     fp_reg->d = cpu_set_fp80(mant, exp);
 104     return 0;
 105 }
 106
 107 static void put_fpreg(QEMUFile *f, void *opaque, size_t size)
 108 {
 109     FPReg *fp_reg = opaque;
 110     uint64_t mant;
 111     uint16_t exp;
 112     /* we save the real CPU data (in case of MMX usage only 'mant'
 113        contains the MMX register */
 114     cpu_get_fp80(&mant, &exp, fp_reg->d);
 115     qemu_put_be64s(f, &mant);
 116     qemu_put_be16s(f, &exp);
 117 }
 118
 119 static const VMStateInfo vmstate_fpreg = {
 120     .name = "fpreg",
 121     .get  = get_fpreg,
 122     .put  = put_fpreg,
 123 };
 124
 125 static int get_fpreg_1_mmx(QEMUFile *f, void *opaque, size_t size)
 126 {
 127     union x86_longdouble *p = opaque;
 128     uint64_t mant;
 129
 130     qemu_get_be64s(f, &mant);
 131     p->mant = mant;
 132     p->exp = 0xffff;
 133     return 0;
 134 }
 135
 136 static const VMStateInfo vmstate_fpreg_1_mmx = {
 137     .name = "fpreg_1_mmx",
 138     .get  = get_fpreg_1_mmx,
 139     .put  = put_fpreg_error,
 140 };
 141
 142 static int get_fpreg_1_no_mmx(QEMUFile *f, void *opaque, size_t size)
 143 {
 144     union x86_longdouble *p = opaque;
 145     uint64_t mant;
 146
 147     qemu_get_be64s(f, &mant);
 148     fp64_to_fp80(p, mant);
 149     return 0;
 150 }
 151
 152 static const VMStateInfo vmstate_fpreg_1_no_mmx = {
 153     .name = "fpreg_1_no_mmx",
 154     .get  = get_fpreg_1_no_mmx,
 155     .put  = put_fpreg_error,
 156 };
 157
 158 static bool fpregs_is_0(void *opaque, int version_id)
 159 {
 160     CPUState *env = opaque;
 161
 162     return (env->fpregs_format_vmstate == 0);
 163 }
 164
 165 static bool fpregs_is_1_mmx(void *opaque, int version_id)
 166 {
 167     CPUState *env = opaque;
 168     int guess_mmx;
 169
 170     guess_mmx = ((env->fptag_vmstate == 0xff) &&
 171                  (env->fpus_vmstate & 0x3800) == 0);
 172     return (guess_mmx && (env->fpregs_format_vmstate == 1));
 173 }
 174
 175 static bool fpregs_is_1_no_mmx(void *opaque, int version_id)
 176 {
 177     CPUState *env = opaque;
 178     int guess_mmx;
 179
 180     guess_mmx = ((env->fptag_vmstate == 0xff) &&
 181                  (env->fpus_vmstate & 0x3800) == 0);
 182     return (!guess_mmx && (env->fpregs_format_vmstate == 1));
 183 }
 184
 185 #define VMSTATE_FP_REGS(_field, _state, _n)                               \
 186     VMSTATE_ARRAY_TEST(_field, _state, _n, fpregs_is_0, vmstate_fpreg, FPReg), \
 187     VMSTATE_ARRAY_TEST(_field, _state, _n, fpregs_is_1_mmx, vmstate_fpreg_1_mmx, FPReg), \
 188     VMSTATE_ARRAY_TEST(_field, _state, _n, fpregs_is_1_no_mmx, vmstate_fpreg_1_no_mmx, FPReg)
 189
 190 #else
 191 static int get_fpreg(QEMUFile *f, void *opaque, size_t size)
 192 {
 193     FPReg *fp_reg = opaque;
 194
 195     qemu_get_be64s(f, &fp_reg->mmx.MMX_Q(0));
 196     return 0;
 197 }
 198
 199 static void put_fpreg(QEMUFile *f, void *opaque, size_t size)
 200 {
 201     FPReg *fp_reg = opaque;
 202     /* if we use doubles for float emulation, we save the doubles to
 203        avoid losing information in case of MMX usage. It can give
 204        problems if the image is restored on a CPU where long
 205        doubles are used instead. */
 206     qemu_put_be64s(f, &fp_reg->mmx.MMX_Q(0));
 207 }
 208
 209 const VMStateInfo vmstate_fpreg = {
 210     .name = "fpreg",
 211     .get  = get_fpreg,
 212     .put  = put_fpreg,
 213 };
 214
 215 static int get_fpreg_0_mmx(QEMUFile *f, void *opaque, size_t size)
 216 {
 217     FPReg *fp_reg = opaque;
 218     uint64_t mant;
 219     uint16_t exp;
 220
 221     qemu_get_be64s(f, &mant);
 222     qemu_get_be16s(f, &exp);
 223     fp_reg->mmx.MMX_Q(0) = mant;
 224     return 0;
 225 }
 226
 227 const VMStateInfo vmstate_fpreg_0_mmx = {
 228     .name = "fpreg_0_mmx",
 229     .get  = get_fpreg_0_mmx,
 230     .put  = put_fpreg_error,
 231 };
 232
 233 static int get_fpreg_0_no_mmx(QEMUFile *f, void *opaque, size_t size)
 234 {
 235     FPReg *fp_reg = opaque;
 236     uint64_t mant;
 237     uint16_t exp;
 238
 239     qemu_get_be64s(f, &mant);
 240     qemu_get_be16s(f, &exp);
 241
 242     fp_reg->d = cpu_set_fp80(mant, exp);
 243     return 0;
 244 }
 245
 246 const VMStateInfo vmstate_fpreg_0_no_mmx = {
 247     .name = "fpreg_0_no_mmx",
 248     .get  = get_fpreg_0_no_mmx,
 249     .put  = put_fpreg_error,
 250 };
 251
 252 static bool fpregs_is_1(void *opaque, int version_id)
 253 {
 254     CPUState *env = opaque;
 255
 256     return env->fpregs_format_vmstate == 1;
 257 }
 258
 259 static bool fpregs_is_0_mmx(void *opaque, int version_id)
 260 {
 261     CPUState *env = opaque;
 262     int guess_mmx;
 263
 264     guess_mmx = ((env->fptag_vmstate == 0xff) &&
 265                  (env->fpus_vmstate & 0x3800) == 0);
 266     return guess_mmx && env->fpregs_format_vmstate == 0;
 267 }
 268
 269 static bool fpregs_is_0_no_mmx(void *opaque, int version_id)
 270 {
 271     CPUState *env = opaque;
 272     int guess_mmx;
 273
 274     guess_mmx = ((env->fptag_vmstate == 0xff) &&
 275                  (env->fpus_vmstate & 0x3800) == 0);
 276     return !guess_mmx && env->fpregs_format_vmstate == 0;
 277 }
 278
 279 #define VMSTATE_FP_REGS(_field, _state, _n)                               \
 280     VMSTATE_ARRAY_TEST(_field, _state, _n, fpregs_is_1, vmstate_fpreg, FPReg), \
 281     VMSTATE_ARRAY_TEST(_field, _state, _n, fpregs_is_0_mmx, vmstate_fpreg_0_mmx, FPReg), \
 282     VMSTATE_ARRAY_TEST(_field, _state, _n, fpregs_is_0_no_mmx, vmstate_fpreg_0_no_mmx, FPReg)
 283
 284 #endif /* USE_X86LDOUBLE */
 285
 286 static bool version_is_5(void *opaque, int version_id)
 287 {
 288     return version_id == 5;
 289 }
 290
 291 #ifdef TARGET_X86_64
 292 static bool less_than_7(void *opaque, int version_id)
 293 {
 294     return version_id < 7;
 295 }
 296
 297 static int get_uint64_as_uint32(QEMUFile *f, void *pv, size_t size)
 298 {
 299     uint64_t *v = pv;
 300     *v = qemu_get_be32(f);
 301     return 0;
 302 }
 303
 304 static void put_uint64_as_uint32(QEMUFile *f, void *pv, size_t size)
 305 {
 306     uint64_t *v = pv;
 307     qemu_put_be32(f, *v);
 308 }
 309
 310 static const VMStateInfo vmstate_hack_uint64_as_uint32 = {
 311     .name = "uint64_as_uint32",
 312     .get  = get_uint64_as_uint32,
 313     .put  = put_uint64_as_uint32,
 314 };
 315
 316 #define VMSTATE_HACK_UINT32(_f, _s, _t)                                  \
 317     VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_hack_uint64_as_uint32, uint64_t)
 318 #endif
 319
 320 static void cpu_pre_save(void *opaque)
 321 {
 322     CPUState *env = opaque;
 323     int i;
 324
 325     cpu_synchronize_state(env);
 326     kvm_save_mpstate(env);
 327
 328     /* FPU */
 329     env->fpus_vmstate = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
 330     env->fptag_vmstate = 0;
 331     for(i = 0; i < 8; i++) {
 332         env->fptag_vmstate |= ((!env->fptags[i]) << i);
 333     }
 334
 335 #ifdef USE_X86LDOUBLE
 336     env->fpregs_format_vmstate = 0;
 337 #else
 338     env->fpregs_format_vmstate = 1;
 339 #endif
 340 }
 341
 342 static int cpu_pre_load(void *opaque)
 343 {
 344     CPUState *env = opaque;
 345
 346     cpu_synchronize_state(env);
 347     return 0;
 348 }
 349
 350 static int cpu_post_load(void *opaque, int version_id)
 351 {
 352     CPUState *env = opaque;
 353     int i;
 354
 355     /* XXX: restore FPU round state */
 356     env->fpstt = (env->fpus_vmstate >> 11) & 7;
 357     env->fpus = env->fpus_vmstate & ~0x3800;
 358     env->fptag_vmstate ^= 0xff;
 359     for(i = 0; i < 8; i++) {
 360         env->fptags[i] = (env->fptag_vmstate >> i) & 1;
 361     }
 362
 363     cpu_breakpoint_remove_all(env, BP_CPU);
 364     cpu_watchpoint_remove_all(env, BP_CPU);
 365     for (i = 0; i < 4; i++)
 366         hw_breakpoint_insert(env, i);
 367
 368     tlb_flush(env, 1);
 369
 370     if (kvm_enabled()) {
 371         /* when in-kernel irqchip is used, env->halted causes deadlock
 372            because no userspace IRQs will ever clear this flag */
 373         env->halted = 0;
 374
 375         kvm_load_tsc(env);
 376         kvm_load_mpstate(env);
 377     }
 378
 379     return 0;
 380 }
 381
 382 static const VMStateDescription vmstate_cpu = {
 383     .name = "cpu",
 384     .version_id = CPU_SAVE_VERSION,
 385     .minimum_version_id = 3,
 386     .minimum_version_id_old = 3,
 387     .pre_save = cpu_pre_save,
 388     .pre_load = cpu_pre_load,
 389     .post_load = cpu_post_load,
 390     .fields      = (VMStateField []) {
 391         VMSTATE_UINTTL_ARRAY(regs, CPUState, CPU_NB_REGS),
 392         VMSTATE_UINTTL(eip, CPUState),
 393         VMSTATE_UINTTL(eflags, CPUState),
 394         VMSTATE_UINT32(hflags, CPUState),
 395         /* FPU */
 396         VMSTATE_UINT16(fpuc, CPUState),
 397         VMSTATE_UINT16(fpus_vmstate, CPUState),
 398         VMSTATE_UINT16(fptag_vmstate, CPUState),
 399         VMSTATE_UINT16(fpregs_format_vmstate, CPUState),
 400         VMSTATE_FP_REGS(fpregs, CPUState, 8),
 401
 402         VMSTATE_SEGMENT_ARRAY(segs, CPUState, 6),
 403         VMSTATE_SEGMENT(ldt, CPUState),
 404         VMSTATE_SEGMENT(tr, CPUState),
 405         VMSTATE_SEGMENT(gdt, CPUState),
 406         VMSTATE_SEGMENT(idt, CPUState),
 407
 408         VMSTATE_UINT32(sysenter_cs, CPUState),
 409 #ifdef TARGET_X86_64
 410         /* Hack: In v7 size changed from 32 to 64 bits on x86_64 */
 411         VMSTATE_HACK_UINT32(sysenter_esp, CPUState, less_than_7),
 412         VMSTATE_HACK_UINT32(sysenter_eip, CPUState, less_than_7),
 413         VMSTATE_UINTTL_V(sysenter_esp, CPUState, 7),
 414         VMSTATE_UINTTL_V(sysenter_eip, CPUState, 7),
 415 #else
 416         VMSTATE_UINTTL(sysenter_esp, CPUState),
 417         VMSTATE_UINTTL(sysenter_eip, CPUState),
 418 #endif
 419
 420         VMSTATE_UINTTL(cr[0], CPUState),
 421         VMSTATE_UINTTL(cr[2], CPUState),
 422         VMSTATE_UINTTL(cr[3], CPUState),
 423         VMSTATE_UINTTL(cr[4], CPUState),
 424         VMSTATE_UINTTL_ARRAY(dr, CPUState, 8),
 425         /* MMU */
 426         VMSTATE_INT32(a20_mask, CPUState),
 427         /* XMM */
 428         VMSTATE_UINT32(mxcsr, CPUState),
 429         VMSTATE_XMM_REGS(xmm_regs, CPUState, CPU_NB_REGS),
 430
 431 #ifdef TARGET_X86_64
 432         VMSTATE_UINT64(efer, CPUState),
 433         VMSTATE_UINT64(star, CPUState),
 434         VMSTATE_UINT64(lstar, CPUState),
 435         VMSTATE_UINT64(cstar, CPUState),
 436         VMSTATE_UINT64(fmask, CPUState),
 437         VMSTATE_UINT64(kernelgsbase, CPUState),
 438 #endif
 439         VMSTATE_UINT32_V(smbase, CPUState, 4),
 440
 441         VMSTATE_UINT64_V(pat, CPUState, 5),
 442         VMSTATE_UINT32_V(hflags2, CPUState, 5),
 443
 444         VMSTATE_UINT32_TEST(halted, CPUState, version_is_5),
 445         VMSTATE_UINT64_V(vm_hsave, CPUState, 5),
 446         VMSTATE_UINT64_V(vm_vmcb, CPUState, 5),
 447         VMSTATE_UINT64_V(tsc_offset, CPUState, 5),
 448         VMSTATE_UINT64_V(intercept, CPUState, 5),
 449         VMSTATE_UINT16_V(intercept_cr_read, CPUState, 5),
 450         VMSTATE_UINT16_V(intercept_cr_write, CPUState, 5),
 451         VMSTATE_UINT16_V(intercept_dr_read, CPUState, 5),
 452         VMSTATE_UINT16_V(intercept_dr_write, CPUState, 5),
 453         VMSTATE_UINT32_V(intercept_exceptions, CPUState, 5),
 454         VMSTATE_UINT8_V(v_tpr, CPUState, 5),
 455         /* MTRRs */
 456         VMSTATE_UINT64_ARRAY_V(mtrr_fixed, CPUState, 11, 8),
 457         VMSTATE_UINT64_V(mtrr_deftype, CPUState, 8),
 458         VMSTATE_MTRR_VARS(mtrr_var, CPUState, 8, 8),
 459         /* KVM-related states */
 460         VMSTATE_INT32_V(interrupt_injected, CPUState, 9),
 461         VMSTATE_UINT32_V(mp_state, CPUState, 9),
 462         VMSTATE_UINT64_V(tsc, CPUState, 9),
 463         VMSTATE_INT32_V(exception_injected, CPUState, 11),
 464         VMSTATE_UINT8_V(soft_interrupt, CPUState, 11),
 465         VMSTATE_UINT8_V(nmi_injected, CPUState, 11),
 466         VMSTATE_UINT8_V(nmi_pending, CPUState, 11),
 467         VMSTATE_UINT8_V(has_error_code, CPUState, 11),
 468         VMSTATE_UINT32_V(sipi_vector, CPUState, 11),
 469         /* MCE */
 470         VMSTATE_UINT64_V(mcg_cap, CPUState, 10),
 471         VMSTATE_UINT64_V(mcg_status, CPUState, 10),
 472         VMSTATE_UINT64_V(mcg_ctl, CPUState, 10),
 473         VMSTATE_UINT64_ARRAY_V(mce_banks, CPUState, MCE_BANKS_DEF *4, 10),
 474         /* rdtscp */
 475         VMSTATE_UINT64_V(tsc_aux, CPUState, 11),
 476         /* KVM pvclock msr */
 477         VMSTATE_UINT64_V(system_time_msr, CPUState, 11),
 478         VMSTATE_UINT64_V(wall_clock_msr, CPUState, 11),
 479         VMSTATE_END_OF_LIST()
 480         /* The above list is not sorted /wrt version numbers, watch out! */
 481     }
 482 };
 483
 484 void cpu_save(QEMUFile *f, void *opaque)
 485 {
 486     vmstate_save_state(f, &vmstate_cpu, opaque);
 487 }
 488
 489 int cpu_load(QEMUFile *f, void *opaque, int version_id)
 490 {
 491     return vmstate_load_state(f, &vmstate_cpu, opaque, version_id);
 492 }