Skip to contentSkip to conversation

GICv3 live migration support

RFC PATCH Superseded Pavel Fedin 1 participant 6 messages Oct 13, 2015

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

v2 cover GICv3 live migration support

This series introduces support for GICv3 live migration. It is based on kernel API which is not released yet, therefore i post it as an RFC.

Kernel patches which implement this functionality are:
- [PATCH v5 0/7] KVM: arm64: Implement API for vGICv3 live migration
http://www.spinics.net/lists/kvm/msg122040.html

The main purpose of this RFC is to agree on GICv3 state data format, because software implementation of GICv3 is also going to use it. In order to simplify GICv3 software emulation development, parts 1 and 2 of this patchset can be accepted right now, without waiting for the kernel part.

v1 => v2:
- Use different kernel API, agreed upon by KVM developers
- Reworked state representation, do not duplicate SPI fields any more
- Added basic LPI support (PROPBASER and PENDBASER).

Pavel Fedin (5):
target-arm: Add mp-affinity property for ARM CPU class hw/intc/arm_gicv3_common: Add state information
kernel: Add definitions for GICv3 attributes hw/intc/arm_gicv3_kvm: Implement get/put functions hw/intc/arm_gicv3_common: Add vmstate descriptors

 hw/intc/arm_gicv3_common.c         | 157 ++++++++++++-
 hw/intc/arm_gicv3_kvm.c            | 463 ++++++++++++++++++++++++++++++++++++-
 hw/intc/gicv3_internal.h           | 225 ++++++++++++++++++
 include/hw/intc/arm_gicv3_common.h |  76 +++++-
 include/migration/vmstate.h        |   9 +
 linux-headers/asm-arm64/kvm.h      |  17 +-
 target-arm/cpu.c                   |   1 +
 7 files changed, 934 insertions(+), 14 deletions(-)
 create mode 100644 hw/intc/gicv3_internal.h
Signature · 1 line
2.4.4
#1 lore raw

RFC PATCH v2 1/5 target-arm: Add mp-affinity property for ARM CPU class

Allows to override default affinity IDs on a per-machine basis, and read assigned IDs. Will be used by vGICv3 live migration code.

---
 target-arm/cpu.c | 1 +
 1 file changed, 1 insertion(+)
target-arm/cpu.c +1 -0
index 30739fc..3810709 100644
@@ -1373,6 +1373,7 @@ static Property arm_cpu_properties[] = {
     DEFINE_PROP_BOOL("start-powered-off", ARMCPU, start_powered_off, false),
     DEFINE_PROP_UINT32("psci-conduit", ARMCPU, psci_conduit, 0),
     DEFINE_PROP_UINT32("midr", ARMCPU, midr, 0),
+    DEFINE_PROP_UINT64("mp-affinity", ARMCPU, mp_affinity, 0),
     DEFINE_PROP_END_OF_LIST()
 };
 
Signature · 1 line
2.4.4
#2 lore raw

RFC PATCH v2 2/5 hw/intc/arm_gicv3_common: Add state information

In reply to Pavel Fedin

Add state information to GICv3 object structure and implement arm_gicv3_common_reset(). Also, add some functions for registers which are not stored directly but simulated.

State information includes not only pure GICv3 data, but also some legacy registers. This will be useful for implementing software emulation of GICv3 with v2 backwards compatilibity mode.

---
 hw/intc/arm_gicv3_common.c         | 111 +++++++++++++++++-
 hw/intc/gicv3_internal.h           | 225 +++++++++++++++++++++++++++++++++++++
 include/hw/intc/arm_gicv3_common.h |  76 ++++++++++++-
 3 files changed, 407 insertions(+), 5 deletions(-)
 create mode 100644 hw/intc/gicv3_internal.h
hw/intc/arm_gicv3_common.c +109 -2
index 032ece2..32aca02 100644
@@ -3,8 +3,9 @@
  *
  * Copyright (c) 2012 Linaro Limited
  * Copyright (c) 2015 Huawei.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
  * Written by Peter Maydell
- * Extended to 64 cores by Shlomo Pongratz
+ * Reworked for GICv3 by Shlomo Pongratz and Pavel Fedin
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,6 +22,7 @@
  */
 
 #include "hw/intc/arm_gicv3_common.h"
+#include "gicv3_internal.h"
 
 static void gicv3_pre_save(void *opaque)
 {
@@ -98,11 +100,116 @@ static void arm_gicv3_common_realize(DeviceState *dev, Error **errp)
         error_setg(errp, "unsupported GIC revision %d", s->revision);
         return;
     }
+
+    if (s->num_irq > GICV3_MAXIRQ) {
+        error_setg(errp,
+                   "requested %u interrupt lines exceeds GIC maximum %d",
+                   s->num_irq, GICV3_MAXIRQ);
+        return;
+    }
+
+    s->cpu = g_malloc(s->num_cpu * sizeof(GICv3CPUState));
 }
 
 static void arm_gicv3_common_reset(DeviceState *dev)
 {
-    /* TODO */
+    GICv3State *s = ARM_GICV3_COMMON(dev);
+    int i;
+
+    for (i = 0; i < s->num_cpu; i++) {
+        GICv3CPUState *c = &s->cpu[i];
+
+        c->cpu_enabled = false;
+        c->redist_ctlr = 0;
+        c->propbaser = GICR_PROPBASER_InnerShareable|GICR_PROPBASER_WaWb;
+        c->pendbaser = GICR_PENDBASER_InnerShareable|GICR_PENDBASER_WaWb;
+        /* Workaround!
+         * Linux (drivers/irqchip/irq-gic-v3.c) is enabling only group one,
+         * in gic_cpu_sys_reg_init it calls gic_write_grpen1(1);
+         * but it doesn't conigure any interrupt to be in group one.
+         * The same for SPIs below
+         */
+        c->group = 0xffffffff;
+        /* GIC-500 comment 'j' SGI are always enabled */
+        c->enabled = 0x0000ffff;
+        c->pending = 0;
+        c->active = 0;
+        c->level = 0;
+        c->edge_trigger = 0x0000ffff;
+        memset(c->priority, 0, sizeof(c->priority));
+
+        c->ctlr[0] = 0;
+        c->ctlr[1] = 0;
+        c->legacy_ctlr = 0;
+        c->priority_mask = 0;
+        c->bpr[0] = GIC_MIN_BPR0;
+        c->bpr[1] = GIC_MIN_BPR1;
+        memset(c->apr, 0, sizeof(c->apr));
+
+        c->current_pending = 1023;
+        c->running_irq = 1023;
+        c->running_priority = 0x100;
+        memset(c->last_active, 0, sizeof(c->last_active));
+    }
+
+    memset(s->group, 0, sizeof(s->group));
+    memset(s->enabled, 0, sizeof(s->enabled));
+    memset(s->pending, 0, sizeof(s->pending));
+    memset(s->active, 0, sizeof(s->active));
+    memset(s->level, 0, sizeof(s->level));
+    memset(s->edge_trigger, 0, sizeof(s->edge_trigger));
+
+    /* Workaround! (the same as c->group above) */
+    for (i = GIC_INTERNAL; i < s->num_irq; i++) {
+        set_bit(i - GIC_INTERNAL, s->group);
+    }
+
+    /* By default all interrupts always target CPU #0 */
+    for (i = 0; i < GICV3_MAXSPI; i++) {
+        s->irq_target[i] = 1;
+    }
+    memset(s->irq_route, 0, sizeof(s->irq_route));
+    memset(s->priority, 0, sizeof(s->priority));
+
+    /* With all configuration we don't support GICv2 backwards computability */
+    if (s->security_extn) {
+        /* GICv3 5.3.20 With two security So DS is RAZ/WI ARE_NS is RAO/WI
+         * and ARE_S is RAO/WI
+         */
+         s->ctlr = GICD_CTLR_ARE_S | GICD_CTLR_ARE_NS;
+    } else {
+        /* GICv3 5.3.20 With one security So DS is RAO/WI ARE is RAO/WI
+         */
+        s->ctlr = GICD_CTLR_DS | GICD_CTLR_ARE;
+    }
+}
+
+uint32_t gicv3_get_igrpen0(GICv3State *s, int cpuindex)
+{
+    GICv3CPUState *c = &s->cpu[cpuindex];
+
+    return extract32(c->legacy_ctlr, GICC_CTLR_EN_GRP0_SHIFT, 1);
+}
+
+void gicv3_set_igrpen0(GICv3State *s, int cpuindex, uint32_t val)
+{
+    GICv3CPUState *c = &s->cpu[cpuindex];
+
+    c->legacy_ctlr = deposit32(c->legacy_ctlr, GICC_CTLR_EN_GRP0_SHIFT, 1, val);
+}
+
+uint32_t gicv3_get_igrpen1(GICv3State *s, int cpuindex)
+{
+    GICv3CPUState *c = &s->cpu[cpuindex];
+
+    return extract32(c->legacy_ctlr, GICC_CTLR_EN_GRP1_SHIFT, 1);
+}
+
+void gicv3_set_igrpen1(GICv3State *s, int cpuindex, uint32_t val)
+{
+    GICv3CPUState *c = &s->cpu[cpuindex];
+
+    c->legacy_ctlr = deposit32(c->legacy_ctlr, GICC_CTLR_EN_GRP1_SHIFT, 1, val);
 }
 
 static Property arm_gicv3_common_properties[] = {
hw/intc/gicv3_internal.h new file +225 -0

225 lines not on this page · raw message

include/hw/intc/arm_gicv3_common.h +73 -3

99 lines not on this page · raw message

Signature · 1 line
2.4.4
#3 lore raw

RFC PATCH v2 3/5 kernel: Add definitions for GICv3 attributes

In reply to Pavel Fedin

This temporary patch adds kernel API definitions. Use proper header update procedure after these features are released.

---
 linux-headers/asm-arm64/kvm.h | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)
linux-headers/asm-arm64/kvm.h +13 -4
index c8abf25..e16268d 100644
@@ -146,14 +146,14 @@ struct kvm_arch_memory_slot {
 	KVM_REG_ARM64_SYSREG_ ## n ## _MASK)
 
 #define __ARM64_SYS_REG(op0,op1,crn,crm,op2) \
-	(KVM_REG_ARM64 | KVM_REG_ARM64_SYSREG | \
-	ARM64_SYS_REG_SHIFT_MASK(op0, OP0) | \
+	(ARM64_SYS_REG_SHIFT_MASK(op0, OP0) | \
 	ARM64_SYS_REG_SHIFT_MASK(op1, OP1) | \
 	ARM64_SYS_REG_SHIFT_MASK(crn, CRN) | \
 	ARM64_SYS_REG_SHIFT_MASK(crm, CRM) | \
 	ARM64_SYS_REG_SHIFT_MASK(op2, OP2))
 
-#define ARM64_SYS_REG(...) (__ARM64_SYS_REG(__VA_ARGS__) | KVM_REG_SIZE_U64)
+#define ARM64_SYS_REG(...) (__ARM64_SYS_REG(__VA_ARGS__) | KVM_REG_ARM64 | \
+			    KVM_REG_SIZE_U64 | KVM_REG_ARM64_SYSREG)
 
 #define KVM_REG_ARM_TIMER_CTL		ARM64_SYS_REG(3, 3, 14, 3, 1)
 #define KVM_REG_ARM_TIMER_CNT		ARM64_SYS_REG(3, 3, 14, 3, 2)
@@ -164,12 +164,21 @@ struct kvm_arch_memory_slot {
 #define KVM_DEV_ARM_VGIC_GRP_DIST_REGS	1
 #define KVM_DEV_ARM_VGIC_GRP_CPU_REGS	2
 #define   KVM_DEV_ARM_VGIC_CPUID_SHIFT	32
-#define   KVM_DEV_ARM_VGIC_CPUID_MASK	(0xffULL << KVM_DEV_ARM_VGIC_CPUID_SHIFT)
+#define   KVM_DEV_ARM_VGIC_CPUID_MASK	(0xffffffffULL << KVM_DEV_ARM_VGIC_CPUID_SHIFT)
 #define   KVM_DEV_ARM_VGIC_OFFSET_SHIFT	0
 #define   KVM_DEV_ARM_VGIC_OFFSET_MASK	(0xffffffffULL << KVM_DEV_ARM_VGIC_OFFSET_SHIFT)
 #define KVM_DEV_ARM_VGIC_GRP_NR_IRQS	3
 #define KVM_DEV_ARM_VGIC_GRP_CTRL	4
 #define   KVM_DEV_ARM_VGIC_CTRL_INIT	0
+#define KVM_DEV_ARM_VGIC_GRP_REDIST_REGS 5
+#define KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS 6
+#define   KVM_DEV_ARM_VGIC_SYSREG_MASK	(KVM_REG_ARM64_SYSREG_OP0_MASK | \
+					 KVM_REG_ARM64_SYSREG_OP1_MASK | \
+					 KVM_REG_ARM64_SYSREG_CRN_MASK | \
+					 KVM_REG_ARM64_SYSREG_CRM_MASK | \
+					 KVM_REG_ARM64_SYSREG_OP2_MASK)
+#define   KVM_DEV_ARM_VGIC_SYSREG(op0,op1,crn,crm,op2) \
+					__ARM64_SYS_REG(op0,op1,crn,crm,op2)
 
 /* KVM_IRQ_LINE irq field index values */
 #define KVM_ARM_IRQ_TYPE_SHIFT		24
Signature · 1 line
2.4.4
#4 lore raw

RFC PATCH v2 4/5 hw/intc/arm_gicv3_kvm: Implement get/put functions

In reply to Pavel Fedin

This actually implements pre_save and post_load methods for in-kernel vGICv3.

---
 hw/intc/arm_gicv3_kvm.c | 463 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 459 insertions(+), 4 deletions(-)
hw/intc/arm_gicv3_kvm.c +459 -4
index b48f78f..4553608 100644
@@ -21,8 +21,10 @@
 
 #include "hw/intc/arm_gicv3_common.h"
 #include "hw/sysbus.h"
+#include "qemu/error-report.h"
 #include "sysemu/kvm.h"
 #include "kvm_arm.h"
+#include "gicv3_internal.h"
 #include "vgic_common.h"
 
 #ifdef DEBUG_GICV3_KVM
@@ -41,6 +43,23 @@
 #define KVM_ARM_GICV3_GET_CLASS(obj) \
      OBJECT_GET_CLASS(KVMARMGICv3Class, (obj), TYPE_KVM_ARM_GICV3)
 
+#define ICC_PMR_EL1     \
+    KVM_DEV_ARM_VGIC_SYSREG(0b11, 0b000, 0b0100, 0b0110, 0b000)
+#define ICC_BPR0_EL1    \
+    KVM_DEV_ARM_VGIC_SYSREG(0b11, 0b000, 0b1100, 0b1000, 0b011)
+#define ICC_APR0_EL1(n) \
+    KVM_DEV_ARM_VGIC_SYSREG(0b11, 0b000, 0b1100, 0b1000, 0b100 | n)
+#define ICC_APR1_EL1(n) \
+    KVM_DEV_ARM_VGIC_SYSREG(0b11, 0b000, 0b1100, 0b1001, 0b000 | n)
+#define ICC_BPR1_EL1    \
+    KVM_DEV_ARM_VGIC_SYSREG(0b11, 0b000, 0b1100, 0b1100, 0b011)
+#define ICC_CTLR_EL1    \
+    KVM_DEV_ARM_VGIC_SYSREG(0b11, 0b000, 0b1100, 0b1100, 0b100)
+#define ICC_IGRPEN0_EL1 \
+    KVM_DEV_ARM_VGIC_SYSREG(0b11, 0b000, 0b1100, 0b1100, 0b110)
+#define ICC_IGRPEN1_EL1 \
+    KVM_DEV_ARM_VGIC_SYSREG(0b11, 0b000, 0b1100, 0b1100, 0b111)
+
 typedef struct KVMARMGICv3Class {
     ARMGICv3CommonClass parent_class;
     DeviceRealize parent_realize;
@@ -54,16 +73,446 @@ static void kvm_arm_gicv3_set_irq(void *opaque, int irq, int level)
     kvm_arm_gic_set_irq(s->num_irq, irq, level);
 }
 
+static uint32_t kvm_arm_gicv3_get_cpuid(int ncpu)
+{
+    Object *cpu = OBJECT(qemu_get_cpu(ncpu));
+    uint64_t cpuid = object_property_get_int(cpu, "mp-affinity", NULL);
+
+    return ((cpuid & ARM_AFF3_MASK) >> 8) | (cpuid & ARM32_AFFINITY_MASK);
+}
+
+#define KVM_VGIC_ATTR(reg, cpuid) \
+    (((uint64_t)(cpuid) << KVM_DEV_ARM_VGIC_CPUID_SHIFT) | (reg))
+
+static inline void kvm_gicd_access(GICv3State *s, int offset, uint32_t cpuid,
+                                   uint64_t *val, bool write)
+{
+    kvm_device_access(s->dev_fd, KVM_DEV_ARM_VGIC_GRP_DIST_REGS,
+                      KVM_VGIC_ATTR(offset, cpuid), val, write);
+}
+
+static inline void kvm_gicr_access(GICv3State *s, int offset, uint32_t cpuid,
+                                   uint64_t *val, bool write)
+{
+    kvm_device_access(s->dev_fd, KVM_DEV_ARM_VGIC_GRP_REDIST_REGS,
+                      KVM_VGIC_ATTR(offset, cpuid), val, write);
+}
+
+static inline void kvm_gicc_access(GICv3State *s, uint64_t reg, uint32_t cpuid,
+                                   uint64_t *val, bool write)
+{
+    kvm_device_access(s->dev_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
+                      KVM_VGIC_ATTR(reg, cpuid), val, write);
+}
+
+/*
+ * Translate from the in-kernel field for an IRQ value to/from the qemu
+ * representation.
+ */
+typedef void (*vgic_translate_fn)(GICv3State *s, GICv3CPUState *c, int irq,
+                                  uint32_t *field, bool to_kernel);
+
+/* synthetic translate function used for clear/set registers to completely
+ * clear a setting using a clear-register before setting the remaining bits
+ * using a set-register */
+static void translate_clear(GICv3State *s, GICv3CPUState *c, int irq,
+                            uint32_t *field, bool to_kernel)
+{
+    if (to_kernel) {
+        *field = ~0;
+    } else {
+        /* does not make sense: qemu model doesn't use set/clear regs */
+        abort();
+    }
+}
+
+static void translate_enabled(GICv3State *s, GICv3CPUState *c, int irq,
+                              uint32_t *field, bool to_kernel)
+{
+    if (to_kernel) {
+        *field = GIC_TEST_BIT(irq, enabled);
+    } else {
+        GIC_REPLACE_BIT(irq, enabled, *field);
+    }
+}
+
+static void translate_group(GICv3State *s, GICv3CPUState *c, int irq,
+                            uint32_t *field, bool to_kernel)
+{
+    if (to_kernel) {
+        *field = GIC_TEST_BIT(irq, group);
+    } else {
+        GIC_REPLACE_BIT(irq, group, *field);
+    }
+}
+
+static void translate_trigger(GICv3State *s, GICv3CPUState *c, int irq,
+                              uint32_t *field, bool to_kernel)
+{
+    if (to_kernel) {
+        *field = GIC_TEST_BIT(irq, edge_trigger) ? 2 : 0;
+    } else {
+        GIC_REPLACE_BIT(irq, edge_trigger, *field & 2);
+    }
+}
+
+static void translate_pending(GICv3State *s, GICv3CPUState *c, int irq,
+                              uint32_t *field, bool to_kernel)
+{
+    if (to_kernel) {
+        *field = GIC_TEST_BIT(irq, pending);
+    } else {
+        GIC_REPLACE_BIT(irq, pending, *field);
+        /* TODO: Capture if level-line is held high in the kernel */
+    }
+}
+
+static void translate_active(GICv3State *s, GICv3CPUState *c, int irq,
+                             uint32_t *field, bool to_kernel)
+{
+    if (to_kernel) {
+        *field = GIC_TEST_BIT(irq, active);
+    } else {
+        GIC_REPLACE_BIT(irq, active, *field);
+    }
+}
+
+static void translate_priority(GICv3State *s, GICv3CPUState *c, int irq,
+                               uint32_t *field, bool to_kernel)
+{
+    if (to_kernel) {
+        *field = GIC_GET_PRIORITY(irq);
+    } else {
+        GIC_SET_PRIORITY(irq, *field);
+    }
+}
+
+#define for_each_irq_reg(_irq, _max, _field_width) \
+    for (_irq = 0; _irq < _max; _irq += (32 / _field_width))
+
+/* Read a register group from the kernel VGIC */
+static void kvm_dist_get(GICv3State *s, uint32_t offset, int width,
+                         vgic_translate_fn translate_fn)
+{
+    uint64_t reg;
+    int j;
+    int irq, cpu, maxcpu;
+    uint32_t field, cpuid;
+    int regsz = 32 / width; /* irqs per kernel register */
+
+    for_each_irq_reg(irq, s->num_irq, width) {
+        maxcpu = irq < GIC_INTERNAL ? s->num_cpu : 1;
+        for (cpu = 0; cpu < maxcpu; cpu++) {
+            cpuid = kvm_arm_gicv3_get_cpuid(cpu);
+            /* In GICv3 SGI/PPIs are stored in redistributor
+             * Offsets in SGI area are the same as in distributor
+             */
+            if (irq < GIC_INTERNAL) {
+                kvm_gicr_access(s, offset + GICR_SGI_OFFSET, cpuid, &reg,
+                                false);
+            } else {
+                kvm_gicd_access(s, offset, cpuid, &reg, false);
+            }
+            for (j = 0; j < regsz; j++) {
+                field = extract32(reg, j * width, width);
+                translate_fn(s, &s->cpu[cpu], irq + j, &field, false);
+            }
+        }
+        offset += 4;
+    }
+}
+
+/* Write a register group to the kernel VGIC */
+static void kvm_dist_put(GICv3State *s, uint32_t offset, int width,
+                         vgic_translate_fn translate_fn)
+{
+    uint64_t reg;
+    int j;
+    int irq, cpu, maxcpu;
+    uint32_t field, cpuid;
+    int regsz = 32 / width; /* irqs per kernel register */
+
+    for_each_irq_reg(irq, s->num_irq, width) {
+        maxcpu = irq < GIC_INTERNAL ? s->num_cpu : 1;
+        for (cpu = 0; cpu < maxcpu; cpu++) {
+            cpuid = kvm_arm_gicv3_get_cpuid(cpu);
+            reg = 0;
+            for (j = 0; j < regsz; j++) {
+                translate_fn(s, &s->cpu[cpu], irq + j, &field, true);
+                reg = deposit32(reg, j * width, width, field);
+            }
+            /* In GICv3 SGI/PPIs are stored in redistributor
+             * Offsets in SGI area are the same as in distributor
+             */
+            if (irq < GIC_INTERNAL) {
+                kvm_gicr_access(s, offset + GICR_SGI_OFFSET, cpuid, &reg,
+                                true);
+            } else {
+                kvm_gicd_access(s, offset, cpuid, &reg, true);
+            }
+        }
+        offset += 4;
+    }
+}
+
+static void kvm_arm_gicv3_check(GICv3State *s, uint32_t cpuid0)
+{
+    uint64_t reg;
+    uint32_t num_irq;
+
+    /* Sanity checking s->num_irq */
+    kvm_gicd_access(s, GICD_TYPER, cpuid0, &reg, false);
+    num_irq = ((reg & 0x1f) + 1) * 32;
+
+    if (num_irq < s->num_irq) {
+        error_report("Model requests %u IRQs, but kernel supports max %u\n",
+                     s->num_irq, num_irq);
+        abort();
+    }
+
+    /* TODO: Consider checking compatibility with the IIDR ? */
+}
+
 static void kvm_arm_gicv3_put(GICv3State *s)
 {
-    /* TODO */
-    DPRINTF("Cannot put kernel gic state, no kernel interface\n");
+    uint32_t cpuid0 = kvm_arm_gicv3_get_cpuid(0);
+    uint64_t reg, redist_typer;
+    int ncpu, i;
+
+    kvm_arm_gicv3_check(s, cpuid0);
+
+    kvm_gicr_access(s, GICR_TYPER, cpuid0, &redist_typer, false);
+
+    /*****************************************************************
+     * (Re)distributor State
+     */
+
+    reg = s->ctlr;
+    kvm_gicd_access(s, GICD_CTLR, 0, &reg, true);
+
+    if (redist_typer & GICR_TYPER_PLPIS) {
+        /* Set base addresses before LPIs are enabled by GICR_CTLR write */
+        for (ncpu = 0; ncpu < s->num_cpu; ncpu++) {
+            GICv3CPUState *c = &s->cpu[ncpu];
+            uint32_t cpuid = kvm_arm_gicv3_get_cpuid(ncpu);
+
+            reg = c->propbaser & (GICR_PROPBASER_OUTER_CACHEABILITY_MASK |
+                                  GICR_PROPBASER_ADDR_MASK |
+                                  GICR_PROPBASER_SHAREABILITY_MASK |
+                                  GICR_PROPBASER_CACHEABILITY_MASK |
+                                  GICR_PROPBASER_IDBITS_MASK);
+            kvm_gicr_access(s, GICR_PROPBASER, cpuid, &reg, true);
+
+            reg = c->pendbaser & (GICR_PENDBASER_OUTER_CACHEABILITY_MASK |
+                                  GICR_PENDBASER_ADDR_MASK |
+                                  GICR_PENDBASER_SHAREABILITY_MASK |
+                                  GICR_PENDBASER_CACHEABILITY_MASK);
+            if (!c->redist_ctlr & GICR_CTLR_ENABLE_LPIS) {
+                reg |= GICR_PENDBASER_PTZ;
+            }
+            kvm_gicr_access(s, GICR_PENDBASER, cpuid, &reg, true);
+        }
+    }
+
+    for (ncpu = 0; ncpu < s->num_cpu; ncpu++) {
+        GICv3CPUState *c = &s->cpu[ncpu];
+        uint32_t cpuid = kvm_arm_gicv3_get_cpuid(ncpu);
+
+        reg = c->redist_ctlr & (GICR_CTLR_ENABLE_LPIS | GICR_CTLR_DPG0 |
+                                GICR_CTLR_DPG1NS | GICR_CTLR_DPG1S);
+        kvm_gicr_access(s, GICR_CTLR, cpuid, &reg, true);
+
+        reg = c->cpu_enabled ? 0 : GICR_WAKER_ProcessorSleep;
+        kvm_gicr_access(s, GICR_WAKER, cpuid, &reg, true);
+    }
+
+    /* irq_state[n].enabled -> GICD_ISENABLERn */
+    kvm_dist_put(s, GICD_ICENABLER, 1, translate_clear);
+    kvm_dist_put(s, GICD_ISENABLER, 1, translate_enabled);
+
+    /* irq_state[n].group -> GICD_IGROUPRn */
+    kvm_dist_put(s, GICD_IGROUPR, 1, translate_group);
+
+    /* Restore targets before pending to ensure the pending state is set on
+     * the appropriate CPU interfaces in the kernel */
+
+    /* s->route[irq] -> GICD_IROUTERn */
+    for (i = GIC_INTERNAL; i < s->num_irq; i++) {
+        uint32_t offset = GICD_IROUTER + (sizeof(reg) * i);
+
+        reg = s->irq_route[i - GIC_INTERNAL];
+        kvm_gicd_access(s, offset, cpuid0, &reg, true);
+    }
+
+    /* irq_state[n].trigger -> GICD_ICFGRn
+     * (restore configuration registers before pending IRQs so we treat
+     * level/edge correctly) */
+    kvm_dist_put(s, GICD_ICFGR, 2, translate_trigger);
+
+    /* irq_state[n].pending + irq_state[n].level -> GICD_ISPENDRn */
+    kvm_dist_put(s, GICD_ICPENDR, 1, translate_clear);
+    kvm_dist_put(s, GICD_ISPENDR, 1, translate_pending);
+
+    /* irq_state[n].active -> GICD_ISACTIVERn */
+    kvm_dist_put(s, GICD_ICACTIVER, 1, translate_clear);
+    kvm_dist_put(s, GICD_ISACTIVER, 1, translate_active);
+
+    /* s->priorityX[irq] -> ICD_IPRIORITYRn */
+    kvm_dist_put(s, GICD_IPRIORITYR, 8, translate_priority);
+
+    /*****************************************************************
+     * CPU Interface(s) State
+     */
+
+    for (ncpu = 0; ncpu < s->num_cpu; ncpu++) {
+        GICv3CPUState *c = &s->cpu[ncpu];
+        uint32_t cpuid = kvm_arm_gicv3_get_cpuid(ncpu);
+
+        reg = c->ctlr[1] & (ICC_CTLR_CBPR | ICC_CTLR_EOIMODE | ICC_CTLR_PMHE);
+        kvm_gicc_access(s, ICC_CTLR_EL1, cpuid, &reg, true);
+
+        reg = gicv3_get_igrpen0(s, ncpu);
+        kvm_gicc_access(s, ICC_IGRPEN0_EL1, cpuid, &reg, true);
+
+        reg = gicv3_get_igrpen1(s, ncpu);
+        kvm_gicc_access(s, ICC_IGRPEN1_EL1, cpuid, &reg, true);
+
+        reg = c->priority_mask;
+        kvm_gicc_access(s, ICC_PMR_EL1, cpuid, &reg, true);
+
+        reg = c->bpr[0];
+        kvm_gicc_access(s, ICC_BPR0_EL1, cpuid, &reg, true);
+
+        reg = c->bpr[1];
+        kvm_gicc_access(s, ICC_BPR1_EL1, cpuid, &reg, true);
+
+        for (i = 0; i < 4; i++) {
+            reg = c->apr[i][0];
+            kvm_gicc_access(s, ICC_APR0_EL1(i), cpuid, &reg, true);
+        }
+
+        for (i = 0; i < 4; i++) {
+            reg = c->apr[i][1];
+            kvm_gicc_access(s, ICC_APR1_EL1(i), cpuid, &reg, true);
+        }
+    }
 }
 
 static void kvm_arm_gicv3_get(GICv3State *s)
 {
-    /* TODO */
-    DPRINTF("Cannot get kernel gic state, no kernel interface\n");
+    uint32_t cpuid0 = kvm_arm_gicv3_get_cpuid(0);
+    uint64_t reg, redist_typer;
+    int ncpu, i;
+
+    kvm_arm_gicv3_check(s, cpuid0);
+
+    kvm_gicr_access(s, GICR_TYPER, cpuid0, &redist_typer, false);
+
+    /*****************************************************************
+     * (Re)distributor State
+     */
+
+    /* GICD_CTLR -> s->ctlr */
+    kvm_gicd_access(s, GICD_CTLR, 0, &reg, false);
+    s->ctlr = reg;
+
+    for (ncpu = 0; ncpu < s->num_cpu; ncpu++) {
+        GICv3CPUState *c = &s->cpu[ncpu];
+        uint32_t cpuid = kvm_arm_gicv3_get_cpuid(ncpu);
+
+        kvm_gicr_access(s, GICR_CTLR, cpuid, &reg, false);
+        c->redist_ctlr = reg & (GICR_CTLR_ENABLE_LPIS | GICR_CTLR_DPG0 |
+                                GICR_CTLR_DPG1NS | GICR_CTLR_DPG1S);
+
+        kvm_gicr_access(s, GICR_WAKER, cpuid, &reg, false);
+        c->cpu_enabled = !(reg & GICR_WAKER_ProcessorSleep);
+    }
+
+    if (redist_typer & GICR_TYPER_PLPIS) {
+        for (ncpu = 0; ncpu < s->num_cpu; ncpu++) {
+            GICv3CPUState *c = &s->cpu[ncpu];
+            uint32_t cpuid = kvm_arm_gicv3_get_cpuid(ncpu);
+
+            kvm_gicr_access(s, GICR_PROPBASER, cpuid, &reg, false);
+            c->propbaser = reg & (GICR_PROPBASER_OUTER_CACHEABILITY_MASK |
+                                  GICR_PROPBASER_ADDR_MASK |
+                                  GICR_PROPBASER_SHAREABILITY_MASK |
+                                  GICR_PROPBASER_CACHEABILITY_MASK |
+                                  GICR_PROPBASER_IDBITS_MASK);
+
+            kvm_gicr_access(s, GICR_PENDBASER, cpuid, &reg, false);
+            c->pendbaser = reg & (GICR_PENDBASER_OUTER_CACHEABILITY_MASK |
+                                  GICR_PENDBASER_ADDR_MASK |
+                                  GICR_PENDBASER_SHAREABILITY_MASK |
+                                  GICR_PENDBASER_CACHEABILITY_MASK);
+        }
+    }
+
+    /* GICD_IIDR -> ? */
+    /* kvm_gicd_access(s, GICD_IIDR, 0, &reg, false); */
+
+    /* GICD_IGROUPRn -> irq_state[n].group */
+    kvm_dist_get(s, GICD_IGROUPR, 1, translate_group);
+
+    /* GICD_ISENABLERn -> irq_state[n].enabled */
+    kvm_dist_get(s, GICD_ISENABLER, 1, translate_enabled);
+
+    /* GICD_ISPENDRn -> irq_state[n].pending + irq_state[n].level */
+    kvm_dist_get(s, GICD_ISPENDR, 1, translate_pending);
+
+    /* GICD_ISACTIVERn -> irq_state[n].active */
+    kvm_dist_get(s, GICD_ISACTIVER, 1, translate_active);
+
+    /* GICD_ICFRn -> irq_state[n].trigger */
+    kvm_dist_get(s, GICD_ICFGR, 2, translate_trigger);
+
+    /* GICD_IPRIORITYRn -> s->priorityX[irq] */
+    kvm_dist_get(s, GICD_IPRIORITYR, 8, translate_priority);
+
+    /* GICD_IROUTERn -> s->route[irq] */
+    for (i = GIC_INTERNAL; i < s->num_irq; i++) {
+        uint32_t offset = GICD_IROUTER + (sizeof(reg) * i);
+
+        kvm_gicd_access(s, offset, cpuid0, &reg, false);
+        s->irq_route[i - GIC_INTERNAL] = reg;
+    }
+
+    /*****************************************************************
+     * CPU Interface(s) State
+     */
+
+    for (ncpu = 0; ncpu < s->num_cpu; ncpu++) {
+        GICv3CPUState *c = &s->cpu[ncpu];
+        uint32_t cpuid = kvm_arm_gicv3_get_cpuid(ncpu);
+
+        kvm_gicc_access(s, ICC_CTLR_EL1, cpuid, &reg, false);
+        c->ctlr[1] = reg & (ICC_CTLR_CBPR | ICC_CTLR_EOIMODE | ICC_CTLR_PMHE);
+
+        kvm_gicc_access(s, ICC_IGRPEN0_EL1, cpuid, &reg, false);
+        gicv3_set_igrpen0(s, ncpu, reg);
+
+        kvm_gicc_access(s, ICC_IGRPEN1_EL1, cpuid, &reg, false);
+        gicv3_set_igrpen1(s, ncpu, reg);
+
+        kvm_gicc_access(s, ICC_PMR_EL1, cpuid, &reg, false);
+        c->priority_mask = reg & ICC_PMR_PRIORITY_MASK;
+
+        kvm_gicc_access(s, ICC_BPR0_EL1, cpuid, &reg, false);
+        c->bpr[0] = reg & ICC_BPR_BINARYPOINT_MASK;
+
+        kvm_gicc_access(s, ICC_BPR1_EL1, cpuid, &reg, false);
+        c->bpr[1] = reg & ICC_BPR_BINARYPOINT_MASK;
+
+        for (i = 0; i < 4; i++) {
+            kvm_gicc_access(s, ICC_APR0_EL1(i), cpuid, &reg, false);
+            c->apr[i][0] = reg;
+        }
+
+        for (i = 0; i < 4; i++) {
+            kvm_gicc_access(s, ICC_APR1_EL1(i), cpuid, &reg, false);
+            c->apr[i][1] = reg;
+        }
+    }
 }
 
 static void kvm_arm_gicv3_reset(DeviceState *dev)
@@ -74,6 +523,12 @@ static void kvm_arm_gicv3_reset(DeviceState *dev)
     DPRINTF("Reset\n");
 
     kgc->parent_reset(dev);
+
+    if (!kvm_device_check_attr(s->dev_fd, KVM_DEV_ARM_VGIC_GRP_DIST_REGS, 0)) {
+        DPRINTF("Cannot put kernel gic state, no kernel interface\n");
+        return;
+    }
+
     kvm_arm_gicv3_put(s);
 }
 
Signature · 1 line
2.4.4
#5 lore raw

RFC PATCH v2 5/5 hw/intc/arm_gicv3_common: Add vmstate descriptors

In reply to Pavel Fedin

Add state structure descriptors and actually enable live migration.

In order to describe fixed-size bitmaps, VMSTATE_BITMAP_STATIC() macro is added.

---
 hw/intc/arm_gicv3_common.c  | 46 ++++++++++++++++++++++++++++++++++++++++++++-
 include/migration/vmstate.h |  9 +++++++++
 2 files changed, 54 insertions(+), 1 deletion(-)
hw/intc/arm_gicv3_common.c +45 -1
index 32aca02..9c955b6 100644
@@ -45,11 +45,55 @@ static int gicv3_post_load(void *opaque, int version_id)
     return 0;
 }
 
+static const VMStateDescription vmstate_gicv3_cpu = {
+    .name = "arm_gicv3_cpu",
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .fields = (VMStateField[]) {
+        VMSTATE_BOOL(cpu_enabled, GICv3CPUState),
+        VMSTATE_UINT32(redist_ctlr, GICv3CPUState),
+        VMSTATE_UINT32(group, GICv3CPUState),
+        VMSTATE_UINT32(enabled, GICv3CPUState),
+        VMSTATE_UINT32(pending, GICv3CPUState),
+        VMSTATE_UINT32(active, GICv3CPUState),
+        VMSTATE_UINT32(edge_trigger, GICv3CPUState),
+        VMSTATE_UINT8_ARRAY(priority, GICv3CPUState, GIC_INTERNAL),
+        VMSTATE_UINT64(propbaser, GICv3CPUState),
+        VMSTATE_UINT64(pendbaser, GICv3CPUState),
+        VMSTATE_UINT32_ARRAY(ctlr, GICv3CPUState, 2),
+        VMSTATE_UINT32(priority_mask, GICv3CPUState),
+        VMSTATE_UINT32_ARRAY(bpr, GICv3CPUState, 2),
+        VMSTATE_UINT32_2DARRAY(apr, GICv3CPUState, 4, 2),
+        VMSTATE_UINT32(legacy_ctlr, GICv3CPUState),
+        VMSTATE_UINT16(current_pending, GICv3CPUState),
+        VMSTATE_UINT16(running_irq, GICv3CPUState),
+        VMSTATE_UINT16(running_priority, GICv3CPUState),
+        VMSTATE_UINT16_ARRAY(last_active, GICv3CPUState, GICV3_MAXIRQ),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
 static const VMStateDescription vmstate_gicv3 = {
     .name = "arm_gicv3",
-    .unmigratable = 1,
+    .version_id = 1,
+    .minimum_version_id = 1,
     .pre_save = gicv3_pre_save,
     .post_load = gicv3_post_load,
+    .fields = (VMStateField[]) {
+        VMSTATE_UINT32(ctlr, GICv3State),
+        VMSTATE_BITMAP_STATIC(group, GICv3State , 0, GICV3_MAXSPI),
+        VMSTATE_BITMAP_STATIC(enabled, GICv3State , 0, GICV3_MAXSPI),
+        VMSTATE_BITMAP_STATIC(pending, GICv3State , 0, GICV3_MAXSPI),
+        VMSTATE_BITMAP_STATIC(active, GICv3State , 0, GICV3_MAXSPI),
+        VMSTATE_BITMAP_STATIC(level, GICv3State , 0, GICV3_MAXSPI),
+        VMSTATE_BITMAP_STATIC(edge_trigger, GICv3State , 0, GICV3_MAXSPI),
+        VMSTATE_UINT8_ARRAY(priority, GICv3State, GICV3_MAXSPI),
+        VMSTATE_UINT8_ARRAY(irq_target, GICv3State, GICV3_MAXSPI),
+        VMSTATE_UINT64_ARRAY(irq_route, GICv3State, GICV3_MAXSPI),
+        VMSTATE_STRUCT_VARRAY_POINTER_UINT32(cpu, GICv3State, num_cpu,
+                                             vmstate_gicv3_cpu, GICv3CPUState),
+        VMSTATE_END_OF_LIST()
+    }
 };
 
 void gicv3_init_irqs_and_mmio(GICv3State *s, qemu_irq_handler handler,
include/migration/vmstate.h +9 -0
index 9a65522..7d060e9 100644
@@ -537,6 +537,15 @@ extern const VMStateInfo vmstate_info_bitmap;
     .offset       = offsetof(_state, _field),                        \
 }
 
+#define VMSTATE_BITMAP_STATIC(_field, _state, _version, _size) {     \
+    .name         = (stringify(_field)),                             \
+    .version_id   = (_version),                                      \
+    .size         = (_size),                                         \
+    .info         = &vmstate_info_bitmap,                            \
+    .flags        = VMS_BUFFER,                                      \
+    .offset       = offsetof(_state, _field),                        \
+}
+
 /* _f : field name
    _f_n : num of elements field_name
    _n : num of elements
Signature · 1 line
2.4.4