[Xen-changelog] [xen-unstable] x86: Change Xen hypervisor's interrupt infrastructure

[Xen patchbot-unstable <patchbot-unstable@xxxxxxxxxxxxxxxxxxx>]

# HG changeset patch
# User Keir Fraser <keir.fraser@xxxxxxxxxx>
# Date 1250682784 -3600
# Node ID 722c7e94e76421452c035b3e9a46f805a2815445
# Parent  1afd9142eed3f112c76d73818fed717837191caa
x86:  Change Xen hypervisor's interrupt infrastructure
from vector-based to IRQ-based.

In per-cpu vector environment, vector space changes to
multi-demension resource, so vector number is not appropriate
to index irq_desc which stands for unique interrupt source. As
Linux does, irq number is chosen to index irq_desc. This patch
changes vector-based interrupt infrastructure to irq-based one.
Mostly, it follows upstream linux's changes, and some parts are
adapted for Xen.

Signed-off-by: Xiantao Zhang <xiantao.zhang@xxxxxxxxx>
---
 xen/arch/x86/domain.c                          |   20 
 xen/arch/x86/hpet.c                            |  120 ++---
 xen/arch/x86/hvm/vmsi.c                        |    4 
 xen/arch/x86/i8259.c                           |   79 +--
 xen/arch/x86/io_apic.c                         |  218 +++------
 xen/arch/x86/irq.c                             |  573 +++++++++++++++----------
 xen/arch/x86/msi.c                             |  154 +++---
 xen/arch/x86/physdev.c                         |   44 -
 xen/arch/x86/setup.c                           |    2 
 xen/drivers/passthrough/amd/iommu_init.c       |   66 +-
 xen/drivers/passthrough/io.c                   |   53 +-
 xen/drivers/passthrough/pci.c                  |    4 
 xen/drivers/passthrough/vtd/iommu.c            |   95 ++--
 xen/drivers/passthrough/vtd/x86/vtd.c          |    2 
 xen/include/asm-x86/amd-iommu.h                |    2 
 xen/include/asm-x86/domain.h                   |    6 
 xen/include/asm-x86/irq.h                      |   30 -
 xen/include/asm-x86/mach-default/irq_vectors.h |    1 
 xen/include/asm-x86/msi.h                      |   14 
 xen/include/xen/hvm/irq.h                      |    2 
 xen/include/xen/iommu.h                        |    2 
 xen/include/xen/irq.h                          |   31 -
 22 files changed, 832 insertions(+), 690 deletions(-)

diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/domain.c
--- a/xen/arch/x86/domain.c     Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/domain.c     Wed Aug 19 12:53:04 2009 +0100
@@ -474,11 +474,17 @@ int arch_domain_create(struct domain *d,
         share_xen_page_with_guest(
             virt_to_page(d->shared_info), d, XENSHARE_writable);
 
-        d->arch.pirq_vector = xmalloc_array(s16, d->nr_pirqs);
-        if ( !d->arch.pirq_vector )
+        d->arch.pirq_irq = xmalloc_array(int, d->nr_pirqs);
+        if ( !d->arch.pirq_irq )
             goto fail;
-        memset(d->arch.pirq_vector, 0,
-               d->nr_pirqs * sizeof(*d->arch.pirq_vector));
+        memset(d->arch.pirq_irq, 0,
+               d->nr_pirqs * sizeof(*d->arch.pirq_irq));
+
+        d->arch.irq_pirq = xmalloc_array(int, nr_irqs);
+        if ( !d->arch.irq_pirq )
+            goto fail;
+        memset(d->arch.irq_pirq, 0,
+               nr_irqs * sizeof(*d->arch.irq_pirq));
 
         if ( (rc = iommu_domain_init(d)) != 0 )
             goto fail;
@@ -513,7 +519,8 @@ int arch_domain_create(struct domain *d,
 
  fail:
     d->is_dying = DOMDYING_dead;
-    xfree(d->arch.pirq_vector);
+    xfree(d->arch.pirq_irq);
+    xfree(d->arch.irq_pirq);
     free_xenheap_page(d->shared_info);
     if ( paging_initialised )
         paging_final_teardown(d);
@@ -562,7 +569,8 @@ void arch_domain_destroy(struct domain *
 #endif
 
     free_xenheap_page(d->shared_info);
-    xfree(d->arch.pirq_vector);
+    xfree(d->arch.pirq_irq);
+    xfree(d->arch.irq_pirq);
 }
 
 unsigned long pv_guest_cr4_fixup(unsigned long guest_cr4)
diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/hpet.c
--- a/xen/arch/x86/hpet.c       Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/hpet.c       Wed Aug 19 12:53:04 2009 +0100
@@ -38,7 +38,7 @@ struct hpet_event_channel
 
     unsigned int idx;   /* physical channel idx */
     int cpu;            /* msi target */
-    unsigned int vector;/* msi vector */
+    unsigned int irq;/* msi irq */
     unsigned int flags; /* HPET_EVT_x */
 } __cacheline_aligned;
 static struct hpet_event_channel legacy_hpet_event;
@@ -47,13 +47,13 @@ static unsigned int num_hpets_used; /* m
 
 DEFINE_PER_CPU(struct hpet_event_channel *, cpu_bc_channel);
 
-static int vector_channel[NR_VECTORS] = {[0 ... NR_VECTORS-1] = -1};
-
-#define vector_to_channel(vector)   vector_channel[vector]
+static int *irq_channel;
+
+#define irq_to_channel(irq)   irq_channel[irq]
 
 unsigned long hpet_address;
 
-void msi_compose_msg(struct pci_dev *pdev, int vector, struct msi_msg *msg);
+void msi_compose_msg(struct pci_dev *pdev, int irq, struct msi_msg *msg);
 
 /*
  * force_hpet_broadcast: by default legacy hpet broadcast will be stopped
@@ -208,7 +208,7 @@ again:
     spin_unlock_irq(&ch->lock);
 }
 
-static void hpet_interrupt_handler(int vector, void *data,
+static void hpet_interrupt_handler(int irq, void *data,
         struct cpu_user_regs *regs)
 {
     struct hpet_event_channel *ch = (struct hpet_event_channel *)data;
@@ -221,10 +221,10 @@ static void hpet_interrupt_handler(int v
     ch->event_handler(ch);
 }
 
-static void hpet_msi_unmask(unsigned int vector)
+static void hpet_msi_unmask(unsigned int irq)
 {
     unsigned long cfg;
-    int ch_idx = vector_to_channel(vector);
+    int ch_idx = irq_to_channel(irq);
     struct hpet_event_channel *ch;
 
     BUG_ON(ch_idx < 0);
@@ -235,10 +235,10 @@ static void hpet_msi_unmask(unsigned int
     hpet_write32(cfg, HPET_Tn_CFG(ch->idx));
 }
 
-static void hpet_msi_mask(unsigned int vector)
+static void hpet_msi_mask(unsigned int irq)
 {
     unsigned long cfg;
-    int ch_idx = vector_to_channel(vector);
+    int ch_idx = irq_to_channel(irq);
     struct hpet_event_channel *ch;
 
     BUG_ON(ch_idx < 0);
@@ -249,9 +249,9 @@ static void hpet_msi_mask(unsigned int v
     hpet_write32(cfg, HPET_Tn_CFG(ch->idx));
 }
 
-static void hpet_msi_write(unsigned int vector, struct msi_msg *msg)
-{
-    int ch_idx = vector_to_channel(vector);
+static void hpet_msi_write(unsigned int irq, struct msi_msg *msg)
+{
+    int ch_idx = irq_to_channel(irq);
     struct hpet_event_channel *ch;
 
     BUG_ON(ch_idx < 0);
@@ -261,9 +261,9 @@ static void hpet_msi_write(unsigned int 
     hpet_write32(msg->address_lo, HPET_Tn_ROUTE(ch->idx) + 4);
 }
 
-static void hpet_msi_read(unsigned int vector, struct msi_msg *msg)
-{
-    int ch_idx = vector_to_channel(vector);
+static void hpet_msi_read(unsigned int irq, struct msi_msg *msg)
+{
+    int ch_idx = irq_to_channel(irq);
     struct hpet_event_channel *ch;
 
     BUG_ON(ch_idx < 0);
@@ -274,31 +274,32 @@ static void hpet_msi_read(unsigned int v
     msg->address_hi = 0;
 }
 
-static unsigned int hpet_msi_startup(unsigned int vector)
-{
-    hpet_msi_unmask(vector);
+static unsigned int hpet_msi_startup(unsigned int irq)
+{
+    hpet_msi_unmask(irq);
     return 0;
 }
 
-static void hpet_msi_shutdown(unsigned int vector)
-{
-    hpet_msi_mask(vector);
-}
-
-static void hpet_msi_ack(unsigned int vector)
+static void hpet_msi_shutdown(unsigned int irq)
+{
+    hpet_msi_mask(irq);
+}
+
+static void hpet_msi_ack(unsigned int irq)
 {
     ack_APIC_irq();
 }
 
-static void hpet_msi_end(unsigned int vector)
-{
-}
-
-static void hpet_msi_set_affinity(unsigned int vector, cpumask_t mask)
+static void hpet_msi_end(unsigned int irq)
+{
+}
+
+static void hpet_msi_set_affinity(unsigned int irq, cpumask_t mask)
 {
     struct msi_msg msg;
     unsigned int dest;
     cpumask_t tmp;
+    int vector = irq_to_vector(irq);
 
     cpus_and(tmp, mask, cpu_online_map);
     if ( cpus_empty(tmp) )
@@ -314,7 +315,7 @@ static void hpet_msi_set_affinity(unsign
     msg.address_lo |= MSI_ADDR_DEST_ID(dest);
 
     hpet_msi_write(vector, &msg);
-    irq_desc[vector].affinity = mask;
+    irq_desc[irq].affinity = mask;
 }
 
 /*
@@ -331,44 +332,44 @@ static struct hw_interrupt_type hpet_msi
     .set_affinity   = hpet_msi_set_affinity,
 };
 
-static int hpet_setup_msi_irq(unsigned int vector)
+static int hpet_setup_msi_irq(unsigned int irq)
 {
     int ret;
     struct msi_msg msg;
-    struct hpet_event_channel *ch = &hpet_events[vector_to_channel(vector)];
-
-    irq_desc[vector].handler = &hpet_msi_type;
-    ret = request_irq_vector(vector, hpet_interrupt_handler,
+    struct hpet_event_channel *ch = &hpet_events[irq_to_channel(irq)];
+
+    irq_desc[irq].handler = &hpet_msi_type;
+    ret = request_irq(irq, hpet_interrupt_handler,
                       0, "HPET", ch);
     if ( ret < 0 )
         return ret;
 
-    msi_compose_msg(NULL, vector, &msg);
-    hpet_msi_write(vector, &msg);
+    msi_compose_msg(NULL, irq, &msg);
+    hpet_msi_write(irq, &msg);
 
     return 0;
 }
 
 static int hpet_assign_irq(struct hpet_event_channel *ch)
 {
-    int vector;
-
-    if ( ch->vector )
+    int irq;
+
+    if ( ch->irq )
         return 0;
 
-    if ( (vector = assign_irq_vector(AUTO_ASSIGN_IRQ)) < 0 )
-        return vector;
-
-    vector_channel[vector] = ch - &hpet_events[0];
-
-    if ( hpet_setup_msi_irq(vector) )
-    {
-        free_irq_vector(vector);
-        vector_channel[vector] = -1;
+    if ( (irq = create_irq()) < 0 )
+        return irq;
+
+    irq_channel[irq] = ch - &hpet_events[0];
+
+    if ( hpet_setup_msi_irq(irq) )
+    {
+        destroy_irq(irq);
+        irq_channel[irq] = -1;
         return -EINVAL;
     }
 
-    ch->vector = vector;
+    ch->irq = irq;
     return 0;
 }
 
@@ -402,8 +403,8 @@ static int hpet_fsb_cap_lookup(void)
         /* set default irq affinity */
         ch->cpu = num_chs_used;
         per_cpu(cpu_bc_channel, ch->cpu) = ch;
-        irq_desc[ch->vector].handler->
-            set_affinity(ch->vector, cpumask_of_cpu(ch->cpu));
+        irq_desc[ch->irq].handler->
+            set_affinity(ch->irq, cpumask_of_cpu(ch->cpu));
 
         num_chs_used++;
 
@@ -462,8 +463,8 @@ static void hpet_attach_channel_share(in
         return;
 
     /* set irq affinity */
-    irq_desc[ch->vector].handler->
-        set_affinity(ch->vector, cpumask_of_cpu(ch->cpu));
+    irq_desc[ch->irq].handler->
+        set_affinity(ch->irq, cpumask_of_cpu(ch->cpu));
 }
 
 static void hpet_detach_channel_share(int cpu)
@@ -484,8 +485,8 @@ static void hpet_detach_channel_share(in
 
     ch->cpu = first_cpu(ch->cpumask);
     /* set irq affinity */
-    irq_desc[ch->vector].handler->
-        set_affinity(ch->vector, cpumask_of_cpu(ch->cpu));
+    irq_desc[ch->irq].handler->
+        set_affinity(ch->irq, cpumask_of_cpu(ch->cpu));
 }
 
 static void (*hpet_attach_channel)(int cpu, struct hpet_event_channel *ch);
@@ -522,6 +523,11 @@ void hpet_broadcast_init(void)
     u64 hpet_rate;
     u32 hpet_id, cfg;
     int i;
+
+    irq_channel= xmalloc_array(int, nr_irqs);
+    BUG_ON(!irq_channel);
+    for (i = 0; i < nr_irqs ; i++)
+        irq_channel[i] = -1;
 
     hpet_rate = hpet_setup();
     if ( hpet_rate == 0 )
diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/hvm/vmsi.c
--- a/xen/arch/x86/hvm/vmsi.c   Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/hvm/vmsi.c   Wed Aug 19 12:53:04 2009 +0100
@@ -374,7 +374,7 @@ static void del_msixtbl_entry(struct msi
 
 int msixtbl_pt_register(struct domain *d, int pirq, uint64_t gtable)
 {
-    irq_desc_t *irq_desc;
+    struct irq_desc *irq_desc;
     struct msi_desc *msi_desc;
     struct pci_dev *pdev;
     struct msixtbl_entry *entry, *new_entry;
@@ -429,7 +429,7 @@ out:
 
 void msixtbl_pt_unregister(struct domain *d, int pirq)
 {
-    irq_desc_t *irq_desc;
+    struct irq_desc *irq_desc;
     struct msi_desc *msi_desc;
     struct pci_dev *pdev;
     struct msixtbl_entry *entry;
diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/i8259.c
--- a/xen/arch/x86/i8259.c      Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/i8259.c      Wed Aug 19 12:53:04 2009 +0100
@@ -106,38 +106,28 @@ BUILD_SMP_INTERRUPT(cmci_interrupt, CMCI
 
 static DEFINE_SPINLOCK(i8259A_lock);
 
-static void disable_8259A_vector(unsigned int vector)
-{
-    disable_8259A_irq(LEGACY_IRQ_FROM_VECTOR(vector));
-}
-
-static void enable_8259A_vector(unsigned int vector)
-{
-    enable_8259A_irq(LEGACY_IRQ_FROM_VECTOR(vector));
-}
-
-static void mask_and_ack_8259A_vector(unsigned int);
-
-static void end_8259A_vector(unsigned int vector)
-{
-    if (!(irq_desc[vector].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
-        enable_8259A_vector(vector);
-}
-
-static unsigned int startup_8259A_vector(unsigned int vector)
-{ 
-    enable_8259A_vector(vector);
+static void mask_and_ack_8259A_irq(unsigned int irq);
+
+static unsigned int startup_8259A_irq(unsigned int irq)
+{
+    enable_8259A_irq(irq);
     return 0; /* never anything pending */
+}
+
+static void end_8259A_irq(unsigned int irq)
+{
+    if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
+        enable_8259A_irq(irq);
 }
 
 static struct hw_interrupt_type i8259A_irq_type = {
     .typename = "XT-PIC",
-    .startup  = startup_8259A_vector,
-    .shutdown = disable_8259A_vector,
-    .enable   = enable_8259A_vector,
-    .disable  = disable_8259A_vector,
-    .ack      = mask_and_ack_8259A_vector,
-    .end      = end_8259A_vector
+    .startup  = startup_8259A_irq,
+    .shutdown = disable_8259A_irq,
+    .enable   = enable_8259A_irq,
+    .disable  = disable_8259A_irq,
+    .ack      = mask_and_ack_8259A_irq,
+    .end      = end_8259A_irq
 };
 
 /*
@@ -237,9 +227,8 @@ static inline int i8259A_irq_real(unsign
  * first, _then_ send the EOI, and the order of EOI
  * to the two 8259s is important!
  */
-static void mask_and_ack_8259A_vector(unsigned int vector)
-{
-    unsigned int irq = LEGACY_IRQ_FROM_VECTOR(vector);
+static void mask_and_ack_8259A_irq(unsigned int irq)
+{
     unsigned int irqmask = 1 << irq;
     unsigned long flags;
 
@@ -369,9 +358,9 @@ void __devinit init_8259A(int auto_eoi)
          * in AEOI mode we just have to mask the interrupt
          * when acking.
          */
-        i8259A_irq_type.ack = disable_8259A_vector;
-    else
-        i8259A_irq_type.ack = mask_and_ack_8259A_vector;
+        i8259A_irq_type.ack = disable_8259A_irq;
+    else
+        i8259A_irq_type.ack = mask_and_ack_8259A_irq;
 
     udelay(100);            /* wait for 8259A to initialize */
 
@@ -385,31 +374,25 @@ static struct irqaction cascade = { no_a
 
 void __init init_IRQ(void)
 {
-    int i;
+    int i, vector;
 
     init_bsp_APIC();
 
     init_8259A(0);
 
-    for ( i = 0; i < NR_VECTORS; i++ )
+    BUG_ON(init_irq_data() < 0);
+
+    for ( vector = FIRST_DYNAMIC_VECTOR; vector < NR_VECTORS; vector++ )
     {
-        irq_desc[i].status  = IRQ_DISABLED;
-        irq_desc[i].handler = &no_irq_type;
-        irq_desc[i].action  = NULL;
-        irq_desc[i].depth   = 1;
-        spin_lock_init(&irq_desc[i].lock);
-        cpus_setall(irq_desc[i].affinity);
-        if ( i >= 0x20 )
-            set_intr_gate(i, interrupt[i]);
-    }
-
-    irq_vector = xmalloc_array(u8, nr_irqs_gsi);
-    memset(irq_vector, 0, nr_irqs_gsi * sizeof(*irq_vector));
+        if (vector == HYPERCALL_VECTOR || vector == LEGACY_SYSCALL_VECTOR)
+            continue;
+        set_intr_gate(vector, interrupt[vector]);
+    }
 
     for ( i = 0; i < 16; i++ )
     {
         vector_irq[LEGACY_VECTOR(i)] = i;
-        irq_desc[LEGACY_VECTOR(i)].handler = &i8259A_irq_type;
+        irq_desc[i].handler = &i8259A_irq_type;
     }
 
     /* Never allocate the hypercall vector or Linux/BSD fast-trap vector. */
diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/io_apic.c
--- a/xen/arch/x86/io_apic.c    Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/io_apic.c    Wed Aug 19 12:53:04 2009 +0100
@@ -661,9 +661,6 @@ static inline int IO_APIC_irq_trigger(in
     return 0;
 }
 
-/* irq_vectors is indexed by the sum of all RTEs in all I/O APICs. */
-u8 *irq_vector __read_mostly = (u8 *)(1UL << (BITS_PER_LONG - 1));
-
 static struct hw_interrupt_type ioapic_level_type;
 static struct hw_interrupt_type ioapic_edge_type;
 
@@ -671,13 +668,13 @@ static struct hw_interrupt_type ioapic_e
 #define IOAPIC_EDGE    0
 #define IOAPIC_LEVEL   1
 
-static inline void ioapic_register_intr(int irq, int vector, unsigned long 
trigger)
+static inline void ioapic_register_intr(int irq, unsigned long trigger)
 {
     if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
         trigger == IOAPIC_LEVEL)
-        irq_desc[vector].handler = &ioapic_level_type;
+        irq_desc[irq].handler = &ioapic_level_type;
     else
-        irq_desc[vector].handler = &ioapic_edge_type;
+        irq_desc[irq].handler = &ioapic_edge_type;
 }
 
 static void __init setup_IO_APIC_irqs(void)
@@ -740,7 +737,7 @@ static void __init setup_IO_APIC_irqs(vo
             if (IO_APIC_IRQ(irq)) {
                 vector = assign_irq_vector(irq);
                 entry.vector = vector;
-                ioapic_register_intr(irq, vector, IOAPIC_AUTO);
+                ioapic_register_intr(irq, IOAPIC_AUTO);
 
                 if (!apic && (irq < 16))
                     disable_8259A_irq(irq);
@@ -748,7 +745,7 @@ static void __init setup_IO_APIC_irqs(vo
             spin_lock_irqsave(&ioapic_lock, flags);
             io_apic_write(apic, 0x11+2*pin, *(((int *)&entry)+1));
             io_apic_write(apic, 0x10+2*pin, *(((int *)&entry)+0));
-            set_native_irq_info(entry.vector, TARGET_CPUS);
+            set_native_irq_info(irq, TARGET_CPUS);
             spin_unlock_irqrestore(&ioapic_lock, flags);
        }
     }
@@ -788,7 +785,7 @@ static void __init setup_ExtINT_IRQ0_pin
      * The timer IRQ doesn't have to know that behind the
      * scene we have a 8259A-master in AEOI mode ...
      */
-    irq_desc[IO_APIC_VECTOR(0)].handler = &ioapic_edge_type;
+    irq_desc[0].handler = &ioapic_edge_type;
 
     /*
      * Add it to the IO-APIC irq-routing table:
@@ -1269,7 +1266,7 @@ static unsigned int startup_edge_ioapic_
  */
 static void ack_edge_ioapic_irq(unsigned int irq)
 {
-    if ((irq_desc[IO_APIC_VECTOR(irq)].status & (IRQ_PENDING | IRQ_DISABLED))
+    if ((irq_desc[irq].status & (IRQ_PENDING | IRQ_DISABLED))
         == (IRQ_PENDING | IRQ_DISABLED))
         mask_IO_APIC_irq(irq);
     ack_APIC_irq();
@@ -1359,7 +1356,7 @@ static void end_level_ioapic_irq (unsign
 
     if ( !ioapic_ack_new )
     {
-        if ( !(irq_desc[IO_APIC_VECTOR(irq)].status & IRQ_DISABLED) )
+        if ( !(irq_desc[irq].status & IRQ_DISABLED) )
             unmask_IO_APIC_irq(irq);
         return;
     }
@@ -1395,70 +1392,19 @@ static void end_level_ioapic_irq (unsign
         __mask_IO_APIC_irq(irq);
         __edge_IO_APIC_irq(irq);
         __level_IO_APIC_irq(irq);
-        if ( !(irq_desc[IO_APIC_VECTOR(irq)].status & IRQ_DISABLED) )
+        if ( !(irq_desc[irq].status & IRQ_DISABLED) )
             __unmask_IO_APIC_irq(irq);
         spin_unlock(&ioapic_lock);
     }
 }
 
-static unsigned int startup_edge_ioapic_vector(unsigned int vector)
-{
-    int irq = vector_to_irq(vector);
-    return startup_edge_ioapic_irq(irq);
-}
-
-static void ack_edge_ioapic_vector(unsigned int vector)
-{
-    int irq = vector_to_irq(vector);
-    ack_edge_ioapic_irq(irq);
-}
-
-static unsigned int startup_level_ioapic_vector(unsigned int vector)
-{
-    int irq = vector_to_irq(vector);
-    return startup_level_ioapic_irq (irq);
-}
-
-static void mask_and_ack_level_ioapic_vector(unsigned int vector)
-{
-    int irq = vector_to_irq(vector);
-    mask_and_ack_level_ioapic_irq(irq);
-}
-
-static void end_level_ioapic_vector(unsigned int vector)
-{
-    int irq = vector_to_irq(vector);
-    end_level_ioapic_irq(irq);
-}
-
-static void mask_IO_APIC_vector(unsigned int vector)
-{
-    int irq = vector_to_irq(vector);
-    mask_IO_APIC_irq(irq);
-}
-
-static void unmask_IO_APIC_vector(unsigned int vector)
-{
-    int irq = vector_to_irq(vector);
-    unmask_IO_APIC_irq(irq);
-}
-
-static void set_ioapic_affinity_vector(
-    unsigned int vector, cpumask_t cpu_mask)
-{
-    int irq = vector_to_irq(vector);
-
-    set_native_irq_info(vector, cpu_mask);
-    set_ioapic_affinity_irq(irq, cpu_mask);
-}
-
-static void disable_edge_ioapic_vector(unsigned int vector)
-{
-}
-
-static void end_edge_ioapic_vector(unsigned int vector)
-{
-}
+static void disable_edge_ioapic_irq(unsigned int irq)
+{
+}
+
+static void end_edge_ioapic_irq(unsigned int irq)
+ {
+ }
 
 /*
  * Level and edge triggered IO-APIC interrupts need different handling,
@@ -1470,53 +1416,54 @@ static void end_edge_ioapic_vector(unsig
  */
 static struct hw_interrupt_type ioapic_edge_type = {
     .typename  = "IO-APIC-edge",
-    .startup   = startup_edge_ioapic_vector,
-    .shutdown  = disable_edge_ioapic_vector,
-    .enable    = unmask_IO_APIC_vector,
-    .disable   = disable_edge_ioapic_vector,
-    .ack               = ack_edge_ioapic_vector,
-    .end               = end_edge_ioapic_vector,
-    .set_affinity      = set_ioapic_affinity_vector,
+    .startup   = startup_edge_ioapic_irq,
+    .shutdown  = disable_edge_ioapic_irq,
+    .enable    = unmask_IO_APIC_irq,
+    .disable   = disable_edge_ioapic_irq,
+    .ack               = ack_edge_ioapic_irq,
+    .end               = end_edge_ioapic_irq,
+    .set_affinity      = set_ioapic_affinity_irq,
 };
 
 static struct hw_interrupt_type ioapic_level_type = {
     .typename  = "IO-APIC-level",
-    .startup   = startup_level_ioapic_vector,
-    .shutdown  = mask_IO_APIC_vector,
-    .enable    = unmask_IO_APIC_vector,
-    .disable   = mask_IO_APIC_vector,
-    .ack               = mask_and_ack_level_ioapic_vector,
-    .end               = end_level_ioapic_vector,
-    .set_affinity      = set_ioapic_affinity_vector,
+    .startup   = startup_level_ioapic_irq,
+    .shutdown  = mask_IO_APIC_irq,
+    .enable    = unmask_IO_APIC_irq,
+    .disable   = mask_IO_APIC_irq,
+    .ack               = mask_and_ack_level_ioapic_irq,
+    .end               = end_level_ioapic_irq,
+    .set_affinity      = set_ioapic_affinity_irq,
 };
 
-static unsigned int startup_msi_vector(unsigned int vector)
-{
-    unmask_msi_vector(vector);
+static unsigned int startup_msi_irq(unsigned int irq)
+{
+    unmask_msi_irq(irq);
     return 0;
 }
 
-static void ack_msi_vector(unsigned int vector)
-{
-    if ( msi_maskable_irq(irq_desc[vector].msi_desc) )
+static void ack_msi_irq(unsigned int irq)
+{
+    struct irq_desc *desc = irq_to_desc(irq);
+
+    if ( msi_maskable_irq(desc->msi_desc) )
         ack_APIC_irq(); /* ACKTYPE_NONE */
 }
 
-static void end_msi_vector(unsigned int vector)
-{
-    if ( !msi_maskable_irq(irq_desc[vector].msi_desc) )
+static void end_msi_irq(unsigned int irq)
+{
+    if ( !msi_maskable_irq(irq_desc[irq].msi_desc) )
         ack_APIC_irq(); /* ACKTYPE_EOI */
 }
 
-static void shutdown_msi_vector(unsigned int vector)
-{
-    mask_msi_vector(vector);
-}
-
-static void set_msi_affinity_vector(unsigned int vector, cpumask_t cpu_mask)
-{
-    set_native_irq_info(vector, cpu_mask);
-    set_msi_affinity(vector, cpu_mask);
+static void shutdown_msi_irq(unsigned int irq)
+{
+    mask_msi_irq(irq);
+}
+
+static void set_msi_affinity_irq(unsigned int irq, cpumask_t cpu_mask)
+{
+    set_msi_affinity(irq, cpu_mask);
 }
 
 /*
@@ -1525,13 +1472,13 @@ static void set_msi_affinity_vector(unsi
  */
 struct hw_interrupt_type pci_msi_type = {
     .typename   = "PCI-MSI",
-    .startup    = startup_msi_vector,
-    .shutdown   = shutdown_msi_vector,
-    .enable        = unmask_msi_vector,
-    .disable    = mask_msi_vector,
-    .ack        = ack_msi_vector,
-    .end        = end_msi_vector,
-    .set_affinity   = set_msi_affinity_vector,
+    .startup    = startup_msi_irq,
+    .shutdown   = shutdown_msi_irq,
+    .enable        = unmask_msi_irq,
+    .disable    = mask_msi_irq,
+    .ack        = ack_msi_irq,
+    .end        = end_msi_irq,
+    .set_affinity   = set_msi_affinity_irq,
 };
 
 static inline void init_IO_APIC_traps(void)
@@ -1543,7 +1490,7 @@ static inline void init_IO_APIC_traps(vo
             make_8259A_irq(irq);
 }
 
-static void enable_lapic_vector(unsigned int vector)
+static void enable_lapic_irq(unsigned int irq)
 {
     unsigned long v;
 
@@ -1551,7 +1498,7 @@ static void enable_lapic_vector(unsigned
     apic_write_around(APIC_LVT0, v & ~APIC_LVT_MASKED);
 }
 
-static void disable_lapic_vector(unsigned int vector)
+static void disable_lapic_irq(unsigned int irq)
 {
     unsigned long v;
 
@@ -1559,21 +1506,21 @@ static void disable_lapic_vector(unsigne
     apic_write_around(APIC_LVT0, v | APIC_LVT_MASKED);
 }
 
-static void ack_lapic_vector(unsigned int vector)
+static void ack_lapic_irq(unsigned int irq)
 {
     ack_APIC_irq();
 }
 
-static void end_lapic_vector(unsigned int vector) { /* nothing */ }
+static void end_lapic_irq(unsigned int irq) { /* nothing */ }
 
 static struct hw_interrupt_type lapic_irq_type = {
     .typename  = "local-APIC-edge",
     .startup   = NULL, /* startup_irq() not used for IRQ0 */
     .shutdown  = NULL, /* shutdown_irq() not used for IRQ0 */
-    .enable    = enable_lapic_vector,
-    .disable   = disable_lapic_vector,
-    .ack               = ack_lapic_vector,
-    .end               = end_lapic_vector
+    .enable    = enable_lapic_irq,
+    .disable   = disable_lapic_irq,
+    .ack               = ack_lapic_irq,
+    .end               = end_lapic_irq,
 };
 
 /*
@@ -1661,9 +1608,9 @@ static inline void check_timer(void)
     disable_8259A_irq(0);
     vector = assign_irq_vector(0);
 
-    irq_desc[IO_APIC_VECTOR(0)].action = irq_desc[LEGACY_VECTOR(0)].action;
-    irq_desc[IO_APIC_VECTOR(0)].depth  = 0;
-    irq_desc[IO_APIC_VECTOR(0)].status &= ~IRQ_DISABLED;
+    irq_desc[0].depth  = 0;
+    irq_desc[0].status &= ~IRQ_DISABLED;
+    irq_desc[0].handler = &ioapic_edge_type;
 
     /*
      * Subtle, code in do_timer_interrupt() expects an AEOI
@@ -1736,7 +1683,7 @@ static inline void check_timer(void)
     printk(KERN_INFO "...trying to set up timer as Virtual Wire IRQ...");
 
     disable_8259A_irq(0);
-    irq_desc[vector].handler = &lapic_irq_type;
+    irq_desc[0].handler = &lapic_irq_type;
     apic_write_around(APIC_LVT0, APIC_DM_FIXED | vector);      /* Fixed mode */
     enable_8259A_irq(0);
 
@@ -2002,7 +1949,7 @@ int io_apic_set_pci_routing (int ioapic,
                mp_ioapics[ioapic].mpc_apicid, pin, entry.vector, irq,
                edge_level, active_high_low);
 
-    ioapic_register_intr(irq, entry.vector, edge_level);
+    ioapic_register_intr(irq, edge_level);
 
     if (!ioapic && (irq < 16))
         disable_8259A_irq(irq);
@@ -2010,7 +1957,7 @@ int io_apic_set_pci_routing (int ioapic,
     spin_lock_irqsave(&ioapic_lock, flags);
     io_apic_write(ioapic, 0x11+2*pin, *(((int *)&entry)+1));
     io_apic_write(ioapic, 0x10+2*pin, *(((int *)&entry)+0));
-    set_native_irq_info(entry.vector, TARGET_CPUS);
+    set_native_irq_info(irq, TARGET_CPUS);
     spin_unlock_irqrestore(&ioapic_lock, flags);
 
     return 0;
@@ -2114,12 +2061,13 @@ int ioapic_guest_write(unsigned long phy
 
     if ( old_rte.vector >= FIRST_DYNAMIC_VECTOR )
         old_irq = vector_irq[old_rte.vector];
+
     if ( new_rte.vector >= FIRST_DYNAMIC_VECTOR )
         new_irq = vector_irq[new_rte.vector];
 
     if ( (old_irq != new_irq) && (old_irq >= 0) && IO_APIC_IRQ(old_irq) )
     {
-        if ( irq_desc[IO_APIC_VECTOR(old_irq)].action )
+        if ( irq_desc[old_irq].action )
         {
             WARN_BOGUS_WRITE("Attempt to remove IO-APIC pin of in-use IRQ!\n");
             spin_unlock_irqrestore(&ioapic_lock, flags);
@@ -2131,7 +2079,7 @@ int ioapic_guest_write(unsigned long phy
 
     if ( (new_irq >= 0) && IO_APIC_IRQ(new_irq) )
     {
-        if ( irq_desc[IO_APIC_VECTOR(new_irq)].action )
+        if ( irq_desc[new_irq].action )
         {
             WARN_BOGUS_WRITE("Attempt to %s IO-APIC pin for in-use IRQ!\n",
                              (old_irq != new_irq) ? "add" : "modify");
@@ -2140,7 +2088,7 @@ int ioapic_guest_write(unsigned long phy
         }
         
         /* Set the correct irq-handling type. */
-        irq_desc[IO_APIC_VECTOR(new_irq)].handler = new_rte.trigger ? 
+        irq_desc[new_irq].handler = new_rte.trigger ? 
             &ioapic_level_type: &ioapic_edge_type;
         
         if ( old_irq != new_irq )
@@ -2252,11 +2200,17 @@ void __init init_ioapic_mappings(void)
     }
     if ( !smp_found_config || skip_ioapic_setup || nr_irqs_gsi < 16 )
         nr_irqs_gsi = 16;
-    else if ( nr_irqs_gsi > PAGE_SIZE * 8 )
+    else if ( nr_irqs_gsi > MAX_GSI_IRQS)
     {
         /* for PHYSDEVOP_pirq_eoi_gmfn guest assumptions */
-        printk(KERN_WARNING "Limiting number of IRQs found (%u) to %lu\n",
-               nr_irqs_gsi, PAGE_SIZE * 8);
-        nr_irqs_gsi = PAGE_SIZE * 8;
-    }
-}
+        printk(KERN_WARNING "Limiting number of GSI IRQs found (%u) to %lu\n",
+               nr_irqs_gsi, MAX_GSI_IRQS);
+        nr_irqs_gsi = MAX_GSI_IRQS;
+    }
+
+    if (nr_irqs < 2 * nr_irqs_gsi)
+        nr_irqs = 2 * nr_irqs_gsi;
+
+    if (nr_irqs > MAX_NR_IRQS)
+        nr_irqs = MAX_NR_IRQS;
+}
diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/irq.c
--- a/xen/arch/x86/irq.c        Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/irq.c        Wed Aug 19 12:53:04 2009 +0100
@@ -27,13 +27,162 @@ boolean_param("noirqbalance", opt_noirqb
 boolean_param("noirqbalance", opt_noirqbalance);
 
 unsigned int __read_mostly nr_irqs_gsi = 16;
-irq_desc_t irq_desc[NR_VECTORS];
+unsigned int __read_mostly nr_irqs = 1024;
+integer_param("nr_irqs", nr_irqs);
+
+u8 __read_mostly *irq_vector;
+struct irq_desc __read_mostly *irq_desc = NULL;
+
+int __read_mostly *irq_status = NULL;
+#define IRQ_UNUSED      (0)
+#define IRQ_USED        (1)
+#define IRQ_RSVD        (2)
+
+static struct timer *irq_guest_eoi_timer;
 
 static DEFINE_SPINLOCK(vector_lock);
 int vector_irq[NR_VECTORS] __read_mostly = {
     [0 ... NR_VECTORS - 1] = FREE_TO_ASSIGN_IRQ
 };
 
+static inline int find_unassigned_irq(void)
+{
+    int irq;
+
+    for (irq = nr_irqs_gsi; irq < nr_irqs; irq++)
+        if (irq_status[irq] == IRQ_UNUSED)
+            return irq;
+    return -ENOSPC;
+}
+
+/*
+ * Dynamic irq allocate and deallocation for MSI
+ */
+int create_irq(void)
+{
+    unsigned long flags;
+    int irq, ret;
+    irq = -ENOSPC;
+
+    spin_lock_irqsave(&vector_lock, flags);
+
+    irq = find_unassigned_irq();
+    if (irq < 0)
+         goto out;
+    ret = __assign_irq_vector(irq);
+    if (ret < 0)
+        irq = ret;
+out:
+     spin_unlock_irqrestore(&vector_lock, flags);
+
+    return irq;
+}
+
+void dynamic_irq_cleanup(unsigned int irq)
+{
+    struct irq_desc *desc = irq_to_desc(irq);
+    struct irqaction *action;
+    unsigned long flags;
+
+    spin_lock_irqsave(&desc->lock, flags);
+    desc->status  |= IRQ_DISABLED;
+    desc->handler->shutdown(irq);
+    action = desc->action;
+    desc->action  = NULL;
+    desc->depth   = 1;
+    desc->msi_desc = NULL;
+    desc->handler = &no_irq_type;
+    cpus_setall(desc->affinity);
+    spin_unlock_irqrestore(&desc->lock, flags);
+
+    /* Wait to make sure it's not being used on another CPU */
+    do { smp_mb(); } while ( desc->status & IRQ_INPROGRESS );
+
+    if (action)
+        xfree(action);
+}
+
+static void __clear_irq_vector(int irq)
+{
+    int vector = irq_vector[irq];
+    vector_irq[vector] = FREE_TO_ASSIGN_IRQ;
+    irq_vector[irq] = 0;
+    irq_status[irq] = IRQ_UNUSED;
+}
+
+void clear_irq_vector(int irq)
+{
+    unsigned long flags;
+
+    spin_lock_irqsave(&vector_lock, flags);
+    __clear_irq_vector(irq);
+    spin_unlock_irqrestore(&vector_lock, flags);
+}
+
+void destroy_irq(unsigned int irq)
+{
+    dynamic_irq_cleanup(irq);
+    clear_irq_vector(irq);
+}
+
+int irq_to_vector(int irq)
+{
+    int vector = -1;
+
+    BUG_ON(irq >= nr_irqs || irq < 0);
+
+    if (IO_APIC_IRQ(irq) || MSI_IRQ(irq))
+        vector = irq_vector[irq];
+    else
+        vector = LEGACY_VECTOR(irq);
+
+    return vector;
+}
+
+static void init_one_irq_desc(struct irq_desc *desc)
+{
+        desc->status  = IRQ_DISABLED;
+        desc->handler = &no_irq_type;
+        desc->action  = NULL;
+        desc->depth   = 1;
+        desc->msi_desc = NULL;
+        spin_lock_init(&desc->lock);
+        cpus_setall(desc->affinity);
+}
+
+static void init_one_irq_status(int irq)
+{
+    irq_status[irq] = IRQ_UNUSED;
+}
+
+int init_irq_data(void)
+{
+    struct irq_desc *desc;
+    int irq;
+
+    irq_desc = xmalloc_array(struct irq_desc, nr_irqs);
+    irq_status = xmalloc_array(int, nr_irqs);
+    irq_guest_eoi_timer = xmalloc_array(struct timer, nr_irqs);
+    irq_vector = xmalloc_array(u8, nr_irqs);
+    
+    if (!irq_desc || !irq_status ||! irq_vector || !irq_guest_eoi_timer)
+        return -1;
+
+    memset(irq_desc, 0,  nr_irqs * sizeof(*irq_desc));
+    memset(irq_status, 0,  nr_irqs * sizeof(*irq_status));
+    memset(irq_vector, 0, nr_irqs * sizeof(*irq_vector));
+    memset(irq_guest_eoi_timer, 0, nr_irqs * sizeof(*irq_guest_eoi_timer));
+    
+    for (irq = 0; irq < nr_irqs; irq++) {
+        desc = irq_to_desc(irq);
+        desc->irq = irq;
+        init_one_irq_desc(desc);
+        init_one_irq_status(irq);
+    }
+
+    return 0;
+}
+
 static void __do_IRQ_guest(int vector);
 
 void no_action(int cpl, void *dev_id, struct cpu_user_regs *regs) { }
@@ -41,9 +190,9 @@ static void enable_none(unsigned int vec
 static void enable_none(unsigned int vector) { }
 static unsigned int startup_none(unsigned int vector) { return 0; }
 static void disable_none(unsigned int vector) { }
-static void ack_none(unsigned int vector)
-{
-    ack_bad_irq(vector);
+static void ack_none(unsigned int irq)
+{
+    ack_bad_irq(irq);
 }
 
 #define shutdown_none   disable_none
@@ -61,33 +210,15 @@ struct hw_interrupt_type no_irq_type = {
 
 atomic_t irq_err_count;
 
-int free_irq_vector(int vector)
-{
-    int irq;
-
-    BUG_ON((vector > LAST_DYNAMIC_VECTOR) || (vector < FIRST_DYNAMIC_VECTOR));
-
-    spin_lock(&vector_lock);
-    if ((irq = vector_irq[vector]) == AUTO_ASSIGN_IRQ)
-        vector_irq[vector] = FREE_TO_ASSIGN_IRQ;
-    spin_unlock(&vector_lock);
-
-    return (irq == AUTO_ASSIGN_IRQ) ? 0 : -EINVAL;
-}
-
-int assign_irq_vector(int irq)
+int __assign_irq_vector(int irq)
 {
     static unsigned current_vector = FIRST_DYNAMIC_VECTOR;
     unsigned vector;
 
-    BUG_ON(irq >= nr_irqs_gsi && irq != AUTO_ASSIGN_IRQ);
-
-    spin_lock(&vector_lock);
-
-    if ((irq != AUTO_ASSIGN_IRQ) && (irq_to_vector(irq) > 0)) {
-        spin_unlock(&vector_lock);
+    BUG_ON(irq >= nr_irqs || irq < 0);
+
+    if ((irq_to_vector(irq) > 0)) 
         return irq_to_vector(irq);
-    }
 
     vector = current_vector;
     while (vector_irq[vector] != FREE_TO_ASSIGN_IRQ) {
@@ -95,40 +226,59 @@ int assign_irq_vector(int irq)
         if (vector > LAST_DYNAMIC_VECTOR)
             vector = FIRST_DYNAMIC_VECTOR + ((vector + 1) & 7);
 
-        if (vector == current_vector) {
-            spin_unlock(&vector_lock);
+        if (vector == current_vector)
             return -ENOSPC;
-        }
     }
 
     current_vector = vector;
     vector_irq[vector] = irq;
-    if (irq != AUTO_ASSIGN_IRQ)
-        IO_APIC_VECTOR(irq) = vector;
-
-    spin_unlock(&vector_lock);
+    irq_vector[irq] = vector;
+    irq_status[irq] = IRQ_USED;
 
     return vector;
 }
 
+int assign_irq_vector(int irq)
+{
+    int ret;
+    unsigned long flags;
+    
+    spin_lock_irqsave(&vector_lock, flags);
+    ret = __assign_irq_vector(irq);
+    spin_unlock_irqrestore(&vector_lock, flags);
+
+    return ret;
+}
+
+
 asmlinkage void do_IRQ(struct cpu_user_regs *regs)
 {
-    unsigned int      vector = regs->entry_vector;
-    irq_desc_t       *desc = &irq_desc[vector];
     struct irqaction *action;
     uint32_t          tsc_in;
-
+    unsigned int      vector = regs->entry_vector;
+    int irq = vector_irq[vector];
+    struct irq_desc  *desc;
+    
     perfc_incr(irqs);
 
+    if (irq < 0) {
+        ack_APIC_irq();
+        printk("%s: %d.%d No irq handler for vector (irq %d)\n",
+                __func__, smp_processor_id(), vector, irq);
+        return;
+    }
+
+    desc = irq_to_desc(irq);
+
     spin_lock(&desc->lock);
-    desc->handler->ack(vector);
+    desc->handler->ack(irq);
 
     if ( likely(desc->status & IRQ_GUEST) )
     {
         irq_enter();
         tsc_in = tb_init_done ? get_cycles() : 0;
-        __do_IRQ_guest(vector);
-        TRACE_3D(TRC_TRACE_IRQ, vector, tsc_in, get_cycles());
+        __do_IRQ_guest(irq);
+        TRACE_3D(TRC_TRACE_IRQ, irq, tsc_in, get_cycles());
         irq_exit();
         spin_unlock(&desc->lock);
         return;
@@ -153,8 +303,8 @@ asmlinkage void do_IRQ(struct cpu_user_r
         irq_enter();
         spin_unlock_irq(&desc->lock);
         tsc_in = tb_init_done ? get_cycles() : 0;
-        action->handler(vector_to_irq(vector), action->dev_id, regs);
-        TRACE_3D(TRC_TRACE_IRQ, vector, tsc_in, get_cycles());
+        action->handler(irq, action->dev_id, regs);
+        TRACE_3D(TRC_TRACE_IRQ, irq, tsc_in, get_cycles());
         spin_lock_irq(&desc->lock);
         irq_exit();
     }
@@ -162,11 +312,11 @@ asmlinkage void do_IRQ(struct cpu_user_r
     desc->status &= ~IRQ_INPROGRESS;
 
  out:
-    desc->handler->end(vector);
+    desc->handler->end(irq);
     spin_unlock(&desc->lock);
 }
 
-int request_irq_vector(unsigned int vector,
+int request_irq(unsigned int irq,
         void (*handler)(int, void *, struct cpu_user_regs *),
         unsigned long irqflags, const char * devname, void *dev_id)
 {
@@ -179,7 +329,7 @@ int request_irq_vector(unsigned int vect
      * which interrupt is which (messes up the interrupt freeing
      * logic etc).
      */
-    if (vector >= NR_VECTORS)
+    if (irq >= nr_irqs)
         return -EINVAL;
     if (!handler)
         return -EINVAL;
@@ -192,33 +342,42 @@ int request_irq_vector(unsigned int vect
     action->name = devname;
     action->dev_id = dev_id;
 
-    retval = setup_irq_vector(vector, action);
+    retval = setup_irq(irq, action);
     if (retval)
         xfree(action);
 
     return retval;
 }
 
-void release_irq_vector(unsigned int vector)
-{
-    irq_desc_t *desc = &irq_desc[vector];
+void release_irq(unsigned int irq)
+{
+    struct irq_desc *desc;
     unsigned long flags;
+    struct irqaction *action;
+
+    desc = irq_to_desc(irq);
 
     spin_lock_irqsave(&desc->lock,flags);
+    action = desc->action;
     desc->action  = NULL;
     desc->depth   = 1;
     desc->status |= IRQ_DISABLED;
-    desc->handler->shutdown(vector);
+    desc->handler->shutdown(irq);
     spin_unlock_irqrestore(&desc->lock,flags);
 
     /* Wait to make sure it's not being used on another CPU */
     do { smp_mb(); } while ( desc->status & IRQ_INPROGRESS );
-}
-
-int setup_irq_vector(unsigned int vector, struct irqaction *new)
-{
-    irq_desc_t *desc = &irq_desc[vector];
+
+    if (action)
+        xfree(action);
+}
+
+int setup_irq(unsigned int irq, struct irqaction *new)
+{
+    struct irq_desc *desc;
     unsigned long flags;
+
+    desc = irq_to_desc(irq);
  
     spin_lock_irqsave(&desc->lock,flags);
 
@@ -231,7 +390,7 @@ int setup_irq_vector(unsigned int vector
     desc->action  = new;
     desc->depth   = 0;
     desc->status &= ~IRQ_DISABLED;
-    desc->handler->startup(vector);
+    desc->handler->startup(irq);
 
     spin_unlock_irqrestore(&desc->lock,flags);
 
@@ -261,9 +420,10 @@ typedef struct {
  * order, as only the current highest-priority pending irq can be EOIed.
  */
 struct pending_eoi {
-    u8 vector; /* Vector awaiting EOI */
+    u8 vector; /* vector awaiting EOI */
     u8 ready;  /* Ready for EOI now?  */
 };
+
 static DEFINE_PER_CPU(struct pending_eoi, pending_eoi[NR_VECTORS]);
 #define pending_eoi_sp(p) ((p)[NR_VECTORS-1].vector)
 
@@ -279,26 +439,25 @@ static inline void clear_pirq_eoi(struct
         clear_bit(irq, d->arch.pirq_eoi_map);
 }
 
-static void _irq_guest_eoi(irq_desc_t *desc)
+static void _irq_guest_eoi(struct irq_desc *desc)
 {
     irq_guest_action_t *action = (irq_guest_action_t *)desc->action;
-    unsigned int i, vector = desc - irq_desc;
+    unsigned int i, irq = desc - irq_desc;
 
     if ( !(desc->status & IRQ_GUEST_EOI_PENDING) )
         return;
 
     for ( i = 0; i < action->nr_guests; ++i )
         clear_pirq_eoi(action->guest[i],
-                       domain_vector_to_irq(action->guest[i], vector));
+                       domain_irq_to_pirq(action->guest[i], irq));
 
     desc->status &= ~(IRQ_INPROGRESS|IRQ_GUEST_EOI_PENDING);
-    desc->handler->enable(vector);
-}
-
-static struct timer irq_guest_eoi_timer[NR_VECTORS];
+    desc->handler->enable(irq);
+}
+
 static void irq_guest_eoi_timer_fn(void *data)
 {
-    irq_desc_t *desc = data;
+    struct irq_desc *desc = data;
     unsigned long flags;
 
     spin_lock_irqsave(&desc->lock, flags);
@@ -306,20 +465,21 @@ static void irq_guest_eoi_timer_fn(void 
     spin_unlock_irqrestore(&desc->lock, flags);
 }
 
-static void __do_IRQ_guest(int vector)
-{
-    irq_desc_t         *desc = &irq_desc[vector];
+static void __do_IRQ_guest(int irq)
+{
+    struct irq_desc         *desc = irq_to_desc(irq);
     irq_guest_action_t *action = (irq_guest_action_t *)desc->action;
     struct domain      *d;
     int                 i, sp, already_pending = 0;
     struct pending_eoi *peoi = this_cpu(pending_eoi);
+    int vector = irq_to_vector(irq);
 
     if ( unlikely(action->nr_guests == 0) )
     {
         /* An interrupt may slip through while freeing an ACKTYPE_EOI irq. */
         ASSERT(action->ack_type == ACKTYPE_EOI);
         ASSERT(desc->status & IRQ_DISABLED);
-        desc->handler->end(vector);
+        desc->handler->end(irq);
         return;
     }
 
@@ -336,13 +496,13 @@ static void __do_IRQ_guest(int vector)
 
     for ( i = 0; i < action->nr_guests; i++ )
     {
-        unsigned int irq;
+        unsigned int pirq;
         d = action->guest[i];
-        irq = domain_vector_to_irq(d, vector);
+        pirq = domain_irq_to_pirq(d, irq);
         if ( (action->ack_type != ACKTYPE_NONE) &&
-             !test_and_set_bit(irq, d->pirq_mask) )
+             !test_and_set_bit(pirq, d->pirq_mask) )
             action->in_flight++;
-        if ( hvm_do_IRQ_dpci(d, irq) )
+        if ( hvm_do_IRQ_dpci(d, pirq) )
         {
             if ( action->ack_type == ACKTYPE_NONE )
             {
@@ -350,7 +510,7 @@ static void __do_IRQ_guest(int vector)
                 desc->status |= IRQ_INPROGRESS; /* cleared during hvm eoi */
             }
         }
-        else if ( send_guest_pirq(d, irq) &&
+        else if ( send_guest_pirq(d, pirq) &&
                   (action->ack_type == ACKTYPE_NONE) )
         {
             already_pending++;
@@ -359,13 +519,13 @@ static void __do_IRQ_guest(int vector)
 
     if ( already_pending == action->nr_guests )
     {
-        stop_timer(&irq_guest_eoi_timer[vector]);
-        desc->handler->disable(vector);
+        stop_timer(&irq_guest_eoi_timer[irq]);
+        desc->handler->disable(irq);
         desc->status |= IRQ_GUEST_EOI_PENDING;
         for ( i = 0; i < already_pending; ++i )
         {
             d = action->guest[i];
-            set_pirq_eoi(d, domain_vector_to_irq(d, vector));
+            set_pirq_eoi(d, domain_irq_to_pirq(d, irq));
             /*
              * Could check here whether the guest unmasked the event by now
              * (or perhaps just re-issue the send_guest_pirq()), and if it
@@ -375,9 +535,9 @@ static void __do_IRQ_guest(int vector)
              * - skip the timer setup below.
              */
         }
-        init_timer(&irq_guest_eoi_timer[vector],
+        init_timer(&irq_guest_eoi_timer[irq],
                    irq_guest_eoi_timer_fn, desc, smp_processor_id());
-        set_timer(&irq_guest_eoi_timer[vector], NOW() + MILLISECS(1));
+        set_timer(&irq_guest_eoi_timer[irq], NOW() + MILLISECS(1));
     }
 }
 
@@ -386,21 +546,21 @@ static void __do_IRQ_guest(int vector)
  * The descriptor is returned locked. This function is safe against changes
  * to the per-domain irq-to-vector mapping.
  */
-irq_desc_t *domain_spin_lock_irq_desc(
-    struct domain *d, int irq, unsigned long *pflags)
-{
-    unsigned int vector;
+struct irq_desc *domain_spin_lock_irq_desc(
+    struct domain *d, int pirq, unsigned long *pflags)
+{
+    unsigned int irq;
     unsigned long flags;
-    irq_desc_t *desc;
+    struct irq_desc *desc;
 
     for ( ; ; )
     {
-        vector = domain_irq_to_vector(d, irq);
-        if ( vector <= 0 )
+        irq = domain_pirq_to_irq(d, pirq);
+        if ( irq <= 0 )
             return NULL;
-        desc = &irq_desc[vector];
+        desc = irq_to_desc(irq);
         spin_lock_irqsave(&desc->lock, flags);
-        if ( vector == domain_irq_to_vector(d, irq) )
+        if ( irq == domain_pirq_to_irq(d, pirq) )
             break;
         spin_unlock_irqrestore(&desc->lock, flags);
     }
@@ -414,8 +574,8 @@ static void flush_ready_eoi(void)
 static void flush_ready_eoi(void)
 {
     struct pending_eoi *peoi = this_cpu(pending_eoi);
-    irq_desc_t         *desc;
-    int                 vector, sp;
+    struct irq_desc         *desc;
+    int                irq, sp;
 
     ASSERT(!local_irq_is_enabled());
 
@@ -423,23 +583,23 @@ static void flush_ready_eoi(void)
 
     while ( (--sp >= 0) && peoi[sp].ready )
     {
-        vector = peoi[sp].vector;
-        desc = &irq_desc[vector];
+        irq = vector_irq[peoi[sp].vector];
+        desc = irq_to_desc(irq);
         spin_lock(&desc->lock);
-        desc->handler->end(vector);
+        desc->handler->end(irq);
         spin_unlock(&desc->lock);
     }
 
     pending_eoi_sp(peoi) = sp+1;
 }
 
-static void __set_eoi_ready(irq_desc_t *desc)
+static void __set_eoi_ready(struct irq_desc *desc)
 {
     irq_guest_action_t *action = (irq_guest_action_t *)desc->action;
     struct pending_eoi *peoi = this_cpu(pending_eoi);
-    int                 vector, sp;
-
-    vector = desc - irq_desc;
+    int                 irq, sp;
+
+    irq = desc - irq_desc;
 
     if ( !(desc->status & IRQ_GUEST) ||
          (action->in_flight != 0) ||
@@ -449,7 +609,7 @@ static void __set_eoi_ready(irq_desc_t *
     sp = pending_eoi_sp(peoi);
     do {
         ASSERT(sp > 0);
-    } while ( peoi[--sp].vector != vector );
+    } while ( peoi[--sp].vector != irq_to_vector(irq) );
     ASSERT(!peoi[sp].ready);
     peoi[sp].ready = 1;
 }
@@ -457,7 +617,7 @@ static void __set_eoi_ready(irq_desc_t *
 /* Mark specified IRQ as ready-for-EOI (if it really is) and attempt to EOI. */
 static void set_eoi_ready(void *data)
 {
-    irq_desc_t *desc = data;
+    struct irq_desc *desc = data;
 
     ASSERT(!local_irq_is_enabled());
 
@@ -468,29 +628,29 @@ static void set_eoi_ready(void *data)
     flush_ready_eoi();
 }
 
-static void __pirq_guest_eoi(struct domain *d, int irq)
-{
-    irq_desc_t         *desc;
+static void __pirq_guest_eoi(struct domain *d, int pirq)
+{
+    struct irq_desc         *desc;
     irq_guest_action_t *action;
     cpumask_t           cpu_eoi_map;
-    int                 vector;
+    int                 irq;
 
     ASSERT(local_irq_is_enabled());
-    desc = domain_spin_lock_irq_desc(d, irq, NULL);
+    desc = domain_spin_lock_irq_desc(d, pirq, NULL);
     if ( desc == NULL )
         return;
 
     action = (irq_guest_action_t *)desc->action;
-    vector = desc - irq_desc;
+    irq = desc - irq_desc;
 
     if ( action->ack_type == ACKTYPE_NONE )
     {
-        ASSERT(!test_bit(irq, d->pirq_mask));
-        stop_timer(&irq_guest_eoi_timer[vector]);
+        ASSERT(!test_bit(pirq, d->pirq_mask));
+        stop_timer(&irq_guest_eoi_timer[irq]);
         _irq_guest_eoi(desc);
     }
 
-    if ( unlikely(!test_and_clear_bit(irq, d->pirq_mask)) ||
+    if ( unlikely(!test_and_clear_bit(pirq, d->pirq_mask)) ||
          unlikely(--action->in_flight != 0) )
     {
         spin_unlock_irq(&desc->lock);
@@ -500,7 +660,7 @@ static void __pirq_guest_eoi(struct doma
     if ( action->ack_type == ACKTYPE_UNMASK )
     {
         ASSERT(cpus_empty(action->cpu_eoi_map));
-        desc->handler->end(vector);
+        desc->handler->end(irq);
         spin_unlock_irq(&desc->lock);
         return;
     }
@@ -527,7 +687,7 @@ static void __pirq_guest_eoi(struct doma
 
 int pirq_guest_eoi(struct domain *d, int irq)
 {
-    if ( (irq < 0) || (irq >= d->nr_pirqs) )
+    if ( (irq < 0) || (irq > d->nr_pirqs) )
         return -EINVAL;
 
     __pirq_guest_eoi(d, irq);
@@ -551,16 +711,16 @@ int pirq_guest_unmask(struct domain *d)
 }
 
 extern int ioapic_ack_new;
-static int pirq_acktype(struct domain *d, int irq)
-{
-    irq_desc_t  *desc;
-    unsigned int vector;
-
-    vector = domain_irq_to_vector(d, irq);
-    if ( vector <= 0 )
+static int pirq_acktype(struct domain *d, int pirq)
+{
+    struct irq_desc  *desc;
+    unsigned int irq;
+
+    irq = domain_pirq_to_irq(d, pirq);
+    if ( irq <= 0 )
         return ACKTYPE_NONE;
 
-    desc = &irq_desc[vector];
+    desc = irq_to_desc(irq);
 
     if ( desc->handler == &no_irq_type )
         return ACKTYPE_NONE;
@@ -597,14 +757,14 @@ static int pirq_acktype(struct domain *d
     return 0;
 }
 
-int pirq_shared(struct domain *d, int irq)
-{
-    irq_desc_t         *desc;
+int pirq_shared(struct domain *d, int pirq)
+{
+    struct irq_desc         *desc;
     irq_guest_action_t *action;
     unsigned long       flags;
     int                 shared;
 
-    desc = domain_spin_lock_irq_desc(d, irq, &flags);
+    desc = domain_spin_lock_irq_desc(d, pirq, &flags);
     if ( desc == NULL )
         return 0;
 
@@ -616,10 +776,10 @@ int pirq_shared(struct domain *d, int ir
     return shared;
 }
 
-int pirq_guest_bind(struct vcpu *v, int irq, int will_share)
-{
-    unsigned int        vector;
-    irq_desc_t         *desc;
+int pirq_guest_bind(struct vcpu *v, int pirq, int will_share)
+{
+    unsigned int        irq;
+    struct irq_desc         *desc;
     irq_guest_action_t *action, *newaction = NULL;
     int                 rc = 0;
     cpumask_t           cpumask = CPU_MASK_NONE;
@@ -628,7 +788,7 @@ int pirq_guest_bind(struct vcpu *v, int 
     BUG_ON(!local_irq_is_enabled());
 
  retry:
-    desc = domain_spin_lock_irq_desc(v->domain, irq, NULL);
+    desc = domain_spin_lock_irq_desc(v->domain, pirq, NULL);
     if ( desc == NULL )
     {
         rc = -EINVAL;
@@ -636,7 +796,7 @@ int pirq_guest_bind(struct vcpu *v, int 
     }
 
     action = (irq_guest_action_t *)desc->action;
-    vector = desc - irq_desc;
+    irq = desc - irq_desc;
 
     if ( !(desc->status & IRQ_GUEST) )
     {
@@ -644,7 +804,7 @@ int pirq_guest_bind(struct vcpu *v, int 
         {
             gdprintk(XENLOG_INFO,
                     "Cannot bind IRQ %d to guest. In use by '%s'.\n",
-                    irq, desc->action->name);
+                    pirq, desc->action->name);
             rc = -EBUSY;
             goto unlock_out;
         }
@@ -656,7 +816,7 @@ int pirq_guest_bind(struct vcpu *v, int 
                 goto retry;
             gdprintk(XENLOG_INFO,
                      "Cannot bind IRQ %d to guest. Out of memory.\n",
-                     irq);
+                     pirq);
             rc = -ENOMEM;
             goto out;
         }
@@ -668,23 +828,23 @@ int pirq_guest_bind(struct vcpu *v, int 
         action->nr_guests   = 0;
         action->in_flight   = 0;
         action->shareable   = will_share;
-        action->ack_type    = pirq_acktype(v->domain, irq);
+        action->ack_type    = pirq_acktype(v->domain, pirq);
         cpus_clear(action->cpu_eoi_map);
 
         desc->depth = 0;
         desc->status |= IRQ_GUEST;
         desc->status &= ~IRQ_DISABLED;
-        desc->handler->startup(vector);
+        desc->handler->startup(irq);
 
         /* Attempt to bind the interrupt target to the correct CPU. */
         cpu_set(v->processor, cpumask);
         if ( !opt_noirqbalance && (desc->handler->set_affinity != NULL) )
-            desc->handler->set_affinity(vector, cpumask);
+            desc->handler->set_affinity(irq, cpumask);
     }
     else if ( !will_share || !action->shareable )
     {
         gdprintk(XENLOG_INFO, "Cannot bind IRQ %d to guest. %s.\n",
-                 irq,
+                 pirq,
                  will_share ?
                  "Others do not share" :
                  "Will not share with others");
@@ -707,7 +867,7 @@ int pirq_guest_bind(struct vcpu *v, int 
     if ( action->nr_guests == IRQ_MAX_GUESTS )
     {
         gdprintk(XENLOG_INFO, "Cannot bind IRQ %d to guest. "
-               "Already at max share.\n", irq);
+               "Already at max share.\n", pirq);
         rc = -EBUSY;
         goto unlock_out;
     }
@@ -715,9 +875,9 @@ int pirq_guest_bind(struct vcpu *v, int 
     action->guest[action->nr_guests++] = v->domain;
 
     if ( action->ack_type != ACKTYPE_NONE )
-        set_pirq_eoi(v->domain, irq);
+        set_pirq_eoi(v->domain, pirq);
     else
-        clear_pirq_eoi(v->domain, irq);
+        clear_pirq_eoi(v->domain, pirq);
 
  unlock_out:
     spin_unlock_irq(&desc->lock);
@@ -728,9 +888,9 @@ int pirq_guest_bind(struct vcpu *v, int 
 }
 
 static irq_guest_action_t *__pirq_guest_unbind(
-    struct domain *d, int irq, irq_desc_t *desc)
-{
-    unsigned int        vector;
+    struct domain *d, int pirq, struct irq_desc *desc)
+{
+    unsigned int        irq;
     irq_guest_action_t *action;
     cpumask_t           cpu_eoi_map;
     int                 i;
@@ -738,7 +898,7 @@ static irq_guest_action_t *__pirq_guest_
     BUG_ON(!(desc->status & IRQ_GUEST));
 
     action = (irq_guest_action_t *)desc->action;
-    vector = desc - irq_desc;
+    irq = desc - irq_desc;
 
     for ( i = 0; (i < action->nr_guests) && (action->guest[i] != d); i++ )
         continue;
@@ -749,13 +909,13 @@ static irq_guest_action_t *__pirq_guest_
     switch ( action->ack_type )
     {
     case ACKTYPE_UNMASK:
-        if ( test_and_clear_bit(irq, d->pirq_mask) &&
+        if ( test_and_clear_bit(pirq, d->pirq_mask) &&
              (--action->in_flight == 0) )
-            desc->handler->end(vector);
+            desc->handler->end(irq);
         break;
     case ACKTYPE_EOI:
         /* NB. If #guests == 0 then we clear the eoi_map later on. */
-        if ( test_and_clear_bit(irq, d->pirq_mask) &&
+        if ( test_and_clear_bit(pirq, d->pirq_mask) &&
              (--action->in_flight == 0) &&
              (action->nr_guests != 0) )
         {
@@ -766,7 +926,7 @@ static irq_guest_action_t *__pirq_guest_
         }
         break;
     case ACKTYPE_NONE:
-        stop_timer(&irq_guest_eoi_timer[vector]);
+        stop_timer(&irq_guest_eoi_timer[irq]);
         _irq_guest_eoi(desc);
         break;
     }
@@ -775,7 +935,7 @@ static irq_guest_action_t *__pirq_guest_
      * The guest cannot re-bind to this IRQ until this function returns. So,
      * when we have flushed this IRQ from pirq_mask, it should remain flushed.
      */
-    BUG_ON(test_bit(irq, d->pirq_mask));
+    BUG_ON(test_bit(pirq, d->pirq_mask));
 
     if ( action->nr_guests != 0 )
         return NULL;
@@ -785,7 +945,7 @@ static irq_guest_action_t *__pirq_guest_
     /* Disabling IRQ before releasing the desc_lock avoids an IRQ storm. */
     desc->depth   = 1;
     desc->status |= IRQ_DISABLED;
-    desc->handler->disable(vector);
+    desc->handler->disable(irq);
 
     /*
      * Mark any remaining pending EOIs as ready to flush.
@@ -808,35 +968,35 @@ static irq_guest_action_t *__pirq_guest_
     desc->action = NULL;
     desc->status &= ~IRQ_GUEST;
     desc->status &= ~IRQ_INPROGRESS;
-    kill_timer(&irq_guest_eoi_timer[vector]);
-    desc->handler->shutdown(vector);
+    kill_timer(&irq_guest_eoi_timer[irq]);
+    desc->handler->shutdown(irq);
 
     /* Caller frees the old guest descriptor block. */
     return action;
 }
 
-void pirq_guest_unbind(struct domain *d, int irq)
+void pirq_guest_unbind(struct domain *d, int pirq)
 {
     irq_guest_action_t *oldaction = NULL;
-    irq_desc_t *desc;
-    int vector;
+    struct irq_desc *desc;
+    int irq;
 
     WARN_ON(!spin_is_locked(&d->event_lock));
 
     BUG_ON(!local_irq_is_enabled());
-    desc = domain_spin_lock_irq_desc(d, irq, NULL);
+    desc = domain_spin_lock_irq_desc(d, pirq, NULL);
 
     if ( desc == NULL )
     {
-        vector = -domain_irq_to_vector(d, irq);
-        BUG_ON(vector <= 0);
-        desc = &irq_desc[vector];
+        irq = -domain_pirq_to_irq(d, pirq);
+        BUG_ON(irq <= 0);
+        desc = irq_to_desc(irq);
         spin_lock_irq(&desc->lock);
-        d->arch.pirq_vector[irq] = d->arch.vector_pirq[vector] = 0;
+        d->arch.pirq_irq[pirq] = d->arch.irq_pirq[irq] = 0;
     }
     else
     {
-        oldaction = __pirq_guest_unbind(d, irq, desc);
+        oldaction = __pirq_guest_unbind(d, pirq, desc);
     }
 
     spin_unlock_irq(&desc->lock);
@@ -847,7 +1007,7 @@ void pirq_guest_unbind(struct domain *d,
 
 static int pirq_guest_force_unbind(struct domain *d, int irq)
 {
-    irq_desc_t *desc;
+    struct irq_desc *desc;
     irq_guest_action_t *action, *oldaction = NULL;
     int i, bound = 0;
 
@@ -887,7 +1047,7 @@ int get_free_pirq(struct domain *d, int 
     if ( type == MAP_PIRQ_TYPE_GSI )
     {
         for ( i = 16; i < nr_irqs_gsi; i++ )
-            if ( !d->arch.pirq_vector[i] )
+            if ( !d->arch.pirq_irq[i] )
                 break;
         if ( i == nr_irqs_gsi )
             return -ENOSPC;
@@ -895,7 +1055,7 @@ int get_free_pirq(struct domain *d, int 
     else
     {
         for ( i = d->nr_pirqs - 1; i >= 16; i-- )
-            if ( !d->arch.pirq_vector[i] )
+            if ( !d->arch.pirq_irq[i] )
                 break;
         if ( i == 16 )
             return -ENOSPC;
@@ -905,11 +1065,11 @@ int get_free_pirq(struct domain *d, int 
 }
 
 int map_domain_pirq(
-    struct domain *d, int pirq, int vector, int type, void *data)
+    struct domain *d, int pirq, int irq, int type, void *data)
 {
     int ret = 0;
-    int old_vector, old_pirq;
-    irq_desc_t *desc;
+    int old_irq, old_pirq;
+    struct irq_desc *desc;
     unsigned long flags;
     struct msi_desc *msi_desc;
     struct pci_dev *pdev = NULL;
@@ -920,21 +1080,21 @@ int map_domain_pirq(
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
 
-    if ( pirq < 0 || pirq >= d->nr_pirqs || vector < 0 || vector >= NR_VECTORS 
)
-    {
-        dprintk(XENLOG_G_ERR, "dom%d: invalid pirq %d or vector %d\n",
-                d->domain_id, pirq, vector);
+    if ( pirq < 0 || pirq >= d->nr_pirqs || irq < 0 || irq >= nr_irqs )
+    {
+        dprintk(XENLOG_G_ERR, "dom%d: invalid pirq %d or irq %d\n",
+                d->domain_id, pirq, irq);
         return -EINVAL;
     }
 
-    old_vector = domain_irq_to_vector(d, pirq);
-    old_pirq = domain_vector_to_irq(d, vector);
-
-    if ( (old_vector && (old_vector != vector) ) ||
+    old_irq = domain_pirq_to_irq(d, pirq);
+    old_pirq = domain_irq_to_pirq(d, irq);
+
+    if ( (old_irq && (old_irq != irq) ) ||
          (old_pirq && (old_pirq != pirq)) )
     {
-        dprintk(XENLOG_G_ERR, "dom%d: pirq %d or vector %d already mapped\n",
-                d->domain_id, pirq, vector);
+        dprintk(XENLOG_G_ERR, "dom%d: pirq %d or irq %d already mapped\n",
+                d->domain_id, pirq, irq);
         return -EINVAL;
     }
 
@@ -946,7 +1106,7 @@ int map_domain_pirq(
         return ret;
     }
 
-    desc = &irq_desc[vector];
+    desc = irq_to_desc(irq);
 
     if ( type == MAP_PIRQ_TYPE_MSI )
     {
@@ -964,18 +1124,18 @@ int map_domain_pirq(
         spin_lock_irqsave(&desc->lock, flags);
 
         if ( desc->handler != &no_irq_type )
-            dprintk(XENLOG_G_ERR, "dom%d: vector %d in use\n",
-              d->domain_id, vector);
+            dprintk(XENLOG_G_ERR, "dom%d: irq %d in use\n",
+              d->domain_id, irq);
         desc->handler = &pci_msi_type;
-        d->arch.pirq_vector[pirq] = vector;
-        d->arch.vector_pirq[vector] = pirq;
-        setup_msi_irq(pdev, msi_desc);
+        d->arch.pirq_irq[pirq] = irq;
+        d->arch.irq_pirq[irq] = pirq;
+        setup_msi_irq(pdev, msi_desc, irq);
         spin_unlock_irqrestore(&desc->lock, flags);
     } else
     {
         spin_lock_irqsave(&desc->lock, flags);
-        d->arch.pirq_vector[pirq] = vector;
-        d->arch.vector_pirq[vector] = pirq;
+        d->arch.pirq_irq[pirq] = irq;
+        d->arch.irq_pirq[irq] = pirq;
         spin_unlock_irqrestore(&desc->lock, flags);
     }
 
@@ -987,8 +1147,8 @@ int unmap_domain_pirq(struct domain *d, 
 int unmap_domain_pirq(struct domain *d, int pirq)
 {
     unsigned long flags;
-    irq_desc_t *desc;
-    int vector, ret = 0;
+    struct irq_desc *desc;
+    int irq, ret = 0;
     bool_t forced_unbind;
     struct msi_desc *msi_desc = NULL;
 
@@ -1001,8 +1161,8 @@ int unmap_domain_pirq(struct domain *d, 
     ASSERT(spin_is_locked(&pcidevs_lock));
     ASSERT(spin_is_locked(&d->event_lock));
 
-    vector = domain_irq_to_vector(d, pirq);
-    if ( vector <= 0 )
+    irq = domain_pirq_to_irq(d, pirq);
+    if ( irq <= 0 )
     {
         dprintk(XENLOG_G_ERR, "dom%d: pirq %d not mapped\n",
                 d->domain_id, pirq);
@@ -1015,44 +1175,41 @@ int unmap_domain_pirq(struct domain *d, 
         dprintk(XENLOG_G_WARNING, "dom%d: forcing unbind of pirq %d\n",
                 d->domain_id, pirq);
 
-    desc = &irq_desc[vector];
+    desc = irq_to_desc(irq);
 
     if ( (msi_desc = desc->msi_desc) != NULL )
         pci_disable_msi(msi_desc);
 
     spin_lock_irqsave(&desc->lock, flags);
 
-    BUG_ON(vector != domain_irq_to_vector(d, pirq));
+    BUG_ON(irq != domain_pirq_to_irq(d, pirq));
 
     if ( msi_desc )
-        teardown_msi_vector(vector);
-
-    if ( desc->handler == &pci_msi_type )
-        desc->handler = &no_irq_type;
+        teardown_msi_irq(irq);
 
     if ( !forced_unbind )
     {
-        d->arch.pirq_vector[pirq] = 0;
-        d->arch.vector_pirq[vector] = 0;
+        d->arch.pirq_irq[pirq] = 0;
+        d->arch.irq_pirq[irq] = 0;
     }
     else
     {
-        d->arch.pirq_vector[pirq] = -vector;
-        d->arch.vector_pirq[vector] = -pirq;
+        d->arch.pirq_irq[pirq] = -irq;
+        d->arch.irq_pirq[irq] = -pirq;
     }
 
     spin_unlock_irqrestore(&desc->lock, flags);
     if (msi_desc)
-    {
-        msi_free_vector(msi_desc);
-        free_irq_vector(vector);
-    }
+        msi_free_irq(msi_desc);
 
     ret = irq_deny_access(d, pirq);
     if ( ret )
         dprintk(XENLOG_G_ERR, "dom%d: could not deny access to irq %d\n",
                 d->domain_id, pirq);
 
+    if ( desc->handler == &pci_msi_type )
+        desc->handler = &no_irq_type;
+
  done:
     return ret;
 }
@@ -1065,7 +1222,7 @@ void free_domain_pirqs(struct domain *d)
     spin_lock(&d->event_lock);
 
     for ( i = 0; i < d->nr_pirqs; i++ )
-        if ( d->arch.pirq_vector[i] > 0 )
+        if ( d->arch.pirq_irq[i] > 0 )
             unmap_domain_pirq(d, i);
 
     spin_unlock(&d->event_lock);
@@ -1077,7 +1234,7 @@ static void dump_irqs(unsigned char key)
 static void dump_irqs(unsigned char key)
 {
     int i, glob_irq, irq, vector;
-    irq_desc_t *desc;
+    struct irq_desc *desc;
     irq_guest_action_t *action;
     struct domain *d;
     unsigned long flags;
@@ -1088,8 +1245,10 @@ static void dump_irqs(unsigned char key)
     {
 
         glob_irq = vector_to_irq(vector);
-
-        desc = &irq_desc[vector];
+        if (glob_irq < 0)
+            continue;
+
+        desc = irq_to_desc(glob_irq);
         if ( desc == NULL || desc->handler == &no_irq_type )
             continue;
 
@@ -1111,7 +1270,7 @@ static void dump_irqs(unsigned char key)
             for ( i = 0; i < action->nr_guests; i++ )
             {
                 d = action->guest[i];
-                irq = domain_vector_to_irq(d, vector);
+                irq = domain_irq_to_pirq(d, vector_irq[vector]);
                 printk("%u:%3d(%c%c%c%c)",
                        d->domain_id, irq,
                        (test_bit(d->pirq_to_evtchn[glob_irq],
@@ -1172,7 +1331,7 @@ void fixup_irqs(cpumask_t map)
         if ( vector_to_irq(vector) == 2 )
             continue;
 
-        desc = &irq_desc[vector];
+        desc = irq_to_desc(vector_to_irq(vector));
 
         spin_lock_irqsave(&desc->lock, flags);
 
@@ -1200,9 +1359,9 @@ void fixup_irqs(cpumask_t map)
     /* Clean up cpu_eoi_map of every interrupt to exclude this CPU. */
     for ( vector = 0; vector < NR_VECTORS; vector++ )
     {
-        if ( !(irq_desc[vector].status & IRQ_GUEST) )
+        if ( !(irq_desc[vector_to_irq(vector)].status & IRQ_GUEST) )
             continue;
-        action = (irq_guest_action_t *)irq_desc[vector].action;
+        action = (irq_guest_action_t *)irq_desc[vector_to_irq(vector)].action;
         cpu_clear(smp_processor_id(), action->cpu_eoi_map);
     }
 
diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/msi.c
--- a/xen/arch/x86/msi.c        Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/msi.c        Wed Aug 19 12:53:04 2009 +0100
@@ -116,11 +116,12 @@ static void msix_put_fixmap(struct pci_d
 /*
  * MSI message composition
  */
-void msi_compose_msg(struct pci_dev *pdev, int vector,
+void msi_compose_msg(struct pci_dev *pdev, int irq,
                             struct msi_msg *msg)
 {
     unsigned dest;
     cpumask_t tmp;
+    int vector = irq_to_vector(irq);
 
     tmp = TARGET_CPUS;
     if ( vector )
@@ -195,31 +196,31 @@ static void read_msi_msg(struct msi_desc
         iommu_read_msi_from_ire(entry, msg);
 }
 
-static int set_vector_msi(struct msi_desc *entry)
-{
-    if ( entry->vector >= NR_VECTORS )
-    {
-        dprintk(XENLOG_ERR, "Trying to install msi data for Vector %d\n",
-                entry->vector);
+static int set_irq_msi(struct msi_desc *entry)
+{
+    if ( entry->irq >= nr_irqs )
+    {
+        dprintk(XENLOG_ERR, "Trying to install msi data for irq %d\n",
+                entry->irq);
         return -EINVAL;
     }
 
-    irq_desc[entry->vector].msi_desc = entry;
+    irq_desc[entry->irq].msi_desc = entry;
     return 0;
 }
 
-static int unset_vector_msi(int vector)
-{
-    ASSERT(spin_is_locked(&irq_desc[vector].lock));
-
-    if ( vector >= NR_VECTORS )
-    {
-        dprintk(XENLOG_ERR, "Trying to uninstall msi data for Vector %d\n",
-                vector);
+static int unset_irq_msi(int irq)
+{
+    ASSERT(spin_is_locked(&irq_desc[irq].lock));
+
+    if ( irq >= nr_irqs )
+    {
+        dprintk(XENLOG_ERR, "Trying to uninstall msi data for irq %d\n",
+                irq);
         return -EINVAL;
     }
 
-    irq_desc[vector].msi_desc = NULL;
+    irq_desc[irq].msi_desc = NULL;
 
     return 0;
 }
@@ -271,9 +272,9 @@ static void write_msi_msg(struct msi_des
     entry->msg = *msg;
 }
 
-void set_msi_affinity(unsigned int vector, cpumask_t mask)
-{
-    struct msi_desc *desc = irq_desc[vector].msi_desc;
+void set_msi_affinity(unsigned int irq, cpumask_t mask)
+{
+    struct msi_desc *desc = irq_desc[irq].msi_desc;
     struct msi_msg msg;
     unsigned int dest;
 
@@ -286,7 +287,7 @@ void set_msi_affinity(unsigned int vecto
     if ( !desc )
         return;
 
-    ASSERT(spin_is_locked(&irq_desc[vector].lock));
+    ASSERT(spin_is_locked(&irq_desc[irq].lock));
     read_msi_msg(desc, &msg);
 
     msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
@@ -333,9 +334,9 @@ static void msix_set_enable(struct pci_d
     }
 }
 
-static void msix_flush_writes(unsigned int vector)
-{
-    struct msi_desc *entry = irq_desc[vector].msi_desc;
+static void msix_flush_writes(unsigned int irq)
+{
+    struct msi_desc *entry = irq_desc[irq].msi_desc;
 
     BUG_ON(!entry || !entry->dev);
     switch (entry->msi_attrib.type) {
@@ -361,11 +362,11 @@ int msi_maskable_irq(const struct msi_de
            || entry->msi_attrib.maskbit;
 }
 
-static void msi_set_mask_bit(unsigned int vector, int flag)
-{
-    struct msi_desc *entry = irq_desc[vector].msi_desc;
-
-    ASSERT(spin_is_locked(&irq_desc[vector].lock));
+static void msi_set_mask_bit(unsigned int irq, int flag)
+{
+    struct msi_desc *entry = irq_desc[irq].msi_desc;
+
+    ASSERT(spin_is_locked(&irq_desc[irq].lock));
     BUG_ON(!entry || !entry->dev);
     switch (entry->msi_attrib.type) {
     case PCI_CAP_ID_MSI:
@@ -397,16 +398,16 @@ static void msi_set_mask_bit(unsigned in
     entry->msi_attrib.masked = !!flag;
 }
 
-void mask_msi_vector(unsigned int vector)
-{
-    msi_set_mask_bit(vector, 1);
-    msix_flush_writes(vector);
-}
-
-void unmask_msi_vector(unsigned int vector)
-{
-    msi_set_mask_bit(vector, 0);
-    msix_flush_writes(vector);
+void mask_msi_irq(unsigned int irq)
+{
+    msi_set_mask_bit(irq, 1);
+    msix_flush_writes(irq);
+}
+
+void unmask_msi_irq(unsigned int irq)
+{
+    msi_set_mask_bit(irq, 0);
+    msix_flush_writes(irq);
 }
 
 static struct msi_desc* alloc_msi_entry(void)
@@ -424,23 +425,23 @@ static struct msi_desc* alloc_msi_entry(
     return entry;
 }
 
-int setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc)
+int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq)
 {
     struct msi_msg msg;
 
-    msi_compose_msg(dev, desc->vector, &msg);
-    set_vector_msi(desc);
-    write_msi_msg(irq_desc[desc->vector].msi_desc, &msg);
+    msi_compose_msg(dev, irq, &msg);
+    set_irq_msi(msidesc);
+    write_msi_msg(irq_desc[irq].msi_desc, &msg);
 
     return 0;
 }
 
-void teardown_msi_vector(int vector)
-{
-    unset_vector_msi(vector);
-}
-
-int msi_free_vector(struct msi_desc *entry)
+void teardown_msi_irq(int irq)
+{
+    unset_irq_msi(irq);
+}
+
+int msi_free_irq(struct msi_desc *entry)
 {
     if ( entry->msi_attrib.type == PCI_CAP_ID_MSIX )
     {
@@ -452,19 +453,20 @@ int msi_free_vector(struct msi_desc *ent
         msix_put_fixmap(entry->dev, virt_to_fix(start));
     }
     list_del(&entry->list);
+    destroy_irq(entry->irq);
     xfree(entry);
     return 0;
 }
 
 static struct msi_desc *find_msi_entry(struct pci_dev *dev,
-                                       int vector, int cap_id)
+                                       int irq, int cap_id)
 {
     struct msi_desc *entry;
 
     list_for_each_entry( entry, &dev->msi_list, list )
     {
         if ( entry->msi_attrib.type == cap_id &&
-             (vector == -1 || entry->vector == vector) )
+             (irq == -1 || entry->irq == irq) )
             return entry;
     }
 
@@ -481,7 +483,7 @@ static struct msi_desc *find_msi_entry(s
  * of an entry zero with the new MSI irq or non-zero for otherwise.
  **/
 static int msi_capability_init(struct pci_dev *dev,
-                               int vector,
+                               int irq,
                                struct msi_desc **desc)
 {
     struct msi_desc *entry;
@@ -507,7 +509,7 @@ static int msi_capability_init(struct pc
     entry->msi_attrib.maskbit = is_mask_bit_support(control);
     entry->msi_attrib.masked = 1;
     entry->msi_attrib.pos = pos;
-    entry->vector = vector;
+    entry->irq = irq;
     if ( is_mask_bit_support(control) )
         entry->mask_base = (void __iomem *)(long)msi_mask_bits_reg(pos,
                                                                    
is_64bit_address(control));
@@ -594,7 +596,7 @@ static int msix_capability_init(struct p
     entry->msi_attrib.maskbit = 1;
     entry->msi_attrib.masked = 1;
     entry->msi_attrib.pos = pos;
-    entry->vector = msi->vector;
+    entry->irq = msi->irq;
     entry->dev = dev;
     entry->mask_base = base;
 
@@ -630,15 +632,15 @@ static int __pci_enable_msi(struct msi_i
     if ( !pdev )
         return -ENODEV;
 
-    if ( find_msi_entry(pdev, msi->vector, PCI_CAP_ID_MSI) )
-    {
-        dprintk(XENLOG_WARNING, "vector %d has already mapped to MSI on "
-                "device %02x:%02x.%01x.\n", msi->vector, msi->bus,
+    if ( find_msi_entry(pdev, msi->irq, PCI_CAP_ID_MSI) )
+    {
+        dprintk(XENLOG_WARNING, "irq %d has already mapped to MSI on "
+                "device %02x:%02x.%01x.\n", msi->irq, msi->bus,
                 PCI_SLOT(msi->devfn), PCI_FUNC(msi->devfn));
         return 0;
     }
 
-    status = msi_capability_init(pdev, msi->vector, desc);
+    status = msi_capability_init(pdev, msi->irq, desc);
     return status;
 }
 
@@ -696,10 +698,10 @@ static int __pci_enable_msix(struct msi_
     if (msi->entry_nr >= nr_entries)
         return -EINVAL;
 
-    if ( find_msi_entry(pdev, msi->vector, PCI_CAP_ID_MSIX) )
-    {
-        dprintk(XENLOG_WARNING, "vector %d has already mapped to MSIX on "
-                "device %02x:%02x.%01x.\n", msi->vector, msi->bus,
+    if ( find_msi_entry(pdev, msi->irq, PCI_CAP_ID_MSIX) )
+    {
+        dprintk(XENLOG_WARNING, "irq %d has already mapped to MSIX on "
+                "device %02x:%02x.%01x.\n", msi->irq, msi->bus,
                 PCI_SLOT(msi->devfn), PCI_FUNC(msi->devfn));
         return 0;
     }
@@ -754,21 +756,21 @@ void pci_disable_msi(struct msi_desc *ms
         __pci_disable_msix(msi_desc);
 }
 
-static void msi_free_vectors(struct pci_dev* dev)
+static void msi_free_irqs(struct pci_dev* dev)
 {
     struct msi_desc *entry, *tmp;
-    irq_desc_t *desc;
-    unsigned long flags, vector;
+    struct irq_desc *desc;
+    unsigned long flags, irq;
 
     list_for_each_entry_safe( entry, tmp, &dev->msi_list, list )
     {
-        vector = entry->vector;
-        desc = &irq_desc[vector];
+        irq = entry->irq;
+        desc = &irq_desc[irq];
         pci_disable_msi(entry);
 
         spin_lock_irqsave(&desc->lock, flags);
 
-        teardown_msi_vector(vector);
+        teardown_msi_irq(irq);
 
         if ( desc->handler == &pci_msi_type )
         {
@@ -778,7 +780,7 @@ static void msi_free_vectors(struct pci_
         }
 
         spin_unlock_irqrestore(&desc->lock, flags);
-        msi_free_vector(entry);
+        msi_free_irq(entry);
     }
 }
 
@@ -787,15 +789,15 @@ void pci_cleanup_msi(struct pci_dev *pde
     /* Disable MSI and/or MSI-X */
     msi_set_enable(pdev, 0);
     msix_set_enable(pdev, 0);
-    msi_free_vectors(pdev);
+    msi_free_irqs(pdev);
 }
 
 int pci_restore_msi_state(struct pci_dev *pdev)
 {
     unsigned long flags;
-    int vector;
+    int irq;
     struct msi_desc *entry, *tmp;
-    irq_desc_t *desc;
+    struct irq_desc *desc;
 
     ASSERT(spin_is_locked(&pcidevs_lock));
 
@@ -804,8 +806,8 @@ int pci_restore_msi_state(struct pci_dev
 
     list_for_each_entry_safe( entry, tmp, &pdev->msi_list, list )
     {
-        vector = entry->vector;
-        desc = &irq_desc[vector];
+        irq = entry->irq;
+        desc = &irq_desc[irq];
 
         spin_lock_irqsave(&desc->lock, flags);
 
@@ -826,7 +828,7 @@ int pci_restore_msi_state(struct pci_dev
 
         write_msi_msg(entry, &entry->msg);
 
-        msi_set_mask_bit(vector, entry->msi_attrib.masked);
+        msi_set_mask_bit(irq, entry->msi_attrib.masked);
 
         if ( entry->msi_attrib.type == PCI_CAP_ID_MSI )
             msi_set_enable(pdev, 1);
diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/physdev.c
--- a/xen/arch/x86/physdev.c    Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/physdev.c    Wed Aug 19 12:53:04 2009 +0100
@@ -30,7 +30,7 @@ static int physdev_map_pirq(struct physd
 static int physdev_map_pirq(struct physdev_map_pirq *map)
 {
     struct domain *d;
-    int vector, pirq, ret = 0;
+    int pirq, irq, ret = 0;
     struct msi_info _msi;
     void *map_data = NULL;
 
@@ -51,7 +51,7 @@ static int physdev_map_pirq(struct physd
         goto free_domain;
     }
 
-    /* Verify or get vector. */
+    /* Verify or get irq. */
     switch ( map->type )
     {
         case MAP_PIRQ_TYPE_GSI:
@@ -62,25 +62,25 @@ static int physdev_map_pirq(struct physd
                 ret = -EINVAL;
                 goto free_domain;
             }
-            vector = domain_irq_to_vector(current->domain, map->index);
-            if ( !vector )
-            {
-                dprintk(XENLOG_G_ERR, "dom%d: map irq with no vector %d\n",
-                        d->domain_id, vector);
+            irq = domain_pirq_to_irq(current->domain, map->index);
+            if ( !irq )
+            {
+                dprintk(XENLOG_G_ERR, "dom%d: map pirq with incorrect irq!\n",
+                        d->domain_id);
                 ret = -EINVAL;
                 goto free_domain;
             }
             break;
 
         case MAP_PIRQ_TYPE_MSI:
-            vector = map->index;
-            if ( vector == -1 )
-                vector = assign_irq_vector(AUTO_ASSIGN_IRQ);
-
-            if ( vector < 0 || vector >= NR_VECTORS )
-            {
-                dprintk(XENLOG_G_ERR, "dom%d: map irq with wrong vector %d\n",
-                        d->domain_id, vector);
+            irq = map->index;
+            if ( irq == -1 )
+                irq = create_irq();
+
+            if ( irq < 0 || irq >= nr_irqs )
+            {
+                dprintk(XENLOG_G_ERR, "dom%d: can't create irq for msi!\n",
+                        d->domain_id);
                 ret = -EINVAL;
                 goto free_domain;
             }
@@ -89,7 +89,7 @@ static int physdev_map_pirq(struct physd
             _msi.devfn = map->devfn;
             _msi.entry_nr = map->entry_nr;
             _msi.table_base = map->table_base;
-            _msi.vector = vector;
+            _msi.irq = irq;
             map_data = &_msi;
             break;
 
@@ -103,7 +103,7 @@ static int physdev_map_pirq(struct physd
     spin_lock(&pcidevs_lock);
     /* Verify or get pirq. */
     spin_lock(&d->event_lock);
-    pirq = domain_vector_to_irq(d, vector);
+    pirq = domain_irq_to_pirq(d, irq);
     if ( map->pirq < 0 )
     {
         if ( pirq )
@@ -132,7 +132,7 @@ static int physdev_map_pirq(struct physd
     {
         if ( pirq && pirq != map->pirq )
         {
-            dprintk(XENLOG_G_ERR, "dom%d: vector %d conflicts with irq %d\n",
+            dprintk(XENLOG_G_ERR, "dom%d: pirq %d conflicts with irq %d\n",
                     d->domain_id, map->index, map->pirq);
             ret = -EEXIST;
             goto done;
@@ -141,7 +141,7 @@ static int physdev_map_pirq(struct physd
             pirq = map->pirq;
     }
 
-    ret = map_domain_pirq(d, pirq, vector, map->type, map_data);
+    ret = map_domain_pirq(d, pirq, irq, map->type, map_data);
     if ( ret == 0 )
         map->pirq = pirq;
 
@@ -149,7 +149,7 @@ done:
     spin_unlock(&d->event_lock);
     spin_unlock(&pcidevs_lock);
     if ( (ret != 0) && (map->type == MAP_PIRQ_TYPE_MSI) && (map->index == -1) )
-        free_irq_vector(vector);
+        destroy_irq(irq);
 free_domain:
     rcu_unlock_domain(d);
     return ret;
@@ -344,14 +344,12 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_H
 
         irq = irq_op.irq;
         ret = -EINVAL;
-        if ( (irq < 0) || (irq >= nr_irqs_gsi) )
-            break;
 
         irq_op.vector = assign_irq_vector(irq);
 
         spin_lock(&pcidevs_lock);
         spin_lock(&dom0->event_lock);
-        ret = map_domain_pirq(dom0, irq_op.irq, irq_op.vector,
+        ret = map_domain_pirq(dom0, irq_op.irq, irq,
                               MAP_PIRQ_TYPE_GSI, NULL);
         spin_unlock(&dom0->event_lock);
         spin_unlock(&pcidevs_lock);
diff -r 1afd9142eed3 -r 722c7e94e764 xen/arch/x86/setup.c
--- a/xen/arch/x86/setup.c      Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/arch/x86/setup.c      Wed Aug 19 12:53:04 2009 +0100
@@ -922,7 +922,7 @@ void __init __start_xen(unsigned long mb
     init_apic_mappings();
 
     init_IRQ();
-
+    
     percpu_init_areas();
 
     xsm_init(&initrdidx, mbi, initial_images_start);
diff -r 1afd9142eed3 -r 722c7e94e764 xen/drivers/passthrough/amd/iommu_init.c
--- a/xen/drivers/passthrough/amd/iommu_init.c  Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/drivers/passthrough/amd/iommu_init.c  Wed Aug 19 12:53:04 2009 +0100
@@ -27,7 +27,7 @@
 #include <asm/hvm/svm/amd-iommu-proto.h>
 #include <asm-x86/fixmap.h>
 
-static struct amd_iommu *vector_to_iommu[NR_VECTORS];
+static struct amd_iommu **irq_to_iommu;
 static int nr_amd_iommus;
 static long amd_iommu_cmd_buffer_entries = IOMMU_CMD_BUFFER_DEFAULT_ENTRIES;
 static long amd_iommu_event_log_entries = IOMMU_EVENT_LOG_DEFAULT_ENTRIES;
@@ -309,7 +309,7 @@ static void amd_iommu_msi_data_init(stru
     u8 bus = (iommu->bdf >> 8) & 0xff;
     u8 dev = PCI_SLOT(iommu->bdf & 0xff);
     u8 func = PCI_FUNC(iommu->bdf & 0xff);
-    int vector = iommu->vector;
+    int vector = irq_to_vector(iommu->irq);
 
     msi_data = MSI_DATA_TRIGGER_EDGE |
         MSI_DATA_LEVEL_ASSERT |
@@ -355,10 +355,10 @@ static void amd_iommu_msi_enable(struct 
         iommu->msi_cap + PCI_MSI_FLAGS, control);
 }
 
-static void iommu_msi_unmask(unsigned int vector)
+static void iommu_msi_unmask(unsigned int irq)
 {
     unsigned long flags;
-    struct amd_iommu *iommu = vector_to_iommu[vector];
+    struct amd_iommu *iommu = irq_to_iommu[irq];
 
     /* FIXME: do not support mask bits at the moment */
     if ( iommu->maskbit )
@@ -369,10 +369,10 @@ static void iommu_msi_unmask(unsigned in
     spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
-static void iommu_msi_mask(unsigned int vector)
+static void iommu_msi_mask(unsigned int irq)
 {
     unsigned long flags;
-    struct amd_iommu *iommu = vector_to_iommu[vector];
+    struct amd_iommu *iommu = irq_to_iommu[irq];
 
     /* FIXME: do not support mask bits at the moment */
     if ( iommu->maskbit )
@@ -383,21 +383,21 @@ static void iommu_msi_mask(unsigned int 
     spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
-static unsigned int iommu_msi_startup(unsigned int vector)
-{
-    iommu_msi_unmask(vector);
+static unsigned int iommu_msi_startup(unsigned int irq)
+{
+    iommu_msi_unmask(irq);
     return 0;
 }
 
-static void iommu_msi_end(unsigned int vector)
-{
-    iommu_msi_unmask(vector);
+static void iommu_msi_end(unsigned int irq)
+{
+    iommu_msi_unmask(irq);
     ack_APIC_irq();
 }
 
-static void iommu_msi_set_affinity(unsigned int vector, cpumask_t dest)
-{
-    struct amd_iommu *iommu = vector_to_iommu[vector];
+static void iommu_msi_set_affinity(unsigned int irq, cpumask_t dest)
+{
+    struct amd_iommu *iommu = irq_to_iommu[irq];
     amd_iommu_msi_addr_init(iommu, cpu_physical_id(first_cpu(dest)));
 }
 
@@ -451,7 +451,7 @@ static void parse_event_log_entry(u32 en
     }
 }
 
-static void amd_iommu_page_fault(int vector, void *dev_id,
+static void amd_iommu_page_fault(int irq, void *dev_id,
                              struct cpu_user_regs *regs)
 {
     u32 event[4];
@@ -477,32 +477,30 @@ static void amd_iommu_page_fault(int vec
 
 static int set_iommu_interrupt_handler(struct amd_iommu *iommu)
 {
-    int vector, ret;
-
-    vector = assign_irq_vector(AUTO_ASSIGN_IRQ);
-    if ( vector <= 0 )
-    {
-        gdprintk(XENLOG_ERR VTDPREFIX, "IOMMU: no vectors\n");
+    int irq, ret;
+
+    irq = create_irq();
+    if ( irq <= 0 )
+    {
+        gdprintk(XENLOG_ERR VTDPREFIX, "IOMMU: no irqs\n");
         return 0;
     }
 
-    irq_desc[vector].handler = &iommu_msi_type;
-    vector_to_iommu[vector] = iommu;
-    ret = request_irq_vector(vector, amd_iommu_page_fault, 0,
+    irq_desc[irq].handler = &iommu_msi_type;
+    irq_to_iommu[irq] = iommu;
+    ret = request_irq(irq, amd_iommu_page_fault, 0,
                              "amd_iommu", iommu);
     if ( ret )
     {
-        irq_desc[vector].handler = &no_irq_type;
-        vector_to_iommu[vector] = NULL;
-        free_irq_vector(vector);
+        irq_desc[irq].handler = &no_irq_type;
+        irq_to_iommu[irq] = NULL;
+        destroy_irq(irq);
         amd_iov_error("can't request irq\n");
         return 0;
     }
 
-    /* Make sure that vector is never re-used. */
-    vector_irq[vector] = NEVER_ASSIGN_IRQ;
-    iommu->vector = vector;
-    return vector;
+    iommu->irq = irq;
+    return irq;
 }
 
 void enable_iommu(struct amd_iommu *iommu)
@@ -510,6 +508,10 @@ void enable_iommu(struct amd_iommu *iomm
     unsigned long flags;
 
     spin_lock_irqsave(&iommu->lock, flags);
+
+    irq_to_iommu = xmalloc_array(struct amd_iommu *, nr_irqs);
+    BUG_ON(!irq_to_iommu);
+    memset(irq_to_iommu, 0, nr_irqs * sizeof(struct iommu*));
 
     if ( iommu->enabled )
     {
diff -r 1afd9142eed3 -r 722c7e94e764 xen/drivers/passthrough/io.c
--- a/xen/drivers/passthrough/io.c      Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/drivers/passthrough/io.c      Wed Aug 19 12:53:04 2009 +0100
@@ -35,7 +35,6 @@ static void pt_irq_time_out(void *data)
 {
     struct hvm_mirq_dpci_mapping *irq_map = data;
     unsigned int guest_gsi, machine_gsi = 0;
-    int vector;
     struct hvm_irq_dpci *dpci = NULL;
     struct dev_intx_gsi_link *digl;
     struct hvm_girq_dpci_mapping *girq;
@@ -68,7 +67,6 @@ static void pt_irq_time_out(void *data)
                                       machine_gsi + 1) )
     {
         clear_bit(machine_gsi, dpci->dirq_mask);
-        vector = domain_irq_to_vector(irq_map->dom, machine_gsi);
         dpci->mirq[machine_gsi].pending = 0;
     }
 
@@ -88,6 +86,7 @@ void free_hvm_irq_dpci(struct hvm_irq_dp
     xfree(dpci->mirq);
     xfree(dpci->dirq_mask);
     xfree(dpci->mapping);
+    xfree(dpci->hvm_timer);
     xfree(dpci);
 }
 
@@ -124,9 +123,11 @@ int pt_irq_create_bind_vtd(
                                                 BITS_TO_LONGS(d->nr_pirqs));
         hvm_irq_dpci->mapping = xmalloc_array(unsigned long,
                                               BITS_TO_LONGS(d->nr_pirqs));
+        hvm_irq_dpci->hvm_timer = xmalloc_array(struct timer, nr_irqs);
         if ( !hvm_irq_dpci->mirq ||
              !hvm_irq_dpci->dirq_mask ||
-             !hvm_irq_dpci->mapping )
+             !hvm_irq_dpci->mapping ||
+             !hvm_irq_dpci->hvm_timer)
         {
             spin_unlock(&d->event_lock);
             free_hvm_irq_dpci(hvm_irq_dpci);
@@ -136,6 +137,8 @@ int pt_irq_create_bind_vtd(
                d->nr_pirqs * sizeof(*hvm_irq_dpci->mirq));
         bitmap_zero(hvm_irq_dpci->dirq_mask, d->nr_pirqs);
         bitmap_zero(hvm_irq_dpci->mapping, d->nr_pirqs);
+        memset(hvm_irq_dpci->hvm_timer, 0, 
+                nr_irqs * sizeof(*hvm_irq_dpci->hvm_timer));
         for ( int i = 0; i < d->nr_pirqs; i++ )
             INIT_LIST_HEAD(&hvm_irq_dpci->mirq[i].digl_list);
         for ( int i = 0; i < NR_HVM_IRQS; i++ )
@@ -236,7 +239,7 @@ int pt_irq_create_bind_vtd(
         /* Bind the same mirq once in the same domain */
         if ( !test_and_set_bit(machine_gsi, hvm_irq_dpci->mapping))
         {
-            unsigned int vector = domain_irq_to_vector(d, machine_gsi);
+            unsigned int irq = domain_pirq_to_irq(d, machine_gsi);
             unsigned int share;
 
             hvm_irq_dpci->mirq[machine_gsi].dom = d;
@@ -256,14 +259,14 @@ int pt_irq_create_bind_vtd(
 
             /* Init timer before binding */
             if ( pt_irq_need_timer(hvm_irq_dpci->mirq[machine_gsi].flags) )
-                init_timer(&hvm_irq_dpci->hvm_timer[vector],
+                init_timer(&hvm_irq_dpci->hvm_timer[irq],
                            pt_irq_time_out, &hvm_irq_dpci->mirq[machine_gsi], 
0);
             /* Deal with gsi for legacy devices */
             rc = pirq_guest_bind(d->vcpu[0], machine_gsi, share);
             if ( unlikely(rc) )
             {
                 if ( pt_irq_need_timer(hvm_irq_dpci->mirq[machine_gsi].flags) )
-                    kill_timer(&hvm_irq_dpci->hvm_timer[vector]);
+                    kill_timer(&hvm_irq_dpci->hvm_timer[irq]);
                 hvm_irq_dpci->mirq[machine_gsi].dom = NULL;
                 clear_bit(machine_gsi, hvm_irq_dpci->mapping);
                 list_del(&girq->list);
@@ -349,7 +352,7 @@ int pt_irq_destroy_bind_vtd(
             pirq_guest_unbind(d, machine_gsi);
             msixtbl_pt_unregister(d, machine_gsi);
             if ( pt_irq_need_timer(hvm_irq_dpci->mirq[machine_gsi].flags) )
-                kill_timer(&hvm_irq_dpci->hvm_timer[domain_irq_to_vector(d, 
machine_gsi)]);
+                kill_timer(&hvm_irq_dpci->hvm_timer[domain_pirq_to_irq(d, 
machine_gsi)]);
             hvm_irq_dpci->mirq[machine_gsi].dom   = NULL;
             hvm_irq_dpci->mirq[machine_gsi].flags = 0;
             clear_bit(machine_gsi, hvm_irq_dpci->mapping);
@@ -357,7 +360,7 @@ int pt_irq_destroy_bind_vtd(
     }
     spin_unlock(&d->event_lock);
     gdprintk(XENLOG_INFO,
-             "XEN_DOMCTL_irq_unmapping: m_irq = %x device = %x intx = %x\n",
+             "XEN_DOMCTL_irq_unmapping: m_irq = 0x%x device = 0x%x intx = 
0x%x\n",
              machine_gsi, device, intx);
 
     return 0;
@@ -367,7 +370,7 @@ int hvm_do_IRQ_dpci(struct domain *d, un
 {
     struct hvm_irq_dpci *dpci = domain_get_irq_dpci(d);
 
-    ASSERT(spin_is_locked(&irq_desc[domain_irq_to_vector(d, mirq)].lock));
+    ASSERT(spin_is_locked(&irq_desc[domain_pirq_to_irq(d, mirq)].lock));
     if ( !iommu_enabled || (d == dom0) || !dpci ||
          !test_bit(mirq, dpci->mapping))
         return 0;
@@ -425,7 +428,7 @@ static int hvm_pci_msi_assert(struct dom
 
 static void hvm_dirq_assist(unsigned long _d)
 {
-    unsigned int irq;
+    unsigned int pirq;
     uint32_t device, intx;
     struct domain *d = (struct domain *)_d;
     struct hvm_irq_dpci *hvm_irq_dpci = d->arch.hvm_domain.irq.dpci;
@@ -433,34 +436,34 @@ static void hvm_dirq_assist(unsigned lon
 
     ASSERT(hvm_irq_dpci);
 
-    for ( irq = find_first_bit(hvm_irq_dpci->dirq_mask, d->nr_pirqs);
-          irq < d->nr_pirqs;
-          irq = find_next_bit(hvm_irq_dpci->dirq_mask, d->nr_pirqs, irq + 1) )
-    {
-        if ( !test_and_clear_bit(irq, hvm_irq_dpci->dirq_mask) )
+    for ( pirq = find_first_bit(hvm_irq_dpci->dirq_mask, d->nr_pirqs);
+          pirq < d->nr_pirqs;
+          pirq = find_next_bit(hvm_irq_dpci->dirq_mask, d->nr_pirqs, pirq + 1) 
)
+    {
+        if ( !test_and_clear_bit(pirq, hvm_irq_dpci->dirq_mask) )
             continue;
 
         spin_lock(&d->event_lock);
 #ifdef SUPPORT_MSI_REMAPPING
-        if ( hvm_irq_dpci->mirq[irq].flags & HVM_IRQ_DPCI_GUEST_MSI )
-        {
-            hvm_pci_msi_assert(d, irq);
+        if ( hvm_irq_dpci->mirq[pirq].flags & HVM_IRQ_DPCI_GUEST_MSI )
+        {
+            hvm_pci_msi_assert(d, pirq);
             spin_unlock(&d->event_lock);
             continue;
         }
 #endif
-        list_for_each_entry ( digl, &hvm_irq_dpci->mirq[irq].digl_list, list )
+        list_for_each_entry ( digl, &hvm_irq_dpci->mirq[pirq].digl_list, list )
         {
             device = digl->device;
             intx = digl->intx;
             hvm_pci_intx_assert(d, device, intx);
-            hvm_irq_dpci->mirq[irq].pending++;
+            hvm_irq_dpci->mirq[pirq].pending++;
 
 #ifdef SUPPORT_MSI_REMAPPING
-            if ( hvm_irq_dpci->mirq[irq].flags & HVM_IRQ_DPCI_TRANSLATE )
+            if ( hvm_irq_dpci->mirq[pirq].flags & HVM_IRQ_DPCI_TRANSLATE )
             {
                 /* for translated MSI to INTx interrupt, eoi as early as 
possible */
-                __msi_pirq_eoi(d, irq);
+                __msi_pirq_eoi(d, pirq);
             }
 #endif
         }
@@ -472,8 +475,8 @@ static void hvm_dirq_assist(unsigned lon
          * guest will never deal with the irq, then the physical interrupt line
          * will never be deasserted.
          */
-        if ( pt_irq_need_timer(hvm_irq_dpci->mirq[irq].flags) )
-            set_timer(&hvm_irq_dpci->hvm_timer[domain_irq_to_vector(d, irq)],
+        if ( pt_irq_need_timer(hvm_irq_dpci->mirq[pirq].flags) )
+            set_timer(&hvm_irq_dpci->hvm_timer[domain_pirq_to_irq(d, pirq)],
                       NOW() + PT_IRQ_TIME_OUT);
         spin_unlock(&d->event_lock);
     }
@@ -501,7 +504,7 @@ static void __hvm_dpci_eoi(struct domain
          ! pt_irq_need_timer(hvm_irq_dpci->mirq[machine_gsi].flags) )
         return;
 
-    stop_timer(&hvm_irq_dpci->hvm_timer[domain_irq_to_vector(d, machine_gsi)]);
+    stop_timer(&hvm_irq_dpci->hvm_timer[domain_pirq_to_irq(d, machine_gsi)]);
     pirq_guest_eoi(d, machine_gsi);
 }
 
diff -r 1afd9142eed3 -r 722c7e94e764 xen/drivers/passthrough/pci.c
--- a/xen/drivers/passthrough/pci.c     Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/drivers/passthrough/pci.c     Wed Aug 19 12:53:04 2009 +0100
@@ -216,7 +216,7 @@ static void pci_clean_dpci_irqs(struct d
               i = find_next_bit(hvm_irq_dpci->mapping, d->nr_pirqs, i + 1) )
         {
             pirq_guest_unbind(d, i);
-            kill_timer(&hvm_irq_dpci->hvm_timer[domain_irq_to_vector(d, i)]);
+            kill_timer(&hvm_irq_dpci->hvm_timer[domain_pirq_to_irq(d, i)]);
 
             list_for_each_safe ( digl_list, tmp,
                                  &hvm_irq_dpci->mirq[i].digl_list )
@@ -408,7 +408,7 @@ static void dump_pci_devices(unsigned ch
                pdev->bus, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
                pdev->domain ? pdev->domain->domain_id : -1);
         list_for_each_entry ( msi, &pdev->msi_list, list )
-               printk("%d ", msi->vector);
+               printk("%d ", msi->irq);
         printk(">\n");
     }
 
diff -r 1afd9142eed3 -r 722c7e94e764 xen/drivers/passthrough/vtd/iommu.c
--- a/xen/drivers/passthrough/vtd/iommu.c       Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/drivers/passthrough/vtd/iommu.c       Wed Aug 19 12:53:04 2009 +0100
@@ -31,6 +31,8 @@
 #include <xen/pci_regs.h>
 #include <xen/keyhandler.h>
 #include <asm/msi.h>
+#include <asm/irq.h>
+#include <mach_apic.h>
 #include "iommu.h"
 #include "dmar.h"
 #include "extern.h"
@@ -659,7 +661,7 @@ static void iommu_disable_translation(st
     spin_unlock_irqrestore(&iommu->register_lock, flags);
 }
 
-static struct iommu *vector_to_iommu[NR_VECTORS];
+static struct iommu **irq_to_iommu;
 static int iommu_page_fault_do_one(struct iommu *iommu, int type,
                                    u8 fault_reason, u16 source_id, u64 addr)
 {
@@ -705,7 +707,7 @@ static void iommu_fault_status(u32 fault
 }
 
 #define PRIMARY_FAULT_REG_LEN (16)
-static void iommu_page_fault(int vector, void *dev_id,
+static void iommu_page_fault(int irq, void *dev_id,
                              struct cpu_user_regs *regs)
 {
     struct iommu *iommu = dev_id;
@@ -777,9 +779,9 @@ clear_overflow:
     }
 }
 
-static void dma_msi_unmask(unsigned int vector)
-{
-    struct iommu *iommu = vector_to_iommu[vector];
+static void dma_msi_unmask(unsigned int irq)
+{
+    struct iommu *iommu = irq_to_iommu[irq];
     unsigned long flags;
 
     /* unmask it */
@@ -788,10 +790,10 @@ static void dma_msi_unmask(unsigned int 
     spin_unlock_irqrestore(&iommu->register_lock, flags);
 }
 
-static void dma_msi_mask(unsigned int vector)
+static void dma_msi_mask(unsigned int irq)
 {
     unsigned long flags;
-    struct iommu *iommu = vector_to_iommu[vector];
+    struct iommu *iommu = irq_to_iommu[irq];
 
     /* mask it */
     spin_lock_irqsave(&iommu->register_lock, flags);
@@ -799,22 +801,23 @@ static void dma_msi_mask(unsigned int ve
     spin_unlock_irqrestore(&iommu->register_lock, flags);
 }
 
-static unsigned int dma_msi_startup(unsigned int vector)
-{
-    dma_msi_unmask(vector);
+static unsigned int dma_msi_startup(unsigned int irq)
+{
+    dma_msi_unmask(irq);
     return 0;
 }
 
-static void dma_msi_end(unsigned int vector)
-{
-    dma_msi_unmask(vector);
+static void dma_msi_end(unsigned int irq)
+{
+    dma_msi_unmask(irq);
     ack_APIC_irq();
 }
 
-static void dma_msi_data_init(struct iommu *iommu, int vector)
+static void dma_msi_data_init(struct iommu *iommu, int irq)
 {
     u32 msi_data = 0;
     unsigned long flags;
+    int vector = irq_to_vector(irq);
 
     /* Fixed, edge, assert mode. Follow MSI setting */
     msi_data |= vector & 0xff;
@@ -842,9 +845,9 @@ static void dma_msi_addr_init(struct iom
     spin_unlock_irqrestore(&iommu->register_lock, flags);
 }
 
-static void dma_msi_set_affinity(unsigned int vector, cpumask_t dest)
-{
-    struct iommu *iommu = vector_to_iommu[vector];
+static void dma_msi_set_affinity(unsigned int irq, cpumask_t dest)
+{
+    struct iommu *iommu = irq_to_iommu[irq];
     dma_msi_addr_init(iommu, cpu_physical_id(first_cpu(dest)));
 }
 
@@ -861,31 +864,28 @@ static struct hw_interrupt_type dma_msi_
 
 static int iommu_set_interrupt(struct iommu *iommu)
 {
-    int vector, ret;
-
-    vector = assign_irq_vector(AUTO_ASSIGN_IRQ);
-    if ( vector <= 0 )
-    {
-        gdprintk(XENLOG_ERR VTDPREFIX, "IOMMU: no vectors\n");
+    int irq, ret;
+
+    irq = create_irq();
+    if ( irq <= 0 )
+    {
+        gdprintk(XENLOG_ERR VTDPREFIX, "IOMMU: no irq available!\n");
         return -EINVAL;
     }
 
-    irq_desc[vector].handler = &dma_msi_type;
-    vector_to_iommu[vector] = iommu;
-    ret = request_irq_vector(vector, iommu_page_fault, 0, "dmar", iommu);
+    irq_desc[irq].handler = &dma_msi_type;
+    irq_to_iommu[irq] = iommu;
+    ret = request_irq(irq, iommu_page_fault, 0, "dmar", iommu);
     if ( ret )
     {
-        irq_desc[vector].handler = &no_irq_type;
-        vector_to_iommu[vector] = NULL;
-        free_irq_vector(vector);
+        irq_desc[irq].handler = &no_irq_type;
+        irq_to_iommu[irq] = NULL;
+        destroy_irq(irq);
         gdprintk(XENLOG_ERR VTDPREFIX, "IOMMU: can't request irq\n");
         return ret;
     }
 
-    /* Make sure that vector is never re-used. */
-    vector_irq[vector] = NEVER_ASSIGN_IRQ;
-
-    return vector;
+    return irq;
 }
 
 static int iommu_alloc(struct acpi_drhd_unit *drhd)
@@ -906,7 +906,7 @@ static int iommu_alloc(struct acpi_drhd_
         return -ENOMEM;
     memset(iommu, 0, sizeof(struct iommu));
 
-    iommu->vector = -1; /* No vector assigned yet. */
+    iommu->irq = -1; /* No irq assigned yet. */
 
     iommu->intel = alloc_intel_iommu();
     if ( iommu->intel == NULL )
@@ -966,7 +966,7 @@ static void iommu_free(struct acpi_drhd_
         iounmap(iommu->reg);
 
     free_intel_iommu(iommu->intel);
-    release_irq_vector(iommu->vector);
+    destroy_irq(iommu->irq);
     xfree(iommu);
 
     drhd->iommu = NULL;
@@ -1581,24 +1581,24 @@ static int init_vtd_hw(void)
     struct acpi_drhd_unit *drhd;
     struct iommu *iommu;
     struct iommu_flush *flush = NULL;
-    int vector;
+    int irq = -1;
     int ret;
     unsigned long flags;
 
     for_each_drhd_unit ( drhd )
     {
         iommu = drhd->iommu;
-        if ( iommu->vector < 0 )
-        {
-            vector = iommu_set_interrupt(iommu);
-            if ( vector < 0 )
+        if ( iommu->irq < 0 )
+        {
+            irq = iommu_set_interrupt(iommu);
+            if ( irq < 0 )
             {
                 gdprintk(XENLOG_ERR VTDPREFIX, "IOMMU: interrupt setup 
failed\n");
-                return vector;
+                return irq;
             }
-            iommu->vector = vector;
-        }
-        dma_msi_data_init(iommu, iommu->vector);
+            iommu->irq = irq;
+        }
+        dma_msi_data_init(iommu, iommu->irq);
         dma_msi_addr_init(iommu, cpu_physical_id(first_cpu(cpu_online_map)));
         clear_fault_bits(iommu);
 
@@ -1702,6 +1702,13 @@ int intel_vtd_setup(void)
 
     spin_lock_init(&domid_bitmap_lock);
     clflush_size = get_cache_line_size();
+
+    irq_to_iommu = xmalloc_array(struct iommu*, nr_irqs);
+    BUG_ON(!irq_to_iommu);
+    memset(irq_to_iommu, 0, nr_irqs * sizeof(struct iommu*));
+
+    if(!irq_to_iommu)
+        return -ENOMEM;
 
     /* We enable the following features only if they are supported by all VT-d
      * engines: Snoop Control, DMA passthrough, Queued Invalidation and
diff -r 1afd9142eed3 -r 722c7e94e764 xen/drivers/passthrough/vtd/x86/vtd.c
--- a/xen/drivers/passthrough/vtd/x86/vtd.c     Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/drivers/passthrough/vtd/x86/vtd.c     Wed Aug 19 12:53:04 2009 +0100
@@ -121,7 +121,7 @@ void hvm_dpci_isairq_eoi(struct domain *
                 hvm_pci_intx_deassert(d, digl->device, digl->intx);
                 if ( --dpci->mirq[i].pending == 0 )
                 {
-                    stop_timer(&dpci->hvm_timer[domain_irq_to_vector(d, i)]);
+                    stop_timer(&dpci->hvm_timer[domain_pirq_to_irq(d, i)]);
                     pirq_guest_eoi(d, i);
                 }
             }
diff -r 1afd9142eed3 -r 722c7e94e764 xen/include/asm-x86/amd-iommu.h
--- a/xen/include/asm-x86/amd-iommu.h   Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/include/asm-x86/amd-iommu.h   Wed Aug 19 12:53:04 2009 +0100
@@ -79,7 +79,7 @@ struct amd_iommu {
     int maskbit;
 
     int enabled;
-    int vector;
+    int irq;
 };
 
 struct ivrs_mappings {
diff -r 1afd9142eed3 -r 722c7e94e764 xen/include/asm-x86/domain.h
--- a/xen/include/asm-x86/domain.h      Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/include/asm-x86/domain.h      Wed Aug 19 12:53:04 2009 +0100
@@ -262,9 +262,9 @@ struct arch_domain
     /* Shadow translated domain: P2M mapping */
     pagetable_t phys_table;
 
-    /* NB. protected by d->event_lock and by irq_desc[vector].lock */
-    int vector_pirq[NR_VECTORS];
-    s16 *pirq_vector;
+    /* NB. protected by d->event_lock and by irq_desc[irq].lock */
+    int *irq_pirq;
+    int *pirq_irq;
 
     /* Shared page for notifying that explicit PIRQ EOI is required. */
     unsigned long *pirq_eoi_map;
diff -r 1afd9142eed3 -r 722c7e94e764 xen/include/asm-x86/irq.h
--- a/xen/include/asm-x86/irq.h Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/include/asm-x86/irq.h Wed Aug 19 12:53:04 2009 +0100
@@ -7,19 +7,25 @@
 #include <asm/atomic.h>
 #include <irq_vectors.h>
 
-#define IO_APIC_IRQ(irq)    (((irq) >= 16) || ((1<<(irq)) & io_apic_irqs))
+#define IO_APIC_IRQ(irq)    (((irq) >= 16 && (irq) < nr_irqs_gsi) \
+        || (((irq) < 16) && (1<<(irq)) & io_apic_irqs))
 #define IO_APIC_VECTOR(irq) (irq_vector[irq])
+
+#define MSI_IRQ(irq)       ((irq) >= nr_irqs_gsi && (irq) < nr_irqs)
 
 #define LEGACY_VECTOR(irq)          ((irq) + FIRST_LEGACY_VECTOR)
 #define LEGACY_IRQ_FROM_VECTOR(vec) ((vec) - FIRST_LEGACY_VECTOR)
 
-#define irq_to_vector(irq)  \
-    (IO_APIC_IRQ(irq) ? IO_APIC_VECTOR(irq) : LEGACY_VECTOR(irq))
 #define vector_to_irq(vec)  (vector_irq[vec])
+#define irq_to_desc(irq)    &irq_desc[(irq)]
+
+#define MAX_GSI_IRQS PAGE_SIZE * 8
+#define MAX_NR_IRQS (2 * MAX_GSI_IRQS)
 
 extern int vector_irq[NR_VECTORS];
 extern u8 *irq_vector;
 
+extern int irq_to_vector(int irq);
 #define platform_legacy_irq(irq)       ((irq) < 16)
 
 fastcall void event_check_interrupt(void);
@@ -51,17 +57,21 @@ extern atomic_t irq_mis_count;
 
 int pirq_shared(struct domain *d , int irq);
 
-int map_domain_pirq(struct domain *d, int pirq, int vector, int type,
+int map_domain_pirq(struct domain *d, int pirq, int irq, int type,
                            void *data);
 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);
 
-#define domain_irq_to_vector(d, irq) ((d)->arch.pirq_vector[irq] ?: \
-                                      IO_APIC_IRQ(irq) ? 0 : 
LEGACY_VECTOR(irq))
-#define domain_vector_to_irq(d, vec) ((d)->arch.vector_pirq[vec] ?: \
-                                      ((vec) < FIRST_LEGACY_VECTOR || \
-                                       (vec) > LAST_LEGACY_VECTOR) ? \
-                                      0 : LEGACY_IRQ_FROM_VECTOR(vec))
+int  init_irq_data(void);
+
+void clear_irq_vector(int irq);
+int __assign_irq_vector(int irq);
+
+int create_irq(void);
+void destroy_irq(unsigned int irq);
+
+#define domain_pirq_to_irq(d, pirq) ((d)->arch.pirq_irq[pirq])
+#define domain_irq_to_pirq(d, irq) ((d)->arch.irq_pirq[irq])
 
 #endif /* _ASM_HW_IRQ_H */
diff -r 1afd9142eed3 -r 722c7e94e764 
xen/include/asm-x86/mach-default/irq_vectors.h
--- a/xen/include/asm-x86/mach-default/irq_vectors.h    Wed Aug 19 12:52:38 
2009 +0100
+++ b/xen/include/asm-x86/mach-default/irq_vectors.h    Wed Aug 19 12:53:04 
2009 +0100
@@ -23,6 +23,7 @@
 #define LAST_LEGACY_VECTOR      0xef
 
 #define HYPERCALL_VECTOR       0x82
+#define LEGACY_SYSCALL_VECTOR   0x80
 
 /* Dynamically-allocated vectors available to any driver. */
 #define FIRST_DYNAMIC_VECTOR   0x20
diff -r 1afd9142eed3 -r 722c7e94e764 xen/include/asm-x86/msi.h
--- a/xen/include/asm-x86/msi.h Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/include/asm-x86/msi.h Wed Aug 19 12:53:04 2009 +0100
@@ -2,7 +2,6 @@
 #define __ASM_MSI_H
 
 #include <xen/cpumask.h>
-#include <asm/irq.h>
 /*
  * Constants for Intel APIC based MSI messages.
  */
@@ -57,7 +56,7 @@ struct msi_info {
 struct msi_info {
     int bus;
     int devfn;
-    int vector;
+    int irq;
     int entry_nr;
     uint64_t table_base;
 };
@@ -70,14 +69,14 @@ struct msi_msg {
 
 struct msi_desc;
 /* Helper functions */
-extern void mask_msi_vector(unsigned int vector);
-extern void unmask_msi_vector(unsigned int vector);
+extern void mask_msi_irq(unsigned int irq);
+extern void unmask_msi_irq(unsigned int irq);
 extern void set_msi_affinity(unsigned int vector, cpumask_t mask);
 extern int pci_enable_msi(struct msi_info *msi, struct msi_desc **desc);
 extern void pci_disable_msi(struct msi_desc *desc);
 extern void pci_cleanup_msi(struct pci_dev *pdev);
-extern int setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc);
-extern void teardown_msi_vector(int vector);
+extern int setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc, int irq);
+extern void teardown_msi_irq(int irq);
 extern int msi_free_vector(struct msi_desc *entry);
 extern int pci_restore_msi_state(struct pci_dev *pdev);
 
@@ -97,7 +96,7 @@ struct msi_desc {
 
        void __iomem *mask_base;        /* va for the entry in mask table */
        struct pci_dev *dev;
-       int vector;
+       int irq;
 
        struct msi_msg msg;             /* Last set MSI message */
 
@@ -105,6 +104,7 @@ struct msi_desc {
 };
 
 int msi_maskable_irq(const struct msi_desc *);
+int msi_free_irq(struct msi_desc *entry);
 
 /*
  * Assume the maximum number of hot plug slots supported by the system is about
diff -r 1afd9142eed3 -r 722c7e94e764 xen/include/xen/hvm/irq.h
--- a/xen/include/xen/hvm/irq.h Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/include/xen/hvm/irq.h Wed Aug 19 12:53:04 2009 +0100
@@ -88,7 +88,7 @@ struct hvm_irq_dpci {
     DECLARE_BITMAP(isairq_map, NR_ISAIRQS);
     /* Record of mapped Links */
     uint8_t link_cnt[NR_LINK];
-    struct timer hvm_timer[NR_VECTORS];
+    struct timer *hvm_timer;
     struct tasklet dirq_tasklet;
 };
 
diff -r 1afd9142eed3 -r 722c7e94e764 xen/include/xen/iommu.h
--- a/xen/include/xen/iommu.h   Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/include/xen/iommu.h   Wed Aug 19 12:53:04 2009 +0100
@@ -53,7 +53,7 @@ struct iommu {
     spinlock_t lock; /* protect context, domain ids */
     spinlock_t register_lock; /* protect iommu register handling */
     u64 root_maddr; /* root entry machine address */
-    int vector;
+    int irq;
     struct intel_iommu *intel;
 };
 
diff -r 1afd9142eed3 -r 722c7e94e764 xen/include/xen/irq.h
--- a/xen/include/xen/irq.h     Wed Aug 19 12:52:38 2009 +0100
+++ b/xen/include/xen/irq.h     Wed Aug 19 12:53:04 2009 +0100
@@ -53,6 +53,7 @@ typedef struct hw_interrupt_type hw_irq_
 # define nr_irqs_gsi NR_IRQS
 #else
 extern unsigned int nr_irqs_gsi;
+extern unsigned int nr_irqs;
 #endif
 
 struct msi_desc;
@@ -63,23 +64,19 @@ struct msi_desc;
  *
  * Pad this out to 32 bytes for cache and indexing reasons.
  */
-typedef struct {
+typedef struct irq_desc{
     unsigned int status;               /* IRQ status */
     hw_irq_controller *handler;
     struct msi_desc   *msi_desc;
     struct irqaction *action;  /* IRQ action list */
     unsigned int depth;                /* nested irq disables */
+    int irq;
     spinlock_t lock;
     cpumask_t affinity;
 } __cacheline_aligned irq_desc_t;
 
+#ifndef CONFIG_X86
 extern irq_desc_t irq_desc[NR_VECTORS];
-
-extern int setup_irq_vector(unsigned int, struct irqaction *);
-extern void release_irq_vector(unsigned int);
-extern int request_irq_vector(unsigned int vector,
-               void (*handler)(int, void *, struct cpu_user_regs *),
-               unsigned long irqflags, const char * devname, void *dev_id);
 
 #define setup_irq(irq, action) \
     setup_irq_vector(irq_to_vector(irq), action)
@@ -89,6 +86,16 @@ extern int request_irq_vector(unsigned i
 
 #define request_irq(irq, handler, irqflags, devname, devid) \
     request_irq_vector(irq_to_vector(irq), handler, irqflags, devname, devid)
+
+#else
+extern struct irq_desc *irq_desc;
+
+extern int setup_irq(unsigned int irq, struct irqaction *);
+extern void release_irq(unsigned int irq);
+extern int request_irq(unsigned int irq,
+               void (*handler)(int, void *, struct cpu_user_regs *),
+               unsigned long irqflags, const char * devname, void *dev_id);
+#endif
 
 extern hw_irq_controller no_irq_type;
 extern void no_action(int cpl, void *dev_id, struct cpu_user_regs *regs);
@@ -102,16 +109,18 @@ extern irq_desc_t *domain_spin_lock_irq_
 extern irq_desc_t *domain_spin_lock_irq_desc(
     struct domain *d, int irq, unsigned long *pflags);
 
-static inline void set_native_irq_info(unsigned int vector, cpumask_t mask)
+static inline void set_native_irq_info(unsigned int irq, cpumask_t mask)
 {
-    irq_desc[vector].affinity = mask;
+    irq_desc[irq].affinity = mask;
 }
 
-#ifdef irq_to_vector
 static inline void set_irq_info(int irq, cpumask_t mask)
 {
+#ifdef CONFIG_X86
+    set_native_irq_info(irq, mask);
+#else
     set_native_irq_info(irq_to_vector(irq), mask);
+#endif
 }
-#endif
 
 #endif /* __XEN_IRQ_H__ */

_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog