Commit 5febe767 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream' into staging 



* kernel header update (requested by David and Vijay)
* GuestPanicInformation fixups (Anton)
* record/replay icount fixes (Pavel)
* cpu-exec cleanup, unification of icount_decr with tcg_exit_req (me)
* KVM_CAP_IMMEDIATE_EXIT support (me)
* vmxcap update (me)
* iscsi locking fix (me)
* VFIO ram device fix (Yongji)
* scsi-hd vs. default CD-ROM (Hervé)
* SMI migration fix (Dave)
* spice-char segfault (Li Qiang)
* improved "info mtree -f" (me)

# gpg: Signature made Fri 03 Mar 2017 15:43:04 GMT
# gpg:                using RSA key 0xBFFBD25F78C7AE83
# gpg: Good signature from "Paolo Bonzini <bonzini@gnu.org>"
# gpg:                 aka "Paolo Bonzini <pbonzini@redhat.com>"
# Primary key fingerprint: 46F5 9FBD 57D6 12E7 BFD4  E2F7 7E15 100C CD36 69B1
#      Subkey fingerprint: F133 3857 4B66 2389 866C  7682 BFFB D25F 78C7 AE83

* remotes/bonzini/tags/for-upstream: (21 commits)
  iscsi: fix missing unlock
  memory: show region offset and ROM/RAM type in "info mtree -f"
  x86: Work around SMI migration breakages
  spice-char: fix segfault in char_spice_finalize
  vl: disable default cdrom when using explicitely scsi-hd
  memory: Introduce DEVICE_HOST_ENDIAN for ram device
  qmp-events: fix GUEST_PANICKED description formatting
  qapi: flatten GuestPanicInformation union
  vmxcap: update for September 2016 SDM
  vmxcap: port to Python 3
  KVM: use KVM_CAP_IMMEDIATE_EXIT
  kvm: use atomic_read/atomic_set to access cpu->exit_request
  KVM: move SIG_IPI handling to kvm-all.c
  KVM: do not use sigtimedwait to catch SIGBUS
  KVM: remove kvm_arch_on_sigbus
  cpus: reorganize signal handling code
  KVM: x86: cleanup SIGBUS handlers
  cpus: remove ugly cast on sigbus_handler
  cpu-exec: remove unnecessary check of cpu->exit_request
  replay: check icount in cpu exec loop
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 5b10b94b f6eb0b31

block/iscsi.c

+4 −0
Original line number Diff line number Diff line
@@ -637,6 +637,7 @@ retry: 
    }

#endif

    if (iTask.task == NULL) {

        qemu_mutex_unlock(&iscsilun->mutex);

        return -ENOMEM;

    }

#if LIBISCSI_API_VERSION < (20160603)
@@ -864,6 +865,7 @@ retry: 
    }

#endif

    if (iTask.task == NULL) {

        qemu_mutex_unlock(&iscsilun->mutex);

        return -ENOMEM;

    }

#if LIBISCSI_API_VERSION < (20160603)
@@ -904,6 +906,7 @@ static int coroutine_fn iscsi_co_flush(BlockDriverState *bs) 
retry:

    if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0,

                                      0, iscsi_co_generic_cb, &iTask) == NULL) {

        qemu_mutex_unlock(&iscsilun->mutex);

        return -ENOMEM;

    }
@@ -1237,6 +1240,7 @@ retry: 
                                            0, 0, iscsi_co_generic_cb, &iTask);

    }

    if (iTask.task == NULL) {

        qemu_mutex_unlock(&iscsilun->mutex);

        return -ENOMEM;

    }

cpu-exec.c

+40 −53
Original line number Diff line number Diff line
@@ -186,12 +186,6 @@ static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, TranslationBlock *itb) 
            cc->set_pc(cpu, last_tb->pc);

        }

    }

    if (tb_exit == TB_EXIT_REQUESTED) {

        /* We were asked to stop executing TBs (probably a pending

         * interrupt. We've now stopped, so clear the flag.

         */

        atomic_set(&cpu->tcg_exit_req, 0);

    }

    return ret;

}
@@ -560,8 +554,9 @@ static inline bool cpu_handle_interrupt(CPUState *cpu, 
        qemu_mutex_unlock_iothread();

    }





    if (unlikely(atomic_read(&cpu->exit_request) || replay_has_interrupt())) {

    /* Finally, check if we need to exit to the main loop.  */

    if (unlikely(atomic_read(&cpu->exit_request)

        || (use_icount && cpu->icount_decr.u16.low + cpu->icount_extra == 0))) {

        atomic_set(&cpu->exit_request, 0);

        cpu->exception_index = EXCP_INTERRUPT;

        return true;
@@ -571,63 +566,55 @@ static inline bool cpu_handle_interrupt(CPUState *cpu, 
}



static inline void cpu_loop_exec_tb(CPUState *cpu, TranslationBlock *tb,

                                    TranslationBlock **last_tb, int *tb_exit,

                                    SyncClocks *sc)

                                    TranslationBlock **last_tb, int *tb_exit)

{

    uintptr_t ret;



    if (unlikely(atomic_read(&cpu->exit_request))) {

        return;

    }

    int32_t insns_left;



    trace_exec_tb(tb, tb->pc);

    ret = cpu_tb_exec(cpu, tb);

    tb = (TranslationBlock *)(ret & ~TB_EXIT_MASK);

    *tb_exit = ret & TB_EXIT_MASK;

    switch (*tb_exit) {

    case TB_EXIT_REQUESTED:

    if (*tb_exit != TB_EXIT_REQUESTED) {

        *last_tb = tb;

        return;

    }



    *last_tb = NULL;

    insns_left = atomic_read(&cpu->icount_decr.u32);

    atomic_set(&cpu->icount_decr.u16.high, 0);

    if (insns_left < 0) {

        /* Something asked us to stop executing chained TBs; just

         * continue round the main loop. Whatever requested the exit

         * will also have set something else (eg interrupt_request)

         * which we will handle next time around the loop.  But we

         * need to ensure the tcg_exit_req read in generated code

         * comes before the next read of cpu->exit_request or

         * cpu->interrupt_request.

         * will also have set something else (eg exit_request or

         * interrupt_request) which we will handle next time around

         * the loop.  But we need to ensure the zeroing of icount_decr

         * comes before the next read of cpu->exit_request

         * or cpu->interrupt_request.

         */

        smp_mb();

        *last_tb = NULL;

        break;

    case TB_EXIT_ICOUNT_EXPIRED:

    {

        return;

    }



    /* Instruction counter expired.  */

#ifdef CONFIG_USER_ONLY

        abort();

#else

        int insns_left = cpu->icount_decr.u32;

        *last_tb = NULL;

        if (cpu->icount_extra && insns_left >= 0) {

    assert(use_icount);

#ifndef CONFIG_USER_ONLY

    if (cpu->icount_extra) {

        /* Refill decrementer and continue execution.  */

        cpu->icount_extra += insns_left;

        insns_left = MIN(0xffff, cpu->icount_extra);

        cpu->icount_extra -= insns_left;

        cpu->icount_decr.u16.low = insns_left;

    } else {

        /* Execute any remaining instructions, then let the main loop

         * handle the next event.

         */

        if (insns_left > 0) {

                /* Execute remaining instructions.  */

            cpu_exec_nocache(cpu, insns_left, tb, false);

                align_clocks(sc, cpu);

        }

            cpu->exception_index = EXCP_INTERRUPT;

            cpu_loop_exit(cpu);

    }

        break;

#endif

}

    default:

        *last_tb = tb;

        break;

    }

}



/* main execution loop */
@@ -635,7 +622,7 @@ int cpu_exec(CPUState *cpu) 
{

    CPUClass *cc = CPU_GET_CLASS(cpu);

    int ret;

    SyncClocks sc;

    SyncClocks sc = { 0 };



    /* replay_interrupt may need current_cpu */

    current_cpu = cpu;
@@ -683,7 +670,7 @@ int cpu_exec(CPUState *cpu) 


        while (!cpu_handle_interrupt(cpu, &last_tb)) {

            TranslationBlock *tb = tb_find(cpu, last_tb, tb_exit);

            cpu_loop_exec_tb(cpu, tb, &last_tb, &tb_exit, &sc);

            cpu_loop_exec_tb(cpu, tb, &last_tb, &tb_exit);

            /* Try to align the host and virtual clocks

               if the guest is in advance */

            align_clocks(&sc, cpu);

cpus.c

+16 −86
Original line number Diff line number Diff line
@@ -51,10 +51,6 @@ 
#include "hw/nmi.h"

#include "sysemu/replay.h"



#ifndef _WIN32

#include "qemu/compatfd.h"

#endif



#ifdef CONFIG_LINUX



#include <sys/prctl.h>
@@ -924,13 +920,23 @@ static void sigbus_reraise(void) 
    abort();

}



static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,

                           void *ctx)

static void sigbus_handler(int n, siginfo_t *siginfo, void *ctx)

{

    if (kvm_on_sigbus(siginfo->ssi_code,

                      (void *)(intptr_t)siginfo->ssi_addr)) {

    if (siginfo->si_code != BUS_MCEERR_AO && siginfo->si_code != BUS_MCEERR_AR) {

        sigbus_reraise();

    }



    if (current_cpu) {

        /* Called asynchronously in VCPU thread.  */

        if (kvm_on_sigbus_vcpu(current_cpu, siginfo->si_code, siginfo->si_addr)) {

            sigbus_reraise();

        }

    } else {

        /* Called synchronously (via signalfd) in main thread.  */

        if (kvm_on_sigbus(siginfo->si_code, siginfo->si_addr)) {

            sigbus_reraise();

        }

    }

}



static void qemu_init_sigbus(void)
@@ -939,92 +945,17 @@ static void qemu_init_sigbus(void) 


    memset(&action, 0, sizeof(action));

    action.sa_flags = SA_SIGINFO;

    action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;

    action.sa_sigaction = sigbus_handler;

    sigaction(SIGBUS, &action, NULL);



    prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);

}



static void qemu_kvm_eat_signals(CPUState *cpu)

{

    struct timespec ts = { 0, 0 };

    siginfo_t siginfo;

    sigset_t waitset;

    sigset_t chkset;

    int r;



    sigemptyset(&waitset);

    sigaddset(&waitset, SIG_IPI);

    sigaddset(&waitset, SIGBUS);



    do {

        r = sigtimedwait(&waitset, &siginfo, &ts);

        if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {

            perror("sigtimedwait");

            exit(1);

        }



        switch (r) {

        case SIGBUS:

            if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {

                sigbus_reraise();

            }

            break;

        default:

            break;

        }



        r = sigpending(&chkset);

        if (r == -1) {

            perror("sigpending");

            exit(1);

        }

    } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));

}



#else /* !CONFIG_LINUX */



static void qemu_init_sigbus(void)

{

}



static void qemu_kvm_eat_signals(CPUState *cpu)

{

}

#endif /* !CONFIG_LINUX */



#ifndef _WIN32

static void dummy_signal(int sig)

{

}



static void qemu_kvm_init_cpu_signals(CPUState *cpu)

{

    int r;

    sigset_t set;

    struct sigaction sigact;



    memset(&sigact, 0, sizeof(sigact));

    sigact.sa_handler = dummy_signal;

    sigaction(SIG_IPI, &sigact, NULL);



    pthread_sigmask(SIG_BLOCK, NULL, &set);

    sigdelset(&set, SIG_IPI);

    sigdelset(&set, SIGBUS);

    r = kvm_set_signal_mask(cpu, &set);

    if (r) {

        fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));

        exit(1);

    }

}



#else /* _WIN32 */

static void qemu_kvm_init_cpu_signals(CPUState *cpu)

{

    abort();

}

#endif /* _WIN32 */



static QemuMutex qemu_global_mutex;



static QemuThread io_thread;
@@ -1099,7 +1030,6 @@ static void qemu_kvm_wait_io_event(CPUState *cpu) 
        qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);

    }



    qemu_kvm_eat_signals(cpu);

    qemu_wait_io_event_common(cpu);

}
@@ -1122,7 +1052,7 @@ static void *qemu_kvm_cpu_thread_fn(void *arg) 
        exit(1);

    }



    qemu_kvm_init_cpu_signals(cpu);

    kvm_init_cpu_signals(cpu);



    /* signal CPU creation */

    cpu->created = true;

include/exec/cpu-common.h

+6 −0
Original line number Diff line number Diff line
@@ -36,6 +36,12 @@ enum device_endian { 
    DEVICE_LITTLE_ENDIAN,

};



#if defined(HOST_WORDS_BIGENDIAN)

#define DEVICE_HOST_ENDIAN DEVICE_BIG_ENDIAN

#else

#define DEVICE_HOST_ENDIAN DEVICE_LITTLE_ENDIAN

#endif



/* address in the RAM (different from a physical address) */

#if defined(CONFIG_XEN_BACKEND)

typedef uint64_t ram_addr_t;

include/exec/gen-icount.h

+25 −28
Original line number Diff line number Diff line
@@ -6,29 +6,23 @@ 
/* Helpers for instruction counting code generation.  */



static int icount_start_insn_idx;

static TCGLabel *icount_label;

static TCGLabel *exitreq_label;



static inline void gen_tb_start(TranslationBlock *tb)

{

    TCGv_i32 count, flag, imm;

    TCGv_i32 count, imm;



    exitreq_label = gen_new_label();

    flag = tcg_temp_new_i32();

    tcg_gen_ld_i32(flag, cpu_env,

                   offsetof(CPUState, tcg_exit_req) - ENV_OFFSET);

    tcg_gen_brcondi_i32(TCG_COND_NE, flag, 0, exitreq_label);

    tcg_temp_free_i32(flag);



    if (!(tb->cflags & CF_USE_ICOUNT)) {

        return;

    if (tb->cflags & CF_USE_ICOUNT) {

        count = tcg_temp_local_new_i32();

    } else {

        count = tcg_temp_new_i32();

    }



    icount_label = gen_new_label();

    count = tcg_temp_local_new_i32();

    tcg_gen_ld_i32(count, cpu_env,

                   -ENV_OFFSET + offsetof(CPUState, icount_decr.u32));



    if (tb->cflags & CF_USE_ICOUNT) {

        imm = tcg_temp_new_i32();

        /* We emit a movi with a dummy immediate argument. Keep the insn index

         * of the movi so that we later (when we know the actual insn count)
@@ -38,26 +32,29 @@ static inline void gen_tb_start(TranslationBlock *tb) 


        tcg_gen_sub_i32(count, count, imm);

        tcg_temp_free_i32(imm);

    }



    tcg_gen_brcondi_i32(TCG_COND_LT, count, 0, exitreq_label);



    tcg_gen_brcondi_i32(TCG_COND_LT, count, 0, icount_label);

    if (tb->cflags & CF_USE_ICOUNT) {

        tcg_gen_st16_i32(count, cpu_env,

                         -ENV_OFFSET + offsetof(CPUState, icount_decr.u16.low));

    }



    tcg_temp_free_i32(count);

}



static void gen_tb_end(TranslationBlock *tb, int num_insns)

{

    gen_set_label(exitreq_label);

    tcg_gen_exit_tb((uintptr_t)tb + TB_EXIT_REQUESTED);



    if (tb->cflags & CF_USE_ICOUNT) {

        /* Update the num_insn immediate parameter now that we know

         * the actual insn count.  */

        tcg_set_insn_param(icount_start_insn_idx, 1, num_insns);

        gen_set_label(icount_label);

        tcg_gen_exit_tb((uintptr_t)tb + TB_EXIT_ICOUNT_EXPIRED);

    }



    gen_set_label(exitreq_label);

    tcg_gen_exit_tb((uintptr_t)tb + TB_EXIT_REQUESTED);



    /* Terminate the linked list.  */

    tcg_ctx.gen_op_buf[tcg_ctx.gen_op_buf[0].prev].next = 0;

}