[PATCH v2 0 of 4] interrupt remapping in HVM guests

[PATCH v2 0 of 4] interrupt remapping in HVM guests

[Stefano Stabellini]

Hi all,
this is the second version of the patch series that implements the
mechanisms needed by a PV on HVM guest to remap interrupts and MSIs into
pirqs in order to receive those interrupts and MSIs as xen events.
This allows the guest to avoid any reads and writes to the emulated
LAPIC.
The series consists of 4 patches, 2 patches for the hypervisor and 2
patches to qemu-xen; the changes are not interdependent.


Changes compared to the last version:

- Jan's comments have been addressed (the initialization of emuirq_pirq
and pirq_emuirq has been fixed);

- the new hvm specific part of physdev_map_pirq has been moved to a
separate function, called physdev_hvm_map_pirq;

- the hypercall PHYSDEVOP_get_nr_pirqs has been removed, a new hypercall
PHYSDEVOP_get_free_pirq has been introduced instead to allow a guest to
get a free pirq number from Xen; the hypervisor would keep that pirq
free for the guest to use in a mapping.


The list of patches follows:

xen: interrupt remapping in HVM guests
xen: introduce PHYSDEVOP_get_free_pirq
qemu-xen: support PV on HVM MSI remapping
qemu-xen: qemu-xen: let xen choose the pirq number

Cheers,

Stefano Stabellini

[PATCH v2 1 of 4] xen: interrupt remapping in HVM guests

[stefano.stabellini]

This patch allows HVM guests to remap interrupts and MSIs into pirqs;
once the mapping is in place the guest will receive the interrupt (or
the MSI) as an event.
The interrupt to be remapped can either be an interrupt of an emulated
device or an interrupt of a passthrough device and we keep track of
that.

Signed-off-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com>

diff -r 7d2fdc083c9c xen/arch/x86/domain.c
--- a/xen/arch/x86/domain.c	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/arch/x86/domain.c	Thu Nov 18 19:54:04 2010 +0000
@@ -509,6 +509,19 @@ int arch_domain_create(struct domain *d,
             if ( !IO_APIC_IRQ(i) )
                 d->arch.irq_pirq[i] = d->arch.pirq_irq[i] = i;
 
+        if ( is_hvm_domain(d) )
+        {
+            d->arch.pirq_emuirq = xmalloc_array(int, d->nr_pirqs);
+            d->arch.emuirq_pirq = xmalloc_array(int, nr_irqs);
+            if ( !d->arch.pirq_emuirq || !d->arch.emuirq_pirq )
+                goto fail;
+            for (i = 0; i < d->nr_pirqs; i++)
+                d->arch.pirq_emuirq[i] = IRQ_UNBOUND;
+            for (i = 0; i < nr_irqs; i++)
+                d->arch.emuirq_pirq[i] = IRQ_UNBOUND;
+        }
+
+
         if ( (rc = iommu_domain_init(d)) != 0 )
             goto fail;
 
@@ -549,6 +562,8 @@ int arch_domain_create(struct domain *d,
     vmce_destroy_msr(d);
     xfree(d->arch.pirq_irq);
     xfree(d->arch.irq_pirq);
+    xfree(d->arch.pirq_emuirq);
+    xfree(d->arch.emuirq_pirq);
     free_xenheap_page(d->shared_info);
     if ( paging_initialised )
         paging_final_teardown(d);
@@ -600,6 +615,8 @@ void arch_domain_destroy(struct domain *
     free_xenheap_page(d->shared_info);
     xfree(d->arch.pirq_irq);
     xfree(d->arch.irq_pirq);
+    xfree(d->arch.pirq_emuirq);
+    xfree(d->arch.emuirq_pirq);
 }
 
 unsigned long pv_guest_cr4_fixup(const struct vcpu *v, unsigned long guest_cr4)
diff -r 7d2fdc083c9c xen/arch/x86/hvm/hvm.c
--- a/xen/arch/x86/hvm/hvm.c	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/arch/x86/hvm/hvm.c	Thu Nov 18 19:54:04 2010 +0000
@@ -2440,6 +2440,20 @@ static long hvm_memory_op(int cmd, XEN_G
     return rc;
 }
 
+static long hvm_physdev_op(int cmd, XEN_GUEST_HANDLE(void) arg)
+{
+    switch ( cmd )
+    {
+        case PHYSDEVOP_map_pirq:
+        case PHYSDEVOP_unmap_pirq:
+        case PHYSDEVOP_eoi:
+        case PHYSDEVOP_irq_status_query:
+            return do_physdev_op(cmd, arg);
+        default:
+            return -ENOSYS;
+    }
+}
+
 static long hvm_vcpu_op(
     int cmd, int vcpuid, XEN_GUEST_HANDLE(void) arg)
 {
@@ -2475,6 +2489,7 @@ static hvm_hypercall_t *hvm_hypercall32_
     [ __HYPERVISOR_memory_op ] = (hvm_hypercall_t *)hvm_memory_op,
     [ __HYPERVISOR_grant_table_op ] = (hvm_hypercall_t *)hvm_grant_table_op,
     [ __HYPERVISOR_vcpu_op ] = (hvm_hypercall_t *)hvm_vcpu_op,
+    [ __HYPERVISOR_physdev_op ] = (hvm_hypercall_t *)hvm_physdev_op,
     HYPERCALL(xen_version),
     HYPERCALL(event_channel_op),
     HYPERCALL(sched_op),
@@ -2526,10 +2541,28 @@ static long hvm_vcpu_op_compat32(
     return rc;
 }
 
+static long hvm_physdev_op_compat32(
+    int cmd, XEN_GUEST_HANDLE(void) arg)
+{
+    switch ( cmd )
+    {
+        case PHYSDEVOP_map_pirq:
+        case PHYSDEVOP_unmap_pirq:
+        case PHYSDEVOP_eoi:
+        case PHYSDEVOP_irq_status_query:
+            return compat_physdev_op(cmd, arg);
+        break;
+    default:
+            return -ENOSYS;
+        break;
+    }
+}
+
 static hvm_hypercall_t *hvm_hypercall64_table[NR_hypercalls] = {
     [ __HYPERVISOR_memory_op ] = (hvm_hypercall_t *)hvm_memory_op,
     [ __HYPERVISOR_grant_table_op ] = (hvm_hypercall_t *)hvm_grant_table_op,
     [ __HYPERVISOR_vcpu_op ] = (hvm_hypercall_t *)hvm_vcpu_op,
+    [ __HYPERVISOR_physdev_op ] = (hvm_hypercall_t *)hvm_physdev_op,
     HYPERCALL(xen_version),
     HYPERCALL(event_channel_op),
     HYPERCALL(sched_op),
@@ -2543,6 +2576,7 @@ static hvm_hypercall_t *hvm_hypercall32_
     [ __HYPERVISOR_memory_op ] = (hvm_hypercall_t *)hvm_memory_op_compat32,
     [ __HYPERVISOR_grant_table_op ] = (hvm_hypercall_t *)hvm_grant_table_op_compat32,
     [ __HYPERVISOR_vcpu_op ] = (hvm_hypercall_t *)hvm_vcpu_op_compat32,
+    [ __HYPERVISOR_physdev_op ] = (hvm_hypercall_t *)hvm_physdev_op_compat32,
     HYPERCALL(xen_version),
     HYPERCALL(event_channel_op),
     HYPERCALL(sched_op),
diff -r 7d2fdc083c9c xen/arch/x86/hvm/irq.c
--- a/xen/arch/x86/hvm/irq.c	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/arch/x86/hvm/irq.c	Thu Nov 18 19:54:04 2010 +0000
@@ -23,9 +23,30 @@
 #include <xen/types.h>
 #include <xen/event.h>
 #include <xen/sched.h>
+#include <xen/irq.h>
 #include <asm/hvm/domain.h>
 #include <asm/hvm/support.h>
 
+/* Must be called with hvm_domain->irq_lock hold */
+static void assert_irq(struct domain *d, unsigned ioapic_gsi, unsigned pic_irq)
+{
+    int pirq = domain_emuirq_to_pirq(d, ioapic_gsi);
+    if ( pirq != IRQ_UNBOUND )
+    {
+        send_guest_pirq(d, pirq);
+        return;
+    }
+    vioapic_irq_positive_edge(d, ioapic_gsi);
+    vpic_irq_positive_edge(d, pic_irq);
+}
+
+/* Must be called with hvm_domain->irq_lock hold */
+static void deassert_irq(struct domain *d, unsigned isa_irq)
+{
+    if ( domain_emuirq_to_pirq(d, isa_irq) != IRQ_UNBOUND )
+        vpic_irq_negative_edge(d, isa_irq);
+}
+
 static void __hvm_pci_intx_assert(
     struct domain *d, unsigned int device, unsigned int intx)
 {
@@ -45,10 +66,7 @@ static void __hvm_pci_intx_assert(
     isa_irq = hvm_irq->pci_link.route[link];
     if ( (hvm_irq->pci_link_assert_count[link]++ == 0) && isa_irq &&
          (hvm_irq->gsi_assert_count[isa_irq]++ == 0) )
-    {
-        vioapic_irq_positive_edge(d, isa_irq);
-        vpic_irq_positive_edge(d, isa_irq);
-    }
+        assert_irq(d, isa_irq, isa_irq);
 }
 
 void hvm_pci_intx_assert(
@@ -77,7 +95,7 @@ static void __hvm_pci_intx_deassert(
     isa_irq = hvm_irq->pci_link.route[link];
     if ( (--hvm_irq->pci_link_assert_count[link] == 0) && isa_irq &&
          (--hvm_irq->gsi_assert_count[isa_irq] == 0) )
-        vpic_irq_negative_edge(d, isa_irq);
+        deassert_irq(d, isa_irq);
 }
 
 void hvm_pci_intx_deassert(
@@ -100,10 +118,7 @@ void hvm_isa_irq_assert(
 
     if ( !__test_and_set_bit(isa_irq, &hvm_irq->isa_irq.i) &&
          (hvm_irq->gsi_assert_count[gsi]++ == 0) )
-    {
-        vioapic_irq_positive_edge(d, gsi);
-        vpic_irq_positive_edge(d, isa_irq);
-    }
+        assert_irq(d, gsi, isa_irq);
 
     spin_unlock(&d->arch.hvm_domain.irq_lock);
 }
@@ -120,7 +135,7 @@ void hvm_isa_irq_deassert(
 
     if ( __test_and_clear_bit(isa_irq, &hvm_irq->isa_irq.i) &&
          (--hvm_irq->gsi_assert_count[gsi] == 0) )
-        vpic_irq_negative_edge(d, isa_irq);
+        deassert_irq(d, isa_irq);
 
     spin_unlock(&d->arch.hvm_domain.irq_lock);
 }
diff -r 7d2fdc083c9c xen/arch/x86/irq.c
--- a/xen/arch/x86/irq.c	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/arch/x86/irq.c	Thu Nov 18 19:54:04 2010 +0000
@@ -1453,7 +1453,11 @@ int get_free_pirq(struct domain *d, int 
     {
         for ( i = 16; i < nr_irqs_gsi; i++ )
             if ( !d->arch.pirq_irq[i] )
-                break;
+            {
+                if ( !is_hvm_domain(d) ||
+                        d->arch.pirq_emuirq[i] == IRQ_UNBOUND )
+                    break;
+            }
         if ( i == nr_irqs_gsi )
             return -ENOSPC;
     }
@@ -1461,7 +1465,11 @@ int get_free_pirq(struct domain *d, int 
     {
         for ( i = d->nr_pirqs - 1; i >= nr_irqs_gsi; i-- )
             if ( !d->arch.pirq_irq[i] )
-                break;
+            {
+                if ( !is_hvm_domain(d) ||
+                        d->arch.pirq_emuirq[i] == IRQ_UNBOUND )
+                    break;
+            }
         if ( i < nr_irqs_gsi )
             return -ENOSPC;
     }
@@ -1792,3 +1800,82 @@ void fixup_irqs(void)
         peoi[sp].ready = 1;
     flush_ready_eoi();
 }
+
+int map_domain_emuirq_pirq(struct domain *d, int pirq, int emuirq)
+{
+    int old_emuirq = IRQ_UNBOUND, old_pirq = IRQ_UNBOUND;
+
+    ASSERT(spin_is_locked(&d->event_lock));
+
+    if ( !is_hvm_domain(d) )
+        return -EINVAL;
+
+    if ( pirq < 0 || pirq >= d->nr_pirqs ||
+            emuirq == IRQ_UNBOUND || emuirq >= (int) nr_irqs )
+    {
+        dprintk(XENLOG_G_ERR, "dom%d: invalid pirq %d or emuirq %d\n",
+                d->domain_id, pirq, emuirq);
+        return -EINVAL;
+    }
+
+    old_emuirq = domain_pirq_to_emuirq(d, pirq);
+    if ( emuirq != IRQ_PT )
+        old_pirq = domain_emuirq_to_pirq(d, emuirq);
+
+    if ( (old_emuirq != IRQ_UNBOUND && (old_emuirq != emuirq) ) ||
+         (old_pirq != IRQ_UNBOUND && (old_pirq != pirq)) )
+    {
+        dprintk(XENLOG_G_WARNING, "dom%d: pirq %d or emuirq %d already mapped\n",
+                d->domain_id, pirq, emuirq);
+        return 0;
+    }
+
+    d->arch.pirq_emuirq[pirq] = emuirq;
+    /* do not store emuirq mappings for pt devices */
+    if ( emuirq != IRQ_PT )
+        d->arch.emuirq_pirq[emuirq] = pirq;
+
+    return 0;
+}
+
+int unmap_domain_pirq_emuirq(struct domain *d, int pirq)
+{
+    int emuirq, ret = 0;
+
+    if ( !is_hvm_domain(d) )
+        return -EINVAL;
+
+    if ( (pirq < 0) || (pirq >= d->nr_pirqs) )
+        return -EINVAL;
+
+    ASSERT(spin_is_locked(&d->event_lock));
+
+    emuirq = domain_pirq_to_emuirq(d, pirq);
+    if ( emuirq == IRQ_UNBOUND )
+    {
+        dprintk(XENLOG_G_ERR, "dom%d: pirq %d not mapped\n",
+                d->domain_id, pirq);
+        ret = -EINVAL;
+        goto done;
+    }
+
+    d->arch.pirq_emuirq[pirq] = IRQ_UNBOUND;
+    d->arch.emuirq_pirq[emuirq] = IRQ_UNBOUND;
+
+ done:
+    return ret;
+}
+
+int hvm_domain_use_pirq(struct domain *d, int pirq)
+{
+    int emuirq;
+    
+    if ( !is_hvm_domain(d) )
+        return 0;
+
+    emuirq = domain_pirq_to_emuirq(d, pirq);
+    if ( emuirq != IRQ_UNBOUND && d->pirq_to_evtchn[pirq] != 0 )
+        return 1;
+    else
+        return 0;
+}
diff -r 7d2fdc083c9c xen/arch/x86/physdev.c
--- a/xen/arch/x86/physdev.c	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/arch/x86/physdev.c	Thu Nov 18 19:54:04 2010 +0000
@@ -27,6 +27,63 @@ int
 ioapic_guest_write(
     unsigned long physbase, unsigned int reg, u32 pval);
 
+static int physdev_hvm_map_pirq(struct domain *d, struct
+        physdev_map_pirq *map)
+{
+    int pirq, ret = 0;
+
+    spin_lock(&d->event_lock);
+    switch ( map->type )
+    {
+        case MAP_PIRQ_TYPE_GSI :
+            {
+                struct hvm_irq_dpci *hvm_irq_dpci;
+                struct hvm_girq_dpci_mapping *girq;
+                uint32_t machine_gsi = 0;
+
+                /* find the machine gsi corresponding to the
+                 * emulated gsi */
+                hvm_irq_dpci = domain_get_irq_dpci(d);
+                if (hvm_irq_dpci) {
+                    list_for_each_entry ( girq,
+                            &hvm_irq_dpci->girq[map->index],
+                            list ) {
+                        machine_gsi = girq->machine_gsi;
+                    }
+                }
+                /* found one, this mean we are dealing with a pt device */
+                if ( machine_gsi )
+                {
+                    map->index = domain_pirq_to_irq(d, machine_gsi);
+                    pirq = machine_gsi;
+                    if ( pirq > 0 )
+                        ret = 0;
+                    else
+                        ret = pirq;
+                }
+                /* we didn't find any, this means we are dealing
+                 * with an emulated device */
+                else
+                {
+                    pirq = map->pirq;
+                    if ( pirq < 0 )
+                    {
+                        pirq = get_free_pirq(d, map->type, map->index);
+                    }
+                    ret = map_domain_emuirq_pirq(d, pirq, map->index);
+                }
+                map->pirq = pirq;
+            }
+            break;
+        default :
+            ret = -EINVAL;
+            dprintk(XENLOG_G_WARNING, "map type %d not supported yet\n", map->type);
+            break;
+    }
+    spin_unlock(&d->event_lock);
+    return ret;
+}
+
 static int physdev_map_pirq(struct physdev_map_pirq *map)
 {
     struct domain *d;
@@ -43,6 +100,12 @@ static int physdev_map_pirq(struct physd
     if ( d == NULL )
         return -ESRCH;
 
+    if ( map->domid == DOMID_SELF && is_hvm_domain(d) )
+    {
+        ret = physdev_hvm_map_pirq(d, map);
+        goto free_domain;
+    }
+
     if ( !IS_PRIV_FOR(current->domain, d) )
     {
         ret = -EPERM;
@@ -148,6 +211,9 @@ static int physdev_map_pirq(struct physd
     if ( ret == 0 )
         map->pirq = pirq;
 
+    if ( !ret && is_hvm_domain(d) )
+        map_domain_emuirq_pirq(d, pirq, IRQ_PT);
+
 done:
     spin_unlock(&d->event_lock);
     spin_unlock(&pcidevs_lock);
@@ -169,6 +235,14 @@ static int physdev_unmap_pirq(struct phy
     if ( d == NULL )
         return -ESRCH;
 
+    if ( is_hvm_domain(d) )
+    {
+        spin_lock(&d->event_lock);
+        ret = unmap_domain_pirq_emuirq(d, unmap->pirq);
+        spin_unlock(&d->event_lock);
+        goto free_domain;
+    }
+
     ret = -EPERM;
     if ( !IS_PRIV_FOR(current->domain, d) )
         goto free_domain;
@@ -202,7 +276,11 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_H
             break;
         if ( v->domain->arch.pirq_eoi_map )
             evtchn_unmask(v->domain->pirq_to_evtchn[eoi.irq]);
-        ret = pirq_guest_eoi(v->domain, eoi.irq);
+        if ( !is_hvm_domain(v->domain) ||
+                domain_pirq_to_emuirq(v->domain, eoi.irq) == IRQ_PT )
+            ret = pirq_guest_eoi(v->domain, eoi.irq);
+        else
+            ret = 0;
         break;
     }
 
@@ -257,6 +335,13 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_H
         if ( (irq < 0) || (irq >= v->domain->nr_pirqs) )
             break;
         irq_status_query.flags = 0;
+        if ( is_hvm_domain(v->domain) &&
+                domain_pirq_to_emuirq(v->domain, irq) != IRQ_PT )
+        {
+            ret = copy_to_guest(arg, &irq_status_query, 1) ? -EFAULT : 0;
+            break;
+        }
+
         /*
          * Even edge-triggered or message-based IRQs can need masking from
          * time to time. If teh guest is not dynamically checking for this
diff -r 7d2fdc083c9c xen/common/event_channel.c
--- a/xen/common/event_channel.c	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/common/event_channel.c	Thu Nov 18 19:54:04 2010 +0000
@@ -331,7 +331,7 @@ static long evtchn_bind_pirq(evtchn_bind
     if ( (pirq < 0) || (pirq >= d->nr_pirqs) )
         return -EINVAL;
 
-    if ( !irq_access_permitted(d, pirq) )
+    if ( !is_hvm_domain(d) && !irq_access_permitted(d, pirq) )
         return -EPERM;
 
     spin_lock(&d->event_lock);
@@ -345,12 +345,15 @@ static long evtchn_bind_pirq(evtchn_bind
     chn = evtchn_from_port(d, port);
 
     d->pirq_to_evtchn[pirq] = port;
-    rc = pirq_guest_bind(v, pirq,
-                         !!(bind->flags & BIND_PIRQ__WILL_SHARE));
-    if ( rc != 0 )
+    if ( !is_hvm_domain(d) )
     {
-        d->pirq_to_evtchn[pirq] = 0;
-        goto out;
+        rc = pirq_guest_bind(v, pirq,
+                !!(bind->flags & BIND_PIRQ__WILL_SHARE));
+        if ( rc != 0 )
+        {
+            d->pirq_to_evtchn[pirq] = 0;
+            goto out;
+        }
     }
 
     chn->state  = ECS_PIRQ;
@@ -403,7 +406,8 @@ static long __evtchn_close(struct domain
         break;
 
     case ECS_PIRQ:
-        pirq_guest_unbind(d1, chn1->u.pirq.irq);
+        if ( !is_hvm_domain(d1) )
+            pirq_guest_unbind(d1, chn1->u.pirq.irq);
         d1->pirq_to_evtchn[chn1->u.pirq.irq] = 0;
         unlink_pirq_port(chn1, d1->vcpu[chn1->notify_vcpu_id]);
         break;
@@ -664,8 +668,17 @@ int send_guest_pirq(struct domain *d, in
     /*
      * It should not be possible to race with __evtchn_close():
      * The caller of this function must synchronise with pirq_guest_unbind().
+     *
+     * In the HVM case port is 0 when the guest disable the
+     * emulated interrupt\evtchn.
      */
-    ASSERT(port != 0);
+    if (!port)
+    {
+        if ( is_hvm_domain(d) )
+            return 0;
+        else
+            return -EINVAL;
+    }
 
     chn = evtchn_from_port(d, port);
     return evtchn_set_pending(d->vcpu[chn->notify_vcpu_id], port);
diff -r 7d2fdc083c9c xen/common/kernel.c
--- a/xen/common/kernel.c	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/common/kernel.c	Thu Nov 18 19:54:04 2010 +0000
@@ -261,7 +261,8 @@ DO(xen_version)(int cmd, XEN_GUEST_HANDL
                              (1U << XENFEAT_gnttab_map_avail_bits);
             else
                 fi.submap |= (1U << XENFEAT_hvm_safe_pvclock) |
-                             (1U << XENFEAT_hvm_callback_vector);
+                             (1U << XENFEAT_hvm_callback_vector) |
+                             (1U << XENFEAT_hvm_pirqs);
 #endif
             break;
         default:
diff -r 7d2fdc083c9c xen/drivers/passthrough/io.c
--- a/xen/drivers/passthrough/io.c	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/drivers/passthrough/io.c	Thu Nov 18 19:54:04 2010 +0000
@@ -375,6 +375,7 @@ int pt_irq_destroy_bind_vtd(
             hvm_irq_dpci->mirq[machine_gsi].dom   = NULL;
             hvm_irq_dpci->mirq[machine_gsi].flags = 0;
             clear_bit(machine_gsi, hvm_irq_dpci->mapping);
+            unmap_domain_pirq_emuirq(d, machine_gsi);
         }
     }
     spin_unlock(&d->event_lock);
@@ -454,7 +455,10 @@ void hvm_dpci_msi_eoi(struct domain *d, 
 extern int vmsi_deliver(struct domain *d, int pirq);
 static int hvm_pci_msi_assert(struct domain *d, int pirq)
 {
-    return vmsi_deliver(d, pirq);
+    if ( hvm_domain_use_pirq(d, pirq) )
+        return send_guest_pirq(d, pirq);
+    else
+        return vmsi_deliver(d, pirq);
 }
 #endif
 
@@ -488,7 +492,10 @@ static void hvm_dirq_assist(unsigned lon
         {
             device = digl->device;
             intx = digl->intx;
-            hvm_pci_intx_assert(d, device, intx);
+            if ( hvm_domain_use_pirq(d, pirq) )
+                send_guest_pirq(d, pirq);
+            else
+                hvm_pci_intx_assert(d, device, intx);
             hvm_irq_dpci->mirq[pirq].pending++;
 
 #ifdef SUPPORT_MSI_REMAPPING
diff -r 7d2fdc083c9c xen/include/asm-x86/domain.h
--- a/xen/include/asm-x86/domain.h	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/include/asm-x86/domain.h	Thu Nov 18 19:54:04 2010 +0000
@@ -257,6 +257,9 @@ struct arch_domain
     /* NB. protected by d->event_lock and by irq_desc[irq].lock */
     int *irq_pirq;
     int *pirq_irq;
+    /* pirq to emulated irq and vice versa */
+    int *emuirq_pirq;
+    int *pirq_emuirq;
 
     /* Shared page for notifying that explicit PIRQ EOI is required. */
     unsigned long *pirq_eoi_map;
diff -r 7d2fdc083c9c xen/include/asm-x86/irq.h
--- a/xen/include/asm-x86/irq.h	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/include/asm-x86/irq.h	Thu Nov 18 19:54:04 2010 +0000
@@ -114,6 +114,9 @@ int map_domain_pirq(struct domain *d, in
 int unmap_domain_pirq(struct domain *d, int pirq);
 int get_free_pirq(struct domain *d, int type, int index);
 void free_domain_pirqs(struct domain *d);
+int map_domain_emuirq_pirq(struct domain *d, int pirq, int irq);
+int unmap_domain_pirq_emuirq(struct domain *d, int pirq);
+int hvm_domain_use_pirq(struct domain *d, int irq);
 
 int  init_irq_data(void);
 
@@ -147,6 +150,10 @@ void irq_set_affinity(struct irq_desc *,
 
 #define domain_pirq_to_irq(d, pirq) ((d)->arch.pirq_irq[pirq])
 #define domain_irq_to_pirq(d, irq) ((d)->arch.irq_pirq[irq])
+#define domain_pirq_to_emuirq(d, pirq) ((d)->arch.pirq_emuirq[pirq])
+#define domain_emuirq_to_pirq(d, emuirq) ((d)->arch.emuirq_pirq[emuirq])
+#define IRQ_UNBOUND -1
+#define IRQ_PT -2
 
 bool_t cpu_has_pending_apic_eoi(void);
 
diff -r 7d2fdc083c9c xen/include/public/features.h
--- a/xen/include/public/features.h	Thu Nov 18 12:28:31 2010 +0000
+++ b/xen/include/public/features.h	Thu Nov 18 19:54:04 2010 +0000
@@ -74,6 +74,9 @@
 /* x86: pvclock algorithm is safe to use on HVM */
 #define XENFEAT_hvm_safe_pvclock           9
 
+/* x86: pirq can be used by HVM guests */
+#define XENFEAT_hvm_pirqs           10
+
 #define XENFEAT_NR_SUBMAPS 1
 
 #endif /* __XEN_PUBLIC_FEATURES_H__ */

[PATCH v2 2 of 4] xen: introduce PHYSDEVOP_get_free_pirq

[stefano.stabellini]

Introduce a new physdev_op called PHYSDEVOP_get_free_pirq to allow a
guest to get a free pirq number from Xen; the hypervisor would keep that
pirq free for the guest to use in a mapping.

Signed-off-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com>

diff -r c585b1651a6f xen/arch/x86/hvm/hvm.c
--- a/xen/arch/x86/hvm/hvm.c	Thu Nov 18 19:54:04 2010 +0000
+++ b/xen/arch/x86/hvm/hvm.c	Fri Nov 19 12:56:20 2010 +0000
@@ -2448,6 +2448,7 @@ static long hvm_physdev_op(int cmd, XEN_
         case PHYSDEVOP_unmap_pirq:
         case PHYSDEVOP_eoi:
         case PHYSDEVOP_irq_status_query:
+        case PHYSDEVOP_get_free_pirq:
             return do_physdev_op(cmd, arg);
         default:
             return -ENOSYS;
@@ -2550,6 +2551,7 @@ static long hvm_physdev_op_compat32(
         case PHYSDEVOP_unmap_pirq:
         case PHYSDEVOP_eoi:
         case PHYSDEVOP_irq_status_query:
+        case PHYSDEVOP_get_free_pirq:
             return compat_physdev_op(cmd, arg);
         break;
     default:
diff -r c585b1651a6f xen/arch/x86/irq.c
--- a/xen/arch/x86/irq.c	Thu Nov 18 19:54:04 2010 +0000
+++ b/xen/arch/x86/irq.c	Fri Nov 19 12:56:20 2010 +0000
@@ -1505,7 +1505,7 @@ int map_domain_pirq(
     old_irq = domain_pirq_to_irq(d, pirq);
     old_pirq = domain_irq_to_pirq(d, irq);
 
-    if ( (old_irq && (old_irq != irq) ) ||
+    if ( (old_irq > 0 && (old_irq != irq) ) ||
          (old_pirq && (old_pirq != pirq)) )
     {
         dprintk(XENLOG_G_WARNING, "dom%d: pirq %d or irq %d already mapped\n",
diff -r c585b1651a6f xen/arch/x86/physdev.c
--- a/xen/arch/x86/physdev.c	Thu Nov 18 19:54:04 2010 +0000
+++ b/xen/arch/x86/physdev.c	Fri Nov 19 12:56:20 2010 +0000
@@ -125,7 +125,7 @@ static int physdev_map_pirq(struct physd
             }
 
             irq = domain_pirq_to_irq(current->domain, map->index);
-            if ( !irq )
+            if ( irq <= 0 )
             {
                 if ( IS_PRIV(current->domain) )
                     irq = map->index;
@@ -561,6 +561,26 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_H
                               setup_gsi.polarity);
         break; 
     }
+    case PHYSDEVOP_get_free_pirq: {
+        struct physdev_get_free_pirq out;
+        struct domain *d;
+
+        d = rcu_lock_current_domain();
+        
+        ret = -EFAULT;
+        if ( copy_from_guest(&out, arg, 1) != 0 )
+            break;
+
+        spin_lock(&d->event_lock);
+        out.pirq = get_free_pirq(d, out.type, 0);
+        d->arch.pirq_irq[out.pirq] = PIRQ_ALLOCATED;
+        spin_unlock(&d->event_lock);
+
+        ret = copy_to_guest(arg, &out, 1) ? -EFAULT : 0;
+
+        rcu_unlock_domain(d);
+        break;
+    }
     default:
         ret = -ENOSYS;
         break;
diff -r c585b1651a6f xen/arch/x86/x86_64/physdev.c
--- a/xen/arch/x86/x86_64/physdev.c	Thu Nov 18 19:54:04 2010 +0000
+++ b/xen/arch/x86/x86_64/physdev.c	Fri Nov 19 12:56:20 2010 +0000
@@ -42,6 +42,9 @@
 #define physdev_manage_pci         compat_physdev_manage_pci
 #define physdev_manage_pci_t       physdev_manage_pci_compat_t
 
+#define physdev_get_free_pirq      compat_physdev_get_free_pirq
+#define physdev_get_free_pirq_t    physdev_get_free_pirq_compat_t
+
 #define COMPAT
 #undef guest_handle_okay
 #define guest_handle_okay          compat_handle_okay
diff -r c585b1651a6f xen/include/asm-x86/irq.h
--- a/xen/include/asm-x86/irq.h	Thu Nov 18 19:54:04 2010 +0000
+++ b/xen/include/asm-x86/irq.h	Fri Nov 19 12:56:20 2010 +0000
@@ -150,6 +150,7 @@ void irq_set_affinity(struct irq_desc *,
 
 #define domain_pirq_to_irq(d, pirq) ((d)->arch.pirq_irq[pirq])
 #define domain_irq_to_pirq(d, irq) ((d)->arch.irq_pirq[irq])
+#define PIRQ_ALLOCATED -1
 #define domain_pirq_to_emuirq(d, pirq) ((d)->arch.pirq_emuirq[pirq])
 #define domain_emuirq_to_pirq(d, emuirq) ((d)->arch.emuirq_pirq[emuirq])
 #define IRQ_UNBOUND -1
diff -r c585b1651a6f xen/include/public/physdev.h
--- a/xen/include/public/physdev.h	Thu Nov 18 19:54:04 2010 +0000
+++ b/xen/include/public/physdev.h	Fri Nov 19 12:56:20 2010 +0000
@@ -240,6 +240,21 @@ struct physdev_setup_gsi {
 typedef struct physdev_setup_gsi physdev_setup_gsi_t;
 DEFINE_XEN_GUEST_HANDLE(physdev_setup_gsi_t);
 
+/* leave PHYSDEVOP 22 free */
+
+/* type is MAP_PIRQ_TYPE_GSI or MAP_PIRQ_TYPE_MSI
+ * the hypercall returns a free pirq */
+#define PHYSDEVOP_get_free_pirq    23
+struct physdev_get_free_pirq {
+    /* IN */ 
+    int type;
+    /* OUT */
+    uint32_t pirq;
+};
+
+typedef struct physdev_get_free_pirq physdev_get_free_pirq_t;
+DEFINE_XEN_GUEST_HANDLE(physdev_get_free_pirq_t);
+
 /*
  * Notify that some PIRQ-bound event channels have been unmasked.
  * ** This command is obsolete since interface version 0x00030202 and is **

[PATCH v2 3 of 4] qemu-xen: support PV on HVM MSI remapping

[stefano.stabellini]

If the guest enables an MSI passing 0 as vector number, then read the
address and use it as pirq number for the following mapping request to
Xen.

Signed-off-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com>

diff --git a/hw/pt-msi.c b/hw/pt-msi.c
index b59b4fa..f0fb3e3 100644
--- a/hw/pt-msi.c
+++ b/hw/pt-msi.c
@@ -65,6 +65,7 @@ static void msix_set_enable(struct pt_dev *dev, int en)
 int pt_msi_setup(struct pt_dev *dev)
 {
     int pirq = -1;
+    uint8_t gvec = 0;
 
     if ( !(dev->msi->flags & MSI_FLAG_UNINIT) )
     {
@@ -72,6 +73,15 @@ int pt_msi_setup(struct pt_dev *dev)
         return -1;
     }
 
+    gvec = dev->msi->data & 0xFF;
+    if (!gvec) {
+        /* if gvec is 0, the guest is asking for a particular pirq that
+         * is passed as dest_id */
+        pirq = (dev->msi->addr_hi & 0xffffff00) |
+               ((dev->msi->addr_lo >> MSI_TARGET_CPU_SHIFT) & 0xff);
+        PT_LOG("pt_msi_setup requested pirq = %d\n", pirq);
+    }
+
     if ( xc_physdev_map_pirq_msi(xc_handle, domid, AUTO_ASSIGN, &pirq,
                                  PCI_DEVFN(dev->pci_dev->dev,
                                             ev->pci_dev->func),

[PATCH v2 4 of 4] qemu-xen: let xen choose the pirq number

[stefano.stabellini]

When remapping an interrupt into the guest, let xen choose the pirq,
otherwise we might have to handle possible conflicts.

Signed-off-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com>

diff --git a/hw/pass-through.c b/hw/pass-through.c
index f6ae4b2..81ae3f3 100644
--- a/hw/pass-through.c
+++ b/hw/pass-through.c
@@ -4265,7 +4265,7 @@ static struct pt_dev * register_real_device(PCIBus *e_bus,
 
     if ( PT_MACHINE_IRQ_AUTO == machine_irq )
     {
-        int pirq = pci_dev->irq;
+        int pirq = -1;
 
         machine_irq = pci_dev->irq;
         rc = xc_physdev_map_pirq(xc_handle, domid, machine_irq, &pirq);

Re: [PATCH v2 0 of 4] interrupt remapping in HVM guests for Xen 4.0.2

[Pasi Kärkkäinen]

On Fri, Nov 19, 2010 at 01:07:19PM +0000, Stefano Stabellini wrote:
> Hi all,
> this is the second version of the patch series that implements the
> mechanisms needed by a PV on HVM guest to remap interrupts and MSIs into
> pirqs in order to receive those interrupts and MSIs as xen events.
> This allows the guest to avoid any reads and writes to the emulated
> LAPIC.
> The series consists of 4 patches, 2 patches for the hypervisor and 2
> patches to qemu-xen; the changes are not interdependent.
> 

Hello,

I think this patch series was merged to xen-unstable here:
http://xenbits.xen.org/xen-unstable.hg?rev/6663214f06ac

I can't find that from xen-4.0-testing.hg .. 
I think it'd be good have this for Xen 4.0.2 aswell.

Any plans to backport? 

-- Pasi

> 
> Changes compared to the last version:
> 
> - Jan's comments have been addressed (the initialization of emuirq_pirq
> and pirq_emuirq has been fixed);
> 
> - the new hvm specific part of physdev_map_pirq has been moved to a
> separate function, called physdev_hvm_map_pirq;
> 
> - the hypercall PHYSDEVOP_get_nr_pirqs has been removed, a new hypercall
> PHYSDEVOP_get_free_pirq has been introduced instead to allow a guest to
> get a free pirq number from Xen; the hypervisor would keep that pirq
> free for the guest to use in a mapping.
> 
> 
> The list of patches follows:
> 
> xen: interrupt remapping in HVM guests
> xen: introduce PHYSDEVOP_get_free_pirq
> qemu-xen: support PV on HVM MSI remapping
> qemu-xen: qemu-xen: let xen choose the pirq number
> 
> Cheers,
> 
> Stefano Stabellini
> 
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xensource.com
> http://lists.xensource.com/xen-devel

Re: [PATCH v2 0 of 4] interrupt remapping in HVM guests for Xen 4.0.2

[Keir Fraser]

On 31/12/2010 10:53, "Pasi Kärkkäinen" <pasik@iki.fi> wrote:

> I think this patch series was merged to xen-unstable here:
> http://xenbits.xen.org/xen-unstable.hg?rev/6663214f06ac
> 
> I can't find that from xen-4.0-testing.hg ..
> I think it'd be good have this for Xen 4.0.2 aswell.
> 
> Any plans to backport?

Not a chance.

 -- Keir