cpu: Reclaim vCPU objects

In order to deal well with the kvm vcpus (which can not be removed without any
protection), we do not close KVM vcpu fd, just record and mark it as stopped
into a list, so that we can reuse it for the appending cpu hot-add request if
possible. It is also the approach that kvm guys suggested:
https://www.mail-archive.com/[email protected]/msg102839.html

Signed-off-by: Chen Fan <[email protected]>
Signed-off-by: Gu Zheng <[email protected]>
Signed-off-by: Zhu Guihua <[email protected]>
Signed-off-by: Bharata B Rao <[email protected]>
               [- Explicit CPU_REMOVE() from qemu_kvm/tcg_destroy_vcpu()
                  isn't needed as it is done from cpu_exec_exit()
                - Use iothread mutex instead of global mutex during
                  destroy
                - Don't cleanup vCPU object from vCPU thread context
                  but leave it to the callers (device_add/device_del)]
Reviewed-by: Thomas Huth <[email protected]>
Reviewed-by: David Gibson <[email protected]>
Signed-off-by: David Gibson <[email protected]>

diff --git a/cpus.c b/cpus.c
index e75895a458ba3e5a07240fcb635aabaa00cfc80d..3e3ef95e381a190f112735d82c15046e795233b4 100644 (file)
--- a/cpus.c
+++ b/cpus.c
@@ -972,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;


@@ -1061,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) {


@@ -1069,8 +1081,10 @@ 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);
+    qemu_mutex_unlock_iothread();

     return NULL;
 }
 
     return NULL;
 }
 


@@ -1124,6 +1138,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();
 


@@ -1161,6 +1176,16 @@ 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);
+            remove_cpu = NULL;
+        }

     }
 
     return NULL;
     }
 
     return NULL;


@@ -1317,6 +1342,13 @@ void resume_all_vcpus(void)
     }
 }
 
     }
 }
 

+void cpu_remove(CPUState *cpu)
+{
+    cpu->stop = true;
+    cpu->unplug = true;
+    qemu_cpu_kick(cpu);
+}
+

 /* 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
 


@@ -1533,6 +1565,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;
         }
     }

diff --git a/include/qom/cpu.h b/include/qom/cpu.h
index c9ba16ca824710a5c159c8abdd9099bf943d270f..3b5775715b5837b90dfb487180634ec3dad95c12 100644 (file)
--- a/include/qom/cpu.h
+++ b/include/qom/cpu.h
@@ -244,6 +244,7 @@ struct qemu_work_item {
  * @halted: Nonzero if the CPU is in suspended state.
  * @stop: Indicates a pending stop request.
  * @stopped: Indicates the CPU has been artificially stopped.
  * @halted: Nonzero if the CPU is in suspended state.
  * @stop: Indicates a pending stop request.
  * @stopped: Indicates the CPU has been artificially stopped.

+ * @unplug: Indicates a pending CPU unplug request.

  * @crash_occurred: Indicates the OS reported a crash (panic) for this CPU
  * @tcg_exit_req: Set to force TCG to stop executing linked TBs for this
  *           CPU and return to its top level loop.
  * @crash_occurred: Indicates the OS reported a crash (panic) for this CPU
  * @tcg_exit_req: Set to force TCG to stop executing linked TBs for this
  *           CPU and return to its top level loop.


@@ -296,6 +297,7 @@ struct CPUState {
     bool created;
     bool stop;
     bool stopped;
     bool created;
     bool stop;
     bool stopped;

+    bool unplug;

     bool crash_occurred;
     bool exit_request;
     bool tb_flushed;
     bool crash_occurred;
     bool exit_request;
     bool tb_flushed;


@@ -762,6 +764,14 @@ void cpu_exit(CPUState *cpu);
  */
 void cpu_resume(CPUState *cpu);
 
  */
 void cpu_resume(CPUState *cpu);
 

+/**
+ * cpu_remove:
+ * @cpu: The CPU to remove.
+ *
+ * Requests the CPU to be removed.
+ */
+void cpu_remove(CPUState *cpu);
+

 /**
  * qemu_init_vcpu:
  * @cpu: The vCPU to initialize.
 /**
  * qemu_init_vcpu:
  * @cpu: The vCPU to initialize.

diff --git a/include/sysemu/kvm.h b/include/sysemu/kvm.h
index f357ccde91223c49a9f9eaf459cf558045e7287a..65569ed43821b152f2f586b08c51119367dcc93e 100644 (file)
--- a/include/sysemu/kvm.h
+++ b/include/sysemu/kvm.h
@@ -216,6 +216,7 @@ int kvm_has_intx_set_mask(void);
 
 int kvm_init_vcpu(CPUState *cpu);
 int kvm_cpu_exec(CPUState *cpu);
 
 int kvm_init_vcpu(CPUState *cpu);
 int kvm_cpu_exec(CPUState *cpu);

+int kvm_destroy_vcpu(CPUState *cpu);

 
 #ifdef NEED_CPU_H
 #include "cpu.h"
 
 #ifdef NEED_CPU_H
 #include "cpu.h"

diff --git a/kvm-all.c b/kvm-all.c
index e56f385278156426a9ae1b76b6c8ee02089a08a6..d317dcb33ed592d2ee936a4b9162420306e6aec5 100644 (file)
--- a/kvm-all.c
+++ b/kvm-all.c
@@ -61,6 +61,12 @@
 
 #define KVM_MSI_HASHTAB_SIZE    256
 
 
 #define KVM_MSI_HASHTAB_SIZE    256
 

+struct KVMParkedVcpu {
+    unsigned long vcpu_id;
+    int kvm_fd;
+    QLIST_ENTRY(KVMParkedVcpu) node;
+};
+

 struct KVMState
 {
     AccelState parent_obj;
 struct KVMState
 {
     AccelState parent_obj;


@@ -94,6 +100,7 @@ struct KVMState
     QTAILQ_HEAD(msi_hashtab, KVMMSIRoute) msi_hashtab[KVM_MSI_HASHTAB_SIZE];
 #endif
     KVMMemoryListener memory_listener;
     QTAILQ_HEAD(msi_hashtab, KVMMSIRoute) msi_hashtab[KVM_MSI_HASHTAB_SIZE];
 #endif
     KVMMemoryListener memory_listener;

+    QLIST_HEAD(, KVMParkedVcpu) kvm_parked_vcpus;

 };
 
 KVMState *kvm_state;
 };
 
 KVMState *kvm_state;


@@ -237,6 +244,53 @@ static int kvm_set_user_memory_region(KVMMemoryListener *kml, KVMSlot *slot)
     return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 }
 
     return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 }
 

+int kvm_destroy_vcpu(CPUState *cpu)
+{
+    KVMState *s = kvm_state;
+    long mmap_size;
+    struct KVMParkedVcpu *vcpu = NULL;
+    int ret = 0;
+
+    DPRINTF("kvm_destroy_vcpu\n");
+
+    mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
+    if (mmap_size < 0) {
+        ret = mmap_size;
+        DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
+        goto err;
+    }
+
+    ret = munmap(cpu->kvm_run, mmap_size);
+    if (ret < 0) {
+        goto err;
+    }
+
+    vcpu = g_malloc0(sizeof(*vcpu));
+    vcpu->vcpu_id = kvm_arch_vcpu_id(cpu);
+    vcpu->kvm_fd = cpu->kvm_fd;
+    QLIST_INSERT_HEAD(&kvm_state->kvm_parked_vcpus, vcpu, node);
+err:
+    return ret;
+}
+
+static int kvm_get_vcpu(KVMState *s, unsigned long vcpu_id)
+{
+    struct KVMParkedVcpu *cpu;
+
+    QLIST_FOREACH(cpu, &s->kvm_parked_vcpus, node) {
+        if (cpu->vcpu_id == vcpu_id) {
+            int kvm_fd;
+
+            QLIST_REMOVE(cpu, node);
+            kvm_fd = cpu->kvm_fd;
+            g_free(cpu);
+            return kvm_fd;
+        }
+    }
+
+    return kvm_vm_ioctl(s, KVM_CREATE_VCPU, (void *)vcpu_id);
+}
+

 int kvm_init_vcpu(CPUState *cpu)
 {
     KVMState *s = kvm_state;
 int kvm_init_vcpu(CPUState *cpu)
 {
     KVMState *s = kvm_state;


@@ -245,7 +299,7 @@ int kvm_init_vcpu(CPUState *cpu)
 
     DPRINTF("kvm_init_vcpu\n");
 
 
     DPRINTF("kvm_init_vcpu\n");
 

-    ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, (void *)kvm_arch_vcpu_id(cpu));
+    ret = kvm_get_vcpu(s, kvm_arch_vcpu_id(cpu));

     if (ret < 0) {
         DPRINTF("kvm_create_vcpu failed\n");
         goto err;
     if (ret < 0) {
         DPRINTF("kvm_create_vcpu failed\n");
         goto err;


@@ -1501,6 +1555,7 @@ static int kvm_init(MachineState *ms)
 #ifdef KVM_CAP_SET_GUEST_DEBUG
     QTAILQ_INIT(&s->kvm_sw_breakpoints);
 #endif
 #ifdef KVM_CAP_SET_GUEST_DEBUG
     QTAILQ_INIT(&s->kvm_sw_breakpoints);
 #endif

+    QLIST_INIT(&s->kvm_parked_vcpus);

     s->vmfd = -1;
     s->fd = qemu_open("/dev/kvm", O_RDWR);
     if (s->fd == -1) {
     s->vmfd = -1;
     s->fd = qemu_open("/dev/kvm", O_RDWR);
     if (s->fd == -1) {

diff --git a/kvm-stub.c b/kvm-stub.c
index 63735a872a96c1355ea331e9cb1eb1183e8cb845..07c09d114179acd4865f5c6eae0373fff17eec1c 100644 (file)
--- a/kvm-stub.c
+++ b/kvm-stub.c
@@ -32,6 +32,11 @@ bool kvm_allowed;
 bool kvm_readonly_mem_allowed;
 bool kvm_ioeventfd_any_length_allowed;
 
 bool kvm_readonly_mem_allowed;
 bool kvm_ioeventfd_any_length_allowed;
 

+int kvm_destroy_vcpu(CPUState *cpu)
+{
+    return -ENOSYS;
+}
+

 int kvm_init_vcpu(CPUState *cpu)
 {
     return -ENOSYS;
 int kvm_init_vcpu(CPUState *cpu)
 {
     return -ENOSYS;