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