Commit ad584d37 authored by Peter Maydell's avatar Peter Maydell
Browse files

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



* GUEST_PANICKED improvements (Anton)
* vCont gdbstub rewrite (Claudio)
* Fix CPU creation with -device (Liyang)
* Logging fixes for pty chardevs (Ed)
* Makefile "move if changed" fix (Lin)
* First part of cpu_exec refactoring (me)
* SVM emulation fix (me)
* apic_delivered fix (Pavel)
* "info ioapic" fix (Peter)
* qemu-nbd socket activation (Richard)
* QOMification of mcf_uart (Thomas)

# gpg: Signature made Thu 16 Feb 2017 17:37:31 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: (23 commits)
  target-i386: correctly propagate retaddr into SVM helpers
  vl: log available guest crash information
  report guest crash information in GUEST_PANICKED event
  i386/cpu: add crash-information QOM property
  Makefile: avoid leaving the temporary QEMU_PKGVERSION header file
  vl: Move the cpu_synchronize_all_post_init() after generic devices initialization
  qemu-nbd: Implement socket activation.
  qemu-doc: Clarify that -vga std is now the default
  cpu-exec: remove outermost infinite loop
  cpu-exec: avoid repeated sigsetjmp on interrupts
  cpu-exec: avoid cpu_loop_exit in cpu_handle_interrupt
  cpu-exec: tighten barrier on TCG_EXIT_REQUESTED
  cpu-exec: fix icount out-of-bounds access
  hw/char/mcf_uart: QOMify the ColdFire UART
  gdbstub: Fix vCont behaviour
  move vm_start to cpus.c
  char: drop data written to a disconnected pty
  apic: reset apic_delivered global variable on machine reset
  qemu-char: socket backend: disconnect on write error
  test-vmstate: remove yield_until_fd_readable
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 7a37b59f 65c9d60a

Makefile

+5 −1
Original line number Diff line number Diff line
@@ -299,7 +299,11 @@ qemu-version.h: FORCE 
				printf '""\n'; \

			fi; \

		fi) > $@.tmp)

	$(call quiet-command, cmp -s $@ $@.tmp || mv $@.tmp $@)

	$(call quiet-command, if ! cmp -s $@ $@.tmp; then \

	  mv $@.tmp $@; \

	 else \

	  rm $@.tmp; \

	 fi)



config-host.h: config-host.h-timestamp

config-host.h-timestamp: config-host.mak

chardev/char-pty.c

+1 −1
Original line number Diff line number Diff line
@@ -129,7 +129,7 @@ static int char_pty_chr_write(Chardev *chr, const uint8_t *buf, int len) 
        /* guest sends data, check for (re-)connect */

        pty_chr_update_read_handler_locked(chr);

        if (!s->connected) {

            return 0;

            return len;

        }

    }

    return io_channel_send(s->ioc, buf, len);

chardev/char-socket.c

+10 −0
Original line number Diff line number Diff line
@@ -97,6 +97,9 @@ static gboolean tcp_chr_accept(QIOChannel *chan, 
                               GIOCondition cond,

                               void *opaque);



static int tcp_chr_read_poll(void *opaque);

static void tcp_chr_disconnect(Chardev *chr);



/* Called with chr_write_lock held.  */

static int tcp_chr_write(Chardev *chr, const uint8_t *buf, int len)

{
@@ -114,6 +117,13 @@ static int tcp_chr_write(Chardev *chr, const uint8_t *buf, int len) 
            s->write_msgfds_num = 0;

        }



        if (ret < 0 && errno != EAGAIN) {

            if (tcp_chr_read_poll(chr) <= 0) {

                tcp_chr_disconnect(chr);

                return len;

            } /* else let the read handler finish it properly */

        }



        return ret;

    } else {

        /* XXX: indicate an error ? */

cpu-exec.c

+42 −44
Original line number Diff line number Diff line
@@ -461,7 +461,7 @@ static inline bool cpu_handle_exception(CPUState *cpu, int *ret) 
    return false;

}



static inline void cpu_handle_interrupt(CPUState *cpu,

static inline bool cpu_handle_interrupt(CPUState *cpu,

                                        TranslationBlock **last_tb)

{

    CPUClass *cc = CPU_GET_CLASS(cpu);
@@ -475,7 +475,7 @@ static inline void cpu_handle_interrupt(CPUState *cpu, 
        if (interrupt_request & CPU_INTERRUPT_DEBUG) {

            cpu->interrupt_request &= ~CPU_INTERRUPT_DEBUG;

            cpu->exception_index = EXCP_DEBUG;

            cpu_loop_exit(cpu);

            return true;

        }

        if (replay_mode == REPLAY_MODE_PLAY && !replay_has_interrupt()) {

            /* Do nothing */
@@ -484,23 +484,23 @@ static inline void cpu_handle_interrupt(CPUState *cpu, 
            cpu->interrupt_request &= ~CPU_INTERRUPT_HALT;

            cpu->halted = 1;

            cpu->exception_index = EXCP_HLT;

            cpu_loop_exit(cpu);

            return true;

        }

#if defined(TARGET_I386)

        else if (interrupt_request & CPU_INTERRUPT_INIT) {

            X86CPU *x86_cpu = X86_CPU(cpu);

            CPUArchState *env = &x86_cpu->env;

            replay_interrupt();

            cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0);

            cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0, 0);

            do_cpu_init(x86_cpu);

            cpu->exception_index = EXCP_HALTED;

            cpu_loop_exit(cpu);

            return true;

        }

#else

        else if (interrupt_request & CPU_INTERRUPT_RESET) {

            replay_interrupt();

            cpu_reset(cpu);

            cpu_loop_exit(cpu);

            return true;

        }

#endif

        /* The target hook has 3 exit conditions:
@@ -526,8 +526,10 @@ static inline void cpu_handle_interrupt(CPUState *cpu, 
    if (unlikely(atomic_read(&cpu->exit_request) || replay_has_interrupt())) {

        atomic_set(&cpu->exit_request, 0);

        cpu->exception_index = EXCP_INTERRUPT;

        cpu_loop_exit(cpu);

        return true;

    }



    return false;

}



static inline void cpu_loop_exec_tb(CPUState *cpu, TranslationBlock *tb,
@@ -542,7 +544,7 @@ static inline void cpu_loop_exec_tb(CPUState *cpu, TranslationBlock *tb, 


    trace_exec_tb(tb, tb->pc);

    ret = cpu_tb_exec(cpu, tb);

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

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

    *tb_exit = ret & TB_EXIT_MASK;

    switch (*tb_exit) {

    case TB_EXIT_REQUESTED:
@@ -552,11 +554,11 @@ static inline void cpu_loop_exec_tb(CPUState *cpu, TranslationBlock *tb, 
         * 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 tcg_exit_req read in generated code

         * ensure the zeroing of tcg_exit_req (see cpu_tb_exec)

         * comes before the next read of cpu->exit_request

         * or cpu->interrupt_request.

         */

        smp_rmb();

        smp_mb();

        *last_tb = NULL;

        break;

    case TB_EXIT_ICOUNT_EXPIRED:
@@ -566,6 +568,7 @@ static inline void cpu_loop_exec_tb(CPUState *cpu, TranslationBlock *tb, 
        abort();

#else

        int insns_left = cpu->icount_decr.u32;

        *last_tb = NULL;

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

            /* Refill decrementer and continue execution.  */

            cpu->icount_extra += insns_left;
@@ -575,17 +578,17 @@ static inline void cpu_loop_exec_tb(CPUState *cpu, TranslationBlock *tb, 
        } else {

            if (insns_left > 0) {

                /* Execute remaining instructions.  */

                cpu_exec_nocache(cpu, insns_left, *last_tb, false);

                cpu_exec_nocache(cpu, insns_left, tb, false);

                align_clocks(sc, cpu);

            }

            cpu->exception_index = EXCP_INTERRUPT;

            *last_tb = NULL;

            cpu_loop_exit(cpu);

        }

        break;

#endif

    }

    default:

        *last_tb = tb;

        break;

    }

}
@@ -621,26 +624,8 @@ int cpu_exec(CPUState *cpu) 
     */

    init_delay_params(&sc, cpu);



    for(;;) {

    /* prepare setjmp context for exception handling */

        if (sigsetjmp(cpu->jmp_env, 0) == 0) {

            TranslationBlock *tb, *last_tb = NULL;

            int tb_exit = 0;



            /* if an exception is pending, we execute it here */

            if (cpu_handle_exception(cpu, &ret)) {

                break;

            }



            for(;;) {

                cpu_handle_interrupt(cpu, &last_tb);

                tb = tb_find(cpu, last_tb, tb_exit);

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

                /* Try to align the host and virtual clocks

                   if the guest is in advance */

                align_clocks(&sc, cpu);

            } /* for(;;) */

        } else {

    if (sigsetjmp(cpu->jmp_env, 0) != 0) {

#if defined(__clang__) || !QEMU_GNUC_PREREQ(4, 6)

        /* Some compilers wrongly smash all local variables after

         * siglongjmp. There were bug reports for gcc 4.5.0 and clang.
@@ -656,7 +641,20 @@ int cpu_exec(CPUState *cpu) 
        cpu->can_do_io = 1;

        tb_lock_reset();

    }

    } /* for(;;) */



    /* if an exception is pending, we execute it here */

    while (!cpu_handle_exception(cpu, &ret)) {

        TranslationBlock *last_tb = NULL;

        int tb_exit = 0;



        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);

            /* Try to align the host and virtual clocks

               if the guest is in advance */

            align_clocks(&sc, cpu);

        }

    }



    cc->cpu_exec_exit(cpu);

    rcu_read_unlock();

cpus.c

+42 −0
Original line number Diff line number Diff line
@@ -1578,6 +1578,48 @@ int vm_stop(RunState state) 
    return do_vm_stop(state);

}



/**

 * Prepare for (re)starting the VM.

 * Returns -1 if the vCPUs are not to be restarted (e.g. if they are already

 * running or in case of an error condition), 0 otherwise.

 */

int vm_prepare_start(void)

{

    RunState requested;

    int res = 0;



    qemu_vmstop_requested(&requested);

    if (runstate_is_running() && requested == RUN_STATE__MAX) {

        return -1;

    }



    /* Ensure that a STOP/RESUME pair of events is emitted if a

     * vmstop request was pending.  The BLOCK_IO_ERROR event, for

     * example, according to documentation is always followed by

     * the STOP event.

     */

    if (runstate_is_running()) {

        qapi_event_send_stop(&error_abort);

        res = -1;

    } else {

        replay_enable_events();

        cpu_enable_ticks();

        runstate_set(RUN_STATE_RUNNING);

        vm_state_notify(1, RUN_STATE_RUNNING);

    }



    /* We are sending this now, but the CPUs will be resumed shortly later */

    qapi_event_send_resume(&error_abort);

    return res;

}



void vm_start(void)

{

    if (!vm_prepare_start()) {

        resume_all_vcpus();

    }

}



/* does a state transition even if the VM is already stopped,

   current state is forgotten forever */

int vm_stop_force_state(RunState state)