← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to target-i386/misc_helper.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-i386/misc_helper.c
122
122
 
123
123
    cpu_svm_check_intercept_param(env, SVM_EXIT_CPUID, 0);
124
124
 
125
 
    cpu_x86_cpuid(env, (uint32_t)EAX, (uint32_t)ECX, &eax, &ebx, &ecx, &edx);
126
 
    EAX = eax;
127
 
    EBX = ebx;
128
 
    ECX = ecx;
129
 
    EDX = edx;
 
125
    cpu_x86_cpuid(env, (uint32_t)env->regs[R_EAX], (uint32_t)env->regs[R_ECX],
 
126
                  &eax, &ebx, &ecx, &edx);
 
127
    env->regs[R_EAX] = eax;
 
128
    env->regs[R_EBX] = ebx;
 
129
    env->regs[R_ECX] = ecx;
 
130
    env->regs[R_EDX] = edx;
130
131
}
131
132
 
132
133
#if defined(CONFIG_USER_ONLY)
234
235
    cpu_svm_check_intercept_param(env, SVM_EXIT_RDTSC, 0);
235
236
 
236
237
    val = cpu_get_tsc(env) + env->tsc_offset;
237
 
    EAX = (uint32_t)(val);
238
 
    EDX = (uint32_t)(val >> 32);
 
238
    env->regs[R_EAX] = (uint32_t)(val);
 
239
    env->regs[R_EDX] = (uint32_t)(val >> 32);
239
240
}
240
241
 
241
242
void helper_rdtscp(CPUX86State *env)
242
243
{
243
244
    helper_rdtsc(env);
244
 
    ECX = (uint32_t)(env->tsc_aux);
 
245
    env->regs[R_ECX] = (uint32_t)(env->tsc_aux);
245
246
}
246
247
 
247
248
void helper_rdpmc(CPUX86State *env)
271
272
 
272
273
    cpu_svm_check_intercept_param(env, SVM_EXIT_MSR, 1);
273
274
 
274
 
    val = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
 
275
    val = ((uint32_t)env->regs[R_EAX]) |
 
276
        ((uint64_t)((uint32_t)env->regs[R_EDX]) << 32);
275
277
 
276
 
    switch ((uint32_t)ECX) {
 
278
    switch ((uint32_t)env->regs[R_ECX]) {
277
279
    case MSR_IA32_SYSENTER_CS:
278
280
        env->sysenter_cs = val & 0xffff;
279
281
        break;
350
352
    case MSR_MTRRphysBase(5):
351
353
    case MSR_MTRRphysBase(6):
352
354
    case MSR_MTRRphysBase(7):
353
 
        env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysBase(0)) / 2].base = val;
 
355
        env->mtrr_var[((uint32_t)env->regs[R_ECX] -
 
356
                       MSR_MTRRphysBase(0)) / 2].base = val;
354
357
        break;
355
358
    case MSR_MTRRphysMask(0):
356
359
    case MSR_MTRRphysMask(1):
360
363
    case MSR_MTRRphysMask(5):
361
364
    case MSR_MTRRphysMask(6):
362
365
    case MSR_MTRRphysMask(7):
363
 
        env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysMask(0)) / 2].mask = val;
 
366
        env->mtrr_var[((uint32_t)env->regs[R_ECX] -
 
367
                       MSR_MTRRphysMask(0)) / 2].mask = val;
364
368
        break;
365
369
    case MSR_MTRRfix64K_00000:
366
 
        env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix64K_00000] = val;
 
370
        env->mtrr_fixed[(uint32_t)env->regs[R_ECX] -
 
371
                        MSR_MTRRfix64K_00000] = val;
367
372
        break;
368
373
    case MSR_MTRRfix16K_80000:
369
374
    case MSR_MTRRfix16K_A0000:
370
 
        env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix16K_80000 + 1] = val;
 
375
        env->mtrr_fixed[(uint32_t)env->regs[R_ECX] -
 
376
                        MSR_MTRRfix16K_80000 + 1] = val;
371
377
        break;
372
378
    case MSR_MTRRfix4K_C0000:
373
379
    case MSR_MTRRfix4K_C8000:
377
383
    case MSR_MTRRfix4K_E8000:
378
384
    case MSR_MTRRfix4K_F0000:
379
385
    case MSR_MTRRfix4K_F8000:
380
 
        env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix4K_C0000 + 3] = val;
 
386
        env->mtrr_fixed[(uint32_t)env->regs[R_ECX] -
 
387
                        MSR_MTRRfix4K_C0000 + 3] = val;
381
388
        break;
382
389
    case MSR_MTRRdefType:
383
390
        env->mtrr_deftype = val;
398
405
        env->msr_ia32_misc_enable = val;
399
406
        break;
400
407
    default:
401
 
        if ((uint32_t)ECX >= MSR_MC0_CTL
402
 
            && (uint32_t)ECX < MSR_MC0_CTL + (4 * env->mcg_cap & 0xff)) {
403
 
            uint32_t offset = (uint32_t)ECX - MSR_MC0_CTL;
 
408
        if ((uint32_t)env->regs[R_ECX] >= MSR_MC0_CTL
 
409
            && (uint32_t)env->regs[R_ECX] < MSR_MC0_CTL +
 
410
            (4 * env->mcg_cap & 0xff)) {
 
411
            uint32_t offset = (uint32_t)env->regs[R_ECX] - MSR_MC0_CTL;
404
412
            if ((offset & 0x3) != 0
405
413
                || (val == 0 || val == ~(uint64_t)0)) {
406
414
                env->mce_banks[offset] = val;
418
426
 
419
427
    cpu_svm_check_intercept_param(env, SVM_EXIT_MSR, 0);
420
428
 
421
 
    switch ((uint32_t)ECX) {
 
429
    switch ((uint32_t)env->regs[R_ECX]) {
422
430
    case MSR_IA32_SYSENTER_CS:
423
431
        val = env->sysenter_cs;
424
432
        break;
480
488
    case MSR_MTRRphysBase(5):
481
489
    case MSR_MTRRphysBase(6):
482
490
    case MSR_MTRRphysBase(7):
483
 
        val = env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysBase(0)) / 2].base;
 
491
        val = env->mtrr_var[((uint32_t)env->regs[R_ECX] -
 
492
                             MSR_MTRRphysBase(0)) / 2].base;
484
493
        break;
485
494
    case MSR_MTRRphysMask(0):
486
495
    case MSR_MTRRphysMask(1):
490
499
    case MSR_MTRRphysMask(5):
491
500
    case MSR_MTRRphysMask(6):
492
501
    case MSR_MTRRphysMask(7):
493
 
        val = env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysMask(0)) / 2].mask;
 
502
        val = env->mtrr_var[((uint32_t)env->regs[R_ECX] -
 
503
                             MSR_MTRRphysMask(0)) / 2].mask;
494
504
        break;
495
505
    case MSR_MTRRfix64K_00000:
496
506
        val = env->mtrr_fixed[0];
497
507
        break;
498
508
    case MSR_MTRRfix16K_80000:
499
509
    case MSR_MTRRfix16K_A0000:
500
 
        val = env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix16K_80000 + 1];
 
510
        val = env->mtrr_fixed[(uint32_t)env->regs[R_ECX] -
 
511
                              MSR_MTRRfix16K_80000 + 1];
501
512
        break;
502
513
    case MSR_MTRRfix4K_C0000:
503
514
    case MSR_MTRRfix4K_C8000:
507
518
    case MSR_MTRRfix4K_E8000:
508
519
    case MSR_MTRRfix4K_F0000:
509
520
    case MSR_MTRRfix4K_F8000:
510
 
        val = env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix4K_C0000 + 3];
 
521
        val = env->mtrr_fixed[(uint32_t)env->regs[R_ECX] -
 
522
                              MSR_MTRRfix4K_C0000 + 3];
511
523
        break;
512
524
    case MSR_MTRRdefType:
513
525
        val = env->mtrr_deftype;
538
550
        val = env->msr_ia32_misc_enable;
539
551
        break;
540
552
    default:
541
 
        if ((uint32_t)ECX >= MSR_MC0_CTL
542
 
            && (uint32_t)ECX < MSR_MC0_CTL + (4 * env->mcg_cap & 0xff)) {
543
 
            uint32_t offset = (uint32_t)ECX - MSR_MC0_CTL;
 
553
        if ((uint32_t)env->regs[R_ECX] >= MSR_MC0_CTL
 
554
            && (uint32_t)env->regs[R_ECX] < MSR_MC0_CTL +
 
555
            (4 * env->mcg_cap & 0xff)) {
 
556
            uint32_t offset = (uint32_t)env->regs[R_ECX] - MSR_MC0_CTL;
544
557
            val = env->mce_banks[offset];
545
558
            break;
546
559
        }
548
561
        val = 0;
549
562
        break;
550
563
    }
551
 
    EAX = (uint32_t)(val);
552
 
    EDX = (uint32_t)(val >> 32);
 
564
    env->regs[R_EAX] = (uint32_t)(val);
 
565
    env->regs[R_EDX] = (uint32_t)(val >> 32);
553
566
}
554
567
#endif
555
568
 
569
582
    X86CPU *cpu = x86_env_get_cpu(env);
570
583
 
571
584
    cpu_svm_check_intercept_param(env, SVM_EXIT_HLT, 0);
572
 
    EIP += next_eip_addend;
 
585
    env->eip += next_eip_addend;
573
586
 
574
587
    do_hlt(cpu);
575
588
}
576
589
 
577
590
void helper_monitor(CPUX86State *env, target_ulong ptr)
578
591
{
579
 
    if ((uint32_t)ECX != 0) {
 
592
    if ((uint32_t)env->regs[R_ECX] != 0) {
580
593
        raise_exception(env, EXCP0D_GPF);
581
594
    }
582
595
    /* XXX: store address? */
588
601
    CPUState *cs;
589
602
    X86CPU *cpu;
590
603
 
591
 
    if ((uint32_t)ECX != 0) {
 
604
    if ((uint32_t)env->regs[R_ECX] != 0) {
592
605
        raise_exception(env, EXCP0D_GPF);
593
606
    }
594
607
    cpu_svm_check_intercept_param(env, SVM_EXIT_MWAIT, 0);
595
 
    EIP += next_eip_addend;
 
608
    env->eip += next_eip_addend;
596
609
 
597
610
    cpu = x86_env_get_cpu(env);
598
611
    cs = CPU(cpu);
599
612
    /* XXX: not complete but not completely erroneous */
600
 
    if (cs->cpu_index != 0 || env->next_cpu != NULL) {
 
613
    if (cs->cpu_index != 0 || cs->next_cpu != NULL) {
601
614
        /* more than one CPU: do not sleep because another CPU may
602
615
           wake this one */
603
616
    } else {