← Back to branch summary

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

« back to all changes in this revision

Viewing changes to target-i386/kvm.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/kvm.c
318
318
 
319
319
    if ((env->mcg_cap & MCG_SER_P) && addr
320
320
        && (code == BUS_MCEERR_AR || code == BUS_MCEERR_AO)) {
321
 
        if (qemu_ram_addr_from_host(addr, &ram_addr) ||
 
321
        if (qemu_ram_addr_from_host(addr, &ram_addr) == NULL ||
322
322
            !kvm_physical_memory_addr_from_host(c->kvm_state, addr, &paddr)) {
323
323
            fprintf(stderr, "Hardware memory error for memory used by "
324
324
                    "QEMU itself instead of guest system!\n");
345
345
 
346
346
int kvm_arch_on_sigbus(int code, void *addr)
347
347
{
348
 
    if ((first_cpu->mcg_cap & MCG_SER_P) && addr && code == BUS_MCEERR_AO) {
 
348
    X86CPU *cpu = X86_CPU(first_cpu);
 
349
 
 
350
    if ((cpu->env.mcg_cap & MCG_SER_P) && addr && code == BUS_MCEERR_AO) {
349
351
        ram_addr_t ram_addr;
350
352
        hwaddr paddr;
351
353
 
352
354
        /* Hope we are lucky for AO MCE */
353
 
        if (qemu_ram_addr_from_host(addr, &ram_addr) ||
354
 
            !kvm_physical_memory_addr_from_host(CPU(first_cpu)->kvm_state,
 
355
        if (qemu_ram_addr_from_host(addr, &ram_addr) == NULL ||
 
356
            !kvm_physical_memory_addr_from_host(first_cpu->kvm_state,
355
357
                                                addr, &paddr)) {
356
358
            fprintf(stderr, "Hardware memory error for memory used by "
357
359
                    "QEMU itself instead of guest system!: %p\n", addr);
358
360
            return 0;
359
361
        }
360
362
        kvm_hwpoison_page_add(ram_addr);
361
 
        kvm_mce_inject(x86_env_get_cpu(first_cpu), paddr, code);
 
363
        kvm_mce_inject(X86_CPU(first_cpu), paddr, code);
362
364
    } else {
363
365
        if (code == BUS_MCEERR_AO) {
364
366
            return 0;
741
743
 
742
744
int kvm_arch_init(KVMState *s)
743
745
{
744
 
    QemuOptsList *list = qemu_find_opts("machine");
745
746
    uint64_t identity_base = 0xfffbc000;
746
747
    uint64_t shadow_mem;
747
748
    int ret;
790
791
    }
791
792
    qemu_register_reset(kvm_unpoison_all, NULL);
792
793
 
793
 
    if (!QTAILQ_EMPTY(&list->head)) {
794
 
        shadow_mem = qemu_opt_get_size(QTAILQ_FIRST(&list->head),
795
 
                                       "kvm_shadow_mem", -1);
796
 
        if (shadow_mem != -1) {
797
 
            shadow_mem /= 4096;
798
 
            ret = kvm_vm_ioctl(s, KVM_SET_NR_MMU_PAGES, shadow_mem);
799
 
            if (ret < 0) {
800
 
                return ret;
801
 
            }
 
794
    shadow_mem = qemu_opt_get_size(qemu_get_machine_opts(),
 
795
                                   "kvm_shadow_mem", -1);
 
796
    if (shadow_mem != -1) {
 
797
        shadow_mem /= 4096;
 
798
        ret = kvm_vm_ioctl(s, KVM_SET_NR_MMU_PAGES, shadow_mem);
 
799
        if (ret < 0) {
 
800
            return ret;
802
801
        }
803
802
    }
804
803
    return 0;
1595
1594
 
1596
1595
static int kvm_guest_debug_workarounds(X86CPU *cpu)
1597
1596
{
 
1597
    CPUState *cs = CPU(cpu);
1598
1598
    CPUX86State *env = &cpu->env;
1599
1599
    int ret = 0;
1600
1600
    unsigned long reinject_trap = 0;
1617
1617
     * reinject them via SET_GUEST_DEBUG.
1618
1618
     */
1619
1619
    if (reinject_trap ||
1620
 
        (!kvm_has_robust_singlestep() && env->singlestep_enabled)) {
1621
 
        ret = kvm_update_guest_debug(env, reinject_trap);
 
1620
        (!kvm_has_robust_singlestep() && cs->singlestep_enabled)) {
 
1621
        ret = kvm_update_guest_debug(cs, reinject_trap);
1622
1622
    }
1623
1623
    return ret;
1624
1624
}
1857
1857
 
1858
1858
        cs->interrupt_request &= ~CPU_INTERRUPT_MCE;
1859
1859
 
1860
 
        kvm_cpu_synchronize_state(env);
 
1860
        kvm_cpu_synchronize_state(cs);
1861
1861
 
1862
1862
        if (env->exception_injected == EXCP08_DBLE) {
1863
1863
            /* this means triple fault */
1888
1888
        cs->halted = 0;
1889
1889
    }
1890
1890
    if (cs->interrupt_request & CPU_INTERRUPT_INIT) {
1891
 
        kvm_cpu_synchronize_state(env);
 
1891
        kvm_cpu_synchronize_state(cs);
1892
1892
        do_cpu_init(cpu);
1893
1893
    }
1894
1894
    if (cs->interrupt_request & CPU_INTERRUPT_SIPI) {
1895
 
        kvm_cpu_synchronize_state(env);
 
1895
        kvm_cpu_synchronize_state(cs);
1896
1896
        do_cpu_sipi(cpu);
1897
1897
    }
1898
1898
    if (cs->interrupt_request & CPU_INTERRUPT_TPR) {
1899
1899
        cs->interrupt_request &= ~CPU_INTERRUPT_TPR;
1900
 
        kvm_cpu_synchronize_state(env);
 
1900
        kvm_cpu_synchronize_state(cs);
1901
1901
        apic_handle_tpr_access_report(env->apic_state, env->eip,
1902
1902
                                      env->tpr_access_type);
1903
1903
    }
1932
1932
    return 1;
1933
1933
}
1934
1934
 
1935
 
int kvm_arch_insert_sw_breakpoint(CPUState *cpu, struct kvm_sw_breakpoint *bp)
 
1935
int kvm_arch_insert_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
1936
1936
{
1937
 
    CPUX86State *env = &X86_CPU(cpu)->env;
1938
1937
    static const uint8_t int3 = 0xcc;
1939
1938
 
1940
 
    if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 0) ||
1941
 
        cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&int3, 1, 1)) {
 
1939
    if (cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn, 1, 0) ||
 
1940
        cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&int3, 1, 1)) {
1942
1941
        return -EINVAL;
1943
1942
    }
1944
1943
    return 0;
1945
1944
}
1946
1945
 
1947
 
int kvm_arch_remove_sw_breakpoint(CPUState *cpu, struct kvm_sw_breakpoint *bp)
 
1946
int kvm_arch_remove_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
1948
1947
{
1949
 
    CPUX86State *env = &X86_CPU(cpu)->env;
1950
1948
    uint8_t int3;
1951
1949
 
1952
 
    if (cpu_memory_rw_debug(env, bp->pc, &int3, 1, 0) || int3 != 0xcc ||
1953
 
        cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) {
 
1950
    if (cpu_memory_rw_debug(cs, bp->pc, &int3, 1, 0) || int3 != 0xcc ||
 
1951
        cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) {
1954
1952
        return -EINVAL;
1955
1953
    }
1956
1954
    return 0;
2043
2041
static int kvm_handle_debug(X86CPU *cpu,
2044
2042
                            struct kvm_debug_exit_arch *arch_info)
2045
2043
{
 
2044
    CPUState *cs = CPU(cpu);
2046
2045
    CPUX86State *env = &cpu->env;
2047
2046
    int ret = 0;
2048
2047
    int n;
2049
2048
 
2050
2049
    if (arch_info->exception == 1) {
2051
2050
        if (arch_info->dr6 & (1 << 14)) {
2052
 
            if (env->singlestep_enabled) {
 
2051
            if (cs->singlestep_enabled) {
2053
2052
                ret = EXCP_DEBUG;
2054
2053
            }
2055
2054
        } else {
2079
2078
        ret = EXCP_DEBUG;
2080
2079
    }
2081
2080
    if (ret == 0) {
2082
 
        cpu_synchronize_state(env);
 
2081
        cpu_synchronize_state(CPU(cpu));
2083
2082
        assert(env->exception_injected == -1);
2084
2083
 
2085
2084
        /* pass to guest */
2184
2183
    X86CPU *cpu = X86_CPU(cs);
2185
2184
    CPUX86State *env = &cpu->env;
2186
2185
 
2187
 
    kvm_cpu_synchronize_state(env);
 
2186
    kvm_cpu_synchronize_state(cs);
2188
2187
    return !(env->cr[0] & CR0_PE_MASK) ||
2189
2188
           ((env->segs[R_CS].selector  & 3) != 3);
2190
2189
}