Merge remote-tracking branch 'remotes/armbru/tags/pull-include-2016-07-12' into staging

[qemu.git] / cpus.c

diff --git a/cpus.c b/cpus.c
index 725a51dac948a0b87890da9e77d8a778644d8cb2..84c3520d446f53a57a57c5732bbb9dcc230070bf 100644 (file)
--- a/cpus.c
+++ b/cpus.c
@@ -23,16 +23,19 @@
  */
 
 /* Needed early for CONFIG_BSD etc. */
  */
 
 /* Needed early for CONFIG_BSD etc. */

-#include "config-host.h"
-
+#include "qemu/osdep.h"
+#include "qemu-common.h"
+#include "cpu.h"

 #include "monitor/monitor.h"
 #include "qapi/qmp/qerror.h"
 #include "qemu/error-report.h"
 #include "sysemu/sysemu.h"
 #include "monitor/monitor.h"
 #include "qapi/qmp/qerror.h"
 #include "qemu/error-report.h"
 #include "sysemu/sysemu.h"

+#include "sysemu/block-backend.h"

 #include "exec/gdbstub.h"
 #include "sysemu/dma.h"
 #include "sysemu/kvm.h"
 #include "qmp-commands.h"
 #include "exec/gdbstub.h"
 #include "sysemu/dma.h"
 #include "sysemu/kvm.h"
 #include "qmp-commands.h"

+#include "exec/exec-all.h"

 
 #include "qemu/thread.h"
 #include "sysemu/cpus.h"
 
 #include "qemu/thread.h"
 #include "sysemu/cpus.h"


@@ -246,13 +249,13 @@ int64_t cpu_get_clock(void)
 void cpu_enable_ticks(void)
 {
     /* Here, the really thing protected by seqlock is cpu_clock_offset. */
 void cpu_enable_ticks(void)
 {
     /* Here, the really thing protected by seqlock is cpu_clock_offset. */

-    seqlock_write_lock(&timers_state.vm_clock_seqlock);
+    seqlock_write_begin(&timers_state.vm_clock_seqlock);

     if (!timers_state.cpu_ticks_enabled) {
         timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
         timers_state.cpu_clock_offset -= get_clock();
         timers_state.cpu_ticks_enabled = 1;
     }
     if (!timers_state.cpu_ticks_enabled) {
         timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
         timers_state.cpu_clock_offset -= get_clock();
         timers_state.cpu_ticks_enabled = 1;
     }

-    seqlock_write_unlock(&timers_state.vm_clock_seqlock);
+    seqlock_write_end(&timers_state.vm_clock_seqlock);

 }
 
 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 }
 
 /* disable cpu_get_ticks() : the clock is stopped. You must not call


@@ -262,20 +265,20 @@ void cpu_enable_ticks(void)
 void cpu_disable_ticks(void)
 {
     /* Here, the really thing protected by seqlock is cpu_clock_offset. */
 void cpu_disable_ticks(void)
 {
     /* Here, the really thing protected by seqlock is cpu_clock_offset. */

-    seqlock_write_lock(&timers_state.vm_clock_seqlock);
+    seqlock_write_begin(&timers_state.vm_clock_seqlock);

     if (timers_state.cpu_ticks_enabled) {
         timers_state.cpu_ticks_offset += cpu_get_host_ticks();
         timers_state.cpu_clock_offset = cpu_get_clock_locked();
         timers_state.cpu_ticks_enabled = 0;
     }
     if (timers_state.cpu_ticks_enabled) {
         timers_state.cpu_ticks_offset += cpu_get_host_ticks();
         timers_state.cpu_clock_offset = cpu_get_clock_locked();
         timers_state.cpu_ticks_enabled = 0;
     }

-    seqlock_write_unlock(&timers_state.vm_clock_seqlock);
+    seqlock_write_end(&timers_state.vm_clock_seqlock);

 }
 
 /* Correlation between real and virtual time is always going to be
    fairly approximate, so ignore small variation.
    When the guest is idle real and virtual time will be aligned in
    the IO wait loop.  */
 }
 
 /* Correlation between real and virtual time is always going to be
    fairly approximate, so ignore small variation.
    When the guest is idle real and virtual time will be aligned in
    the IO wait loop.  */

-#define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
+#define ICOUNT_WOBBLE (NANOSECONDS_PER_SECOND / 10)

 
 static void icount_adjust(void)
 {
 
 static void icount_adjust(void)
 {


@@ -291,7 +294,7 @@ static void icount_adjust(void)
         return;
     }
 
         return;
     }
 

-    seqlock_write_lock(&timers_state.vm_clock_seqlock);
+    seqlock_write_begin(&timers_state.vm_clock_seqlock);

     cur_time = cpu_get_clock_locked();
     cur_icount = cpu_get_icount_locked();
 
     cur_time = cpu_get_clock_locked();
     cur_icount = cpu_get_icount_locked();
 


@@ -312,7 +315,7 @@ static void icount_adjust(void)
     last_delta = delta;
     timers_state.qemu_icount_bias = cur_icount
                               - (timers_state.qemu_icount << icount_time_shift);
     last_delta = delta;
     timers_state.qemu_icount_bias = cur_icount
                               - (timers_state.qemu_icount << icount_time_shift);

-    seqlock_write_unlock(&timers_state.vm_clock_seqlock);
+    seqlock_write_end(&timers_state.vm_clock_seqlock);

 }
 
 static void icount_adjust_rt(void *opaque)
 }
 
 static void icount_adjust_rt(void *opaque)


@@ -326,7 +329,7 @@ static void icount_adjust_vm(void *opaque)
 {
     timer_mod(icount_vm_timer,
                    qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
 {
     timer_mod(icount_vm_timer,
                    qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +

-                   get_ticks_per_sec() / 10);
+                   NANOSECONDS_PER_SECOND / 10);

     icount_adjust();
 }
 
     icount_adjust();
 }
 


@@ -337,14 +340,22 @@ static int64_t qemu_icount_round(int64_t count)
 
 static void icount_warp_rt(void)
 {
 
 static void icount_warp_rt(void)
 {

+    unsigned seq;
+    int64_t warp_start;
+

     /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
      * changes from -1 to another value, so the race here is okay.
      */
     /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
      * changes from -1 to another value, so the race here is okay.
      */

-    if (atomic_read(&vm_clock_warp_start) == -1) {
+    do {
+        seq = seqlock_read_begin(&timers_state.vm_clock_seqlock);
+        warp_start = vm_clock_warp_start;
+    } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, seq));
+
+    if (warp_start == -1) {

         return;
     }
 
         return;
     }
 

-    seqlock_write_lock(&timers_state.vm_clock_seqlock);
+    seqlock_write_begin(&timers_state.vm_clock_seqlock);

     if (runstate_is_running()) {
         int64_t clock = REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT,
                                      cpu_get_clock_locked());
     if (runstate_is_running()) {
         int64_t clock = REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT,
                                      cpu_get_clock_locked());


@@ -363,16 +374,19 @@ static void icount_warp_rt(void)
         timers_state.qemu_icount_bias += warp_delta;
     }
     vm_clock_warp_start = -1;
         timers_state.qemu_icount_bias += warp_delta;
     }
     vm_clock_warp_start = -1;

-    seqlock_write_unlock(&timers_state.vm_clock_seqlock);
+    seqlock_write_end(&timers_state.vm_clock_seqlock);

 
     if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
         qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
     }
 }
 
 
     if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
         qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
     }
 }
 

-static void icount_dummy_timer(void *opaque)
+static void icount_timer_cb(void *opaque)

 {
 {

-    (void)opaque;
+    /* No need for a checkpoint because the timer already synchronizes
+     * with CHECKPOINT_CLOCK_VIRTUAL_RT.
+     */
+    icount_warp_rt();

 }
 
 void qtest_clock_warp(int64_t dest)
 }
 
 void qtest_clock_warp(int64_t dest)


@@ -385,9 +399,9 @@ void qtest_clock_warp(int64_t dest)
         int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
         int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
 
         int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
         int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
 

-        seqlock_write_lock(&timers_state.vm_clock_seqlock);
+        seqlock_write_begin(&timers_state.vm_clock_seqlock);

         timers_state.qemu_icount_bias += warp;
         timers_state.qemu_icount_bias += warp;

-        seqlock_write_unlock(&timers_state.vm_clock_seqlock);
+        seqlock_write_end(&timers_state.vm_clock_seqlock);

 
         qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
         timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
 
         qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
         timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);


@@ -396,17 +410,12 @@ void qtest_clock_warp(int64_t dest)
     qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
 }
 
     qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
 }
 

-void qemu_clock_warp(QEMUClockType type)
+void qemu_start_warp_timer(void)

 {
     int64_t clock;
     int64_t deadline;
 
 {
     int64_t clock;
     int64_t deadline;
 

-    /*
-     * There are too many global variables to make the "warp" behavior
-     * applicable to other clocks.  But a clock argument removes the
-     * need for if statements all over the place.
-     */
-    if (type != QEMU_CLOCK_VIRTUAL || !use_icount) {
+    if (!use_icount) {

         return;
     }
 
         return;
     }
 


@@ -418,29 +427,17 @@ void qemu_clock_warp(QEMUClockType type)
     }
 
     /* warp clock deterministically in record/replay mode */
     }
 
     /* warp clock deterministically in record/replay mode */

-    if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP)) {
+    if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_START)) {

         return;
     }
 
         return;
     }
 

-    if (icount_sleep) {
-        /*
-         * If the CPUs have been sleeping, advance QEMU_CLOCK_VIRTUAL timer now.
-         * This ensures that the deadline for the timer is computed correctly
-         * below.
-         * This also makes sure that the insn counter is synchronized before
-         * the CPU starts running, in case the CPU is woken by an event other
-         * than the earliest QEMU_CLOCK_VIRTUAL timer.
-         */
-        icount_warp_rt();
-        timer_del(icount_warp_timer);
-    }

     if (!all_cpu_threads_idle()) {
         return;
     }
 
     if (qtest_enabled()) {
         /* When testing, qtest commands advance icount.  */
     if (!all_cpu_threads_idle()) {
         return;
     }
 
     if (qtest_enabled()) {
         /* When testing, qtest commands advance icount.  */

-       return;
+        return;

     }
 
     /* We want to use the earliest deadline from ALL vm_clocks */
     }
 
     /* We want to use the earliest deadline from ALL vm_clocks */


@@ -471,9 +468,9 @@ void qemu_clock_warp(QEMUClockType type)
              * It is useful when we want a deterministic execution time,
              * isolated from host latencies.
              */
              * It is useful when we want a deterministic execution time,
              * isolated from host latencies.
              */

-            seqlock_write_lock(&timers_state.vm_clock_seqlock);
+            seqlock_write_begin(&timers_state.vm_clock_seqlock);

             timers_state.qemu_icount_bias += deadline;
             timers_state.qemu_icount_bias += deadline;

-            seqlock_write_unlock(&timers_state.vm_clock_seqlock);
+            seqlock_write_end(&timers_state.vm_clock_seqlock);

             qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
         } else {
             /*
             qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
         } else {
             /*


@@ -484,11 +481,11 @@ void qemu_clock_warp(QEMUClockType type)
              * you will not be sending network packets continuously instead of
              * every 100ms.
              */
              * you will not be sending network packets continuously instead of
              * every 100ms.
              */

-            seqlock_write_lock(&timers_state.vm_clock_seqlock);
+            seqlock_write_begin(&timers_state.vm_clock_seqlock);

             if (vm_clock_warp_start == -1 || vm_clock_warp_start > clock) {
                 vm_clock_warp_start = clock;
             }
             if (vm_clock_warp_start == -1 || vm_clock_warp_start > clock) {
                 vm_clock_warp_start = clock;
             }

-            seqlock_write_unlock(&timers_state.vm_clock_seqlock);
+            seqlock_write_end(&timers_state.vm_clock_seqlock);

             timer_mod_anticipate(icount_warp_timer, clock + deadline);
         }
     } else if (deadline == 0) {
             timer_mod_anticipate(icount_warp_timer, clock + deadline);
         }
     } else if (deadline == 0) {


@@ -496,6 +493,28 @@ void qemu_clock_warp(QEMUClockType type)
     }
 }
 
     }
 }
 

+static void qemu_account_warp_timer(void)
+{
+    if (!use_icount || !icount_sleep) {
+        return;
+    }
+
+    /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
+     * do not fire, so computing the deadline does not make sense.
+     */
+    if (!runstate_is_running()) {
+        return;
+    }
+
+    /* warp clock deterministically in record/replay mode */
+    if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_ACCOUNT)) {
+        return;
+    }
+
+    timer_del(icount_warp_timer);
+    icount_warp_rt();
+}
+

 static bool icount_state_needed(void *opaque)
 {
     return use_icount;
 static bool icount_state_needed(void *opaque)
 {
     return use_icount;


@@ -602,7 +621,7 @@ int cpu_throttle_get_percentage(void)
 
 void cpu_ticks_init(void)
 {
 
 void cpu_ticks_init(void)
 {

-    seqlock_init(&timers_state.vm_clock_seqlock, NULL);
+    seqlock_init(&timers_state.vm_clock_seqlock);

     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
     throttle_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
                                            cpu_throttle_timer_tick, NULL);
     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
     throttle_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
                                            cpu_throttle_timer_tick, NULL);


@@ -624,13 +643,13 @@ void configure_icount(QemuOpts *opts, Error **errp)
     icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
     if (icount_sleep) {
         icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
     icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
     if (icount_sleep) {
         icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,

-                                         icount_dummy_timer, NULL);
+                                         icount_timer_cb, NULL);

     }
 
     icount_align_option = qemu_opt_get_bool(opts, "align", false);
 
     if (icount_align_option && !icount_sleep) {
     }
 
     icount_align_option = qemu_opt_get_bool(opts, "align", false);
 
     if (icount_align_option && !icount_sleep) {

-        error_setg(errp, "align=on and sleep=no are incompatible");
+        error_setg(errp, "align=on and sleep=off are incompatible");

     }
     if (strcmp(option, "auto") != 0) {
         errno = 0;
     }
     if (strcmp(option, "auto") != 0) {
         errno = 0;


@@ -643,7 +662,7 @@ void configure_icount(QemuOpts *opts, Error **errp)
     } else if (icount_align_option) {
         error_setg(errp, "shift=auto and align=on are incompatible");
     } else if (!icount_sleep) {
     } else if (icount_align_option) {
         error_setg(errp, "shift=auto and align=on are incompatible");
     } else if (!icount_sleep) {

-        error_setg(errp, "shift=auto and sleep=no are incompatible");
+        error_setg(errp, "shift=auto and sleep=off are incompatible");

     }
 
     use_icount = 2;
     }
 
     use_icount = 2;


@@ -665,7 +684,7 @@ void configure_icount(QemuOpts *opts, Error **errp)
                                         icount_adjust_vm, NULL);
     timer_mod(icount_vm_timer,
                    qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
                                         icount_adjust_vm, NULL);
     timer_mod(icount_vm_timer,
                    qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +

-                   get_ticks_per_sec() / 10);
+                   NANOSECONDS_PER_SECOND / 10);

 }
 
 /***********************************************************/
 }
 
 /***********************************************************/


@@ -726,7 +745,7 @@ static int do_vm_stop(RunState state)
     }
 
     bdrv_drain_all();
     }
 
     bdrv_drain_all();

-    ret = bdrv_flush_all();
+    ret = blk_flush_all();

 
     return ret;
 }
 
     return ret;
 }


@@ -761,7 +780,7 @@ static void sigbus_reraise(void)
         raise(SIGBUS);
         sigemptyset(&set);
         sigaddset(&set, SIGBUS);
         raise(SIGBUS);
         sigemptyset(&set);
         sigaddset(&set, SIGBUS);

-        sigprocmask(SIG_UNBLOCK, &set, NULL);
+        pthread_sigmask(SIG_UNBLOCK, &set, NULL);

     }
     perror("Failed to re-raise SIGBUS!\n");
     abort();
     }
     perror("Failed to re-raise SIGBUS!\n");
     abort();


@@ -953,6 +972,18 @@ void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
     qemu_cpu_kick(cpu);
 }
 
     qemu_cpu_kick(cpu);
 }
 

+static void qemu_kvm_destroy_vcpu(CPUState *cpu)
+{
+    if (kvm_destroy_vcpu(cpu) < 0) {
+        error_report("kvm_destroy_vcpu failed");
+        exit(EXIT_FAILURE);
+    }
+}
+
+static void qemu_tcg_destroy_vcpu(CPUState *cpu)
+{
+}
+

 static void flush_queued_work(CPUState *cpu)
 {
     struct qemu_work_item *wi;
 static void flush_queued_work(CPUState *cpu)
 {
     struct qemu_work_item *wi;


@@ -986,7 +1017,7 @@ static void qemu_wait_io_event_common(CPUState *cpu)
     if (cpu->stop) {
         cpu->stop = false;
         cpu->stopped = true;
     if (cpu->stop) {
         cpu->stop = false;
         cpu->stopped = true;

-        qemu_cond_signal(&qemu_pause_cond);
+        qemu_cond_broadcast(&qemu_pause_cond);

     }
     flush_queued_work(cpu);
     cpu->thread_kicked = false;
     }
     flush_queued_work(cpu);
     cpu->thread_kicked = false;


@@ -995,9 +1026,6 @@ static void qemu_wait_io_event_common(CPUState *cpu)
 static void qemu_tcg_wait_io_event(CPUState *cpu)
 {
     while (all_cpu_threads_idle()) {
 static void qemu_tcg_wait_io_event(CPUState *cpu)
 {
     while (all_cpu_threads_idle()) {

-       /* Start accounting real time to the virtual clock if the CPUs
-          are idle.  */
-        qemu_clock_warp(QEMU_CLOCK_VIRTUAL);

         qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
     }
 
         qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
     }
 


@@ -1045,7 +1073,7 @@ static void *qemu_kvm_cpu_thread_fn(void *arg)
     cpu->created = true;
     qemu_cond_signal(&qemu_cpu_cond);
 
     cpu->created = true;
     qemu_cond_signal(&qemu_cpu_cond);
 

-    while (1) {
+    do {

         if (cpu_can_run(cpu)) {
             r = kvm_cpu_exec(cpu);
             if (r == EXCP_DEBUG) {
         if (cpu_can_run(cpu)) {
             r = kvm_cpu_exec(cpu);
             if (r == EXCP_DEBUG) {


@@ -1053,8 +1081,12 @@ static void *qemu_kvm_cpu_thread_fn(void *arg)
             }
         }
         qemu_kvm_wait_io_event(cpu);
             }
         }
         qemu_kvm_wait_io_event(cpu);

-    }
+    } while (!cpu->unplug || cpu_can_run(cpu));

 
 

+    qemu_kvm_destroy_vcpu(cpu);
+    cpu->created = false;
+    qemu_cond_signal(&qemu_cpu_cond);
+    qemu_mutex_unlock_iothread();

     return NULL;
 }
 
     return NULL;
 }
 


@@ -1108,6 +1140,7 @@ static void tcg_exec_all(void);
 static void *qemu_tcg_cpu_thread_fn(void *arg)
 {
     CPUState *cpu = arg;
 static void *qemu_tcg_cpu_thread_fn(void *arg)
 {
     CPUState *cpu = arg;

+    CPUState *remove_cpu = NULL;

 
     rcu_register_thread();
 
 
     rcu_register_thread();
 


@@ -1145,6 +1178,18 @@ static void *qemu_tcg_cpu_thread_fn(void *arg)
             }
         }
         qemu_tcg_wait_io_event(QTAILQ_FIRST(&cpus));
             }
         }
         qemu_tcg_wait_io_event(QTAILQ_FIRST(&cpus));

+        CPU_FOREACH(cpu) {
+            if (cpu->unplug && !cpu_can_run(cpu)) {
+                remove_cpu = cpu;
+                break;
+            }
+        }
+        if (remove_cpu) {
+            qemu_tcg_destroy_vcpu(remove_cpu);
+            cpu->created = false;
+            qemu_cond_signal(&qemu_cpu_cond);
+            remove_cpu = NULL;
+        }

     }
 
     return NULL;
     }
 
     return NULL;


@@ -1301,6 +1346,21 @@ void resume_all_vcpus(void)
     }
 }
 
     }
 }
 

+void cpu_remove(CPUState *cpu)
+{
+    cpu->stop = true;
+    cpu->unplug = true;
+    qemu_cpu_kick(cpu);
+}
+
+void cpu_remove_sync(CPUState *cpu)
+{
+    cpu_remove(cpu);
+    while (cpu->created) {
+        qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
+    }
+}
+

 /* For temporary buffers for forming a name */
 #define VCPU_THREAD_NAME_SIZE 16
 
 /* For temporary buffers for forming a name */
 #define VCPU_THREAD_NAME_SIZE 16
 


@@ -1375,8 +1435,10 @@ void qemu_init_vcpu(CPUState *cpu)
         /* If the target cpu hasn't set up any address spaces itself,
          * give it the default one.
          */
         /* If the target cpu hasn't set up any address spaces itself,
          * give it the default one.
          */

+        AddressSpace *as = address_space_init_shareable(cpu->memory,
+                                                        "cpu-memory");

         cpu->num_ases = 1;
         cpu->num_ases = 1;

-        cpu_address_space_init(cpu, &address_space_memory, 0);
+        cpu_address_space_init(cpu, as, 0);

     }
 
     if (kvm_enabled()) {
     }
 
     if (kvm_enabled()) {


@@ -1394,7 +1456,7 @@ void cpu_stop_current(void)
         current_cpu->stop = false;
         current_cpu->stopped = true;
         cpu_exit(current_cpu);
         current_cpu->stop = false;
         current_cpu->stopped = true;
         cpu_exit(current_cpu);

-        qemu_cond_signal(&qemu_pause_cond);
+        qemu_cond_broadcast(&qemu_pause_cond);

     }
 }
 
     }
 }
 


@@ -1426,7 +1488,7 @@ int vm_stop_force_state(RunState state)
         bdrv_drain_all();
         /* Make sure to return an error if the flush in a previous vm_stop()
          * failed. */
         bdrv_drain_all();
         /* Make sure to return an error if the flush in a previous vm_stop()
          * failed. */

-        return bdrv_flush_all();
+        return blk_flush_all();

     }
 }
 
     }
 }
 


@@ -1497,7 +1559,7 @@ static void tcg_exec_all(void)
     int r;
 
     /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
     int r;
 
     /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */

-    qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
+    qemu_account_warp_timer();

 
     if (next_cpu == NULL) {
         next_cpu = first_cpu;
 
     if (next_cpu == NULL) {
         next_cpu = first_cpu;


@@ -1515,6 +1577,9 @@ static void tcg_exec_all(void)
                 break;
             }
         } else if (cpu->stop || cpu->stopped) {
                 break;
             }
         } else if (cpu->stop || cpu->stopped) {

+            if (cpu->unplug) {
+                next_cpu = CPU_NEXT(cpu);
+            }

             break;
         }
     }
             break;
         }
     }


@@ -1566,28 +1631,22 @@ CpuInfoList *qmp_query_cpus(Error **errp)
         info->value->thread_id = cpu->thread_id;
 #if defined(TARGET_I386)
         info->value->arch = CPU_INFO_ARCH_X86;
         info->value->thread_id = cpu->thread_id;
 #if defined(TARGET_I386)
         info->value->arch = CPU_INFO_ARCH_X86;

-        info->value->u.x86 = g_new0(CpuInfoX86, 1);
-        info->value->u.x86->pc = env->eip + env->segs[R_CS].base;
+        info->value->u.x86.pc = env->eip + env->segs[R_CS].base;

 #elif defined(TARGET_PPC)
         info->value->arch = CPU_INFO_ARCH_PPC;
 #elif defined(TARGET_PPC)
         info->value->arch = CPU_INFO_ARCH_PPC;

-        info->value->u.ppc = g_new0(CpuInfoPPC, 1);
-        info->value->u.ppc->nip = env->nip;
+        info->value->u.ppc.nip = env->nip;

 #elif defined(TARGET_SPARC)
         info->value->arch = CPU_INFO_ARCH_SPARC;
 #elif defined(TARGET_SPARC)
         info->value->arch = CPU_INFO_ARCH_SPARC;

-        info->value->u.sparc = g_new0(CpuInfoSPARC, 1);
-        info->value->u.sparc->pc = env->pc;
-        info->value->u.sparc->npc = env->npc;
+        info->value->u.q_sparc.pc = env->pc;
+        info->value->u.q_sparc.npc = env->npc;

 #elif defined(TARGET_MIPS)
         info->value->arch = CPU_INFO_ARCH_MIPS;
 #elif defined(TARGET_MIPS)
         info->value->arch = CPU_INFO_ARCH_MIPS;

-        info->value->u.mips = g_new0(CpuInfoMIPS, 1);
-        info->value->u.mips->PC = env->active_tc.PC;
+        info->value->u.q_mips.PC = env->active_tc.PC;

 #elif defined(TARGET_TRICORE)
         info->value->arch = CPU_INFO_ARCH_TRICORE;
 #elif defined(TARGET_TRICORE)
         info->value->arch = CPU_INFO_ARCH_TRICORE;

-        info->value->u.tricore = g_new0(CpuInfoTricore, 1);
-        info->value->u.tricore->PC = env->PC;
+        info->value->u.tricore.PC = env->PC;

 #else
         info->value->arch = CPU_INFO_ARCH_OTHER;
 #else
         info->value->arch = CPU_INFO_ARCH_OTHER;

-        info->value->u.other = g_new0(CpuInfoOther, 1);

 #endif
 
         /* XXX: waiting for the qapi to support GSList */
 #endif
 
         /* XXX: waiting for the qapi to support GSList */


@@ -1681,21 +1740,7 @@ exit:
 
 void qmp_inject_nmi(Error **errp)
 {
 
 void qmp_inject_nmi(Error **errp)
 {

-#if defined(TARGET_I386)
-    CPUState *cs;
-
-    CPU_FOREACH(cs) {
-        X86CPU *cpu = X86_CPU(cs);
-
-        if (!cpu->apic_state) {
-            cpu_interrupt(cs, CPU_INTERRUPT_NMI);
-        } else {
-            apic_deliver_nmi(cpu->apic_state);
-        }
-    }
-#else

     nmi_monitor_handle(monitor_get_cpu_index(), errp);
     nmi_monitor_handle(monitor_get_cpu_index(), errp);

-#endif

 }
 
 void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
 }
 
 void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)