x86_64: (NEW) Dynamically allocate arch specific system vectors]

Index: linuxnext.latest/arch/x86/kernel/io_apic_64.c
===================================================================
@@ -85,10 +85,6 @@
 
 static int assign_irq_vector(int irq, cpumask_t mask);
 
-int first_system_vector = 0xfe;
-
-char system_vectors[NR_VECTORS] = { [0 ... NR_VECTORS-1] = SYS_VECTOR_FREE};
-
 #define __apicdebuginit  __init
 
 int sis_apic_bug; /* not actually supported, dummy for compile */

@@ -770,7 +766,7 @@
 	return irq;
 }
 
-static int __assign_irq_vector(int irq, cpumask_t mask)
+static int __assign_irq_vector(int irq, int priority, cpumask_t *mask)
 {
 	/*
 	 * NOTE! The local APIC isn't very good at handling

@@ -783,63 +779,99 @@
 	 * Also, we've got to be careful not to trash gate
 	 * 0x80, because int 0x80 is hm, kind of importantish. ;)
 	 */
-	static int current_vector = FIRST_DEVICE_VECTOR, current_offset = 0;
+	static int current_device_vector = FIRST_DYNAMIC_VECTOR;
+	static int current_device_offset;	/* initially 0 */
+	int current_vector;
+	int current_offset;
 	unsigned int old_vector;
-	int cpu;
+	cpumask_t target_cpu_mask;
+	int target_cpu;
+	cpumask_t domain_cpu_mask;
 	struct irq_cfg *cfg;
 
 	BUG_ON((unsigned)irq >= NR_IRQS);
 	cfg = &irq_cfg[irq];
 
-	/* Only try and allocate irqs on cpus that are present */
-	cpus_and(mask, mask, cpu_online_map);
-
 	if ((cfg->move_in_progress) || cfg->move_cleanup_count)
 		return -EBUSY;
 
+	if (priority == IRQ_PRIORITY_NONE) {
+		/* Only try and allocate irqs on cpus that are present */
+		cpus_and(target_cpu_mask, *mask, cpu_online_map);
+
+		current_vector = current_device_vector;
+		current_offset = current_device_offset;
+	} else {
+		cpus_and(target_cpu_mask, *mask, cpu_possible_map);
+		domain_cpu_mask = target_cpu_mask;
+
+		if (priority == IRQ_PRIORITY_HIGH)
+			current_vector = first_fixed_system_vector;
+		else if (priority == IRQ_PRIORITY_LOW)
+			current_vector = FIRST_DYNAMIC_VECTOR - 1;
+		else
+			BUG();
+		current_offset = 0;
+	}
+
 	old_vector = cfg->vector;
 	if (old_vector) {
 		cpumask_t tmp;
-		cpus_and(tmp, cfg->domain, mask);
+		cpus_and(tmp, cfg->domain, target_cpu_mask);
 		if (!cpus_empty(tmp))
 			return 0;
 	}
 
-	for_each_cpu_mask_nr(cpu, mask) {
-		cpumask_t domain, new_mask;
-		int new_cpu;
+	for_each_cpu_mask_nr(target_cpu, target_cpu_mask) {
+		int domain_cpu;
 		int vector, offset;
 
-		domain = vector_allocation_domain(cpu);
-		cpus_and(new_mask, domain, cpu_online_map);
+		if (priority == IRQ_PRIORITY_NONE) {
+			domain_cpu_mask = vector_allocation_domain(target_cpu);
+			cpus_and(domain_cpu_mask, domain_cpu_mask,
+				 cpu_online_map);
+		}
 
 		vector = current_vector;
 		offset = current_offset;
 next:
-		vector += 8;
-		if (vector >= first_system_vector) {
-			/* If we run out of vectors on large boxen, must share them. */
-			offset = (offset + 1) % 8;
-			vector = FIRST_DEVICE_VECTOR + offset;
+		if (priority == IRQ_PRIORITY_HIGH) {
+			if (--vector < FIRST_DYNAMIC_VECTOR)
+				break;
+		} else if (priority == IRQ_PRIORITY_LOW) {
+			if (++vector == first_fixed_system_vector)
+				break;
+		} else {
+			vector += 8;
+			if (vector > last_dynamic_device_vector) {
+				/*
+				 * If we run out of vectors on large boxes,
+				 * must share them.
+				 */
+				offset = (offset + 1) % 8;
+				vector = FIRST_DYNAMIC_VECTOR + offset;
+			}
+			if (unlikely(current_vector == vector))
+				continue;
 		}
-		if (unlikely(current_vector == vector))
-			continue;
 		if (vector == IA32_SYSCALL_VECTOR)
 			goto next;
-		for_each_cpu_mask_nr(new_cpu, new_mask)
-			if (per_cpu(vector_irq, new_cpu)[vector] != -1)
+		for_each_cpu_mask_nr(domain_cpu, domain_cpu_mask)
+			if (per_cpu(vector_irq, domain_cpu)[vector] != -1)
 				goto next;
 		/* Found one! */
-		current_vector = vector;
-		current_offset = offset;
+		if (priority == IRQ_PRIORITY_NONE) {
+			current_device_vector = vector;
+			current_device_offset = offset;
+		}
 		if (old_vector) {
 			cfg->move_in_progress = 1;
 			cfg->old_domain = cfg->domain;
 		}
-		for_each_cpu_mask_nr(new_cpu, new_mask)
-			per_cpu(vector_irq, new_cpu)[vector] = irq;
+		for_each_cpu_mask_nr(domain_cpu, domain_cpu_mask)
+			per_cpu(vector_irq, domain_cpu)[vector] = irq;
 		cfg->vector = vector;
-		cfg->domain = domain;
+		cfg->domain = domain_cpu_mask;
 		return 0;
 	}
 	return -ENOSPC;

@@ -851,7 +883,7 @@
 	unsigned long flags;
 
 	spin_lock_irqsave(&vector_lock, flags);
-	err = __assign_irq_vector(irq, mask);
+	err = __assign_irq_vector(irq, IRQ_PRIORITY_NONE, &mask);
 	spin_unlock_irqrestore(&vector_lock, flags);
 	return err;
 }

@@ -2256,23 +2288,30 @@
 device_initcall(ioapic_init_sysfs);
 
 /*
- * Dynamic irq allocate and deallocation
+ * Dynamically allocate an irq vector mapping.
  */
-int create_irq(void)
+static int do_create_irq(int priority, cpumask_t *mask)
 {
 	/* Allocate an unused irq */
 	int irq;
 	int new;
 	unsigned long flags;
+	cpumask_t target_cpu_mask;
 
 	irq = -ENOSPC;
 	spin_lock_irqsave(&vector_lock, flags);
+
+	if (mask)
+		target_cpu_mask = *mask;
+	else
+		target_cpu_mask = TARGET_CPUS;
+
 	for (new = (NR_IRQS - 1); new >= 0; new--) {
 		if (platform_legacy_irq(new))
 			continue;
 		if (irq_cfg[new].vector != 0)
 			continue;
-		if (__assign_irq_vector(new, TARGET_CPUS) == 0)
+		if (__assign_irq_vector(new, priority, &target_cpu_mask) == 0)
 			irq = new;
 		break;
 	}

@@ -2284,6 +2323,17 @@
 	return irq;
 }
 
+/*
+ * Dynamically allocate an irq device vector mapping.
+ */
+int create_irq(void)
+{
+	return do_create_irq(IRQ_PRIORITY_NONE, NULL);
+}
+
+/*
+ * Free a dynamically allocated irq device vector mapping.
+ */
 void destroy_irq(unsigned int irq)
 {
 	unsigned long flags;

@@ -2299,6 +2349,106 @@
 }
 
 /*
+ * NOP functions
+ */
+static void noop(unsigned int irq)
+{
+}
+
+static unsigned int noop_ret(unsigned int irq)
+{
+	return 0;
+}
+
+static void ack_apic(unsigned int irq)
+{
+	ack_APIC_irq();
+}
+
+/*
+ * For dynamic allocation of system vectors where
+ * an ack_APIC_irq() is needed after handling the IRQ
+ */
+static struct irq_chip ack_apic_chip = {
+	.name		= "ack_apic",
+	.startup	= noop_ret,
+	.shutdown	= noop,
+	.enable		= noop,
+	.disable	= noop,
+	.ack		= noop,
+	.mask		= noop,
+	.unmask		= noop,
+	.eoi		= ack_apic,
+	.end		= noop,
+};
+
+/*
+ * Dynamically allocate an irq system vector mapping.
+ * (The irq is not to be shared.)
+ *
+ * After calling this function, the caller is responsible for any needed
+ * calls to:
+ *   set_irq_data(&any_driver_data);
+ *   set_irq_type(irq, IRQ_TYPE...);
+ * Then make the call to request_irq() to create the irqaction:
+ *   request_irq(irq, interrupt_handler, irqflags, "devname", NULL);
+ *   You might consider the flag IRQF_NOBALANCING.
+ */
+int create_irq_system_vector(int priority, cpumask_t *mask, char *irq_name,
+			     int *assigned_vector)
+{
+	unsigned long flags;
+	int irq;
+
+	/* locate an available irq */
+	irq = do_create_irq(priority, mask);
+	if (irq < 0)
+		return irq;
+
+	spin_lock_irqsave(&vector_lock, flags);
+	set_irq_chip_and_handler_name(irq, &ack_apic_chip, handle_percpu_irq,
+				      irq_name);
+
+	spin_unlock_irqrestore(&vector_lock, flags);
+
+	*assigned_vector = irq_cfg[irq].vector;
+	return irq;
+}
+EXPORT_SYMBOL(create_irq_system_vector);
+
+/*
+ * Free a dynamically allocated irq system vector mapping.
+ *
+ * Before calling this function, the caller is responsible for calling
+ * free_irq(irq, dev_id);  to free the irqaction.
+ */
+void destroy_irq_system_vector(int irq)
+{
+	unsigned long flags;
+	int cpu;
+
+	if ((unsigned)irq >= NR_IRQS || irq_cfg[irq].vector == 0)
+		return;
+
+#ifdef CONFIG_SMP
+	synchronize_irq(irq);
+#endif
+	dynamic_irq_cleanup(irq);
+	disable_irq(irq);
+
+	spin_lock_irqsave(&vector_lock, flags);
+
+	for_each_cpu_mask_nr(cpu, irq_cfg[irq].domain)
+		per_cpu(vector_irq, cpu)[irq_cfg[irq].vector] = -1;
+
+	irq_cfg[irq].vector = 0;
+	cpus_clear(irq_cfg[irq].domain);
+
+	spin_unlock_irqrestore(&vector_lock, flags);
+}
+EXPORT_SYMBOL(destroy_irq_system_vector);
+
+/*
  * MSI message composition
  */
 #ifdef CONFIG_PCI_MSI

@@ -2533,7 +2683,7 @@
 {
 	int irq, ret;
 
-	irq = create_irq();
+	irq = do_create_irq(IRQ_PRIORITY_NONE, NULL);
 	if (irq < 0)
 		return irq;
 

@@ -2571,7 +2721,7 @@
 
 	sub_handle = 0;
 	list_for_each_entry(desc, &dev->msi_list, list) {
-		irq = create_irq();
+		irq = do_create_irq(IRQ_PRIORITY_NONE, NULL);
 		if (irq < 0)
 			return irq;
 #ifdef CONFIG_INTR_REMAP

Index: linuxnext.latest/include/linux/irq.h
===================================================================
@@ -352,10 +352,14 @@
 extern void set_irq_noprobe(unsigned int irq);
 extern void set_irq_probe(unsigned int irq);
 
-/* Handle dynamic irq creation and destruction */
+/* Handle dynamic irq device vector mapping and unmapping */
 extern int create_irq(void);
 extern void destroy_irq(unsigned int irq);
 
+/* Handle dynamic irq system vector mapping and unmapping */
+extern int create_irq_system_vector(int, cpumask_t *, char *, int *);
+extern void destroy_irq_system_vector(int);
+
 /* Test to see if a driver has successfully requested an irq */
 static inline int irq_has_action(unsigned int irq)
 {

Index: linuxnext.latest/include/asm-x86/irq_vectors.h
===================================================================
@@ -91,14 +91,40 @@
 #define LOCAL_TIMER_VECTOR	0xef
 
 /*
+ * The first device or system vector (lowest numbered) available for dynamic
+ * allocation is defined by FIRST_DYNAMIC_VECTOR.
+ *
+ * The last device vector available for dynamic allocation is defined by
+ * last_dynamic_device_vector, which is initially set to
+ * LAST_DYNAMIC_DEVICE_VECTOR.
+ *
+ * The last system vector available for dynamic allocation is defined by
+ * first_fixed_system_vector - 1. The variable first_fixed_system_vector
+ * is initially set to FIRST_FIXED_SYSTEM_VECTOR.
+ *
+ * SGI-UV uses LAST_UV_DYNAMIC_DEVICE_VECTOR to reserve a range of
+ * vectors that falls between the first_fixed_system_vector and
+ * last_dynamic_device_vector for dynamic system vector allocations.
+ */
+#define FIRST_FIXED_SYSTEM_VECTOR		0xfe
+#define LAST_DYNAMIC_DEVICE_VECTOR		FIRST_FIXED_SYSTEM_VECTOR
+#define LAST_UV_DYNAMIC_DEVICE_VECTOR		0xe0
+#define IRQ_PRIORITY_NONE			1
+#define IRQ_PRIORITY_LOW			2
+#define IRQ_PRIORITY_HIGH			3
+
+/*
  * First APIC vector available to drivers: (vectors 0x30-0xee) we
  * start at 0x31(0x41) to spread out vectors evenly between priority
  * levels. (0x80 is the syscall vector)
+ *
+ * Device vectors are dynamically allocated as numbers in the range of
+ * FIRST_DYNAMIC_VECTOR to last_dynamic_device_vector (inclusive).
  */
 #ifdef CONFIG_X86_32
-# define FIRST_DEVICE_VECTOR	0x31
+# define FIRST_DYNAMIC_VECTOR	0x31
 #else
-# define FIRST_DEVICE_VECTOR	(IRQ15_VECTOR + 2)
+# define FIRST_DYNAMIC_VECTOR	(IRQ15_VECTOR + 2)
 #endif
 
 #define NR_VECTORS		256

Index: linuxnext.latest/arch/x86/kernel/io_apic_32.c
===================================================================
@@ -1165,11 +1165,15 @@
 }
 
 /* irq_vectors is indexed by the sum of all RTEs in all I/O APICs. */
-static u8 irq_vector[NR_IRQ_VECTORS] __read_mostly = { FIRST_DEVICE_VECTOR , 0 };
+static u8 irq_vector[NR_IRQ_VECTORS] __read_mostly = {
+	FIRST_DYNAMIC_VECTOR,
+	0
+};
 
 static int __assign_irq_vector(int irq)
 {
-	static int current_vector = FIRST_DEVICE_VECTOR, current_offset;
+	static int current_vector = FIRST_DYNAMIC_VECTOR;
+	static int current_offset;
 	int vector, offset;
 
 	BUG_ON((unsigned)irq >= NR_IRQ_VECTORS);

@@ -1181,9 +1185,9 @@
 	offset = current_offset;
 next:
 	vector += 8;
-	if (vector >= first_system_vector) {
+	if (vector > last_dynamic_device_vector) {
 		offset = (offset + 1) % 8;
-		vector = FIRST_DEVICE_VECTOR + offset;
+		vector = FIRST_DYNAMIC_VECTOR + offset;
 	}
 	if (vector == current_vector)
 		return -ENOSPC;

@@ -2314,7 +2318,7 @@
 	int i;
 
 	/* Reserve all the system vectors. */
-	for (i = first_system_vector; i < NR_VECTORS; i++)
+	for (i = last_dynamic_device_vector + 1; i < NR_VECTORS; i++)
 		set_bit(i, used_vectors);
 
 	enable_IO_APIC();

@@ -2435,9 +2439,9 @@
 device_initcall(ioapic_init_sysfs);
 
 /*
- * Dynamic irq allocate and deallocation
+ * Dynamically allocate an irq vector mapping.
  */
-int create_irq(void)
+static int do_create_irq(int priority, cpumask_t *mask)
 {
 	/* Allocate an unused irq */
 	int irq, new, vector = 0;

@@ -2464,6 +2468,17 @@
 	return irq;
 }
 
+/*
+ * Dynamically allocate an irq device vector mapping.
+ */
+int create_irq(void)
+{
+	return do_create_irq(IRQ_PRIORITY_NONE, NULL);
+}
+
+/*
+ * Free a dynamically allocated irq device vector mapping.
+ */
 void destroy_irq(unsigned int irq)
 {
 	unsigned long flags;

@@ -2560,7 +2575,7 @@
 {
 	struct msi_msg msg;
 	int irq, ret;
-	irq = create_irq();
+	irq = do_create_irq(IRQ_PRIORITY_NONE, NULL);
 	if (irq < 0)
 		return irq;
 

Index: linuxnext.latest/include/asm-x86/desc.h
===================================================================
@@ -310,22 +310,25 @@
 #define SYS_VECTOR_FREE		0
 #define SYS_VECTOR_ALLOCED	1
 
-extern int first_system_vector;
-extern char system_vectors[];
-
-static inline void alloc_system_vector(int vector)
-{
-	if (system_vectors[vector] == SYS_VECTOR_FREE) {
-		system_vectors[vector] = SYS_VECTOR_ALLOCED;
-		if (first_system_vector > vector)
-			first_system_vector = vector;
+extern int last_dynamic_device_vector;
+extern int first_fixed_system_vector;
+extern char fixed_system_vectors[];
+
+static inline void alloc_fixed_system_vector(int vector)
+{
+	if (fixed_system_vectors[vector] == SYS_VECTOR_FREE) {
+		fixed_system_vectors[vector] = SYS_VECTOR_ALLOCED;
+		if (first_fixed_system_vector > vector)
+			first_fixed_system_vector = vector;
+		if (last_dynamic_device_vector >= vector)
+			last_dynamic_device_vector = vector - 1;
 	} else
 		BUG();
 }
 
 static inline void alloc_intr_gate(unsigned int n, void *addr)
 {
-	alloc_system_vector(n);
+	alloc_fixed_system_vector(n);
 	set_intr_gate(n, addr);
 }
 

Index: linuxnext.latest/arch/x86/kernel/apic_32.c
===================================================================
@@ -68,9 +68,11 @@
 int local_apic_timer_c2_ok;
 EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok);
 
-int first_system_vector = 0xfe;
-
-char system_vectors[NR_VECTORS] = { [0 ... NR_VECTORS-1] = SYS_VECTOR_FREE};
+int last_dynamic_device_vector = LAST_DYNAMIC_DEVICE_VECTOR;
+int first_fixed_system_vector = FIRST_FIXED_SYSTEM_VECTOR;
+char fixed_system_vectors[NR_VECTORS] = {
+	[0 ... NR_VECTORS-1] = SYS_VECTOR_FREE
+};
 
 /*
  * Debug level, exported for io_apic.c

@@ -1361,7 +1363,7 @@
 	 * IRQ0 must be given a fixed assignment and initialized,
 	 * because it's used before the IO-APIC is set up.
 	 */
-	set_intr_gate(FIRST_DEVICE_VECTOR, interrupt[0]);
+	set_intr_gate(FIRST_DYNAMIC_VECTOR, interrupt[0]);
 
 	/*
 	 * The reschedule interrupt is a CPU-to-CPU reschedule-helper

Index: linuxnext.latest/arch/x86/kernel/irqinit_64.c
===================================================================
@@ -22,6 +22,7 @@
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/i8259.h>
+#include <asm/genapic.h>
 
 /*
  * Common place to define all x86 IRQ vectors

@@ -217,6 +218,11 @@
 	alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt);
 	alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt);
 
+	if (is_uv_system() &&
+	    LAST_UV_DYNAMIC_DEVICE_VECTOR < last_dynamic_device_vector) {
+		last_dynamic_device_vector = LAST_UV_DYNAMIC_DEVICE_VECTOR;
+	}
+
 	if (!acpi_ioapic)
 		setup_irq(2, &irq2);
 }

Index: linuxnext.latest/arch/x86/kernel/vmiclock_32.c
===================================================================
@@ -81,7 +81,7 @@
 static inline unsigned int vmi_get_timer_vector(void)
 {
 #ifdef CONFIG_X86_IO_APIC
-	return FIRST_DEVICE_VECTOR;
+	return FIRST_DYNAMIC_VECTOR;
 #else
 	return FIRST_EXTERNAL_VECTOR;
 #endif

Index: linuxnext.latest/arch/x86/kernel/apic_64.c
===================================================================
@@ -33,6 +33,7 @@
 #include <asm/smp.h>
 #include <asm/mtrr.h>
 #include <asm/mpspec.h>
+#include <asm/desc.h>
 #include <asm/hpet.h>
 #include <asm/pgalloc.h>
 #include <asm/nmi.h>

@@ -58,6 +59,13 @@
 int local_apic_timer_c2_ok;
 EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok);
 
+int last_dynamic_device_vector = LAST_DYNAMIC_DEVICE_VECTOR;
+int first_fixed_system_vector = FIRST_FIXED_SYSTEM_VECTOR;
+char fixed_system_vectors[NR_VECTORS] = {
+	[0 ... NR_VECTORS-1] = SYS_VECTOR_FREE
+};
+
+
 /*
  * Debug level, exported for io_apic.c
  */

Index: linuxnext.latest/kernel/irq/chip.c
===================================================================
@@ -78,6 +78,7 @@
 	desc->chip_data = NULL;
 	desc->handle_irq = handle_bad_irq;
 	desc->chip = &no_irq_chip;
+	desc->name = "none";
 	spin_unlock_irqrestore(&desc->lock, flags);
 }
 

Index: linuxnext.latest/arch/x86/kernel/io_apic_64.c
===================================================================
@@ -85,10 +85,6 @@
 
 static int assign_irq_vector(int irq, cpumask_t mask);
 
-int first_system_vector = 0xfe;
-
-char system_vectors[NR_VECTORS] = { [0 ... NR_VECTORS-1] = SYS_VECTOR_FREE};
-
 #define __apicdebuginit  __init
 
 int sis_apic_bug; /* not actually supported, dummy for compile */

@@ -770,7 +766,7 @@
 	return irq;
 }
 
-static int __assign_irq_vector(int irq, cpumask_t mask)
+static int __assign_irq_vector(int irq, int priority, cpumask_t *mask)
 {
 	/*
 	 * NOTE! The local APIC isn't very good at handling

@@ -783,63 +779,99 @@
 	 * Also, we've got to be careful not to trash gate
 	 * 0x80, because int 0x80 is hm, kind of importantish. ;)
 	 */
-	static int current_vector = FIRST_DEVICE_VECTOR, current_offset = 0;
+	static int current_device_vector = FIRST_DYNAMIC_VECTOR;
+	static int current_device_offset;	/* initially 0 */
+	int current_vector;
+	int current_offset;
 	unsigned int old_vector;
-	int cpu;
+	cpumask_t target_cpu_mask;
+	int target_cpu;
+	cpumask_t domain_cpu_mask;
 	struct irq_cfg *cfg;
 
 	BUG_ON((unsigned)irq >= NR_IRQS);
 	cfg = &irq_cfg[irq];
 
-	/* Only try and allocate irqs on cpus that are present */
-	cpus_and(mask, mask, cpu_online_map);
-
 	if ((cfg->move_in_progress) || cfg->move_cleanup_count)
 		return -EBUSY;
 
+	if (priority == IRQ_PRIORITY_NONE) {
+		/* Only try and allocate irqs on cpus that are present */
+		cpus_and(target_cpu_mask, *mask, cpu_online_map);
+
+		current_vector = current_device_vector;
+		current_offset = current_device_offset;
+	} else {
+		cpus_and(target_cpu_mask, *mask, cpu_possible_map);
+		domain_cpu_mask = target_cpu_mask;
+
+		if (priority == IRQ_PRIORITY_HIGH)
+			current_vector = first_fixed_system_vector;
+		else if (priority == IRQ_PRIORITY_LOW)
+			current_vector = FIRST_DYNAMIC_VECTOR - 1;
+		else
+			BUG();
+		current_offset = 0;
+	}
+
 	old_vector = cfg->vector;
 	if (old_vector) {
 		cpumask_t tmp;
-		cpus_and(tmp, cfg->domain, mask);
+		cpus_and(tmp, cfg->domain, target_cpu_mask);
 		if (!cpus_empty(tmp))
 			return 0;
 	}
 
-	for_each_cpu_mask_nr(cpu, mask) {
-		cpumask_t domain, new_mask;
-		int new_cpu;
+	for_each_cpu_mask_nr(target_cpu, target_cpu_mask) {
+		int domain_cpu;
 		int vector, offset;
 
-		domain = vector_allocation_domain(cpu);
-		cpus_and(new_mask, domain, cpu_online_map);
+		if (priority == IRQ_PRIORITY_NONE) {
+			domain_cpu_mask = vector_allocation_domain(target_cpu);
+			cpus_and(domain_cpu_mask, domain_cpu_mask,
+				 cpu_online_map);
+		}
 
 		vector = current_vector;
 		offset = current_offset;
 next:
-		vector += 8;
-		if (vector >= first_system_vector) {
-			/* If we run out of vectors on large boxen, must share them. */
-			offset = (offset + 1) % 8;
-			vector = FIRST_DEVICE_VECTOR + offset;
+		if (priority == IRQ_PRIORITY_HIGH) {
+			if (--vector < FIRST_DYNAMIC_VECTOR)
+				break;
+		} else if (priority == IRQ_PRIORITY_LOW) {
+			if (++vector == first_fixed_system_vector)
+				break;
+		} else {
+			vector += 8;
+			if (vector > last_dynamic_device_vector) {
+				/*
+				 * If we run out of vectors on large boxes,
+				 * must share them.
+				 */
+				offset = (offset + 1) % 8;
+				vector = FIRST_DYNAMIC_VECTOR + offset;
+			}
+			if (unlikely(current_vector == vector))
+				continue;
 		}
-		if (unlikely(current_vector == vector))
-			continue;
 		if (vector == IA32_SYSCALL_VECTOR)
 			goto next;
-		for_each_cpu_mask_nr(new_cpu, new_mask)
-			if (per_cpu(vector_irq, new_cpu)[vector] != -1)
+		for_each_cpu_mask_nr(domain_cpu, domain_cpu_mask)
+			if (per_cpu(vector_irq, domain_cpu)[vector] != -1)
 				goto next;
 		/* Found one! */
-		current_vector = vector;
-		current_offset = offset;
+		if (priority == IRQ_PRIORITY_NONE) {
+			current_device_vector = vector;
+			current_device_offset = offset;
+		}
 		if (old_vector) {
 			cfg->move_in_progress = 1;
 			cfg->old_domain = cfg->domain;
 		}
-		for_each_cpu_mask_nr(new_cpu, new_mask)
-			per_cpu(vector_irq, new_cpu)[vector] = irq;
+		for_each_cpu_mask_nr(domain_cpu, domain_cpu_mask)
+			per_cpu(vector_irq, domain_cpu)[vector] = irq;
 		cfg->vector = vector;
-		cfg->domain = domain;
+		cfg->domain = domain_cpu_mask;
 		return 0;
 	}
 	return -ENOSPC;

@@ -851,7 +883,7 @@
 	unsigned long flags;
 
 	spin_lock_irqsave(&vector_lock, flags);
-	err = __assign_irq_vector(irq, mask);
+	err = __assign_irq_vector(irq, IRQ_PRIORITY_NONE, &mask);
 	spin_unlock_irqrestore(&vector_lock, flags);
 	return err;
 }

@@ -2256,23 +2288,30 @@
 device_initcall(ioapic_init_sysfs);
 
 /*
- * Dynamic irq allocate and deallocation
+ * Dynamically allocate an irq vector mapping.
  */
-int create_irq(void)
+static int do_create_irq(int priority, cpumask_t *mask)
 {
 	/* Allocate an unused irq */
 	int irq;
 	int new;
 	unsigned long flags;
+	cpumask_t target_cpu_mask;
 
 	irq = -ENOSPC;
 	spin_lock_irqsave(&vector_lock, flags);
+
+	if (mask)
+		target_cpu_mask = *mask;
+	else
+		target_cpu_mask = TARGET_CPUS;
+
 	for (new = (NR_IRQS - 1); new >= 0; new--) {
 		if (platform_legacy_irq(new))
 			continue;
 		if (irq_cfg[new].vector != 0)
 			continue;
-		if (__assign_irq_vector(new, TARGET_CPUS) == 0)
+		if (__assign_irq_vector(new, priority, &target_cpu_mask) == 0)
 			irq = new;
 		break;
 	}

@@ -2284,6 +2323,17 @@
 	return irq;
 }
 
+/*
+ * Dynamically allocate an irq device vector mapping.
+ */
+int create_irq(void)
+{
+	return do_create_irq(IRQ_PRIORITY_NONE, NULL);
+}
+
+/*
+ * Free a dynamically allocated irq device vector mapping.
+ */
 void destroy_irq(unsigned int irq)
 {
 	unsigned long flags;

@@ -2299,6 +2349,106 @@
 }
 
 /*
+ * NOP functions
+ */
+static void noop(unsigned int irq)
+{
+}
+
+static unsigned int noop_ret(unsigned int irq)
+{
+	return 0;
+}
+
+static void ack_apic(unsigned int irq)
+{
+	ack_APIC_irq();
+}
+
+/*
+ * For dynamic allocation of system vectors where
+ * an ack_APIC_irq() is needed after handling the IRQ
+ */
+static struct irq_chip ack_apic_chip = {
+	.name		= "ack_apic",
+	.startup	= noop_ret,
+	.shutdown	= noop,
+	.enable		= noop,
+	.disable	= noop,
+	.ack		= noop,
+	.mask		= noop,
+	.unmask		= noop,
+	.eoi		= ack_apic,
+	.end		= noop,
+};
+
+/*
+ * Dynamically allocate an irq system vector mapping.
+ * (The irq is not to be shared.)
+ *
+ * After calling this function, the caller is responsible for any needed
+ * calls to:
+ *   set_irq_data(&any_driver_data);
+ *   set_irq_type(irq, IRQ_TYPE...);
+ * Then make the call to request_irq() to create the irqaction:
+ *   request_irq(irq, interrupt_handler, irqflags, "devname", NULL);
+ *   You might consider the flag IRQF_NOBALANCING.
+ */
+int create_irq_system_vector(int priority, cpumask_t *mask, char *irq_name,
+			     int *assigned_vector)
+{
+	unsigned long flags;
+	int irq;
+
+	/* locate an available irq */
+	irq = do_create_irq(priority, mask);
+	if (irq < 0)
+		return irq;
+
+	spin_lock_irqsave(&vector_lock, flags);
+	set_irq_chip_and_handler_name(irq, &ack_apic_chip, handle_percpu_irq,
+				      irq_name);
+
+	spin_unlock_irqrestore(&vector_lock, flags);
+
+	*assigned_vector = irq_cfg[irq].vector;
+	return irq;
+}
+EXPORT_SYMBOL(create_irq_system_vector);
+
+/*
+ * Free a dynamically allocated irq system vector mapping.
+ *
+ * Before calling this function, the caller is responsible for calling
+ * free_irq(irq, dev_id);  to free the irqaction.
+ */
+void destroy_irq_system_vector(int irq)
+{
+	unsigned long flags;
+	int cpu;
+
+	if ((unsigned)irq >= NR_IRQS || irq_cfg[irq].vector == 0)
+		return;
+
+#ifdef CONFIG_SMP
+	synchronize_irq(irq);
+#endif
+	dynamic_irq_cleanup(irq);
+	disable_irq(irq);
+
+	spin_lock_irqsave(&vector_lock, flags);
+
+	for_each_cpu_mask_nr(cpu, irq_cfg[irq].domain)
+		per_cpu(vector_irq, cpu)[irq_cfg[irq].vector] = -1;
+
+	irq_cfg[irq].vector = 0;
+	cpus_clear(irq_cfg[irq].domain);
+
+	spin_unlock_irqrestore(&vector_lock, flags);
+}
+EXPORT_SYMBOL(destroy_irq_system_vector);
+
+/*
  * MSI message composition
  */
 #ifdef CONFIG_PCI_MSI

@@ -2533,7 +2683,7 @@
 {
 	int irq, ret;
 
-	irq = create_irq();
+	irq = do_create_irq(IRQ_PRIORITY_NONE, NULL);
 	if (irq < 0)
 		return irq;
 

@@ -2571,7 +2721,7 @@
 
 	sub_handle = 0;
 	list_for_each_entry(desc, &dev->msi_list, list) {
-		irq = create_irq();
+		irq = do_create_irq(IRQ_PRIORITY_NONE, NULL);
 		if (irq < 0)
 			return irq;
 #ifdef CONFIG_INTR_REMAP

Index: linuxnext.latest/include/linux/irq.h
===================================================================
@@ -352,10 +352,14 @@
 extern void set_irq_noprobe(unsigned int irq);
 extern void set_irq_probe(unsigned int irq);
 
-/* Handle dynamic irq creation and destruction */
+/* Handle dynamic irq device vector mapping and unmapping */
 extern int create_irq(void);
 extern void destroy_irq(unsigned int irq);
 
+/* Handle dynamic irq system vector mapping and unmapping */
+extern int create_irq_system_vector(int, cpumask_t *, char *, int *);
+extern void destroy_irq_system_vector(int);
+
 /* Test to see if a driver has successfully requested an irq */
 static inline int irq_has_action(unsigned int irq)
 {

Index: linuxnext.latest/include/asm-x86/irq_vectors.h
===================================================================
@@ -91,14 +91,40 @@
 #define LOCAL_TIMER_VECTOR	0xef
 
 /*
+ * The first device or system vector (lowest numbered) available for dynamic
+ * allocation is defined by FIRST_DYNAMIC_VECTOR.
+ *
+ * The last device vector available for dynamic allocation is defined by
+ * last_dynamic_device_vector, which is initially set to
+ * LAST_DYNAMIC_DEVICE_VECTOR.
+ *
+ * The last system vector available for dynamic allocation is defined by
+ * first_fixed_system_vector - 1. The variable first_fixed_system_vector
+ * is initially set to FIRST_FIXED_SYSTEM_VECTOR.
+ *
+ * SGI-UV uses LAST_UV_DYNAMIC_DEVICE_VECTOR to reserve a range of
+ * vectors that falls between the first_fixed_system_vector and
+ * last_dynamic_device_vector for dynamic system vector allocations.
+ */
+#define FIRST_FIXED_SYSTEM_VECTOR		0xfe
+#define LAST_DYNAMIC_DEVICE_VECTOR		FIRST_FIXED_SYSTEM_VECTOR
+#define LAST_UV_DYNAMIC_DEVICE_VECTOR		0xe0
+#define IRQ_PRIORITY_NONE			1
+#define IRQ_PRIORITY_LOW			2
+#define IRQ_PRIORITY_HIGH			3
+
+/*
  * First APIC vector available to drivers: (vectors 0x30-0xee) we
  * start at 0x31(0x41) to spread out vectors evenly between priority
  * levels. (0x80 is the syscall vector)
+ *
+ * Device vectors are dynamically allocated as numbers in the range of
+ * FIRST_DYNAMIC_VECTOR to last_dynamic_device_vector (inclusive).
  */
 #ifdef CONFIG_X86_32
-# define FIRST_DEVICE_VECTOR	0x31
+# define FIRST_DYNAMIC_VECTOR	0x31
 #else
-# define FIRST_DEVICE_VECTOR	(IRQ15_VECTOR + 2)
+# define FIRST_DYNAMIC_VECTOR	(IRQ15_VECTOR + 2)
 #endif
 
 #define NR_VECTORS		256

Index: linuxnext.latest/arch/x86/kernel/io_apic_32.c
===================================================================
@@ -1165,11 +1165,15 @@
 }
 
 /* irq_vectors is indexed by the sum of all RTEs in all I/O APICs. */
-static u8 irq_vector[NR_IRQ_VECTORS] __read_mostly = { FIRST_DEVICE_VECTOR , 0 };
+static u8 irq_vector[NR_IRQ_VECTORS] __read_mostly = {
+	FIRST_DYNAMIC_VECTOR,
+	0
+};
 
 static int __assign_irq_vector(int irq)
 {
-	static int current_vector = FIRST_DEVICE_VECTOR, current_offset;
+	static int current_vector = FIRST_DYNAMIC_VECTOR;
+	static int current_offset;
 	int vector, offset;
 
 	BUG_ON((unsigned)irq >= NR_IRQ_VECTORS);

@@ -1181,9 +1185,9 @@
 	offset = current_offset;
 next:
 	vector += 8;
-	if (vector >= first_system_vector) {
+	if (vector > last_dynamic_device_vector) {
 		offset = (offset + 1) % 8;
-		vector = FIRST_DEVICE_VECTOR + offset;
+		vector = FIRST_DYNAMIC_VECTOR + offset;
 	}
 	if (vector == current_vector)
 		return -ENOSPC;

@@ -2314,7 +2318,7 @@
 	int i;
 
 	/* Reserve all the system vectors. */
-	for (i = first_system_vector; i < NR_VECTORS; i++)
+	for (i = last_dynamic_device_vector + 1; i < NR_VECTORS; i++)
 		set_bit(i, used_vectors);
 
 	enable_IO_APIC();

@@ -2435,9 +2439,9 @@
 device_initcall(ioapic_init_sysfs);
 
 /*
- * Dynamic irq allocate and deallocation
+ * Dynamically allocate an irq vector mapping.
  */
-int create_irq(void)
+static int do_create_irq(int priority, cpumask_t *mask)
 {
 	/* Allocate an unused irq */
 	int irq, new, vector = 0;

@@ -2464,6 +2468,17 @@
 	return irq;
 }
 
+/*
+ * Dynamically allocate an irq device vector mapping.
+ */
+int create_irq(void)
+{
+	return do_create_irq(IRQ_PRIORITY_NONE, NULL);
+}
+
+/*
+ * Free a dynamically allocated irq device vector mapping.
+ */
 void destroy_irq(unsigned int irq)
 {
 	unsigned long flags;

@@ -2560,7 +2575,7 @@
 {
 	struct msi_msg msg;
 	int irq, ret;
-	irq = create_irq();
+	irq = do_create_irq(IRQ_PRIORITY_NONE, NULL);
 	if (irq < 0)
 		return irq;
 

Index: linuxnext.latest/include/asm-x86/desc.h
===================================================================
@@ -310,22 +310,25 @@
 #define SYS_VECTOR_FREE		0
 #define SYS_VECTOR_ALLOCED	1
 
-extern int first_system_vector;
-extern char system_vectors[];
-
-static inline void alloc_system_vector(int vector)
-{
-	if (system_vectors[vector] == SYS_VECTOR_FREE) {
-		system_vectors[vector] = SYS_VECTOR_ALLOCED;
-		if (first_system_vector > vector)
-			first_system_vector = vector;
+extern int last_dynamic_device_vector;
+extern int first_fixed_system_vector;
+extern char fixed_system_vectors[];
+
+static inline void alloc_fixed_system_vector(int vector)
+{
+	if (fixed_system_vectors[vector] == SYS_VECTOR_FREE) {
+		fixed_system_vectors[vector] = SYS_VECTOR_ALLOCED;
+		if (first_fixed_system_vector > vector)
+			first_fixed_system_vector = vector;
+		if (last_dynamic_device_vector >= vector)
+			last_dynamic_device_vector = vector - 1;
 	} else
 		BUG();
 }
 
 static inline void alloc_intr_gate(unsigned int n, void *addr)
 {
-	alloc_system_vector(n);
+	alloc_fixed_system_vector(n);
 	set_intr_gate(n, addr);
 }
 

Index: linuxnext.latest/arch/x86/kernel/apic_32.c
===================================================================
@@ -68,9 +68,11 @@
 int local_apic_timer_c2_ok;
 EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok);
 
-int first_system_vector = 0xfe;
-
-char system_vectors[NR_VECTORS] = { [0 ... NR_VECTORS-1] = SYS_VECTOR_FREE};
+int last_dynamic_device_vector = LAST_DYNAMIC_DEVICE_VECTOR;
+int first_fixed_system_vector = FIRST_FIXED_SYSTEM_VECTOR;
+char fixed_system_vectors[NR_VECTORS] = {
+	[0 ... NR_VECTORS-1] = SYS_VECTOR_FREE
+};
 
 /*
  * Debug level, exported for io_apic.c

@@ -1361,7 +1363,7 @@
 	 * IRQ0 must be given a fixed assignment and initialized,
 	 * because it's used before the IO-APIC is set up.
 	 */
-	set_intr_gate(FIRST_DEVICE_VECTOR, interrupt[0]);
+	set_intr_gate(FIRST_DYNAMIC_VECTOR, interrupt[0]);
 
 	/*
 	 * The reschedule interrupt is a CPU-to-CPU reschedule-helper

Index: linuxnext.latest/arch/x86/kernel/irqinit_64.c
===================================================================
@@ -22,6 +22,7 @@
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/i8259.h>
+#include <asm/genapic.h>
 
 /*
  * Common place to define all x86 IRQ vectors

@@ -217,6 +218,11 @@
 	alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt);
 	alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt);
 
+	if (is_uv_system() &&
+	    LAST_UV_DYNAMIC_DEVICE_VECTOR < last_dynamic_device_vector) {
+		last_dynamic_device_vector = LAST_UV_DYNAMIC_DEVICE_VECTOR;
+	}
+
 	if (!acpi_ioapic)
 		setup_irq(2, &irq2);
 }

Index: linuxnext.latest/arch/x86/kernel/vmiclock_32.c
===================================================================
@@ -81,7 +81,7 @@
 static inline unsigned int vmi_get_timer_vector(void)
 {
 #ifdef CONFIG_X86_IO_APIC
-	return FIRST_DEVICE_VECTOR;
+	return FIRST_DYNAMIC_VECTOR;
 #else
 	return FIRST_EXTERNAL_VECTOR;
 #endif

Index: linuxnext.latest/arch/x86/kernel/apic_64.c
===================================================================
@@ -33,6 +33,7 @@
 #include <asm/smp.h>
 #include <asm/mtrr.h>
 #include <asm/mpspec.h>
+#include <asm/desc.h>
 #include <asm/hpet.h>
 #include <asm/pgalloc.h>
 #include <asm/nmi.h>

@@ -58,6 +59,13 @@
 int local_apic_timer_c2_ok;
 EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok);
 
+int last_dynamic_device_vector = LAST_DYNAMIC_DEVICE_VECTOR;
+int first_fixed_system_vector = FIRST_FIXED_SYSTEM_VECTOR;
+char fixed_system_vectors[NR_VECTORS] = {
+	[0 ... NR_VECTORS-1] = SYS_VECTOR_FREE
+};
+
+
 /*
  * Debug level, exported for io_apic.c
  */

Index: linuxnext.latest/kernel/irq/chip.c
===================================================================
@@ -78,6 +78,7 @@
 	desc->chip_data = NULL;
 	desc->handle_irq = handle_bad_irq;
 	desc->chip = &no_irq_chip;
+	desc->name = "none";
 	spin_unlock_irqrestore(&desc->lock, flags);
 }
 

Index: linux/arch/x86/kernel/io_apic.c
===================================================================
@@ -1222,6 +1222,7 @@ static int __assign_irq_vector(int irq, 
 	unsigned int old_vector;
 	int cpu;
 	struct irq_cfg *cfg;
+	struct irq_desc *desc;
 
 	cfg = irq_cfg(irq);
 

@@ -1239,6 +1240,8 @@ static int __assign_irq_vector(int irq, 
 			return 0;
 	}
 
+	desc = irq_to_desc_alloc(irq);
+
 	for_each_cpu_mask_nr(cpu, mask) {
 		cpumask_t domain, new_mask;
 		int new_cpu;

@@ -1266,7 +1269,7 @@ next:
 			goto next;
 #endif
 		for_each_cpu_mask_nr(new_cpu, new_mask)
-			if (per_cpu(vector_irq, new_cpu)[vector] != -1)
+			if (per_cpu(vector_irq, new_cpu)[vector] != NULL)
 				goto next;
 		/* Found one! */
 		current_vector = vector;

@@ -1276,7 +1279,7 @@ next:
 			cfg->old_domain = cfg->domain;
 		}
 		for_each_cpu_mask_nr(new_cpu, new_mask)
-			per_cpu(vector_irq, new_cpu)[vector] = irq;
+			per_cpu(vector_irq, new_cpu)[vector] = desc;
 		cfg->vector = vector;
 		cfg->domain = domain;
 		return 0;

@@ -1307,7 +1310,7 @@ static void __clear_irq_vector(int irq)
 	vector = cfg->vector;
 	cpus_and(mask, cfg->domain, cpu_online_map);
 	for_each_cpu_mask_nr(cpu, mask)
-		per_cpu(vector_irq, cpu)[vector] = -1;
+		per_cpu(vector_irq, cpu)[vector] = NULL;
 
 	cfg->vector = 0;
 	cpus_clear(cfg->domain);

@@ -1319,23 +1322,26 @@ void __setup_vector_irq(int cpu)
 	/* This function must be called with vector_lock held */
 	int irq, vector;
 	struct irq_cfg *cfg;
+	struct irq_desc *desc;
 
 	/* Mark the inuse vectors */
 	for_each_irq_cfg(irq, cfg) {
 		if (!cpu_isset(cpu, cfg->domain))
 			continue;
 		vector = cfg->vector;
-		per_cpu(vector_irq, cpu)[vector] = irq;
+		desc = irq_to_desc(irq);
+		BUG_ON(desc == NULL);
+		per_cpu(vector_irq, cpu)[vector] = desc;
 	}
 	/* Mark the free vectors */
 	for (vector = 0; vector < NR_VECTORS; ++vector) {
-		irq = per_cpu(vector_irq, cpu)[vector];
-		if (irq < 0)
+		desc = per_cpu(vector_irq, cpu)[vector];
+		if (desc == NULL)
 			continue;
 
-		cfg = irq_cfg(irq);
+		cfg = irq_cfg(desc->irq);
 		if (!cpu_isset(cpu, cfg->domain))
-			per_cpu(vector_irq, cpu)[vector] = -1;
+			per_cpu(vector_irq, cpu)[vector] = NULL;
 	}
 }
 

@@ -2370,16 +2376,14 @@ asmlinkage void smp_irq_move_cleanup_int
 
 	me = smp_processor_id();
 	for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
-		unsigned int irq;
 		struct irq_desc *desc;
 		struct irq_cfg *cfg;
-		irq = __get_cpu_var(vector_irq)[vector];
 
-		desc = irq_to_desc(irq);
-		if (!desc)
+		desc = __get_cpu_var(vector_irq)[vector];
+		if (desc == NULL)
 			continue;
 
-		cfg = irq_cfg(irq);
+		cfg = irq_cfg(desc->irq);
 		spin_lock(&desc->lock);
 		if (!cfg->move_cleanup_count)
 			goto unlock;

@@ -2387,7 +2391,7 @@ asmlinkage void smp_irq_move_cleanup_int
 		if ((vector == cfg->vector) && cpu_isset(me, cfg->domain))
 			goto unlock;
 
-		__get_cpu_var(vector_irq)[vector] = -1;
+		__get_cpu_var(vector_irq)[vector] = NULL;
 		cfg->move_cleanup_count--;
 unlock:
 		spin_unlock(&desc->lock);

Index: linux/include/asm-x86/hw_irq.h
===================================================================
@@ -113,7 +113,7 @@ extern asmlinkage void smp_invalidate_in
 extern void (*const interrupt[NR_VECTORS])(void);
 #endif
 
-typedef int vector_irq_t[NR_VECTORS];
+typedef struct irq_desc *vector_irq_t[NR_VECTORS];
 DECLARE_PER_CPU(vector_irq_t, vector_irq);
 
 #ifdef CONFIG_X86_IO_APIC

Index: linux/arch/x86/kernel/irq_32.c
===================================================================
@@ -226,26 +226,24 @@ unsigned int do_IRQ(struct pt_regs *regs
 	int overflow;
 	unsigned vector = ~regs->orig_ax;
 	struct irq_desc *desc;
-	unsigned irq;
 
 
 	old_regs = set_irq_regs(regs);
 	irq_enter();
-	irq = __get_cpu_var(vector_irq)[vector];
 
 	overflow = check_stack_overflow();
 
-	desc = irq_to_desc(irq);
-	if (unlikely(!desc)) {
-		printk(KERN_EMERG "%s: cannot handle IRQ %d vector %#x cpu %d\n",
-					__func__, irq, vector, smp_processor_id());
+	desc = __get_cpu_var(vector_irq)[vector];
+	if (unlikely(desc == NULL)) {
+		printk(KERN_EMERG "%s: cannot handle IRQ vector %#x cpu %d\n",
+					__func__, vector, smp_processor_id());
 		BUG();
 	}
 
-	if (!execute_on_irq_stack(overflow, desc, irq)) {
+	if (!execute_on_irq_stack(overflow, desc, desc->irq)) {
 		if (unlikely(overflow))
 			print_stack_overflow();
-		desc->handle_irq(irq, desc);
+		desc->handle_irq(desc->irq, desc);
 	}
 
 	irq_exit();

Index: linux/arch/x86/kernel/irq_64.c
===================================================================
@@ -213,20 +213,18 @@ asmlinkage unsigned int do_IRQ(struct pt
 
 	/* high bit used in ret_from_ code  */
 	unsigned vector = ~regs->orig_ax;
-	unsigned irq;
 
 	exit_idle();
 	irq_enter();
-	irq = __get_cpu_var(vector_irq)[vector];
 
 #ifdef CONFIG_DEBUG_STACKOVERFLOW
 	stack_overflow_check(regs);
 #endif
 
-	desc = irq_to_desc(irq);
-	if (likely(desc))
-		generic_handle_irq_desc(irq, desc);
-	else {
+	desc = __get_cpu_var(vector_irq)[vector];
+	if (likely(desc != NULL)) {
+		generic_handle_irq_desc(desc->irq, desc);
+	} else {
 		if (!disable_apic)
 			ack_APIC_irq();
 

Index: linux/arch/x86/kernel/vmiclock_32.c
===================================================================
@@ -242,7 +242,7 @@ void __init vmi_time_init(void)
 	vmi_time_init_clockevent();
 	setup_irq(0, &vmi_clock_action);
 	for_each_possible_cpu(cpu)
-		per_cpu(vector_irq, cpu)[vmi_get_timer_vector()] = 0;
+		per_cpu(vector_irq, cpu)[vmi_get_timer_vector()] = NULL;
 }
 
 #ifdef CONFIG_X86_LOCAL_APIC

Index: linux/arch/x86/xen/irq.c
===================================================================
@@ -27,8 +27,9 @@ static void __init __xen_init_IRQ(void)
 	for(i = 0; i < NR_VECTORS; i++) {
 		int cpu;
 
+		desc = irq_to_desc_alloc(i);
 		for_each_possible_cpu(cpu)
-			per_cpu(vector_irq, cpu)[i] = i;
+			per_cpu(vector_irq, cpu)[i] = desc;
 	}
 
 	xen_init_IRQ();

Index: linux/arch/x86/kernel/irqinit_32.c
===================================================================
@@ -59,6 +59,8 @@ static struct irqaction fpu_irq = {
 void __init init_ISA_irqs (void)
 {
 	int i;
+	int cpu;
+	unsigned int vector;
 
 #ifdef CONFIG_X86_LOCAL_APIC
 	init_bsp_APIC();

@@ -76,6 +78,12 @@ void __init init_ISA_irqs (void)
 		desc->action = NULL;
 		desc->depth = 1;
 
+		vector = IRQ0_VECTOR + i;
+		for_each_cpu_mask_nr(cpu, cpu_possible_map) {
+			BUG_ON(per_cpu(vector_irq, cpu)[vector] != NULL);
+			per_cpu(vector_irq, cpu)[vector] = desc;
+		}
+
 		set_irq_chip_and_handler_name(i, &i8259A_chip,
 					      handle_level_irq, "XT");
 	}

@@ -90,26 +98,7 @@ static struct irqaction irq2 = {
 	.name = "cascade",
 };
 
-DEFINE_PER_CPU(vector_irq_t, vector_irq) = {
-	[0 ... IRQ0_VECTOR - 1] = -1,
-	[IRQ0_VECTOR] = 0,
-	[IRQ1_VECTOR] = 1,
-	[IRQ2_VECTOR] = 2,
-	[IRQ3_VECTOR] = 3,
-	[IRQ4_VECTOR] = 4,
-	[IRQ5_VECTOR] = 5,
-	[IRQ6_VECTOR] = 6,
-	[IRQ7_VECTOR] = 7,
-	[IRQ8_VECTOR] = 8,
-	[IRQ9_VECTOR] = 9,
-	[IRQ10_VECTOR] = 10,
-	[IRQ11_VECTOR] = 11,
-	[IRQ12_VECTOR] = 12,
-	[IRQ13_VECTOR] = 13,
-	[IRQ14_VECTOR] = 14,
-	[IRQ15_VECTOR] = 15,
-	[IRQ15_VECTOR + 1 ... NR_VECTORS - 1] = -1
-};
+DEFINE_PER_CPU(vector_irq_t, vector_irq);
 
 /* Overridden in paravirt.c */
 void init_IRQ(void) __attribute__((weak, alias("native_init_IRQ")));

Index: linux/arch/x86/kernel/irqinit_64.c
===================================================================
@@ -114,30 +114,13 @@ static struct irqaction irq2 = {
 	.mask = CPU_MASK_NONE,
 	.name = "cascade",
 };
-DEFINE_PER_CPU(vector_irq_t, vector_irq) = {
-	[0 ... IRQ0_VECTOR - 1] = -1,
-	[IRQ0_VECTOR] = 0,
-	[IRQ1_VECTOR] = 1,
-	[IRQ2_VECTOR] = 2,
-	[IRQ3_VECTOR] = 3,
-	[IRQ4_VECTOR] = 4,
-	[IRQ5_VECTOR] = 5,
-	[IRQ6_VECTOR] = 6,
-	[IRQ7_VECTOR] = 7,
-	[IRQ8_VECTOR] = 8,
-	[IRQ9_VECTOR] = 9,
-	[IRQ10_VECTOR] = 10,
-	[IRQ11_VECTOR] = 11,
-	[IRQ12_VECTOR] = 12,
-	[IRQ13_VECTOR] = 13,
-	[IRQ14_VECTOR] = 14,
-	[IRQ15_VECTOR] = 15,
-	[IRQ15_VECTOR + 1 ... NR_VECTORS - 1] = -1
-};
+DEFINE_PER_CPU(vector_irq_t, vector_irq);
 
 static void __init init_ISA_irqs (void)
 {
 	int i;
+	int cpu;
+	unsigned int vector;
 
 	init_bsp_APIC();
 	init_8259A(0);

@@ -150,6 +133,12 @@ static void __init init_ISA_irqs (void)
 		desc->action = NULL;
 		desc->depth = 1;
 
+		vector = IRQ0_VECTOR + i;
+		for_each_cpu_mask_nr(cpu, cpu_possible_map) {
+			BUG_ON(per_cpu(vector_irq, cpu)[vector] != NULL);
+			per_cpu(vector_irq, cpu)[vector] = desc;
+		}
+
 		/*
 		 * 16 old-style INTA-cycle interrupts:
 		 */

Index: linux/arch/x86/kernel/io_apic.c
===================================================================
@@ -1205,7 +1205,34 @@ void unlock_vector_lock(void)
 	spin_unlock(&vector_lock);
 }
 
-static int __assign_irq_vector(int irq, cpumask_t mask)
+bool __grab_irq_vector(struct irq_desc *desc, unsigned int vector,
+		       cpumask_t *new_domain_mask)
+{
+	/* Must be called with vector lock */
+	struct irq_cfg *cfg;
+	int cpu;
+
+	for_each_cpu_mask_nr(cpu, *new_domain_mask) {
+		if (per_cpu(vector_irq, cpu)[vector] != NULL)
+			return false;
+	}
+
+	/* Available reserve it */
+	for_each_cpu_mask_nr(cpu, *new_domain_mask)
+		per_cpu(vector_irq, cpu)[vector] = desc;
+
+	cfg = irq_cfg(desc->irq);
+	if (cfg->vector) {
+		cfg->move_in_progress = 1;
+		cfg->old_domain = cfg->domain;
+	}
+	cfg->vector = vector;
+	cfg->domain = *new_domain_mask;
+
+	return true;
+}
+
+static int __assign_irq_vector(int irq, cpumask_t *mask)
 {
 	/*
 	 * NOTE! The local APIC isn't very good at handling

@@ -1219,42 +1246,40 @@ static int __assign_irq_vector(int irq, 
 	 * 0x80, because int 0x80 is hm, kind of importantish. ;)
 	 */
 	static int current_vector = FIRST_DEVICE_VECTOR, current_offset = 0;
-	unsigned int old_vector;
+	cpumask_t target_cpus_mask;
 	int cpu;
 	struct irq_cfg *cfg;
 	struct irq_desc *desc;
 
 	cfg = irq_cfg(irq);
 
-	/* Only try and allocate irqs on cpus that are present */
-	cpus_and(mask, mask, cpu_online_map);
-
 	if ((cfg->move_in_progress) || cfg->move_cleanup_count)
 		return -EBUSY;
 
-	old_vector = cfg->vector;
-	if (old_vector) {
+	/* Only try and allocate irqs on cpus that are present */
+	cpus_and(target_cpus_mask, *mask, cpu_online_map);
+
+	if (cfg->vector) {
 		cpumask_t tmp;
-		cpus_and(tmp, cfg->domain, mask);
+		cpus_and(tmp, cfg->domain, target_cpus_mask);
 		if (!cpus_empty(tmp))
 			return 0;
 	}
 
 	desc = irq_to_desc_alloc(irq);
 
-	for_each_cpu_mask_nr(cpu, mask) {
-		cpumask_t domain, new_mask;
-		int new_cpu;
+	for_each_cpu_mask_nr(cpu, target_cpus_mask) {
+		cpumask_t domain, new_domain_mask;
 		int vector, offset;
 
 		domain = vector_allocation_domain(cpu);
-		cpus_and(new_mask, domain, cpu_online_map);
+		cpus_and(new_domain_mask, domain, cpu_online_map);
 
 		vector = current_vector;
 		offset = current_offset;
 next:
 		vector += 8;
-		if (vector >= first_system_vector) {
+		if (vector > last_device_vector) {
 			/* If we run out of vectors on large boxen, must share them. */
 			offset = (offset + 1) % 8;
 			vector = FIRST_DEVICE_VECTOR + offset;

@@ -1268,20 +1293,12 @@ next:
 		if (vector == SYSCALL_VECTOR)
 			goto next;
 #endif
-		for_each_cpu_mask_nr(new_cpu, new_mask)
-			if (per_cpu(vector_irq, new_cpu)[vector] != NULL)
-				goto next;
+		if (!__grab_irq_vector(desc, vector, &new_domain_mask))
+			goto next;
+
 		/* Found one! */
 		current_vector = vector;
 		current_offset = offset;
-		if (old_vector) {
-			cfg->move_in_progress = 1;
-			cfg->old_domain = cfg->domain;
-		}
-		for_each_cpu_mask_nr(new_cpu, new_mask)
-			per_cpu(vector_irq, new_cpu)[vector] = desc;
-		cfg->vector = vector;
-		cfg->domain = domain;
 		return 0;
 	}
 	return -ENOSPC;

@@ -1293,11 +1310,51 @@ static int assign_irq_vector(int irq, cp
 	unsigned long flags;
 
 	spin_lock_irqsave(&vector_lock, flags);
-	err = __assign_irq_vector(irq, mask);
+	err = __assign_irq_vector(irq, &mask);
 	spin_unlock_irqrestore(&vector_lock, flags);
 	return err;
 }
 
+static int __assign_irq_system_vector(int irq, cpumask_t *mask, int priority)
+{
+	int vector;
+	cpumask_t target_cpus_mask;
+	int cpu;
+	cpumask_t domain;
+	cpumask_t new_domain_mask = CPU_MASK_NONE;
+	struct irq_desc *desc;
+
+	if (priority == IRQ_PRIORITY_HIGH)
+		vector = first_static_system_vector;
+	else if (priority == IRQ_PRIORITY_LOW)
+		vector = FIRST_DEVICE_VECTOR - 1;
+	else
+		BUG();
+
+	cpus_and(target_cpus_mask, *mask, cpu_possible_map);
+	for_each_cpu_mask_nr(cpu, target_cpus_mask) {
+		domain = vector_allocation_domain(cpu);
+		cpus_and(domain, domain, cpu_possible_map);
+		cpus_or(new_domain_mask, new_domain_mask, domain);
+	}
+
+	desc = irq_to_desc_alloc(irq);
+
+	do {
+		if (priority == IRQ_PRIORITY_HIGH) {
+			if (--vector < FIRST_DEVICE_VECTOR)
+				return -ENOSPC;
+		} else {	/* IRQ_PRIORITY_LOW */
+			if (++vector == first_static_system_vector)
+				return -ENOSPC;
+		}
+
+	} while (!__grab_irq_vector(desc, vector, &new_domain_mask));
+
+	/* found one */
+	return 0;
+}
+
 static void __clear_irq_vector(int irq)
 {
 	struct irq_cfg *cfg;

@@ -3045,21 +3102,22 @@ static int __init ioapic_init_sysfs(void
 
 device_initcall(ioapic_init_sysfs);
 
-/*
- * Dynamic irq allocate and deallocation
- */
-unsigned int create_irq_nr(unsigned int irq_want)
+#define DEVICE_VECTOR	1
+#define SYSTEM_VECTOR	2
+
+static unsigned int __create_irq_nr(int vector_type, unsigned int irq_want,
+				    cpumask_t *mask, int priority)
 {
 	/* Allocate an unused irq */
 	unsigned int irq;
 	unsigned int new;
 	unsigned long flags;
 	struct irq_cfg *cfg_new;
+	int ret;
 
 #ifndef CONFIG_HAVE_SPARSE_IRQ
 	irq_want = nr_irqs - 1;
 #endif
-
 	irq = 0;
 	spin_lock_irqsave(&vector_lock, flags);
 	for (new = irq_want; new > 0; new--) {

@@ -3071,18 +3129,34 @@ unsigned int create_irq_nr(unsigned int 
 		/* check if need to create one */
 		if (!cfg_new)
 			cfg_new = irq_cfg_alloc(new);
-		if (__assign_irq_vector(new, TARGET_CPUS) == 0)
+		if (vector_type == DEVICE_VECTOR)
+			ret = __assign_irq_vector(new, mask);
+		else
+			ret = __assign_irq_system_vector(new, mask, priority);
+
+		if (ret == 0)
 			irq = new;
 		break;
 	}
 	spin_unlock_irqrestore(&vector_lock, flags);
 
-	if (irq > 0) {
+	if (irq > 0)
 		dynamic_irq_init(irq);
-	}
+
 	return irq;
 }
 
+unsigned int create_irq_nr(unsigned int irq_want)
+{
+	cpumask_t mask = TARGET_CPUS;
+
+	return __create_irq_nr(DEVICE_VECTOR, irq_want, &mask,
+			       IRQ_PRIORITY_LOW);
+}
+
+/*
+ * Dynamic irq device vector allocation.
+ */
 int create_irq(void)
 {
 	int irq;

@@ -3095,6 +3169,9 @@ int create_irq(void)
 	return irq;
 }
 
+/*
+ * Dynamic irq device vector deallocation.
+ */
 void destroy_irq(unsigned int irq)
 {
 	unsigned long flags;

@@ -3109,6 +3186,127 @@ void destroy_irq(unsigned int irq)
 	spin_unlock_irqrestore(&vector_lock, flags);
 }
 
+static void noop(unsigned int irq)
+{
+}
+
+static unsigned int noop_ret(unsigned int irq)
+{
+	return 0;
+}
+
+static void ack_apic(unsigned int irq)
+{
+	ack_APIC_irq();
+}
+
+static struct irq_chip ack_apic_chip = {
+	.name		= "ack_apic",
+	.startup	= noop_ret,
+	.shutdown	= noop,
+	.enable		= noop,
+	.disable	= noop,
+	.ack		= noop,
+	.mask		= noop,
+	.unmask		= noop,
+	.eoi		= ack_apic,
+	.end		= noop,
+};
+
+unsigned int create_irq_system_vector_nr(unsigned int irq_want, cpumask_t *mask,
+					 int priority)
+{
+	return __create_irq_nr(SYSTEM_VECTOR, irq_want, mask, priority);
+}
+
+/*
+ * Dynamic irq system vector allocation.
+ */
+unsigned int create_irq_system_vector(cpumask_t *mask, int priority,
+				      char *irq_name, int *assigned_vector)
+{
+	unsigned long flags;
+	struct irq_cfg *cfg;
+	int irq;
+
+	/* allocate an available irq and vector mapping */
+	irq = create_irq_system_vector_nr(nr_irqs - 1, mask, priority);
+	if (irq == 0)
+		return -1;
+
+	spin_lock_irqsave(&vector_lock, flags);
+	set_irq_chip_and_handler_name(irq, &ack_apic_chip, handle_percpu_irq,
+				      irq_name);
+	spin_unlock_irqrestore(&vector_lock, flags);
+
+	cfg = irq_cfg(irq);
+	*assigned_vector = cfg->vector;
+	return irq;
+}
+EXPORT_SYMBOL(create_irq_system_vector);
+
+/*
+ * Dynamic irq system vector deallocation.
+ */
+void destroy_irq_system_vector(unsigned int irq)
+{
+	unsigned long flags;
+	struct irq_cfg *cfg;
+	int cpu;
+
+	if (irq >= nr_irqs)
+		return;
+	cfg = irq_cfg(irq);
+	if (cfg->vector == 0)
+		return;
+
+#ifdef CONFIG_SMP
+	synchronize_irq(irq);
+#endif
+	dynamic_irq_cleanup(irq);
+	disable_irq(irq);
+
+	spin_lock_irqsave(&vector_lock, flags);
+
+	for_each_cpu_mask_nr(cpu, cfg->domain)
+		per_cpu(vector_irq, cpu)[cfg->vector] = NULL;
+
+	cfg->vector = 0;
+	cpus_clear(cfg->domain);
+
+	spin_unlock_irqrestore(&vector_lock, flags);
+}
+EXPORT_SYMBOL(destroy_irq_system_vector);
+
+int reserve_system_vectors(int number)
+{
+	unsigned long flags;
+	int new_last_device_vector;
+	int vector;
+	int cpu;
+	int ret = -EBUSY;
+
+	spin_lock_irqsave(&vector_lock, flags);
+
+	new_last_device_vector = last_device_vector - number;
+	if (new_last_device_vector < MIN_LAST_DEVICE_VECTOR)
+		goto out;
+
+	for (vector = last_device_vector; vector > new_last_device_vector;
+	     vector--) {
+		for_each_cpu_mask_nr(cpu, cpu_possible_map) {
+			if (per_cpu(vector_irq, cpu)[vector] != NULL)
+				goto out;
+		}
+	}
+
+	last_device_vector = new_last_device_vector;
+	ret = 0;
+out:
+	spin_unlock_irqrestore(&vector_lock, flags);
+	return ret;
+}
+
 /*
  * MSI message composition
  */

Index: linux/include/linux/irq.h
===================================================================
@@ -390,11 +390,22 @@ set_irq_chained_handler(unsigned int irq
 extern void set_irq_noprobe(unsigned int irq);
 extern void set_irq_probe(unsigned int irq);
 
-/* Handle dynamic irq creation and destruction */
+/* Handle dynamic irq device vector allocation and deallocation */
 extern unsigned int create_irq_nr(unsigned int irq_want);
 extern int create_irq(void);
 extern void destroy_irq(unsigned int irq);
 
+/* Handle dynamic irq system vector allocation and deallocation */
+extern unsigned int create_irq_system_vector(cpumask_t *mask, int priority,
+					     char *irq_name,
+					     int *assigned_vector);
+#define IRQ_PRIORITY_LOW	1
+#define IRQ_PRIORITY_HIGH	2
+
+extern void destroy_irq_system_vector(unsigned int irq);
+
+extern int reserve_system_vectors(int number);
+
 /* Test to see if a driver has successfully requested an irq */
 static inline int irq_has_action(unsigned int irq)
 {

Index: linux/arch/x86/kernel/apic.c
===================================================================
@@ -116,7 +116,8 @@ static int disable_apic_timer __cpuinitd
 int local_apic_timer_c2_ok;
 EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok);
 
-int first_system_vector = 0xfe;
+int first_static_system_vector = 0xfe;
+int last_device_vector = 0xfd;
 
 char system_vectors[NR_VECTORS] = { [0 ... NR_VECTORS-1] = SYS_VECTOR_FREE};
 

Index: linux/include/asm-x86/desc.h
===================================================================
@@ -323,22 +323,25 @@ static inline void set_intr_gate(unsigne
 #define SYS_VECTOR_FREE		0
 #define SYS_VECTOR_ALLOCED	1
 
-extern int first_system_vector;
+extern int first_static_system_vector;
+extern int last_device_vector;
 extern char system_vectors[];
 
-static inline void alloc_system_vector(int vector)
+static inline void alloc_static_system_vector(int vector)
 {
 	if (system_vectors[vector] == SYS_VECTOR_FREE) {
 		system_vectors[vector] = SYS_VECTOR_ALLOCED;
-		if (first_system_vector > vector)
-			first_system_vector = vector;
+		if (first_static_system_vector > vector)
+			first_static_system_vector = vector;
+		if (last_device_vector > vector - 1)
+			last_device_vector = vector - 1;
 	} else
 		BUG();
 }
 
 static inline void alloc_intr_gate(unsigned int n, void *addr)
 {
-	alloc_system_vector(n);
+	alloc_static_system_vector(n);
 	set_intr_gate(n, addr);
 }
 

Index: linux/include/asm-x86/irq_vectors.h
===================================================================
@@ -92,6 +92,7 @@
  * levels. (0x80 is the syscall vector)
  */
 #define FIRST_DEVICE_VECTOR	(IRQ15_VECTOR + 2)
+#define MIN_LAST_DEVICE_VECTOR	(LOCAL_TIMER_VECTOR - 16)
 
 #define NR_VECTORS		256
 

Index: linux/arch/x86/kernel/irqinit_64.c
===================================================================
@@ -22,6 +22,7 @@
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/i8259.h>
+#include <asm/genapic.h>
 
 /*
  * Common place to define all x86 IRQ vectors

@@ -202,6 +203,9 @@ void __init native_init_IRQ(void)
 	alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt);
 	alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt);
 
+	if (is_uv_system())
+		reserve_system_vectors(8);
+
 	if (!acpi_ioapic)
 		setup_irq(2, &irq2);
 }

Index: linux/arch/x86/kernel/apic.c
===================================================================
@@ -119,8 +119,6 @@ EXPORT_SYMBOL_GPL(local_apic_timer_c2_ok
 int first_static_system_vector = 0xfe;
 int last_device_vector = 0xfd;
 
-char system_vectors[NR_VECTORS] = { [0 ... NR_VECTORS-1] = SYS_VECTOR_FREE};
-
 /*
  * Debug level, exported for io_apic.c
  */

Index: linux/include/asm-x86/desc.h
===================================================================
@@ -6,6 +6,7 @@
 #include <asm/ldt.h>
 #include <asm/mmu.h>
 #include <linux/smp.h>
+#include <linux/irq.h>
 
 static inline void fill_ldt(struct desc_struct *desc,
 			    const struct user_desc *info)

@@ -329,14 +330,18 @@ extern char system_vectors[];
 
 static inline void alloc_static_system_vector(int vector)
 {
-	if (system_vectors[vector] == SYS_VECTOR_FREE) {
-		system_vectors[vector] = SYS_VECTOR_ALLOCED;
-		if (first_static_system_vector > vector)
-			first_static_system_vector = vector;
-		if (last_device_vector > vector - 1)
-			last_device_vector = vector - 1;
-	} else
-		BUG();
+	unsigned long flags;
+	bool ret;
+
+	spin_lock_irqsave(&vector_lock, flags);
+	ret = __grab_irq_vector(NON_IRQ_DESC, vector, &cpu_possible_map);
+	BUG_ON(ret == false);
+
+	if (first_static_system_vector > vector)
+		first_static_system_vector = vector;
+	if (last_device_vector > vector - 1)
+		last_device_vector = vector - 1;
+	spin_unlock_irqrestore(&vector_lock, flags);
 }
 
 static inline void alloc_intr_gate(unsigned int n, void *addr)

Index: linux/arch/x86/kernel/io_apic.c
===================================================================
@@ -70,7 +70,7 @@
 int sis_apic_bug = -1;
 
 static DEFINE_SPINLOCK(ioapic_lock);
-static DEFINE_SPINLOCK(vector_lock);
+DEFINE_SPINLOCK(vector_lock);
 
 /*
  * # of IRQ routing registers

@@ -1221,13 +1221,15 @@ bool __grab_irq_vector(struct irq_desc *
 	for_each_cpu_mask_nr(cpu, *new_domain_mask)
 		per_cpu(vector_irq, cpu)[vector] = desc;
 
-	cfg = irq_cfg(desc->irq);
-	if (cfg->vector) {
-		cfg->move_in_progress = 1;
-		cfg->old_domain = cfg->domain;
+	if (desc != NON_IRQ_DESC) {
+		cfg = irq_cfg(desc->irq);
+		if (cfg->vector) {
+			cfg->move_in_progress = 1;
+			cfg->old_domain = cfg->domain;
+		}
+		cfg->vector = vector;
+		cfg->domain = *new_domain_mask;
 	}
-	cfg->vector = vector;
-	cfg->domain = *new_domain_mask;
 
 	return true;
 }

@@ -1387,13 +1389,13 @@ void __setup_vector_irq(int cpu)
 			continue;
 		vector = cfg->vector;
 		desc = irq_to_desc(irq);
-		BUG_ON(desc == NULL);
+		BUG_ON(desc == NULL || desc == NON_IRQ_DESC);
 		per_cpu(vector_irq, cpu)[vector] = desc;
 	}
 	/* Mark the free vectors */
 	for (vector = 0; vector < NR_VECTORS; ++vector) {
 		desc = per_cpu(vector_irq, cpu)[vector];
-		if (desc == NULL)
+		if (desc == NULL || desc == NON_IRQ_DESC)
 			continue;
 
 		cfg = irq_cfg(desc->irq);

@@ -2437,7 +2439,7 @@ asmlinkage void smp_irq_move_cleanup_int
 		struct irq_cfg *cfg;
 
 		desc = __get_cpu_var(vector_irq)[vector];
-		if (desc == NULL)
+		if (desc == NULL || desc == NON_IRQ_DESC)
 			continue;
 
 		cfg = irq_cfg(desc->irq);

Index: linux/include/linux/irq.h
===================================================================
@@ -390,6 +390,11 @@ set_irq_chained_handler(unsigned int irq
 extern void set_irq_noprobe(unsigned int irq);
 extern void set_irq_probe(unsigned int irq);
 
+extern bool __grab_irq_vector(struct irq_desc *desc, unsigned int vector,
+			      cpumask_t *new_domain_mask);
+
+#define NON_IRQ_DESC	((struct irq_desc *)-1UL)
+
 /* Handle dynamic irq device vector allocation and deallocation */
 extern unsigned int create_irq_nr(unsigned int irq_want);
 extern int create_irq(void);

Index: linux/arch/x86/kernel/irq_32.c
===================================================================
@@ -234,7 +234,7 @@ unsigned int do_IRQ(struct pt_regs *regs
 	overflow = check_stack_overflow();
 
 	desc = __get_cpu_var(vector_irq)[vector];
-	if (unlikely(desc == NULL)) {
+	if (unlikely(desc == NULL || desc == NON_IRQ_DESC)) {
 		printk(KERN_EMERG "%s: cannot handle IRQ vector %#x cpu %d\n",
 					__func__, vector, smp_processor_id());
 		BUG();

Index: linux/arch/x86/kernel/irq_64.c
===================================================================
@@ -222,7 +222,7 @@ asmlinkage unsigned int do_IRQ(struct pt
 #endif
 
 	desc = __get_cpu_var(vector_irq)[vector];
-	if (likely(desc != NULL)) {
+	if (likely(desc != NULL && desc != NON_IRQ_DESC)) {
 		generic_handle_irq_desc(desc->irq, desc);
 	} else {
 		if (!disable_apic)

Index: linux/include/asm-x86/irq.h
===================================================================
@@ -47,4 +47,6 @@ extern void native_init_IRQ(void);
 /* Interrupt vector management */
 extern DECLARE_BITMAP(used_vectors, NR_VECTORS);
 
+extern spinlock_t vector_lock;
+
 #endif /* ASM_X86__IRQ_H */

Index: linux/arch/x86/kernel/traps_32.c
===================================================================
@@ -63,9 +63,6 @@
 
 #include "mach_traps.h"
 
-DECLARE_BITMAP(used_vectors, NR_VECTORS);
-EXPORT_SYMBOL_GPL(used_vectors);
-
 asmlinkage int system_call(void);
 
 /* Do we ignore FPU interrupts ? */

@@ -1189,6 +1186,8 @@ asmlinkage void math_emulate(long arg)
 void __init trap_init(void)
 {
 	int i;
+	bool ret;
+	unsigned long flags;
 
 #ifdef CONFIG_EISA
 	void __iomem *p = early_ioremap(0x0FFFD9, 4);

@@ -1236,10 +1235,16 @@ void __init trap_init(void)
 	set_system_gate(SYSCALL_VECTOR, &system_call);
 
 	/* Reserve all the builtin and the syscall vector: */
-	for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++)
-		set_bit(i, used_vectors);
+	spin_lock_irqsave(&vector_lock, flags);
+	for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++) {
+		ret =__grab_irq_vector(NON_IRQ_DESC, i, &cpu_possible_map);
+		BUG_ON(ret == false);
+	}
 
-	set_bit(SYSCALL_VECTOR, used_vectors);
+	ret = __grab_irq_vector(NON_IRQ_DESC, SYSCALL_VECTOR,
+				&cpu_possible_map);
+	BUG_ON(ret == false);
+	spin_unlock_irqrestore(&vector_lock, flags);
 
 	/*
 	 * Should be a barrier for any external CPU state:

Index: linux/include/asm-x86/irq.h
===================================================================
@@ -44,9 +44,6 @@ extern unsigned int do_IRQ(struct pt_reg
 extern void init_IRQ(void);
 extern void native_init_IRQ(void);
 
-/* Interrupt vector management */
-extern DECLARE_BITMAP(used_vectors, NR_VECTORS);
-
 extern spinlock_t vector_lock;
 
 #endif /* ASM_X86__IRQ_H */

Index: linux/drivers/lguest/interrupts_and_traps.c
===================================================================
@@ -221,19 +221,35 @@ bool check_syscall_vector(struct lguest 
 
 int init_interrupts(void)
 {
+	unsigned long flags;
+	bool ret;
+
 	/* If they want some strange system call vector, reserve it now */
-	if (syscall_vector != SYSCALL_VECTOR
-	    && test_and_set_bit(syscall_vector, used_vectors)) {
-		printk("lg: couldn't reserve syscall %u\n", syscall_vector);
-		return -EBUSY;
+	if (syscall_vector != SYSCALL_VECTOR) {
+		spin_lock_irqsave(&vector_lock, flags);
+		ret = __grab_irq_vector(NON_IRQ_DESC, syscall_vector,
+					&cpu_possible_map);
+		spin_unlock_irqrestore(&vector_lock, flags);
+		if (ret == false) {
+			printk("lg: couldn't reserve syscall %u\n",
+			       syscall_vector);
+			return -EBUSY;
+		}
 	}
 	return 0;
 }
 
 void free_interrupts(void)
 {
-	if (syscall_vector != SYSCALL_VECTOR)
-		clear_bit(syscall_vector, used_vectors);
+	int cpu;
+
+	if (syscall_vector != SYSCALL_VECTOR) {
+		for_each_cpu_mask_nr(cpu, cpu_possible_map) {
+			BUG_ON(per_cpu(vector_irq, cpu)[syscall_vector] !=
+			       NON_IRQ_DESC);
+			per_cpu(vector_irq, cpu)[syscall_vector] = NULL;
+		}
+	}
 }
 
 /*H:220 Now we've got the routines to deliver interrupts, delivering traps like