1 files changed, 166 insertions, 12 deletions

diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c
index 2d30e3afdaf9..9ada5549216d 100644
--- a/arch/arm/kvm/arm.c
+++ b/arch/arm/kvm/arm.c
@@ -54,11 +54,40 @@ static DEFINE_PER_CPU(unsigned long, kvm_arm_hyp_stack_page);
 static struct vfp_hard_struct __percpu *kvm_host_vfp_state;
 static unsigned long hyp_default_vectors;
 
+/* Per-CPU variable containing the currently running vcpu. */
+static DEFINE_PER_CPU(struct kvm_vcpu *, kvm_arm_running_vcpu);
+
 /* The VMID used in the VTTBR */
 static atomic64_t kvm_vmid_gen = ATOMIC64_INIT(1);
 static u8 kvm_next_vmid;
 static DEFINE_SPINLOCK(kvm_vmid_lock);
 
+static bool vgic_present;
+
+static void kvm_arm_set_running_vcpu(struct kvm_vcpu *vcpu)
+{
+        BUG_ON(preemptible());
+        __get_cpu_var(kvm_arm_running_vcpu) = vcpu;
+}
+
+/**
+ * kvm_arm_get_running_vcpu - get the vcpu running on the current CPU.
+ * Must be called from non-preemptible context
+ */
+struct kvm_vcpu *kvm_arm_get_running_vcpu(void)
+{
+        BUG_ON(preemptible());
+        return __get_cpu_var(kvm_arm_running_vcpu);
+}
+
+/**
+ * kvm_arm_get_running_vcpus - get the per-CPU array of currently running vcpus.
+ */
+struct kvm_vcpu __percpu **kvm_get_running_vcpus(void)
+{
+        return &kvm_arm_running_vcpu;
+}
+
 int kvm_arch_hardware_enable(void *garbage)
 {
         return 0;
@@ -157,6 +186,9 @@ int kvm_dev_ioctl_check_extension(long ext)
 {
         int r;
         switch (ext) {
+        case KVM_CAP_IRQCHIP:
+                r = vgic_present;
+                break;
         case KVM_CAP_USER_MEMORY:
         case KVM_CAP_SYNC_MMU:
         case KVM_CAP_DESTROY_MEMORY_REGION_WORKS:
@@ -167,6 +199,8 @@ int kvm_dev_ioctl_check_extension(long ext)
         case KVM_CAP_COALESCED_MMIO:
                 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
                 break;
+        case KVM_CAP_ARM_SET_DEVICE_ADDR:
+                r = 1;
         case KVM_CAP_NR_VCPUS:
                 r = num_online_cpus();
                 break;
@@ -255,6 +289,7 @@ int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
 {
         kvm_mmu_free_memory_caches(vcpu);
+        kvm_timer_vcpu_terminate(vcpu);
         kmem_cache_free(kvm_vcpu_cache, vcpu);
 }
 
@@ -286,8 +321,19 @@ int __attribute_const__ kvm_target_cpu(void)
 
 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
 {
+        int ret;
+
         /* Force users to call KVM_ARM_VCPU_INIT */
         vcpu->arch.target = -1;
+
+        /* Set up VGIC */
+        ret = kvm_vgic_vcpu_init(vcpu);
+        if (ret)
+                return ret;
+
+        /* Set up the timer */
+        kvm_timer_vcpu_init(vcpu);
+
         return 0;
 }
 
@@ -308,10 +354,13 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
          */
         if (cpumask_test_and_clear_cpu(cpu, &vcpu->arch.require_dcache_flush))
                 flush_cache_all(); /* We'd really want v7_flush_dcache_all() */
+
+        kvm_arm_set_running_vcpu(vcpu);
 }
 
 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
 {
+        kvm_arm_set_running_vcpu(NULL);
 }
 
 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
@@ -342,7 +391,7 @@ int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
  */
 int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
 {
-        return !!v->arch.irq_lines;
+        return !!v->arch.irq_lines || kvm_vgic_vcpu_pending_irq(v);
 }
 
 /* Just ensure a guest exit from a particular CPU */
@@ -597,6 +646,17 @@ static int kvm_vcpu_first_run_init(struct kvm_vcpu *vcpu)
         vcpu->arch.has_run_once = true;
 
         /*
+         * Initialize the VGIC before running a vcpu the first time on
+         * this VM.
+         */
+        if (irqchip_in_kernel(vcpu->kvm) &&
+            unlikely(!vgic_initialized(vcpu->kvm))) {
+                int ret = kvm_vgic_init(vcpu->kvm);
+                if (ret)
+                        return ret;
+        }
+
+        /*
          * Handle the "start in power-off" case by calling into the
          * PSCI code.
          */
@@ -661,6 +721,9 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
                 if (vcpu->arch.pause)
                         vcpu_pause(vcpu);
 
+                kvm_vgic_flush_hwstate(vcpu);
+                kvm_timer_flush_hwstate(vcpu);
+
                 local_irq_disable();
 
                 /*
@@ -673,6 +736,8 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
 
                 if (ret <= 0 || need_new_vmid_gen(vcpu->kvm)) {
                         local_irq_enable();
+                        kvm_timer_sync_hwstate(vcpu);
+                        kvm_vgic_sync_hwstate(vcpu);
                         continue;
                 }
 
@@ -705,6 +770,9 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
                  * Back from guest
                  *************************************************************/
 
+                kvm_timer_sync_hwstate(vcpu);
+                kvm_vgic_sync_hwstate(vcpu);
+
                 ret = handle_exit(vcpu, run, ret);
         }
 
@@ -760,20 +828,49 @@ int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_level)
 
         trace_kvm_irq_line(irq_type, vcpu_idx, irq_num, irq_level->level);
 
-        if (irq_type != KVM_ARM_IRQ_TYPE_CPU)
-                return -EINVAL;
+        switch (irq_type) {
+        case KVM_ARM_IRQ_TYPE_CPU:
+                if (irqchip_in_kernel(kvm))
+                        return -ENXIO;
 
-        if (vcpu_idx >= nrcpus)
-                return -EINVAL;
+                if (vcpu_idx >= nrcpus)
+                        return -EINVAL;
 
-        vcpu = kvm_get_vcpu(kvm, vcpu_idx);
-        if (!vcpu)
-                return -EINVAL;
+                vcpu = kvm_get_vcpu(kvm, vcpu_idx);
+                if (!vcpu)
+                        return -EINVAL;
 
-        if (irq_num > KVM_ARM_IRQ_CPU_FIQ)
-                return -EINVAL;
+                if (irq_num > KVM_ARM_IRQ_CPU_FIQ)
+                        return -EINVAL;
+
+                return vcpu_interrupt_line(vcpu, irq_num, level);
+        case KVM_ARM_IRQ_TYPE_PPI:
+                if (!irqchip_in_kernel(kvm))
+                        return -ENXIO;
 
-        return vcpu_interrupt_line(vcpu, irq_num, level);
+                if (vcpu_idx >= nrcpus)
+                        return -EINVAL;
+
+                vcpu = kvm_get_vcpu(kvm, vcpu_idx);
+                if (!vcpu)
+                        return -EINVAL;
+
+                if (irq_num < VGIC_NR_SGIS || irq_num >= VGIC_NR_PRIVATE_IRQS)
+                        return -EINVAL;
+
+                return kvm_vgic_inject_irq(kvm, vcpu->vcpu_id, irq_num, level);
+        case KVM_ARM_IRQ_TYPE_SPI:
+                if (!irqchip_in_kernel(kvm))
+                        return -ENXIO;
+
+                if (irq_num < VGIC_NR_PRIVATE_IRQS ||
+                    irq_num > KVM_ARM_IRQ_GIC_MAX)
+                        return -EINVAL;
+
+                return kvm_vgic_inject_irq(kvm, 0, irq_num, level);
+        }
+
+        return -EINVAL;
 }
 
 long kvm_arch_vcpu_ioctl(struct file *filp,
@@ -827,10 +924,49 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log)
         return -EINVAL;
 }
 
+static int kvm_vm_ioctl_set_device_addr(struct kvm *kvm,
+                                        struct kvm_arm_device_addr *dev_addr)
+{
+        unsigned long dev_id, type;
+
+        dev_id = (dev_addr->id & KVM_ARM_DEVICE_ID_MASK) >>
+                KVM_ARM_DEVICE_ID_SHIFT;
+        type = (dev_addr->id & KVM_ARM_DEVICE_TYPE_MASK) >>
+                KVM_ARM_DEVICE_TYPE_SHIFT;
+
+        switch (dev_id) {
+        case KVM_ARM_DEVICE_VGIC_V2:
+                if (!vgic_present)
+                        return -ENXIO;
+                return kvm_vgic_set_addr(kvm, type, dev_addr->addr);
+        default:
+                return -ENODEV;
+        }
+}
+
 long kvm_arch_vm_ioctl(struct file *filp,
                        unsigned int ioctl, unsigned long arg)
 {
-        return -EINVAL;
+        struct kvm *kvm = filp->private_data;
+        void __user *argp = (void __user *)arg;
+
+        switch (ioctl) {
+        case KVM_CREATE_IRQCHIP: {
+                if (vgic_present)
+                        return kvm_vgic_create(kvm);
+                else
+                        return -ENXIO;
+        }
+        case KVM_ARM_SET_DEVICE_ADDR: {
+                struct kvm_arm_device_addr dev_addr;
+
+                if (copy_from_user(&dev_addr, argp, sizeof(dev_addr)))
+                        return -EFAULT;
+                return kvm_vm_ioctl_set_device_addr(kvm, &dev_addr);
+        }
+        default:
+                return -EINVAL;
+        }
 }
 
 static void cpu_init_hyp_mode(void *vector)
@@ -960,6 +1096,24 @@ static int init_hyp_mode(void)
                 }
         }
 
+        /*
+         * Init HYP view of VGIC
+         */
+        err = kvm_vgic_hyp_init();
+        if (err)
+                goto out_free_vfp;
+
+#ifdef CONFIG_KVM_ARM_VGIC
+                vgic_present = true;
+#endif
+
+        /*
+         * Init HYP architected timer support
+         */
+        err = kvm_timer_hyp_init();
+        if (err)
+                goto out_free_mappings;
+
         kvm_info("Hyp mode initialized successfully\n");
         return 0;
 out_free_vfp: