Merge remote-tracking branch 'remotes/mcayland/tags/qemu-openbios-20180618' into...

[qemu.git] / hw / intc / xics_kvm.c

diff --git a/hw/intc/xics_kvm.c b/hw/intc/xics_kvm.c
index 0a3daca3bb5ab6c0ee545a390b0ad2cc7dfb0ad8..8dba2f84e71e866ef7583b9fbdcd315145bde8b7 100644 (file)
--- a/hw/intc/xics_kvm.c
+++ b/hw/intc/xics_kvm.c
@@ -42,16 +42,20 @@
 
 static int kernel_xics_fd = -1;
 
 
 static int kernel_xics_fd = -1;
 

+typedef struct KVMEnabledICP {
+    unsigned long vcpu_id;
+    QLIST_ENTRY(KVMEnabledICP) node;
+} KVMEnabledICP;
+
+static QLIST_HEAD(, KVMEnabledICP)
+    kvm_enabled_icps = QLIST_HEAD_INITIALIZER(&kvm_enabled_icps);
+

 /*
  * ICP-KVM
  */
 static void icp_get_kvm_state(ICPState *icp)
 {
     uint64_t state;
 /*
  * ICP-KVM
  */
 static void icp_get_kvm_state(ICPState *icp)
 {
     uint64_t state;

-    struct kvm_one_reg reg = {
-        .id = KVM_REG_PPC_ICP_STATE,
-        .addr = (uintptr_t)&state,
-    };

     int ret;
 
     /* ICP for this CPU thread is not in use, exiting */
     int ret;
 
     /* ICP for this CPU thread is not in use, exiting */


@@ -59,7 +63,7 @@ static void icp_get_kvm_state(ICPState *icp)
         return;
     }
 
         return;
     }
 

-    ret = kvm_vcpu_ioctl(icp->cs, KVM_GET_ONE_REG, &reg);
+    ret = kvm_get_one_reg(icp->cs, KVM_REG_PPC_ICP_STATE, &state);

     if (ret != 0) {
         error_report("Unable to retrieve KVM interrupt controller state"
                 " for CPU %ld: %s", kvm_arch_vcpu_id(icp->cs), strerror(errno));
     if (ret != 0) {
         error_report("Unable to retrieve KVM interrupt controller state"
                 " for CPU %ld: %s", kvm_arch_vcpu_id(icp->cs), strerror(errno));


@@ -73,13 +77,21 @@ static void icp_get_kvm_state(ICPState *icp)
         & KVM_REG_PPC_ICP_PPRI_MASK;
 }
 
         & KVM_REG_PPC_ICP_PPRI_MASK;
 }
 

+static void do_icp_synchronize_state(CPUState *cpu, run_on_cpu_data arg)
+{
+    icp_get_kvm_state(arg.host_ptr);
+}
+
+static void icp_synchronize_state(ICPState *icp)
+{
+    if (icp->cs) {
+        run_on_cpu(icp->cs, do_icp_synchronize_state, RUN_ON_CPU_HOST_PTR(icp));
+    }
+}
+

 static int icp_set_kvm_state(ICPState *icp, int version_id)
 {
     uint64_t state;
 static int icp_set_kvm_state(ICPState *icp, int version_id)
 {
     uint64_t state;

-    struct kvm_one_reg reg = {
-        .id = KVM_REG_PPC_ICP_STATE,
-        .addr = (uintptr_t)&state,
-    };

     int ret;
 
     /* ICP for this CPU thread is not in use, exiting */
     int ret;
 
     /* ICP for this CPU thread is not in use, exiting */


@@ -91,7 +103,7 @@ static int icp_set_kvm_state(ICPState *icp, int version_id)
         | ((uint64_t)icp->mfrr << KVM_REG_PPC_ICP_MFRR_SHIFT)
         | ((uint64_t)icp->pending_priority << KVM_REG_PPC_ICP_PPRI_SHIFT);
 
         | ((uint64_t)icp->mfrr << KVM_REG_PPC_ICP_MFRR_SHIFT)
         | ((uint64_t)icp->pending_priority << KVM_REG_PPC_ICP_PPRI_SHIFT);
 

-    ret = kvm_vcpu_ioctl(icp->cs, KVM_SET_ONE_REG, &reg);
+    ret = kvm_set_one_reg(icp->cs, KVM_REG_PPC_ICP_STATE, &state);

     if (ret != 0) {
         error_report("Unable to restore KVM interrupt controller state (0x%"
                 PRIx64 ") for CPU %ld: %s", state, kvm_arch_vcpu_id(icp->cs),
     if (ret != 0) {
         error_report("Unable to restore KVM interrupt controller state (0x%"
                 PRIx64 ") for CPU %ld: %s", state, kvm_arch_vcpu_id(icp->cs),


@@ -102,25 +114,16 @@ static int icp_set_kvm_state(ICPState *icp, int version_id)
     return 0;
 }
 
     return 0;
 }
 

-static void icp_kvm_reset(DeviceState *dev)
+static void icp_kvm_reset(ICPState *icp)

 {
 {

-    ICPState *icp = ICP(dev);
-
-    icp->xirr = 0;
-    icp->pending_priority = 0xff;
-    icp->mfrr = 0xff;
-
-    /* Make all outputs as deasserted only if the CPU thread is in use */
-    if (icp->output) {
-        qemu_set_irq(icp->output, 0);
-    }
-

     icp_set_kvm_state(icp, 1);
 }
 
     icp_set_kvm_state(icp, 1);
 }
 

-static void icp_kvm_cpu_setup(ICPState *icp, PowerPCCPU *cpu)
+static void icp_kvm_realize(ICPState *icp, Error **errp)

 {
 {

-    CPUState *cs = CPU(cpu);
+    CPUState *cs = icp->cs;
+    KVMEnabledICP *enabled_icp;
+    unsigned long vcpu_id = kvm_arch_vcpu_id(cs);

     int ret;
 
     if (kernel_xics_fd == -1) {
     int ret;
 
     if (kernel_xics_fd == -1) {


@@ -132,29 +135,32 @@ static void icp_kvm_cpu_setup(ICPState *icp, PowerPCCPU *cpu)
      * which was hot-removed earlier we don't have to renable
      * KVM_CAP_IRQ_XICS capability again.
      */
      * which was hot-removed earlier we don't have to renable
      * KVM_CAP_IRQ_XICS capability again.
      */

-    if (icp->cap_irq_xics_enabled) {
-        return;
+    QLIST_FOREACH(enabled_icp, &kvm_enabled_icps, node) {
+        if (enabled_icp->vcpu_id == vcpu_id) {
+            return;
+        }

     }
 
     }
 

-    ret = kvm_vcpu_enable_cap(cs, KVM_CAP_IRQ_XICS, 0, kernel_xics_fd,
-                              kvm_arch_vcpu_id(cs));
+    ret = kvm_vcpu_enable_cap(cs, KVM_CAP_IRQ_XICS, 0, kernel_xics_fd, vcpu_id);

     if (ret < 0) {
     if (ret < 0) {

-        error_report("Unable to connect CPU%ld to kernel XICS: %s",
-                     kvm_arch_vcpu_id(cs), strerror(errno));
-        exit(1);
+        error_setg(errp, "Unable to connect CPU%ld to kernel XICS: %s", vcpu_id,
+                   strerror(errno));
+        return;

     }
     }

-    icp->cap_irq_xics_enabled = true;
+    enabled_icp = g_malloc(sizeof(*enabled_icp));
+    enabled_icp->vcpu_id = vcpu_id;
+    QLIST_INSERT_HEAD(&kvm_enabled_icps, enabled_icp, node);

 }
 
 static void icp_kvm_class_init(ObjectClass *klass, void *data)
 {
 }
 
 static void icp_kvm_class_init(ObjectClass *klass, void *data)
 {

-    DeviceClass *dc = DEVICE_CLASS(klass);

     ICPStateClass *icpc = ICP_CLASS(klass);
 
     ICPStateClass *icpc = ICP_CLASS(klass);
 

-    dc->reset = icp_kvm_reset;

     icpc->pre_save = icp_get_kvm_state;
     icpc->post_load = icp_set_kvm_state;
     icpc->pre_save = icp_get_kvm_state;
     icpc->post_load = icp_set_kvm_state;

-    icpc->cpu_setup = icp_kvm_cpu_setup;
+    icpc->realize = icp_kvm_realize;
+    icpc->reset = icp_kvm_reset;
+    icpc->synchronize_state = icp_synchronize_state;

 }
 
 static const TypeInfo icp_kvm_info = {
 }
 
 static const TypeInfo icp_kvm_info = {


@@ -171,23 +177,16 @@ static const TypeInfo icp_kvm_info = {
 static void ics_get_kvm_state(ICSState *ics)
 {
     uint64_t state;
 static void ics_get_kvm_state(ICSState *ics)
 {
     uint64_t state;

-    struct kvm_device_attr attr = {
-        .flags = 0,
-        .group = KVM_DEV_XICS_GRP_SOURCES,
-        .addr = (uint64_t)(uintptr_t)&state,
-    };

     int i;
     int i;

+    Error *local_err = NULL;

 
     for (i = 0; i < ics->nr_irqs; i++) {
         ICSIRQState *irq = &ics->irqs[i];
 
     for (i = 0; i < ics->nr_irqs; i++) {
         ICSIRQState *irq = &ics->irqs[i];

-        int ret;

 
 

-        attr.attr = i + ics->offset;
-
-        ret = ioctl(kernel_xics_fd, KVM_GET_DEVICE_ATTR, &attr);
-        if (ret != 0) {
-            error_report("Unable to retrieve KVM interrupt controller state"
-                    " for IRQ %d: %s", i + ics->offset, strerror(errno));
+        kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES,
+                          i + ics->offset, &state, false, &local_err);
+        if (local_err) {
+            error_report_err(local_err);

             exit(1);
         }
 
             exit(1);
         }
 


@@ -208,6 +207,7 @@ static void ics_get_kvm_state(ICSState *ics)
             irq->priority = irq->saved_priority;
         }
 
             irq->priority = irq->saved_priority;
         }
 

+        irq->status = 0;

         if (state & KVM_XICS_PENDING) {
             if (state & KVM_XICS_LEVEL_SENSITIVE) {
                 irq->status |= XICS_STATUS_ASSERTED;
         if (state & KVM_XICS_PENDING) {
             if (state & KVM_XICS_LEVEL_SENSITIVE) {
                 irq->status |= XICS_STATUS_ASSERTED;


@@ -223,25 +223,30 @@ static void ics_get_kvm_state(ICSState *ics)
                     | XICS_STATUS_REJECTED;
             }
         }
                     | XICS_STATUS_REJECTED;
             }
         }

+        if (state & KVM_XICS_PRESENTED) {
+                irq->status |= XICS_STATUS_PRESENTED;
+        }
+        if (state & KVM_XICS_QUEUED) {
+                irq->status |= XICS_STATUS_QUEUED;
+        }

     }
 }
 
     }
 }
 

+static void ics_synchronize_state(ICSState *ics)
+{
+    ics_get_kvm_state(ics);
+}
+

 static int ics_set_kvm_state(ICSState *ics, int version_id)
 {
     uint64_t state;
 static int ics_set_kvm_state(ICSState *ics, int version_id)
 {
     uint64_t state;

-    struct kvm_device_attr attr = {
-        .flags = 0,
-        .group = KVM_DEV_XICS_GRP_SOURCES,
-        .addr = (uint64_t)(uintptr_t)&state,
-    };

     int i;
     int i;

+    Error *local_err = NULL;

 
     for (i = 0; i < ics->nr_irqs; i++) {
         ICSIRQState *irq = &ics->irqs[i];
         int ret;
 
 
     for (i = 0; i < ics->nr_irqs; i++) {
         ICSIRQState *irq = &ics->irqs[i];
         int ret;
 

-        attr.attr = i + ics->offset;
-

         state = irq->server;
         state |= (uint64_t)(irq->saved_priority & KVM_XICS_PRIORITY_MASK)
             << KVM_XICS_PRIORITY_SHIFT;
         state = irq->server;
         state |= (uint64_t)(irq->saved_priority & KVM_XICS_PRIORITY_MASK)
             << KVM_XICS_PRIORITY_SHIFT;


@@ -260,11 +265,17 @@ static int ics_set_kvm_state(ICSState *ics, int version_id)
                 state |= KVM_XICS_PENDING;
             }
         }
                 state |= KVM_XICS_PENDING;
             }
         }

+        if (irq->status & XICS_STATUS_PRESENTED) {
+                state |= KVM_XICS_PRESENTED;
+        }
+        if (irq->status & XICS_STATUS_QUEUED) {
+                state |= KVM_XICS_QUEUED;
+        }

 
 

-        ret = ioctl(kernel_xics_fd, KVM_SET_DEVICE_ATTR, &attr);
-        if (ret != 0) {
-            error_report("Unable to restore KVM interrupt controller state"
-                    " for IRQs %d: %s", i + ics->offset, strerror(errno));
+        ret = kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES,
+                                i + ics->offset, &state, true, &local_err);
+        if (local_err) {
+            error_report_err(local_err);

             return ret;
         }
     }
             return ret;
         }
     }


@@ -293,7 +304,7 @@ static void ics_kvm_set_irq(void *opaque, int srcno, int val)
     }
 }
 
     }
 }
 

-static void ics_kvm_reset(DeviceState *dev)
+static void ics_kvm_reset(void *dev)

 {
     ICSState *ics = ICS_SIMPLE(dev);
     int i;
 {
     ICSState *ics = ICS_SIMPLE(dev);
     int i;


@@ -314,27 +325,26 @@ static void ics_kvm_reset(DeviceState *dev)
     ics_set_kvm_state(ics, 1);
 }
 
     ics_set_kvm_state(ics, 1);
 }
 

-static void ics_kvm_realize(DeviceState *dev, Error **errp)
+static void ics_kvm_realize(ICSState *ics, Error **errp)

 {
 {

-    ICSState *ics = ICS_SIMPLE(dev);
-

     if (!ics->nr_irqs) {
         error_setg(errp, "Number of interrupts needs to be greater 0");
         return;
     }
     ics->irqs = g_malloc0(ics->nr_irqs * sizeof(ICSIRQState));
     ics->qirqs = qemu_allocate_irqs(ics_kvm_set_irq, ics, ics->nr_irqs);
     if (!ics->nr_irqs) {
         error_setg(errp, "Number of interrupts needs to be greater 0");
         return;
     }
     ics->irqs = g_malloc0(ics->nr_irqs * sizeof(ICSIRQState));
     ics->qirqs = qemu_allocate_irqs(ics_kvm_set_irq, ics, ics->nr_irqs);

+
+    qemu_register_reset(ics_kvm_reset, ics);

 }
 
 static void ics_kvm_class_init(ObjectClass *klass, void *data)
 {
 }
 
 static void ics_kvm_class_init(ObjectClass *klass, void *data)
 {

-    DeviceClass *dc = DEVICE_CLASS(klass);

     ICSStateClass *icsc = ICS_BASE_CLASS(klass);
 
     icsc->realize = ics_kvm_realize;
     ICSStateClass *icsc = ICS_BASE_CLASS(klass);
 
     icsc->realize = ics_kvm_realize;

-    dc->reset = ics_kvm_reset;

     icsc->pre_save = ics_get_kvm_state;
     icsc->post_load = ics_set_kvm_state;
     icsc->pre_save = ics_get_kvm_state;
     icsc->post_load = ics_set_kvm_state;

+    icsc->synchronize_state = ics_synchronize_state;

 }
 
 static const TypeInfo ics_kvm_info = {
 }
 
 static const TypeInfo ics_kvm_info = {


@@ -360,10 +370,6 @@ static void rtas_dummy(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 int xics_kvm_init(sPAPRMachineState *spapr, Error **errp)
 {
     int rc;
 int xics_kvm_init(sPAPRMachineState *spapr, Error **errp)
 {
     int rc;

-    struct kvm_create_device xics_create_device = {
-        .type = KVM_DEV_TYPE_XICS,
-        .flags = 0,
-    };

 
     if (!kvm_enabled() || !kvm_check_extension(kvm_state, KVM_CAP_IRQ_XICS)) {
         error_setg(errp,
 
     if (!kvm_enabled() || !kvm_check_extension(kvm_state, KVM_CAP_IRQ_XICS)) {
         error_setg(errp,


@@ -400,20 +406,19 @@ int xics_kvm_init(sPAPRMachineState *spapr, Error **errp)
         goto fail;
     }
 
         goto fail;
     }
 

-    /* Create the kernel ICP */
-    rc = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &xics_create_device);
+    /* Create the KVM XICS device */
+    rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false);

     if (rc < 0) {
         error_setg_errno(errp, -rc, "Error on KVM_CREATE_DEVICE for XICS");
         goto fail;
     }
 
     if (rc < 0) {
         error_setg_errno(errp, -rc, "Error on KVM_CREATE_DEVICE for XICS");
         goto fail;
     }
 

-    kernel_xics_fd = xics_create_device.fd;
-
+    kernel_xics_fd = rc;

     kvm_kernel_irqchip = true;
     kvm_msi_via_irqfd_allowed = true;
     kvm_gsi_direct_mapping = true;
 
     kvm_kernel_irqchip = true;
     kvm_msi_via_irqfd_allowed = true;
     kvm_gsi_direct_mapping = true;
 

-    return rc;
+    return 0;

 
 fail:
     kvmppc_define_rtas_kernel_token(0, "ibm,set-xive");
 
 fail:
     kvmppc_define_rtas_kernel_token(0, "ibm,set-xive");