bitkeeper revision 1.1277.2.1 (425ae61cXUKm0NUhWTRMCwyBexDyrw)

Update to 2.6.11 patch files
Signed-off by: Dan Magenheimer (dan.magenheimer@hp.com)

.rootkeys

@@ -1078,6 +1078,45 @@
 421098b3ys5GAr4z6_H1jD33oem82g xen/arch/ia64/irq.c
 421098b3Heh72KuoVlND3CH6c0B0aA xen/arch/ia64/lib/Makefile
 421098b3O0MYMUsmYVFy84VV_1gFwQ xen/arch/ia64/mm_init.c
+425ae516skiHBZU-Kfwxv2YWXfNRWQ xen/arch/ia64/patch/linux-2.6.11/bootmem.h
+425ae516maKAsHBJVSzs19cdRgt3Nw xen/arch/ia64/patch/linux-2.6.11/cpumask.h
+425ae516rHybgKj6KsvBOE0c_Hruxg xen/arch/ia64/patch/linux-2.6.11/current.h
+425ae516cGqvMzGtihTEsQXAXsuOhQ xen/arch/ia64/patch/linux-2.6.11/efi.c
+425ae516Y1A4q4_Kfre3qnDj7lbHJg xen/arch/ia64/patch/linux-2.6.11/entry.S
+425ae516RoFheL-Ua-EOtFqmLxoc9g xen/arch/ia64/patch/linux-2.6.11/hardirq.h
+425ae516PDO1ESDHXHVeDNvlqUfmdQ xen/arch/ia64/patch/linux-2.6.11/head.S
+425ae5163aiWdc1IZNsON6ruE2-n9g xen/arch/ia64/patch/linux-2.6.11/hpsim_irq.c
+425ae516JR7HWvt1zxJ-wLvEWmJGgg xen/arch/ia64/patch/linux-2.6.11/hpsim_ssc.h
+425ae516AHRNmaVuZjJY-9YjmKRDqg xen/arch/ia64/patch/linux-2.6.11/interrupt.h
+425ae516U2wFUzrUJQUpy3z38jZHsQ xen/arch/ia64/patch/linux-2.6.11/io.h
+425ae516nXL2iTzpziIaSLi3N257qQ xen/arch/ia64/patch/linux-2.6.11/irq.h
+425ae516GGRmXijPBLC5ii6yWOn0rg xen/arch/ia64/patch/linux-2.6.11/irq_ia64.c
+425ae516qQA5dHuIybqfN3nEzM_Zvg xen/arch/ia64/patch/linux-2.6.11/ivt.S
+425ae516_UhrTa3Y8wDG7fTgX6pNYA xen/arch/ia64/patch/linux-2.6.11/kernel-time.c
+425ae516atiECmpn_6nZDw4kkmbJ6g xen/arch/ia64/patch/linux-2.6.11/kregs.h
+425ae516lwlYwHG1Jv93kC3tfU5caw xen/arch/ia64/patch/linux-2.6.11/lds.S
+425ae516UGTH2xC56DEIlHSrPH4oxg xen/arch/ia64/patch/linux-2.6.11/linuxextable.c
+425ae516txAP-owjzpTJ7ThfzWR8nw xen/arch/ia64/patch/linux-2.6.11/linuxhardirq.h
+425ae516kNsO5yYnBHvAISdvCkQ2-g xen/arch/ia64/patch/linux-2.6.11/linuxtime.h
+425ae516Je2zI-Iw30_uGhvUYdlCZQ xen/arch/ia64/patch/linux-2.6.11/mca_asm.h
+425ae5160-9wHxh0tOnIjavEjt6W0A xen/arch/ia64/patch/linux-2.6.11/minstate.h
+425ae516N7SaORdbodDr90tmtCzYXw xen/arch/ia64/patch/linux-2.6.11/mm_contig.c
+425ae516YcBgoZ3xCTEmhCrgX8CjCA xen/arch/ia64/patch/linux-2.6.11/mmzone.h
+425ae516WDLrfEA4zr40d00z0VIWPg xen/arch/ia64/patch/linux-2.6.11/page.h
+425ae516pVQ75NhdItT593SiWI0lbQ xen/arch/ia64/patch/linux-2.6.11/pal.S
+425ae516QfmjiF_a-mabAXqV8Imzkg xen/arch/ia64/patch/linux-2.6.11/pgalloc.h
+425ae516EWaNOBEnc1xnphTbRmNZsw xen/arch/ia64/patch/linux-2.6.11/processor.h
+425ae5165sks4NwRldZOV_p63fspYw xen/arch/ia64/patch/linux-2.6.11/sal.h
+425ae516LecDyXlwh3NLBtHZKXmMcA xen/arch/ia64/patch/linux-2.6.11/series
+425ae516RFiPn2CGkpJ21LM-1lJcQg xen/arch/ia64/patch/linux-2.6.11/setup.c
+425ae516-xgihgqPEv-Aq8-9cNoCXg xen/arch/ia64/patch/linux-2.6.11/slab.h
+425ae516FX_10YaKGMU8Ysf7kkdm_A xen/arch/ia64/patch/linux-2.6.11/swiotlb.c
+425ae516p4ICTkjqNYEfYFxqULj4dw xen/arch/ia64/patch/linux-2.6.11/system.h
+425ae516juUB257qrwUdsL9AsswrqQ xen/arch/ia64/patch/linux-2.6.11/time.c
+425ae5167zQn7zYcgKtDUDX2v-e8mw xen/arch/ia64/patch/linux-2.6.11/tlb.c
+425ae5162bIl2Dgd19x-FceB4L9oGw xen/arch/ia64/patch/linux-2.6.11/types.h
+425ae516cFUNY2jHD46bujcF5NJheA xen/arch/ia64/patch/linux-2.6.11/unaligned.c
+425ae516viTtlyQjWHf6kBmq8KcwiQ xen/arch/ia64/patch/linux-2.6.11/wait.h
 421098b39QFMC-1t1r38CA7NxAYBPA xen/arch/ia64/patch/linux-2.6.7/bootmem.h
 421098b3SIA1vZX9fFUjo1T3o_jMCQ xen/arch/ia64/patch/linux-2.6.7/current.h
 421098b3ZBl80iPuSeDU_Id5AgZl0w xen/arch/ia64/patch/linux-2.6.7/efi.c

xen/arch/ia64/domain.c

@@ -289,6 +289,7 @@ struct page * map_new_domain_page(struct domain *d, unsigned long mpaddr)
 	struct mm_struct *mm = d->arch.mm;
 	struct page *p = (struct page *)0;
 	pgd_t *pgd;
+	pud_t *pud;
 	pmd_t *pmd;
 	pte_t *pte;
 extern unsigned long vhpt_paddr, vhpt_pend;
@@ -299,9 +300,13 @@ extern unsigned long vhpt_paddr, vhpt_pend;
 	}
 	pgd = pgd_offset(mm,mpaddr);
 	if (pgd_none(*pgd))
-		pgd_populate(mm, pgd, pmd_alloc_one(mm,mpaddr));
+		pgd_populate(mm, pgd, pud_alloc_one(mm,mpaddr));
 
-	pmd = pmd_offset(pgd, mpaddr);
+	pud = pud_offset(pgd, mpaddr);
+	if (pud_none(*pud))
+		pud_populate(mm, pud, pmd_alloc_one(mm,mpaddr));
+
+	pmd = pmd_offset(pud, mpaddr);
 	if (pmd_none(*pmd))
 		pmd_populate_kernel(mm, pmd, pte_alloc_one_kernel(mm,mpaddr));
 //		pmd_populate(mm, pmd, pte_alloc_one(mm,mpaddr));
@@ -338,6 +343,7 @@ unsigned long lookup_domain_mpa(struct domain *d, unsigned long mpaddr)
 {
 	struct mm_struct *mm = d->arch.mm;
 	pgd_t *pgd = pgd_offset(mm, mpaddr);
+	pud_t *pud;
 	pmd_t *pmd;
 	pte_t *pte;
 
@@ -356,14 +362,17 @@ unsigned long lookup_domain_mpa(struct domain *d, unsigned long mpaddr)
 #endif
 tryagain:
 	if (pgd_present(*pgd)) {
-		pmd = pmd_offset(pgd,mpaddr);
-		if (pmd_present(*pmd)) {
-			pte = pte_offset_map(pmd,mpaddr);
-			if (pte_present(*pte)) {
+		pud = pud_offset(pgd,mpaddr);
+		if (pud_present(*pud)) {
+			pmd = pmd_offset(pud,mpaddr);
+			if (pmd_present(*pmd)) {
+				pte = pte_offset_map(pmd,mpaddr);
+				if (pte_present(*pte)) {
 //printk("lookup_domain_page: found mapping for %lx, pte=%lx\n",mpaddr,pte_val(*pte));
-				return *(unsigned long *)pte;
+					return *(unsigned long *)pte;
+				}
 			}
-		}	
+		}
 	}
 	/* if lookup fails and mpaddr is "legal", "create" the page */
 	if ((mpaddr >> PAGE_SHIFT) < d->max_pages) {

xen/arch/ia64/irq.c

@@ -492,101 +492,101 @@ EXPORT_SYMBOL(enable_irq);
  * SMP cross-CPU interrupts have their own specific
  * handlers).
  */
-unsigned int do_IRQ(unsigned long irq, struct pt_regs *regs)
+fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs)
 {
-	/*
-	 * We ack quickly, we don't want the irq controller
-	 * thinking we're snobs just because some other CPU has
-	 * disabled global interrupts (we have already done the
-	 * INT_ACK cycles, it's too late to try to pretend to the
-	 * controller that we aren't taking the interrupt).
-	 *
-	 * 0 return value means that this irq is already being
-	 * handled by some other CPU. (or is disabled)
-	 */
-	irq_desc_t *desc = irq_descp(irq);
+	irq_desc_t *desc = irq_desc + irq;
 	struct irqaction * action;
-	irqreturn_t action_ret;
 	unsigned int status;
-	int cpu;
-
-	cpu = smp_processor_id(); /* for CONFIG_PREEMPT, this must come after irq_enter()! */
 
 #ifndef XEN
-	kstat_cpu(cpu).irqs[irq]++;
+	kstat_this_cpu.irqs[irq]++;
 #endif
-
 	if (desc->status & IRQ_PER_CPU) {
-		/* no locking required for CPU-local interrupts: */
+		irqreturn_t action_ret;
+
+		/*
+		 * No locking required for CPU-local interrupts:
+		 */
 		desc->handler->ack(irq);
 		action_ret = handle_IRQ_event(irq, regs, desc->action);
-		desc->handler->end(irq);
-	} else {
-		spin_lock(&desc->lock);
-		desc->handler->ack(irq);
-		/*
-		 * REPLAY is when Linux resends an IRQ that was dropped earlier
-		 * WAITING is used by probe to mark irqs that are being tested
-		 */
-#ifdef XEN
-		status = desc->status & ~IRQ_REPLAY;
-#else
-		status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
-#endif
-		status |= IRQ_PENDING; /* we _want_ to handle it */
-
-		/*
-		 * If the IRQ is disabled for whatever reason, we cannot
-		 * use the action we have.
-		 */
-		action = NULL;
-		if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) {
-			action = desc->action;
-			status &= ~IRQ_PENDING; /* we commit to handling */
-			status |= IRQ_INPROGRESS; /* we are handling it */
-		}
-		desc->status = status;
-
-		/*
-		 * If there is no IRQ handler or it was disabled, exit early.
-		 * Since we set PENDING, if another processor is handling
-		 * a different instance of this same irq, the other processor
-		 * will take care of it.
-		 */
-		if (unlikely(!action))
-			goto out;
-
-		/*
-		 * Edge triggered interrupts need to remember
-		 * pending events.
-		 * This applies to any hw interrupts that allow a second
-		 * instance of the same irq to arrive while we are in do_IRQ
-		 * or in the handler. But the code here only handles the _second_
-		 * instance of the irq, not the third or fourth. So it is mostly
-		 * useful for irq hardware that does not mask cleanly in an
-		 * SMP environment.
-		 */
-		for (;;) {
-			spin_unlock(&desc->lock);
-			action_ret = handle_IRQ_event(irq, regs, action);
-			spin_lock(&desc->lock);
 #ifndef XEN
-			if (!noirqdebug)
-				note_interrupt(irq, desc, action_ret);
+		if (!noirqdebug)
+			note_interrupt(irq, desc, action_ret);
 #endif
-			if (!(desc->status & IRQ_PENDING))
-				break;
-			desc->status &= ~IRQ_PENDING;
-		}
-		desc->status &= ~IRQ_INPROGRESS;
-	  out:
-		/*
-		 * The ->end() handler has to deal with interrupts which got
-		 * disabled while the handler was running.
-		 */
 		desc->handler->end(irq);
-		spin_unlock(&desc->lock);
+		return 1;
 	}
+
+	spin_lock(&desc->lock);
+	desc->handler->ack(irq);
+	/*
+	 * REPLAY is when Linux resends an IRQ that was dropped earlier
+	 * WAITING is used by probe to mark irqs that are being tested
+	 */
+#ifdef XEN
+	status = desc->status & ~IRQ_REPLAY;
+#else
+	status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
+#endif
+	status |= IRQ_PENDING; /* we _want_ to handle it */
+
+	/*
+	 * If the IRQ is disabled for whatever reason, we cannot
+	 * use the action we have.
+	 */
+	action = NULL;
+	if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) {
+		action = desc->action;
+		status &= ~IRQ_PENDING; /* we commit to handling */
+		status |= IRQ_INPROGRESS; /* we are handling it */
+	}
+	desc->status = status;
+
+	/*
+	 * If there is no IRQ handler or it was disabled, exit early.
+	 * Since we set PENDING, if another processor is handling
+	 * a different instance of this same irq, the other processor
+	 * will take care of it.
+	 */
+	if (unlikely(!action))
+		goto out;
+
+	/*
+	 * Edge triggered interrupts need to remember
+	 * pending events.
+	 * This applies to any hw interrupts that allow a second
+	 * instance of the same irq to arrive while we are in do_IRQ
+	 * or in the handler. But the code here only handles the _second_
+	 * instance of the irq, not the third or fourth. So it is mostly
+	 * useful for irq hardware that does not mask cleanly in an
+	 * SMP environment.
+	 */
+	for (;;) {
+		irqreturn_t action_ret;
+
+		spin_unlock(&desc->lock);
+
+		action_ret = handle_IRQ_event(irq, regs, action);
+
+		spin_lock(&desc->lock);
+#ifndef XEN
+		if (!noirqdebug)
+			note_interrupt(irq, desc, action_ret);
+#endif
+		if (likely(!(desc->status & IRQ_PENDING)))
+			break;
+		desc->status &= ~IRQ_PENDING;
+	}
+	desc->status &= ~IRQ_INPROGRESS;
+
+out:
+	/*
+	 * The ->end() handler has to deal with interrupts which got
+	 * disabled while the handler was running.
+	 */
+	desc->handler->end(irq);
+	spin_unlock(&desc->lock);
+
 	return 1;
 }
 

xen/arch/ia64/mm_init.c

@@ -102,6 +102,39 @@ void insert_vm_struct(struct mm_struct * mm, struct vm_area_struct * vma)
 /////////////////////////////////////////////
 //following from linux/mm/memory.c
 
+#ifndef __ARCH_HAS_4LEVEL_HACK
+/*
+ * Allocate page upper directory.
+ *
+ * We've already handled the fast-path in-line, and we own the
+ * page table lock.
+ *
+ * On a two-level or three-level page table, this ends up actually being
+ * entirely optimized away.
+ */
+pud_t fastcall *__pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
+{
+	pud_t *new;
+
+	spin_unlock(&mm->page_table_lock);
+	new = pud_alloc_one(mm, address);
+	spin_lock(&mm->page_table_lock);
+	if (!new)
+		return NULL;
+
+	/*
+	 * Because we dropped the lock, we should re-check the
+	 * entry, as somebody else could have populated it..
+	 */
+	if (pgd_present(*pgd)) {
+		pud_free(new);
+		goto out;
+	}
+	pgd_populate(mm, pgd, new);
+ out:
+	return pud_offset(pgd, address);
+}
+
 /*
  * Allocate page middle directory.
  *
@@ -111,7 +144,7 @@ void insert_vm_struct(struct mm_struct * mm, struct vm_area_struct * vma)
  * On a two-level page table, this ends up actually being entirely
  * optimized away.
  */
-pmd_t fastcall *__pmd_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
+pmd_t fastcall *__pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
 {
 	pmd_t *new;
 
@@ -125,14 +158,15 @@ pmd_t fastcall *__pmd_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long addr
 	 * Because we dropped the lock, we should re-check the
 	 * entry, as somebody else could have populated it..
 	 */
-	if (pgd_present(*pgd)) {
+	if (pud_present(*pud)) {
 		pmd_free(new);
 		goto out;
 	}
-	pgd_populate(mm, pgd, new);
-out:
-	return pmd_offset(pgd, address);
+	pud_populate(mm, pud, new);
+ out:
+	return pmd_offset(pud, address);
 }
+#endif
 
 pte_t fastcall * pte_alloc_map(struct mm_struct *mm, pmd_t *pmd, unsigned long address)
 {

xen/arch/ia64/patch/linux-2.6.11/bootmem.h

@@ -0,0 +1,17 @@
+ bootmem.h |    2 ++
+ 1 files changed, 2 insertions(+)
+
+Index: linux-2.6.11/include/linux/bootmem.h
+===================================================================
+--- linux-2.6.11.orig/include/linux/bootmem.h	2005-03-02 01:38:25.000000000 -0600
++++ linux-2.6.11/include/linux/bootmem.h	2005-03-19 12:39:36.915887729 -0600
+@@ -41,7 +41,9 @@ extern unsigned long __init init_bootmem
+ extern void __init free_bootmem (unsigned long addr, unsigned long size);
+ extern void * __init __alloc_bootmem (unsigned long size, unsigned long align, unsigned long goal);
+ #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
++#ifndef XEN
+ extern void __init reserve_bootmem (unsigned long addr, unsigned long size);
++#endif
+ #define alloc_bootmem(x) \
+ 	__alloc_bootmem((x), SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
+ #define alloc_bootmem_low(x) \

xen/arch/ia64/patch/linux-2.6.11/cpumask.h

@@ -0,0 +1,20 @@
+ cpumask.h |    2 +-
+ 1 files changed, 1 insertion(+), 1 deletion(-)
+
+Index: linux-2.6.11-xendiffs/include/linux/cpumask.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/include/linux/cpumask.h	2005-03-02 01:38:00.000000000 -0600
++++ linux-2.6.11-xendiffs/include/linux/cpumask.h	2005-03-24 15:06:18.408145243 -0600
+@@ -341,11 +341,11 @@ static inline int __cpumask_parse(const 
+  *        main(){ set1(3); set2(5); }
+  */
+ 
++#if NR_CPUS > 1
+ extern cpumask_t cpu_possible_map;
+ extern cpumask_t cpu_online_map;
+ extern cpumask_t cpu_present_map;
+ 
+-#if NR_CPUS > 1
+ #define num_online_cpus()	cpus_weight(cpu_online_map)
+ #define num_possible_cpus()	cpus_weight(cpu_possible_map)
+ #define num_present_cpus()	cpus_weight(cpu_present_map)

xen/arch/ia64/patch/linux-2.6.11/current.h

@@ -0,0 +1,22 @@
+ current.h |    8 ++++++++
+ 1 files changed, 8 insertions(+)
+
+Index: linux-2.6.11/include/asm-ia64/current.h
+===================================================================
+--- linux-2.6.11.orig/include/asm-ia64/current.h	2005-03-02 01:38:19.000000000 -0600
++++ linux-2.6.11/include/asm-ia64/current.h	2005-03-19 12:39:41.410955288 -0600
+@@ -12,6 +12,14 @@
+  * In kernel mode, thread pointer (r13) is used to point to the current task
+  * structure.
+  */
++#ifdef XEN
++struct domain;
++#define get_current()	((struct exec_domain *) ia64_getreg(_IA64_REG_TP))
++#define current get_current()
++//#define set_current(d)	ia64_setreg(_IA64_REG_TP,(void *)d);
++#define set_current(d)		(ia64_r13 = (void *)d)
++#else
+ #define current	((struct task_struct *) ia64_getreg(_IA64_REG_TP))
++#endif
+ 
+ #endif /* _ASM_IA64_CURRENT_H */

xen/arch/ia64/patch/linux-2.6.11/efi.c

@@ -0,0 +1,67 @@
+ efi.c |   32 ++++++++++++++++++++++++++++++++
+ 1 files changed, 32 insertions(+)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/efi.c
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/efi.c	2005-04-07 12:22:08.230781400 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/efi.c	2005-04-07 12:25:11.875195997 -0500
+@@ -25,6 +25,9 @@
+ #include <linux/types.h>
+ #include <linux/time.h>
+ #include <linux/efi.h>
++#ifdef XEN
++#include <xen/sched.h>
++#endif
+ 
+ #include <asm/io.h>
+ #include <asm/kregs.h>
+@@ -218,6 +221,7 @@ efi_gettimeofday (struct timespec *ts)
+ 	if ((*efi.get_time)(&tm, NULL) != EFI_SUCCESS)
+ 		return;
+ 
++	dummy();
+ 	ts->tv_sec = mktime(tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
+ 	ts->tv_nsec = tm.nanosecond;
+ }
+@@ -320,6 +324,10 @@ efi_memmap_walk (efi_freemem_callback_t 
+ 		if (!(md->attribute & EFI_MEMORY_WB))
+ 			continue;
+ 
++#ifdef XEN
++// this is a temporary hack to avoid CONFIG_VIRTUAL_MEM_MAP
++		if (md->phys_addr >= 0x100000000) continue;
++#endif
+ 		/*
+ 		 * granule_addr is the base of md's first granule.
+ 		 * [granule_addr - first_non_wb_addr) is guaranteed to
+@@ -719,6 +727,30 @@ efi_get_iobase (void)
+ 	return 0;
+ }
+ 
++#ifdef XEN
++// variation of efi_get_iobase which returns entire memory descriptor
++efi_memory_desc_t *
++efi_get_io_md (void)
++{
++	void *efi_map_start, *efi_map_end, *p;
++	efi_memory_desc_t *md;
++	u64 efi_desc_size;
++
++	efi_map_start = __va(ia64_boot_param->efi_memmap);
++	efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
++	efi_desc_size = ia64_boot_param->efi_memdesc_size;
++
++	for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
++		md = p;
++		if (md->type == EFI_MEMORY_MAPPED_IO_PORT_SPACE) {
++			if (md->attribute & EFI_MEMORY_UC)
++				return md;
++		}
++	}
++	return 0;
++}
++#endif
++
+ u32
+ efi_mem_type (unsigned long phys_addr)
+ {

xen/arch/ia64/patch/linux-2.6.11/entry.S

@@ -0,0 +1,202 @@
+ entry.S |   86 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
+ 1 files changed, 85 insertions(+), 1 deletion(-)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/entry.S
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/entry.S	2005-04-08 13:32:07.636308237 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/entry.S	2005-04-08 13:37:04.612542509 -0500
+@@ -35,7 +35,9 @@
+ 
+ #include <asm/asmmacro.h>
+ #include <asm/cache.h>
++#ifndef XEN
+ #include <asm/errno.h>
++#endif
+ #include <asm/kregs.h>
+ #include <asm/offsets.h>
+ #include <asm/pgtable.h>
+@@ -46,6 +48,25 @@
+ 
+ #include "minstate.h"
+ 
++#ifdef XEN
++#define	sys_execve 0
++#define do_fork 0
++#define	syscall_trace_enter 0
++#define	syscall_trace_leave 0
++#define schedule 0
++#define do_notify_resume_user 0
++#define ia64_rt_sigsuspend 0
++#define ia64_rt_sigreturn 0
++#define	ia64_handle_unaligned 0
++#define	errno 0
++#define	sys_ni_syscall 0
++#define unw_init_frame_info 0
++#define sys_call_table 0
++#define do_sigdelayed 0
++#endif
++
++	/*
++
+ 	/*
+ 	 * execve() is special because in case of success, we need to
+ 	 * setup a null register window frame.
+@@ -187,11 +208,14 @@ GLOBAL_ENTRY(ia64_switch_to)
+ 	DO_SAVE_SWITCH_STACK
+ 	.body
+ 
++#ifdef XEN
++//#undef IA64_TASK_THREAD_KSP_OFFSET
++//#define	IA64_TASK_THREAD_KSP_OFFSET	0x38
+ 	adds r22=IA64_TASK_THREAD_KSP_OFFSET,r13
+ 	movl r25=init_task
+ 	mov r27=IA64_KR(CURRENT_STACK)
+ 	adds r21=IA64_TASK_THREAD_KSP_OFFSET,in0
+-	dep r20=0,in0,61,3		// physical address of "next"
++	dep r20=0,in0,60,4		// physical address of "next"
+ 	;;
+ 	st8 [r22]=sp			// save kernel stack pointer of old task
+ 	shr.u r26=r20,IA64_GRANULE_SHIFT
+@@ -203,6 +227,22 @@ GLOBAL_ENTRY(ia64_switch_to)
+ (p6)	cmp.eq p7,p6=r26,r27
+ (p6)	br.cond.dpnt .map
+ 	;;
++#else
++	adds r22=IA64_TASK_THREAD_KSP_OFFSET,r13
++	mov r27=IA64_KR(CURRENT_STACK)
++	dep r20=0,in0,61,3		// physical address of "current"
++	;;
++	st8 [r22]=sp			// save kernel stack pointer of old task
++	shr.u r26=r20,IA64_GRANULE_SHIFT
++	adds r21=IA64_TASK_THREAD_KSP_OFFSET,in0
++	;;
++	/*
++	 * If we've already mapped this task's page, we can skip doing it again.
++	 */
++	cmp.eq p7,p6=r26,r27
++(p6)	br.cond.dpnt .map
++	;;
++#endif
+ .done:
+ (p6)	ssm psr.ic			// if we had to map, reenable the psr.ic bit FIRST!!!
+ 	;;
+@@ -220,6 +260,16 @@ GLOBAL_ENTRY(ia64_switch_to)
+ 	br.ret.sptk.many rp		// boogie on out in new context
+ 
+ .map:
++#ifdef XEN
++	// avoid overlapping with kernel TR
++	movl r25=KERNEL_START
++	dep  r23=0,in0,0,KERNEL_TR_PAGE_SHIFT
++	;;
++	cmp.eq p7,p0=r25,r23
++	;;
++(p7)	mov IA64_KR(CURRENT_STACK)=r26	// remember last page we mapped...
++(p7)	br.cond.sptk .done
++#endif
+ 	rsm psr.ic			// interrupts (psr.i) are already disabled here
+ 	movl r25=PAGE_KERNEL
+ 	;;
+@@ -376,7 +426,11 @@ END(save_switch_stack)
+  *	- b7 holds address to return to
+  *	- must not touch r8-r11
+  */
++#ifdef XEN
++GLOBAL_ENTRY(load_switch_stack)
++#else
+ ENTRY(load_switch_stack)
++#endif
+ 	.prologue
+ 	.altrp b7
+ 
+@@ -604,6 +658,11 @@ GLOBAL_ENTRY(ia64_ret_from_clone)
+ 	 */
+ 	br.call.sptk.many rp=ia64_invoke_schedule_tail
+ }
++#ifdef XEN
++	// new domains are cloned but not exec'ed so switch to user mode here
++	cmp.ne pKStk,pUStk=r0,r0
++	br.cond.spnt ia64_leave_kernel
++#else
+ .ret8:
+ 	adds r2=TI_FLAGS+IA64_TASK_SIZE,r13
+ 	;;
+@@ -614,6 +673,7 @@ GLOBAL_ENTRY(ia64_ret_from_clone)
+ 	;;
+ 	cmp.ne p6,p0=r2,r0
+ (p6)	br.cond.spnt .strace_check_retval
++#endif
+ 	;;					// added stop bits to prevent r8 dependency
+ END(ia64_ret_from_clone)
+ 	// fall through
+@@ -700,9 +760,14 @@ ENTRY(ia64_leave_syscall)
+ .work_processed_syscall:
+ 	adds r2=PT(LOADRS)+16,r12
+ 	adds r3=PT(AR_BSPSTORE)+16,r12
++#ifdef XEN
++	mov r31=r0
++	;;
++#else
+ 	adds r18=TI_FLAGS+IA64_TASK_SIZE,r13
+ 	;;
+ (p6)	ld4 r31=[r18]				// load current_thread_info()->flags
++#endif
+ 	ld8 r19=[r2],PT(B6)-PT(LOADRS)		// load ar.rsc value for "loadrs"
+ 	mov b7=r0		// clear b7
+ 	;;
+@@ -757,7 +822,11 @@ ENTRY(ia64_leave_syscall)
+ 	;;
+ 	ld8.fill r12=[r2]	// restore r12 (sp)
+ 	ld8.fill r15=[r3]	// restore r15
++#ifdef XEN
++	movl r3=THIS_CPU(ia64_phys_stacked_size_p8)
++#else
+ 	addl r3=THIS_CPU(ia64_phys_stacked_size_p8),r0
++#endif
+ 	;;
+ (pUStk)	ld4 r3=[r3]		// r3 = cpu_data->phys_stacked_size_p8
+ (pUStk) st1 [r14]=r17
+@@ -814,9 +883,18 @@ GLOBAL_ENTRY(ia64_leave_kernel)
+ (pUStk)	cmp.eq.unc p6,p0=r0,r0		// p6 <- pUStk
+ #endif
+ .work_processed_kernel:
++#ifdef XEN
++	alloc loc0=ar.pfs,0,1,1,0
++	adds out0=16,r12
++	;;
++(p6)	br.call.sptk.many b0=deliver_pending_interrupt
++	mov ar.pfs=loc0
++	mov r31=r0
++#else
+ 	adds r17=TI_FLAGS+IA64_TASK_SIZE,r13
+ 	;;
+ (p6)	ld4 r31=[r17]				// load current_thread_info()->flags
++#endif
+ 	adds r21=PT(PR)+16,r12
+ 	;;
+ 
+@@ -934,7 +1012,11 @@ GLOBAL_ENTRY(ia64_leave_kernel)
+ 	shr.u r18=r19,16	// get byte size of existing "dirty" partition
+ 	;;
+ 	mov r16=ar.bsp		// get existing backing store pointer
++#ifdef XEN
++	movl r17=THIS_CPU(ia64_phys_stacked_size_p8)
++#else
+ 	addl r17=THIS_CPU(ia64_phys_stacked_size_p8),r0
++#endif
+ 	;;
+ 	ld4 r17=[r17]		// r17 = cpu_data->phys_stacked_size_p8
+ (pKStk)	br.cond.dpnt skip_rbs_switch
+@@ -1323,6 +1405,7 @@ GLOBAL_ENTRY(unw_init_running)
+ 	br.ret.sptk.many rp
+ END(unw_init_running)
+ 
++#ifndef XEN
+ 	.rodata
+ 	.align 8
+ 	.globl sys_call_table
+@@ -1585,3 +1668,4 @@ sys_call_table:
+ 	data8 sys_ni_syscall
+ 
+ 	.org sys_call_table + 8*NR_syscalls	// guard against failures to increase NR_syscalls
++#endif

xen/arch/ia64/patch/linux-2.6.11/hardirq.h

@@ -0,0 +1,15 @@
+ hardirq.h |    1 +
+ 1 files changed, 1 insertion(+)
+
+Index: linux-2.6.11-xendiffs/include/asm-ia64/hardirq.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/include/asm-ia64/hardirq.h	2005-03-24 15:59:37.210502749 -0600
++++ linux-2.6.11-xendiffs/include/asm-ia64/hardirq.h	2005-03-24 16:00:19.439540961 -0600
+@@ -20,6 +20,7 @@
+ #define __ARCH_IRQ_STAT	1
+ 
+ #define local_softirq_pending()		(local_cpu_data->softirq_pending)
++#define softirq_pending(cpu)			(cpu_data(cpu)->softirq_pending)
+ 
+ #define HARDIRQ_BITS	14
+ 

xen/arch/ia64/patch/linux-2.6.11/head.S

@@ -0,0 +1,85 @@
+ head.S |   34 ++++++++++++++++++++++++++++++++++
+ 1 files changed, 34 insertions(+)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/head.S
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/head.S	2005-04-07 10:56:19.225128582 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/head.S	2005-04-07 11:00:21.718513399 -0500
+@@ -1,3 +1,8 @@
++#ifdef XEN
++#define	console_print	printf
++#define kernel_thread_helper 0
++#define sys_exit 0
++#endif
+ /*
+  * Here is where the ball gets rolling as far as the kernel is concerned.
+  * When control is transferred to _start, the bootload has already
+@@ -187,7 +192,11 @@ start_ap:
+ 	dep r18=0,r3,0,12
+ 	;;
+ 	or r18=r17,r18
++#ifdef XEN
++	dep r2=-1,r3,60,4	// IMVA of task
++#else
+ 	dep r2=-1,r3,61,3	// IMVA of task
++#endif
+ 	;;
+ 	mov r17=rr[r2]
+ 	shr.u r16=r3,IA64_GRANULE_SHIFT
+@@ -227,7 +236,11 @@ start_ap:
+ 	;;
+ 	mov ar.rsc=0x3		// place RSE in eager mode
+ 
++#ifdef XEN
++(isBP)	dep r28=-1,r28,60,4	// make address virtual
++#else
+ (isBP)	dep r28=-1,r28,61,3	// make address virtual
++#endif
+ (isBP)	movl r2=ia64_boot_param
+ 	;;
+ (isBP)	st8 [r2]=r28		// save the address of the boot param area passed by the bootloader
+@@ -245,7 +258,21 @@ start_ap:
+ 	br.call.sptk.many rp=sys_fw_init
+ .ret1:
+ #endif
++#ifdef XEN
++	alloc r2=ar.pfs,8,0,2,0
++	;;
++#define fake_mbi_magic 0
++#define MULTIBOOT_INFO_SIZE	1024
++	.rodata
++fake_mbi:
++	.skip MULTIBOOT_INFO_SIZE
++	.previous
++	movl out0=fake_mbi
++	;;
++	br.call.sptk.many rp=cmain
++#else
+ 	br.call.sptk.many rp=start_kernel
++#endif
+ .ret2:	addl r3=@ltoff(halt_msg),gp
+ 	;;
+ 	alloc r2=ar.pfs,8,0,2,0
+@@ -254,7 +281,9 @@ start_ap:
+ 	br.call.sptk.many b0=console_print
+ 
+ self:	hint @pause
++	;;
+ 	br.sptk.many self		// endless loop
++	;;
+ END(_start)
+ 
+ GLOBAL_ENTRY(ia64_save_debug_regs)
+@@ -850,7 +879,12 @@ END(ia64_delay_loop)
+  * intermediate precision so that we can produce a full 64-bit result.
+  */
+ GLOBAL_ENTRY(sched_clock)
++#ifdef XEN
++	break 0;;	// FIX IA64_CPUINFO_NSEC_PER_CYC_OFFSET
++	//movl r8=THIS_CPU(cpu_info) + IA64_CPUINFO_NSEC_PER_CYC_OFFSET
++#else
+ 	addl r8=THIS_CPU(cpu_info) + IA64_CPUINFO_NSEC_PER_CYC_OFFSET,r0
++#endif
+ 	mov.m r9=ar.itc		// fetch cycle-counter				(35 cyc)
+ 	;;
+ 	ldf8 f8=[r8]

xen/arch/ia64/patch/linux-2.6.11/hpsim_irq.c

@@ -0,0 +1,41 @@
+ hpsim_irq.c |   15 +++++++++++++++
+ 1 files changed, 15 insertions(+)
+
+Index: linux-2.6.11/arch/ia64/hp/sim/hpsim_irq.c
+===================================================================
+--- linux-2.6.11.orig/arch/ia64/hp/sim/hpsim_irq.c	2005-03-02 01:38:33.000000000 -0600
++++ linux-2.6.11/arch/ia64/hp/sim/hpsim_irq.c	2005-03-19 13:33:57.312014806 -0600
+@@ -9,7 +9,17 @@
+ #include <linux/kernel.h>
+ #include <linux/sched.h>
+ #include <linux/irq.h>
++#ifdef XEN
++#include <asm/hw_irq.h>
++#endif
+ 
++#if 1
++void __init
++hpsim_irq_init (void)
++{
++	printf("*** hpsim_irq_init called: NOT NEEDED?!?!?\n");
++}
++#else
+ static unsigned int
+ hpsim_irq_startup (unsigned int irq)
+ {
+@@ -19,6 +29,10 @@ hpsim_irq_startup (unsigned int irq)
+ static void
+ hpsim_irq_noop (unsigned int irq)
+ {
++#if 1
++printf("hpsim_irq_noop: irq=%d\n",irq);
++while(irq);
++#endif
+ }
+ 
+ static void
+@@ -49,3 +63,4 @@ hpsim_irq_init (void)
+ 			idesc->handler = &irq_type_hp_sim;
+ 	}
+ }
++#endif

xen/arch/ia64/patch/linux-2.6.11/hpsim_ssc.h

@@ -0,0 +1,31 @@
+ hpsim_ssc.h |   19 +++++++++++++++++++
+ 1 files changed, 19 insertions(+)
+
+Index: linux-2.6.11/arch/ia64/hp/sim/hpsim_ssc.h
+===================================================================
+--- linux-2.6.11.orig/arch/ia64/hp/sim/hpsim_ssc.h	2005-03-02 01:38:17.000000000 -0600
++++ linux-2.6.11/arch/ia64/hp/sim/hpsim_ssc.h	2005-03-19 13:34:01.705520375 -0600
+@@ -33,4 +33,23 @@
+  */
+ extern long ia64_ssc (long arg0, long arg1, long arg2, long arg3, int nr);
+ 
++#ifdef XEN
++/* Note: These are declared in linux/arch/ia64/hp/sim/simscsi.c but belong
++ * in linux/include/asm-ia64/hpsim_ssc.h, hence their addition here */
++#define SSC_OPEN			50
++#define SSC_CLOSE			51
++#define SSC_READ			52
++#define SSC_WRITE			53
++#define SSC_GET_COMPLETION		54
++#define SSC_WAIT_COMPLETION		55
++
++#define SSC_WRITE_ACCESS		2
++#define SSC_READ_ACCESS			1
++
++struct ssc_disk_req {
++	unsigned long addr;
++	unsigned long len;
++};
++#endif
++
+ #endif /* _IA64_PLATFORM_HPSIM_SSC_H */

xen/arch/ia64/patch/linux-2.6.11/interrupt.h

@@ -0,0 +1,23 @@
+ interrupt.h |    2 ++
+ 1 files changed, 2 insertions(+)
+
+Index: linux-2.6.11/include/linux/interrupt.h
+===================================================================
+--- linux-2.6.11.orig/include/linux/interrupt.h	2005-03-02 01:38:09.000000000 -0600
++++ linux-2.6.11/include/linux/interrupt.h	2005-03-19 13:41:00.739901125 -0600
+@@ -33,6 +33,7 @@ typedef int irqreturn_t;
+ #define IRQ_HANDLED	(1)
+ #define IRQ_RETVAL(x)	((x) != 0)
+ 
++#ifndef XEN
+ struct irqaction {
+ 	irqreturn_t (*handler)(int, void *, struct pt_regs *);
+ 	unsigned long flags;
+@@ -49,6 +50,7 @@ extern int request_irq(unsigned int,
+ 		       irqreturn_t (*handler)(int, void *, struct pt_regs *),
+ 		       unsigned long, const char *, void *);
+ extern void free_irq(unsigned int, void *);
++#endif
+ 
+ 
+ #ifdef CONFIG_GENERIC_HARDIRQS

xen/arch/ia64/patch/linux-2.6.11/io.h

@@ -0,0 +1,19 @@
+ io.h |    4 ++++
+ 1 files changed, 4 insertions(+)
+
+Index: linux-2.6.11/include/asm-ia64/io.h
+===================================================================
+--- linux-2.6.11.orig/include/asm-ia64/io.h	2005-03-02 01:38:34.000000000 -0600
++++ linux-2.6.11/include/asm-ia64/io.h	2005-03-19 13:42:06.541900818 -0600
+@@ -23,7 +23,11 @@
+ #define __SLOW_DOWN_IO	do { } while (0)
+ #define SLOW_DOWN_IO	do { } while (0)
+ 
++#ifdef XEN
++#define __IA64_UNCACHED_OFFSET	0xdffc000000000000UL	/* region 6 */
++#else
+ #define __IA64_UNCACHED_OFFSET	0xc000000000000000UL	/* region 6 */
++#endif
+ 
+ /*
+  * The legacy I/O space defined by the ia64 architecture supports only 65536 ports, but

xen/arch/ia64/patch/linux-2.6.11/irq.h

@@ -0,0 +1,23 @@
+ irq.h |    9 +++++++++
+ 1 files changed, 9 insertions(+)
+
+Index: linux-2.6.11/include/asm-ia64/irq.h
+===================================================================
+--- linux-2.6.11.orig/include/asm-ia64/irq.h	2005-03-02 01:38:33.000000000 -0600
++++ linux-2.6.11/include/asm-ia64/irq.h	2005-03-19 13:42:27.957677364 -0600
+@@ -30,6 +30,15 @@ extern void disable_irq_nosync (unsigned
+ extern void enable_irq (unsigned int);
+ extern void set_irq_affinity_info (unsigned int irq, int dest, int redir);
+ 
++#ifdef XEN
++// dup'ed from signal.h to avoid changes to includes
++#define	SA_NOPROFILE	0x02000000
++#define	SA_SHIRQ	0x04000000
++#define	SA_RESTART	0x10000000
++#define	SA_INTERRUPT	0x20000000
++#define	SA_SAMPLE_RANDOM	SA_RESTART
++#endif
++
+ #ifdef CONFIG_SMP
+ extern void move_irq(int irq);
+ #else

xen/arch/ia64/patch/linux-2.6.11/irq_ia64.c

@@ -0,0 +1,111 @@
+ irq_ia64.c |   67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 files changed, 67 insertions(+)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/irq_ia64.c
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/irq_ia64.c	2005-04-08 13:30:16.777174938 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/irq_ia64.c	2005-04-08 14:15:47.398616472 -0500
+@@ -17,18 +17,26 @@
+ #include <linux/config.h>
+ #include <linux/module.h>
+ 
++#ifndef XEN
+ #include <linux/jiffies.h>
++#endif
+ #include <linux/errno.h>
+ #include <linux/init.h>
+ #include <linux/interrupt.h>
+ #include <linux/ioport.h>
++#ifndef XEN
+ #include <linux/kernel_stat.h>
++#endif
+ #include <linux/slab.h>
++#ifndef XEN
+ #include <linux/ptrace.h>
+ #include <linux/random.h>	/* for rand_initialize_irq() */
+ #include <linux/signal.h>
++#endif
+ #include <linux/smp.h>
++#ifndef XEN
+ #include <linux/smp_lock.h>
++#endif
+ #include <linux/threads.h>
+ #include <linux/bitops.h>
+ 
+@@ -104,6 +112,24 @@ void
+ ia64_handle_irq (ia64_vector vector, struct pt_regs *regs)
+ {
+ 	unsigned long saved_tpr;
++#if 0
++//FIXME: For debug only, can be removed
++	static char firstirq = 1;
++	static char firsttime[256];
++	static char firstpend[256];
++	if (firstirq) {
++		int i;
++		for (i=0;i<256;i++) firsttime[i] = 1;
++		for (i=0;i<256;i++) firstpend[i] = 1;
++		firstirq = 0;
++	}
++	if (firsttime[vector]) {
++		printf("**** (entry) First received int on vector=%d,itc=%lx\n",
++			(unsigned long) vector, ia64_get_itc());
++		firsttime[vector] = 0;
++	}
++#endif
++
+ 
+ #if IRQ_DEBUG
+ 	{
+@@ -148,6 +174,27 @@ ia64_handle_irq (ia64_vector vector, str
+ 			ia64_setreg(_IA64_REG_CR_TPR, vector);
+ 			ia64_srlz_d();
+ 
++#ifdef XEN
++	if (vector != 0xef) {
++		extern void vcpu_pend_interrupt(void *, int);
++#if 0
++		if (firsttime[vector]) {
++			printf("**** (iterate) First received int on vector=%d,itc=%lx\n",
++			(unsigned long) vector, ia64_get_itc());
++			firsttime[vector] = 0;
++		}
++		if (firstpend[vector]) {
++			printf("**** First pended int on vector=%d,itc=%lx\n",
++				(unsigned long) vector,ia64_get_itc());
++			firstpend[vector] = 0;
++		}
++#endif
++		//FIXME: TEMPORARY HACK!!!!
++		vcpu_pend_interrupt(dom0->exec_domain[0],vector);
++		domain_wake(dom0->exec_domain[0]);
++	}
++	else
++#endif
+ 			__do_IRQ(local_vector_to_irq(vector), regs);
+ 
+ 			/*
+@@ -276,3 +323,23 @@ ia64_send_ipi (int cpu, int vector, int 
+ 
+ 	writeq(ipi_data, ipi_addr);
+ }
++
++/* From linux/kernel/softirq.c */
++#ifdef __ARCH_IRQ_EXIT_IRQS_DISABLED
++# define invoke_softirq()	__do_softirq()
++#else
++# define invoke_softirq()	do_softirq()
++#endif
++
++/*
++ * Exit an interrupt context. Process softirqs if needed and possible:
++ */
++void irq_exit(void)
++{
++	account_system_vtime(current);
++	sub_preempt_count(IRQ_EXIT_OFFSET);
++	if (!in_interrupt() && local_softirq_pending())
++		invoke_softirq();
++	preempt_enable_no_resched();
++}
++/* end from linux/kernel/softirq.c */

xen/arch/ia64/patch/linux-2.6.11/ivt.S

@@ -0,0 +1,533 @@
+ ivt.S |  254 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 files changed, 254 insertions(+)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/ivt.S
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/ivt.S	2005-04-07 10:29:00.565766924 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/ivt.S	2005-04-07 10:29:50.923594750 -0500
+@@ -1,3 +1,21 @@
++
++#ifdef XEN
++//#define CONFIG_DISABLE_VHPT	// FIXME: change when VHPT is enabled??
++// these are all hacked out for now as the entire IVT
++// will eventually be replaced... just want to use it
++// for startup code to handle TLB misses
++//#define ia64_leave_kernel 0
++//#define ia64_ret_from_syscall 0
++//#define ia64_handle_irq 0
++//#define ia64_fault 0
++#define ia64_illegal_op_fault 0
++#define ia64_prepare_handle_unaligned 0
++#define ia64_bad_break 0
++#define ia64_trace_syscall 0
++#define sys_call_table 0
++#define sys_ni_syscall 0
++#include <asm/vhpt.h>
++#endif
+ /*
+  * arch/ia64/kernel/ivt.S
+  *
+@@ -77,6 +95,13 @@
+ 	mov r19=n;;			/* prepare to save predicates */		\
+ 	br.sptk.many dispatch_to_fault_handler
+ 
++#ifdef XEN
++#define REFLECT(n)									\
++	mov r31=pr;									\
++	mov r19=n;;			/* prepare to save predicates */		\
++	br.sptk.many dispatch_reflection
++#endif
++
+ 	.section .text.ivt,"ax"
+ 
+ 	.align 32768	// align on 32KB boundary
+@@ -214,6 +239,13 @@ END(vhpt_miss)
+ // 0x0400 Entry 1 (size 64 bundles) ITLB (21)
+ ENTRY(itlb_miss)
+ 	DBG_FAULT(1)
++#ifdef XEN
++	VHPT_CCHAIN_LOOKUP(itlb_miss,i)
++#ifdef VHPT_GLOBAL
++	br.cond.sptk page_fault
++	;;
++#endif
++#endif
+ 	/*
+ 	 * The ITLB handler accesses the L3 PTE via the virtually mapped linear
+ 	 * page table.  If a nested TLB miss occurs, we switch into physical
+@@ -258,6 +290,13 @@ END(itlb_miss)
+ // 0x0800 Entry 2 (size 64 bundles) DTLB (9,48)
+ ENTRY(dtlb_miss)
+ 	DBG_FAULT(2)
++#ifdef XEN
++	VHPT_CCHAIN_LOOKUP(dtlb_miss,d)
++#ifdef VHPT_GLOBAL
++	br.cond.sptk page_fault
++	;;
++#endif
++#endif
+ 	/*
+ 	 * The DTLB handler accesses the L3 PTE via the virtually mapped linear
+ 	 * page table.  If a nested TLB miss occurs, we switch into physical
+@@ -302,6 +341,13 @@ END(dtlb_miss)
+ // 0x0c00 Entry 3 (size 64 bundles) Alt ITLB (19)
+ ENTRY(alt_itlb_miss)
+ 	DBG_FAULT(3)
++#ifdef XEN
++//#ifdef VHPT_GLOBAL
++//	VHPT_CCHAIN_LOOKUP(alt_itlb_miss,i)
++//	br.cond.sptk page_fault
++//	;;
++//#endif
++#endif
+ 	mov r16=cr.ifa		// get address that caused the TLB miss
+ 	movl r17=PAGE_KERNEL
+ 	mov r21=cr.ipsr
+@@ -340,6 +386,13 @@ END(alt_itlb_miss)
+ // 0x1000 Entry 4 (size 64 bundles) Alt DTLB (7,46)
+ ENTRY(alt_dtlb_miss)
+ 	DBG_FAULT(4)
++#ifdef XEN
++//#ifdef VHPT_GLOBAL
++//	VHPT_CCHAIN_LOOKUP(alt_dtlb_miss,d)
++//	br.cond.sptk page_fault
++//	;;
++//#endif
++#endif
+ 	mov r16=cr.ifa		// get address that caused the TLB miss
+ 	movl r17=PAGE_KERNEL
+ 	mov r20=cr.isr
+@@ -369,6 +422,17 @@ ENTRY(alt_dtlb_miss)
+ 	cmp.ne p8,p0=r0,r23
+ (p9)	cmp.eq.or.andcm p6,p7=IA64_ISR_CODE_LFETCH,r22	// check isr.code field
+ (p8)	br.cond.spnt page_fault
++#ifdef XEN
++	;;
++	// FIXME: inadequate test, this is where we test for Xen address
++	// note that 0xf000 (cached) and 0xd000 (uncached) addresses
++	// should be OK.  (Though no I/O is done in Xen, EFI needs uncached
++	// addresses and some domain EFI calls are passed through)
++	tbit.nz p0,p8=r16,60
++(p8)	br.cond.spnt page_fault
++//(p8)	br.cond.spnt 0
++	;;
++#endif
+ 
+ 	dep r21=-1,r21,IA64_PSR_ED_BIT,1
+ 	or r19=r19,r17		// insert PTE control bits into r19
+@@ -449,6 +513,9 @@ END(nested_dtlb_miss)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x1800 Entry 6 (size 64 bundles) Instruction Key Miss (24)
+ ENTRY(ikey_miss)
++#ifdef XEN
++	REFLECT(6)
++#endif
+ 	DBG_FAULT(6)
+ 	FAULT(6)
+ END(ikey_miss)
+@@ -461,9 +528,16 @@ ENTRY(page_fault)
+ 	srlz.i
+ 	;;
+ 	SAVE_MIN_WITH_COVER
++#ifdef XEN
++	alloc r15=ar.pfs,0,0,4,0
++	mov out0=cr.ifa
++	mov out1=cr.isr
++	mov out3=cr.itir
++#else
+ 	alloc r15=ar.pfs,0,0,3,0
+ 	mov out0=cr.ifa
+ 	mov out1=cr.isr
++#endif
+ 	adds r3=8,r2				// set up second base pointer
+ 	;;
+ 	ssm psr.ic | PSR_DEFAULT_BITS
+@@ -484,6 +558,9 @@ END(page_fault)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x1c00 Entry 7 (size 64 bundles) Data Key Miss (12,51)
+ ENTRY(dkey_miss)
++#ifdef XEN
++	REFLECT(7)
++#endif
+ 	DBG_FAULT(7)
+ 	FAULT(7)
+ END(dkey_miss)
+@@ -492,6 +569,9 @@ END(dkey_miss)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x2000 Entry 8 (size 64 bundles) Dirty-bit (54)
+ ENTRY(dirty_bit)
++#ifdef XEN
++	REFLECT(8)
++#endif
+ 	DBG_FAULT(8)
+ 	/*
+ 	 * What we do here is to simply turn on the dirty bit in the PTE.  We need to
+@@ -554,6 +634,9 @@ END(dirty_bit)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x2400 Entry 9 (size 64 bundles) Instruction Access-bit (27)
+ ENTRY(iaccess_bit)
++#ifdef XEN
++	REFLECT(9)
++#endif
+ 	DBG_FAULT(9)
+ 	// Like Entry 8, except for instruction access
+ 	mov r16=cr.ifa				// get the address that caused the fault
+@@ -619,6 +702,9 @@ END(iaccess_bit)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x2800 Entry 10 (size 64 bundles) Data Access-bit (15,55)
+ ENTRY(daccess_bit)
++#ifdef XEN
++	REFLECT(10)
++#endif
+ 	DBG_FAULT(10)
+ 	// Like Entry 8, except for data access
+ 	mov r16=cr.ifa				// get the address that caused the fault
+@@ -687,6 +773,16 @@ ENTRY(break_fault)
+ 	 * to prevent leaking bits from kernel to user level.
+ 	 */
+ 	DBG_FAULT(11)
++#ifdef XEN
++	mov r16=cr.isr
++	mov r17=cr.iim
++	mov r31=pr
++	;;
++	cmp.eq p7,p0=r0,r17			// is this a psuedo-cover?
++	// FIXME: may also need to check slot==2?
++(p7)	br.sptk.many dispatch_privop_fault
++	br.sptk.many dispatch_break_fault
++#endif
+ 	mov r16=IA64_KR(CURRENT)		// r16 = current task; 12 cycle read lat.
+ 	mov r17=cr.iim
+ 	mov r18=__IA64_BREAK_SYSCALL
+@@ -697,7 +793,9 @@ ENTRY(break_fault)
+ 	mov r27=ar.rsc
+ 	mov r26=ar.pfs
+ 	mov r28=cr.iip
++#ifndef XEN
+ 	mov r31=pr				// prepare to save predicates
++#endif
+ 	mov r20=r1
+ 	;;
+ 	adds r16=IA64_TASK_THREAD_ON_USTACK_OFFSET,r16
+@@ -797,6 +895,36 @@ END(interrupt)
+ 	DBG_FAULT(13)
+ 	FAULT(13)
+ 
++#ifdef XEN
++	// There is no particular reason for this code to be here, other than that
++	// there happens to be space here that would go unused otherwise.  If this
++	// fault ever gets "unreserved", simply moved the following code to a more
++	// suitable spot...
++
++ENTRY(dispatch_break_fault)
++	SAVE_MIN_WITH_COVER
++	;;
++	alloc r14=ar.pfs,0,0,4,0 // now it's safe (must be first in insn group!)
++	mov out0=cr.ifa
++	adds out1=16,sp
++	mov out2=cr.isr		// FIXME: pity to make this slow access twice
++	mov out3=cr.iim		// FIXME: pity to make this slow access twice
++
++	ssm psr.ic | PSR_DEFAULT_BITS
++	;;
++	srlz.i					// guarantee that interruption collection is on
++	;;
++(p15)	ssm psr.i				// restore psr.i
++	adds r3=8,r2				// set up second base pointer
++	;;
++	SAVE_REST
++	movl r14=ia64_leave_kernel
++	;;
++	mov rp=r14
++	br.sptk.many ia64_prepare_handle_break
++END(dispatch_break_fault)
++#endif
++
+ 	.org ia64_ivt+0x3800
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x3800 Entry 14 (size 64 bundles) Reserved
+@@ -850,9 +978,11 @@ END(interrupt)
+ 	 *	- ar.fpsr: set to kernel settings
+ 	 */
+ GLOBAL_ENTRY(ia64_syscall_setup)
++#ifndef XEN
+ #if PT(B6) != 0
+ # error This code assumes that b6 is the first field in pt_regs.
+ #endif
++#endif
+ 	st8 [r1]=r19				// save b6
+ 	add r16=PT(CR_IPSR),r1			// initialize first base pointer
+ 	add r17=PT(R11),r1			// initialize second base pointer
+@@ -992,6 +1122,37 @@ END(dispatch_illegal_op_fault)
+ 	DBG_FAULT(16)
+ 	FAULT(16)
+ 
++#ifdef XEN
++	// There is no particular reason for this code to be here, other than that
++	// there happens to be space here that would go unused otherwise.  If this
++	// fault ever gets "unreserved", simply moved the following code to a more
++	// suitable spot...
++
++ENTRY(dispatch_privop_fault)
++	SAVE_MIN_WITH_COVER
++	;;
++	alloc r14=ar.pfs,0,0,4,0		// now it's safe (must be first in insn group!)
++	mov out0=cr.ifa
++	adds out1=16,sp
++	mov out2=cr.isr		// FIXME: pity to make this slow access twice
++	mov out3=cr.itir
++
++	ssm psr.ic | PSR_DEFAULT_BITS
++	;;
++	srlz.i					// guarantee that interruption collection is on
++	;;
++(p15)	ssm psr.i				// restore psr.i
++	adds r3=8,r2				// set up second base pointer
++	;;
++	SAVE_REST
++	movl r14=ia64_leave_kernel
++	;;
++	mov rp=r14
++	br.sptk.many ia64_prepare_handle_privop
++END(dispatch_privop_fault)
++#endif
++
++
+ 	.org ia64_ivt+0x4400
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x4400 Entry 17 (size 64 bundles) Reserved
+@@ -1108,6 +1269,9 @@ END(dispatch_to_fault_handler)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5000 Entry 20 (size 16 bundles) Page Not Present (10,22,49)
+ ENTRY(page_not_present)
++#ifdef XEN
++	REFLECT(20)
++#endif
+ 	DBG_FAULT(20)
+ 	mov r16=cr.ifa
+ 	rsm psr.dt
+@@ -1128,6 +1292,9 @@ END(page_not_present)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5100 Entry 21 (size 16 bundles) Key Permission (13,25,52)
+ ENTRY(key_permission)
++#ifdef XEN
++	REFLECT(21)
++#endif
+ 	DBG_FAULT(21)
+ 	mov r16=cr.ifa
+ 	rsm psr.dt
+@@ -1141,6 +1308,9 @@ END(key_permission)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5200 Entry 22 (size 16 bundles) Instruction Access Rights (26)
+ ENTRY(iaccess_rights)
++#ifdef XEN
++	REFLECT(22)
++#endif
+ 	DBG_FAULT(22)
+ 	mov r16=cr.ifa
+ 	rsm psr.dt
+@@ -1154,6 +1324,9 @@ END(iaccess_rights)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5300 Entry 23 (size 16 bundles) Data Access Rights (14,53)
+ ENTRY(daccess_rights)
++#ifdef XEN
++	REFLECT(23)
++#endif
+ 	DBG_FAULT(23)
+ 	mov r16=cr.ifa
+ 	rsm psr.dt
+@@ -1171,8 +1344,13 @@ ENTRY(general_exception)
+ 	mov r16=cr.isr
+ 	mov r31=pr
+ 	;;
++#ifdef XEN
++	cmp4.ge p6,p0=0x20,r16
++(p6)	br.sptk.many dispatch_privop_fault
++#else
+ 	cmp4.eq p6,p0=0,r16
+ (p6)	br.sptk.many dispatch_illegal_op_fault
++#endif
+ 	;;
+ 	mov r19=24		// fault number
+ 	br.sptk.many dispatch_to_fault_handler
+@@ -1182,6 +1360,9 @@ END(general_exception)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5500 Entry 25 (size 16 bundles) Disabled FP-Register (35)
+ ENTRY(disabled_fp_reg)
++#ifdef XEN
++	REFLECT(25)
++#endif
+ 	DBG_FAULT(25)
+ 	rsm psr.dfh		// ensure we can access fph
+ 	;;
+@@ -1195,6 +1376,9 @@ END(disabled_fp_reg)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5600 Entry 26 (size 16 bundles) Nat Consumption (11,23,37,50)
+ ENTRY(nat_consumption)
++#ifdef XEN
++	REFLECT(26)
++#endif
+ 	DBG_FAULT(26)
+ 	FAULT(26)
+ END(nat_consumption)
+@@ -1203,6 +1387,10 @@ END(nat_consumption)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5700 Entry 27 (size 16 bundles) Speculation (40)
+ ENTRY(speculation_vector)
++#ifdef XEN
++	// this probably need not reflect...
++	REFLECT(27)
++#endif
+ 	DBG_FAULT(27)
+ 	/*
+ 	 * A [f]chk.[as] instruction needs to take the branch to the recovery code but
+@@ -1246,6 +1434,9 @@ END(speculation_vector)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5900 Entry 29 (size 16 bundles) Debug (16,28,56)
+ ENTRY(debug_vector)
++#ifdef XEN
++	REFLECT(29)
++#endif
+ 	DBG_FAULT(29)
+ 	FAULT(29)
+ END(debug_vector)
+@@ -1254,6 +1445,9 @@ END(debug_vector)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5a00 Entry 30 (size 16 bundles) Unaligned Reference (57)
+ ENTRY(unaligned_access)
++#ifdef XEN
++	REFLECT(30)
++#endif
+ 	DBG_FAULT(30)
+ 	mov r16=cr.ipsr
+ 	mov r31=pr		// prepare to save predicates
+@@ -1265,6 +1459,9 @@ END(unaligned_access)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5b00 Entry 31 (size 16 bundles) Unsupported Data Reference (57)
+ ENTRY(unsupported_data_reference)
++#ifdef XEN
++	REFLECT(31)
++#endif
+ 	DBG_FAULT(31)
+ 	FAULT(31)
+ END(unsupported_data_reference)
+@@ -1273,6 +1470,9 @@ END(unsupported_data_reference)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5c00 Entry 32 (size 16 bundles) Floating-Point Fault (64)
+ ENTRY(floating_point_fault)
++#ifdef XEN
++	REFLECT(32)
++#endif
+ 	DBG_FAULT(32)
+ 	FAULT(32)
+ END(floating_point_fault)
+@@ -1281,6 +1481,9 @@ END(floating_point_fault)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5d00 Entry 33 (size 16 bundles) Floating Point Trap (66)
+ ENTRY(floating_point_trap)
++#ifdef XEN
++	REFLECT(33)
++#endif
+ 	DBG_FAULT(33)
+ 	FAULT(33)
+ END(floating_point_trap)
+@@ -1289,6 +1492,9 @@ END(floating_point_trap)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5e00 Entry 34 (size 16 bundles) Lower Privilege Transfer Trap (66)
+ ENTRY(lower_privilege_trap)
++#ifdef XEN
++	REFLECT(34)
++#endif
+ 	DBG_FAULT(34)
+ 	FAULT(34)
+ END(lower_privilege_trap)
+@@ -1297,6 +1503,9 @@ END(lower_privilege_trap)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x5f00 Entry 35 (size 16 bundles) Taken Branch Trap (68)
+ ENTRY(taken_branch_trap)
++#ifdef XEN
++	REFLECT(35)
++#endif
+ 	DBG_FAULT(35)
+ 	FAULT(35)
+ END(taken_branch_trap)
+@@ -1305,6 +1514,9 @@ END(taken_branch_trap)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x6000 Entry 36 (size 16 bundles) Single Step Trap (69)
+ ENTRY(single_step_trap)
++#ifdef XEN
++	REFLECT(36)
++#endif
+ 	DBG_FAULT(36)
+ 	FAULT(36)
+ END(single_step_trap)
+@@ -1361,6 +1573,9 @@ END(single_step_trap)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x6900 Entry 45 (size 16 bundles) IA-32 Exeception (17,18,29,41,42,43,44,58,60,61,62,72,73,75,76,77)
+ ENTRY(ia32_exception)
++#ifdef XEN
++	REFLECT(45)
++#endif
+ 	DBG_FAULT(45)
+ 	FAULT(45)
+ END(ia32_exception)
+@@ -1369,6 +1584,9 @@ END(ia32_exception)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x6a00 Entry 46 (size 16 bundles) IA-32 Intercept  (30,31,59,70,71)
+ ENTRY(ia32_intercept)
++#ifdef XEN
++	REFLECT(46)
++#endif
+ 	DBG_FAULT(46)
+ #ifdef	CONFIG_IA32_SUPPORT
+ 	mov r31=pr
+@@ -1399,6 +1617,9 @@ END(ia32_intercept)
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // 0x6b00 Entry 47 (size 16 bundles) IA-32 Interrupt  (74)
+ ENTRY(ia32_interrupt)
++#ifdef XEN
++	REFLECT(47)
++#endif
+ 	DBG_FAULT(47)
+ #ifdef CONFIG_IA32_SUPPORT
+ 	mov r31=pr
+@@ -1528,6 +1749,39 @@ END(ia32_interrupt)
+ 	DBG_FAULT(67)
+ 	FAULT(67)
+ 
++#ifdef XEN
++	.org ia64_ivt+0x8000
++ENTRY(dispatch_reflection)
++	/*
++	 * Input:
++	 *	psr.ic:	off
++	 *	r19:	intr type (offset into ivt, see ia64_int.h)
++	 *	r31:	contains saved predicates (pr)
++	 */
++	SAVE_MIN_WITH_COVER_R19
++	alloc r14=ar.pfs,0,0,5,0
++	mov out4=r15
++	mov out0=cr.ifa
++	adds out1=16,sp
++	mov out2=cr.isr
++	mov out3=cr.iim
++//	mov out3=cr.itir
++
++	ssm psr.ic | PSR_DEFAULT_BITS
++	;;
++	srlz.i					// guarantee that interruption collection is on
++	;;
++(p15)	ssm psr.i				// restore psr.i
++	adds r3=8,r2				// set up second base pointer
++	;;
++	SAVE_REST
++	movl r14=ia64_leave_kernel
++	;;
++	mov rp=r14
++	br.sptk.many ia64_prepare_handle_reflection
++END(dispatch_reflection)
++#endif
++
+ #ifdef CONFIG_IA32_SUPPORT
+ 
+ 	/*

xen/arch/ia64/patch/linux-2.6.11/kernel-time.c

@@ -0,0 +1,44 @@
+ time.c |    7 ++++++-
+ 1 files changed, 6 insertions(+), 1 deletion(-)
+
+Index: linux-2.6.11/kernel/time.c
+===================================================================
+--- linux-2.6.11.orig/kernel/time.c	2005-03-02 01:37:50.000000000 -0600
++++ linux-2.6.11/kernel/time.c	2005-03-19 14:56:40.767870674 -0600
+@@ -495,6 +495,7 @@ void getnstimeofday (struct timespec *tv
+ 	tv->tv_nsec = nsec;
+ }
+ 
++#ifndef XEN
+ int do_settimeofday (struct timespec *tv)
+ {
+ 	time_t wtm_sec, sec = tv->tv_sec;
+@@ -503,7 +504,9 @@ int do_settimeofday (struct timespec *tv
+ 	if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
+ 		return -EINVAL;
+ 
++#ifdef TURN_ME_OFF_FOR_NOW_IA64_XEN
+ 	write_seqlock_irq(&xtime_lock);
++#endif
+ 	{
+ 		/*
+ 		 * This is revolting. We need to set "xtime" correctly. However, the value
+@@ -525,7 +528,9 @@ int do_settimeofday (struct timespec *tv
+ 		time_esterror = NTP_PHASE_LIMIT;
+ 		time_interpolator_reset();
+ 	}
++#ifdef TURN_ME_OFF_FOR_NOW_IA64_XEN
+ 	write_sequnlock_irq(&xtime_lock);
++#endif
+ 	clock_was_set();
+ 	return 0;
+ }
+@@ -552,7 +557,7 @@ void do_gettimeofday (struct timeval *tv
+ }
+ 
+ EXPORT_SYMBOL(do_gettimeofday);
+-
++#endif
+ 
+ #else
+ /*

xen/arch/ia64/patch/linux-2.6.11/kregs.h

@@ -0,0 +1,18 @@
+ kregs.h |    4 ++++
+ 1 files changed, 4 insertions(+)
+
+Index: linux-2.6.11/include/asm-ia64/kregs.h
+===================================================================
+--- linux-2.6.11.orig/include/asm-ia64/kregs.h	2005-03-02 01:37:49.000000000 -0600
++++ linux-2.6.11/include/asm-ia64/kregs.h	2005-03-19 13:44:24.362628092 -0600
+@@ -31,6 +31,10 @@
+ #define IA64_TR_PALCODE		1	/* itr1: maps PALcode as required by EFI */
+ #define IA64_TR_PERCPU_DATA	1	/* dtr1: percpu data */
+ #define IA64_TR_CURRENT_STACK	2	/* dtr2: maps kernel's memory- & register-stacks */
++#ifdef XEN
++#define IA64_TR_SHARED_INFO	3	/* dtr3: page shared with domain */
++#define	IA64_TR_VHPT		4	/* dtr4: vhpt */
++#endif
+ 
+ /* Processor status register bits: */
+ #define IA64_PSR_BE_BIT		1

xen/arch/ia64/patch/linux-2.6.11/lds.S

@@ -0,0 +1,22 @@
+ vmlinux.lds.S |    2 ++
+ 1 files changed, 2 insertions(+)
+
+Index: linux-2.6.11/arch/ia64/kernel/vmlinux.lds.S
+===================================================================
+--- linux-2.6.11.orig/arch/ia64/kernel/vmlinux.lds.S	2005-03-02 01:38:25.000000000 -0600
++++ linux-2.6.11/arch/ia64/kernel/vmlinux.lds.S	2005-03-19 13:44:28.746368232 -0600
+@@ -11,12 +11,14 @@
+ OUTPUT_FORMAT("elf64-ia64-little")
+ OUTPUT_ARCH(ia64)
+ ENTRY(phys_start)
++#ifndef XEN
+ jiffies = jiffies_64;
+ PHDRS {
+   code   PT_LOAD;
+   percpu PT_LOAD;
+   data   PT_LOAD;
+ }
++#endif
+ SECTIONS
+ {
+   /* Sections to be discarded */

xen/arch/ia64/patch/linux-2.6.11/linuxextable.c

@@ -0,0 +1,16 @@
+ extable.c |    2 ++
+ 1 files changed, 2 insertions(+)
+
+Index: linux-2.6.11-xendiffs/kernel/extable.c
+===================================================================
+--- linux-2.6.11-xendiffs.orig/kernel/extable.c	2005-03-02 01:37:54.000000000 -0600
++++ linux-2.6.11-xendiffs/kernel/extable.c	2005-04-08 14:30:46.283360881 -0500
+@@ -20,6 +20,8 @@
+ #include <asm/uaccess.h>
+ #include <asm/sections.h>
+ 
++#define __module_text_address(addr)	(NULL)
++
+ extern struct exception_table_entry __start___ex_table[];
+ extern struct exception_table_entry __stop___ex_table[];
+ 

xen/arch/ia64/patch/linux-2.6.11/linuxhardirq.h

@@ -0,0 +1,29 @@
+ hardirq.h |    6 ++++++
+ 1 files changed, 6 insertions(+)
+
+Index: linux-2.6.11-xendiffs/include/linux/hardirq.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/include/linux/hardirq.h	2005-03-02 01:38:00.000000000 -0600
++++ linux-2.6.11-xendiffs/include/linux/hardirq.h	2005-03-25 08:49:57.301998663 -0600
+@@ -2,7 +2,9 @@
+ #define LINUX_HARDIRQ_H
+ 
+ #include <linux/config.h>
++#ifndef XEN
+ #include <linux/smp_lock.h>
++#endif
+ #include <asm/hardirq.h>
+ #include <asm/system.h>
+ 
+@@ -60,7 +62,11 @@
+  */
+ #define in_irq()		(hardirq_count())
+ #define in_softirq()		(softirq_count())
++#ifndef XEN
+ #define in_interrupt()		(irq_count())
++#else
++#define in_interrupt()		0		// FIXME LATER
++#endif
+ 
+ #if defined(CONFIG_PREEMPT) && !defined(CONFIG_PREEMPT_BKL)
+ # define in_atomic()	((preempt_count() & ~PREEMPT_ACTIVE) != kernel_locked())

xen/arch/ia64/patch/linux-2.6.11/linuxtime.h

@@ -0,0 +1,36 @@
+ time.h |    9 +++++++++
+ 1 files changed, 9 insertions(+)
+
+Index: linux-2.6.11/include/linux/time.h
+===================================================================
+--- linux-2.6.11.orig/include/linux/time.h	2005-03-02 01:38:12.000000000 -0600
++++ linux-2.6.11/include/linux/time.h	2005-03-19 13:46:27.987225234 -0600
+@@ -1,11 +1,18 @@
+ #ifndef _LINUX_TIME_H
+ #define _LINUX_TIME_H
+ 
++#ifdef XEN
++typedef	s64 time_t;
++typedef	s64 suseconds_t;
++#endif
++
+ #include <linux/types.h>
+ 
++#ifndef XEN
+ #ifdef __KERNEL__
+ #include <linux/seqlock.h>
+ #endif
++#endif
+ 
+ #ifndef _STRUCT_TIMESPEC
+ #define _STRUCT_TIMESPEC
+@@ -80,7 +87,9 @@ mktime (unsigned int year, unsigned int 
+ 
+ extern struct timespec xtime;
+ extern struct timespec wall_to_monotonic;
++#ifndef XEN
+ extern seqlock_t xtime_lock;
++#endif
+ 
+ static inline unsigned long get_seconds(void)
+ { 

xen/arch/ia64/patch/linux-2.6.11/mca_asm.h

@@ -0,0 +1,37 @@
+ mca_asm.h |   11 +++++++++++
+ 1 files changed, 11 insertions(+)
+
+Index: linux-2.6.11-xendiffs/include/asm-ia64/mca_asm.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/include/asm-ia64/mca_asm.h	2005-03-02 01:38:38.000000000 -0600
++++ linux-2.6.11-xendiffs/include/asm-ia64/mca_asm.h	2005-04-06 22:41:57.392411032 -0500
+@@ -26,8 +26,13 @@
+  * direct mapped to physical addresses.
+  *	1. Lop off bits 61 thru 63 in the virtual address
+  */
++#ifdef XEN
++#define INST_VA_TO_PA(addr)							\
++	dep	addr	= 0, addr, 60, 4
++#else // XEN
+ #define INST_VA_TO_PA(addr)							\
+ 	dep	addr	= 0, addr, 61, 3
++#endif // XEN
+ /*
+  * This macro converts a data virtual address to a physical address
+  * Right now for simulation purposes the virtual addresses are
+@@ -42,9 +47,15 @@
+  * direct mapped to physical addresses.
+  *	1. Put 0x7 in bits 61 thru 63.
+  */
++#ifdef XEN
++#define DATA_PA_TO_VA(addr,temp)							\
++	mov	temp	= 0xf	;;							\
++	dep	addr	= temp, addr, 60, 4
++#else // XEN
+ #define DATA_PA_TO_VA(addr,temp)							\
+ 	mov	temp	= 0x7	;;							\
+ 	dep	addr	= temp, addr, 61, 3
++#endif // XEN
+ 
+ #define GET_THIS_PADDR(reg, var)		\
+ 	mov	reg = IA64_KR(PER_CPU_DATA);;	\

xen/arch/ia64/patch/linux-2.6.11/minstate.h

@@ -0,0 +1,25 @@
+ minstate.h |    4 ++--
+ 1 files changed, 2 insertions(+), 2 deletions(-)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/minstate.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/minstate.h	2005-04-06 22:51:31.170261541 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/minstate.h	2005-04-06 22:54:03.210575034 -0500
+@@ -48,7 +48,7 @@
+ (pUStk)	mov r24=ar.rnat;									\
+ (pUStk)	addl r1=IA64_STK_OFFSET-IA64_PT_REGS_SIZE,r1;	/* compute base of memory stack */	\
+ (pUStk)	mov r23=ar.bspstore;				/* save ar.bspstore */			\
+-(pUStk)	dep r22=-1,r22,61,3;			/* compute kernel virtual addr of RBS */	\
++(pUStk)	dep r22=-1,r22,60,4;			/* compute kernel virtual addr of RBS */	\
+ 	;;											\
+ (pKStk) addl r1=-IA64_PT_REGS_SIZE,r1;		/* if in kernel mode, use sp (r12) */		\
+ (pUStk)	mov ar.bspstore=r22;			/* switch to kernel RBS */			\
+@@ -57,7 +57,7 @@
+ (pUStk)	mov ar.rsc=0x3;		/* set eager mode, pl 0, little-endian, loadrs=0 */		\
+ 
+ #define MINSTATE_END_SAVE_MIN_PHYS								\
+-	dep r12=-1,r12,61,3;		/* make sp a kernel virtual address */			\
++	dep r12=-1,r12,60,4;		/* make sp a kernel virtual address */			\
+ 	;;
+ 
+ #ifdef MINSTATE_VIRT

xen/arch/ia64/patch/linux-2.6.11/mm_contig.c

@@ -0,0 +1,220 @@
+ contig.c |  172 +++++++++++++++++----------------------------------------------
+ 1 files changed, 48 insertions(+), 124 deletions(-)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/mm/contig.c
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/mm/contig.c	2005-04-07 11:02:50.227598140 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/mm/contig.c	2005-04-07 11:05:21.724931959 -0500
+@@ -15,11 +15,21 @@
+  * memory.
+  */
+ #include <linux/config.h>
++#ifdef XEN
++#include <xen/sched.h>
++#endif
+ #include <linux/bootmem.h>
+ #include <linux/efi.h>
+ #include <linux/mm.h>
+ #include <linux/swap.h>
+ 
++#ifdef XEN
++#undef reserve_bootmem
++extern struct page *zero_page_memmap_ptr;
++struct page *mem_map;
++#define MAX_DMA_ADDRESS ~0UL	// FIXME???
++#endif
++
+ #include <asm/meminit.h>
+ #include <asm/pgalloc.h>
+ #include <asm/pgtable.h>
+@@ -38,30 +48,7 @@ static unsigned long num_dma_physpages;
+ void
+ show_mem (void)
+ {
+-	int i, total = 0, reserved = 0;
+-	int shared = 0, cached = 0;
+-
+-	printk("Mem-info:\n");
+-	show_free_areas();
+-
+-	printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
+-	i = max_mapnr;
+-	while (i-- > 0) {
+-		if (!pfn_valid(i))
+-			continue;
+-		total++;
+-		if (PageReserved(mem_map+i))
+-			reserved++;
+-		else if (PageSwapCache(mem_map+i))
+-			cached++;
+-		else if (page_count(mem_map + i))
+-			shared += page_count(mem_map + i) - 1;
+-	}
+-	printk("%d pages of RAM\n", total);
+-	printk("%d reserved pages\n", reserved);
+-	printk("%d pages shared\n", shared);
+-	printk("%d pages swap cached\n", cached);
+-	printk("%ld pages in page table cache\n", pgtable_cache_size);
++	printk("Dummy show_mem\n");
+ }
+ 
+ /* physical address where the bootmem map is located */
+@@ -81,6 +68,9 @@ find_max_pfn (unsigned long start, unsig
+ {
+ 	unsigned long *max_pfnp = arg, pfn;
+ 
++#ifdef XEN
++//printf("find_max_pfn: start=%lx, end=%lx, *arg=%lx\n",start,end,*(unsigned long *)arg);
++#endif
+ 	pfn = (PAGE_ALIGN(end - 1) - PAGE_OFFSET) >> PAGE_SHIFT;
+ 	if (pfn > *max_pfnp)
+ 		*max_pfnp = pfn;
+@@ -134,41 +124,6 @@ find_bootmap_location (unsigned long sta
+ 	return 0;
+ }
+ 
+-/**
+- * find_memory - setup memory map
+- *
+- * Walk the EFI memory map and find usable memory for the system, taking
+- * into account reserved areas.
+- */
+-void
+-find_memory (void)
+-{
+-	unsigned long bootmap_size;
+-
+-	reserve_memory();
+-
+-	/* first find highest page frame number */
+-	max_pfn = 0;
+-	efi_memmap_walk(find_max_pfn, &max_pfn);
+-
+-	/* how many bytes to cover all the pages */
+-	bootmap_size = bootmem_bootmap_pages(max_pfn) << PAGE_SHIFT;
+-
+-	/* look for a location to hold the bootmap */
+-	bootmap_start = ~0UL;
+-	efi_memmap_walk(find_bootmap_location, &bootmap_size);
+-	if (bootmap_start == ~0UL)
+-		panic("Cannot find %ld bytes for bootmap\n", bootmap_size);
+-
+-	bootmap_size = init_bootmem(bootmap_start >> PAGE_SHIFT, max_pfn);
+-
+-	/* Free all available memory, then mark bootmem-map as being in use. */
+-	efi_memmap_walk(filter_rsvd_memory, free_bootmem);
+-	reserve_bootmem(bootmap_start, bootmap_size);
+-
+-	find_initrd();
+-}
+-
+ #ifdef CONFIG_SMP
+ /**
+  * per_cpu_init - setup per-cpu variables
+@@ -228,72 +183,41 @@ count_dma_pages (u64 start, u64 end, voi
+ void
+ paging_init (void)
+ {
+-	unsigned long max_dma;
+-	unsigned long zones_size[MAX_NR_ZONES];
+-#ifdef CONFIG_VIRTUAL_MEM_MAP
+-	unsigned long zholes_size[MAX_NR_ZONES];
+-	unsigned long max_gap;
+-#endif
+-
+-	/* initialize mem_map[] */
+-
+-	memset(zones_size, 0, sizeof(zones_size));
+-
+-	num_physpages = 0;
+-	efi_memmap_walk(count_pages, &num_physpages);
+-
+-	max_dma = virt_to_phys((void *) MAX_DMA_ADDRESS) >> PAGE_SHIFT;
+-
+-#ifdef CONFIG_VIRTUAL_MEM_MAP
+-	memset(zholes_size, 0, sizeof(zholes_size));
++	struct pfn_info *pg;
++	/* Allocate and map the machine-to-phys table */
++	if ((pg = alloc_domheap_pages(NULL, 10)) == NULL)
++		panic("Not enough memory to bootstrap Xen.\n");
++	memset(page_to_virt(pg), 0x55, 16UL << 20);
+ 
+-	num_dma_physpages = 0;
+-	efi_memmap_walk(count_dma_pages, &num_dma_physpages);
++	/* Other mapping setup */
+ 
+-	if (max_low_pfn < max_dma) {
+-		zones_size[ZONE_DMA] = max_low_pfn;
+-		zholes_size[ZONE_DMA] = max_low_pfn - num_dma_physpages;
+-	} else {
+-		zones_size[ZONE_DMA] = max_dma;
+-		zholes_size[ZONE_DMA] = max_dma - num_dma_physpages;
+-		if (num_physpages > num_dma_physpages) {
+-			zones_size[ZONE_NORMAL] = max_low_pfn - max_dma;
+-			zholes_size[ZONE_NORMAL] =
+-				((max_low_pfn - max_dma) -
+-				 (num_physpages - num_dma_physpages));
+-		}
+-	}
+-
+-	max_gap = 0;
+-	efi_memmap_walk(find_largest_hole, (u64 *)&max_gap);
+-	if (max_gap < LARGE_GAP) {
+-		vmem_map = (struct page *) 0;
+-		free_area_init_node(0, &contig_page_data, zones_size, 0,
+-				    zholes_size);
+-	} else {
+-		unsigned long map_size;
+-
+-		/* allocate virtual_mem_map */
+-
+-		map_size = PAGE_ALIGN(max_low_pfn * sizeof(struct page));
+-		vmalloc_end -= map_size;
+-		vmem_map = (struct page *) vmalloc_end;
+-		efi_memmap_walk(create_mem_map_page_table, NULL);
+-
+-		mem_map = contig_page_data.node_mem_map = vmem_map;
+-		free_area_init_node(0, &contig_page_data, zones_size,
+-				    0, zholes_size);
+-
+-		printk("Virtual mem_map starts at 0x%p\n", mem_map);
+-	}
+-#else /* !CONFIG_VIRTUAL_MEM_MAP */
+-	if (max_low_pfn < max_dma)
+-		zones_size[ZONE_DMA] = max_low_pfn;
+-	else {
+-		zones_size[ZONE_DMA] = max_dma;
+-		zones_size[ZONE_NORMAL] = max_low_pfn - max_dma;
+-	}
+-	free_area_init(zones_size);
+-#endif /* !CONFIG_VIRTUAL_MEM_MAP */
+ 	zero_page_memmap_ptr = virt_to_page(ia64_imva(empty_zero_page));
+ }
++
++struct pfn_info *frame_table;
++unsigned long frame_table_size;
++unsigned long max_page;
++
++/* FIXME: postpone support to machines with big holes between physical memorys.
++ * Current hack allows only efi memdesc upto 4G place. (See efi.c)
++ */
++#ifndef CONFIG_VIRTUAL_MEM_MAP
++#define FT_ALIGN_SIZE	(16UL << 20)
++void __init init_frametable(void)
++{
++	unsigned long i, p;
++	frame_table_size = max_page * sizeof(struct pfn_info);
++	frame_table_size = (frame_table_size + PAGE_SIZE - 1) & PAGE_MASK;
++
++	/* Request continuous trunk from boot allocator, since HV
++	 * address is identity mapped */
++	p = alloc_boot_pages(frame_table_size, FT_ALIGN_SIZE);
++	if (p == 0)
++		panic("Not enough memory for frame table.\n");
++
++	frame_table = __va(p);
++	memset(frame_table, 0, frame_table_size);
++	printk("size of frame_table: %lukB\n",
++		frame_table_size >> 10);
++}
++#endif

xen/arch/ia64/patch/linux-2.6.11/mmzone.h

@@ -0,0 +1,19 @@
+ mmzone.h |    4 ++++
+ 1 files changed, 4 insertions(+)
+
+Index: linux-2.6.11/include/linux/mmzone.h
+===================================================================
+--- linux-2.6.11.orig/include/linux/mmzone.h	2005-03-02 01:38:10.000000000 -0600
++++ linux-2.6.11/include/linux/mmzone.h	2005-03-19 13:49:30.427573139 -0600
+@@ -209,7 +209,11 @@ struct zone {
+ 	 * rarely used fields:
+ 	 */
+ 	char			*name;
++#ifdef XEN
++};
++#else
+ } ____cacheline_maxaligned_in_smp;
++#endif
+ 
+ 
+ /*

xen/arch/ia64/patch/linux-2.6.11/page.h

@@ -0,0 +1,94 @@
+ page.h |   42 +++++++++++++++++++++++++++++++++++++++---
+ 1 files changed, 39 insertions(+), 3 deletions(-)
+
+Index: linux-2.6.11-xendiffs/include/asm-ia64/page.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/include/asm-ia64/page.h	2005-04-06 22:58:07.597539393 -0500
++++ linux-2.6.11-xendiffs/include/asm-ia64/page.h	2005-04-06 23:06:15.908576975 -0500
+@@ -12,6 +12,9 @@
+ #include <asm/intrinsics.h>
+ #include <asm/types.h>
+ 
++#ifndef __ASSEMBLY__
++#include <asm/flushtlb.h>
++#endif
+ /*
+  * PAGE_SHIFT determines the actual kernel page size.
+  */
+@@ -95,9 +98,11 @@ extern int ia64_pfn_valid (unsigned long
+ #endif
+ 
+ #ifndef CONFIG_DISCONTIGMEM
++#ifdef XEN
++#define pfn_valid(pfn)		(0)
++#else
+ # define pfn_valid(pfn)		(((pfn) < max_mapnr) && ia64_pfn_valid(pfn))
+-# define page_to_pfn(page)	((unsigned long) (page - mem_map))
+-# define pfn_to_page(pfn)	(mem_map + (pfn))
++#endif
+ #else
+ extern struct page *vmem_map;
+ extern unsigned long max_low_pfn;
+@@ -106,9 +111,15 @@ extern unsigned long max_low_pfn;
+ # define pfn_to_page(pfn)	(vmem_map + (pfn))
+ #endif
+ 
+-#define page_to_phys(page)	(page_to_pfn(page) << PAGE_SHIFT)
++#define page_to_pfn(_page)	((unsigned long)((_page) - frame_table))
++#define page_to_virt(_page)	phys_to_virt(page_to_phys(_page))
++
++#define page_to_phys(_page)	(page_to_pfn(_page) << PAGE_SHIFT)
+ #define virt_to_page(kaddr)	pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
+ 
++#define pfn_to_page(_pfn)	(frame_table + (_pfn))
++#define phys_to_page(kaddr)	pfn_to_page(((kaddr) >> PAGE_SHIFT))
++
+ typedef union ia64_va {
+ 	struct {
+ 		unsigned long off : 61;		/* intra-region offset */
+@@ -124,8 +135,25 @@ typedef union ia64_va {
+  * expressed in this way to ensure they result in a single "dep"
+  * instruction.
+  */
++#ifdef XEN
++typedef union xen_va {
++	struct {
++		unsigned long off : 60;
++		unsigned long reg : 4;
++	} f;
++	unsigned long l;
++	void *p;
++} xen_va;
++
++// xen/drivers/console.c uses __va in a declaration (should be fixed!)
++#define __pa(x)		({xen_va _v; _v.l = (long) (x); _v.f.reg = 0; _v.l;})
++#define __va(x)		({xen_va _v; _v.l = (long) (x); _v.f.reg = -1; _v.p;})
++//# define __pa(x)	((unsigned long)(((unsigned long)x) - PAGE_OFFSET))
++//# define __va(x)	((void *)((char *)(x) + PAGE_OFFSET))
++#else
+ #define __pa(x)		({ia64_va _v; _v.l = (long) (x); _v.f.reg = 0; _v.l;})
+ #define __va(x)		({ia64_va _v; _v.l = (long) (x); _v.f.reg = -1; _v.p;})
++#endif
+ 
+ #define REGION_NUMBER(x)	({ia64_va _v; _v.l = (long) (x); _v.f.reg;})
+ #define REGION_OFFSET(x)	({ia64_va _v; _v.l = (long) (x); _v.f.off;})
+@@ -197,11 +225,19 @@ get_order (unsigned long size)
+ # define __pgprot(x)	(x)
+ #endif /* !STRICT_MM_TYPECHECKS */
+ 
++#ifdef XEN
++#define PAGE_OFFSET			__IA64_UL_CONST(0xf000000000000000)
++#else
+ #define PAGE_OFFSET			__IA64_UL_CONST(0xe000000000000000)
++#endif
+ 
+ #define VM_DATA_DEFAULT_FLAGS		(VM_READ | VM_WRITE |					\
+ 					 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC |		\
+ 					 (((current->personality & READ_IMPLIES_EXEC) != 0)	\
+ 					  ? VM_EXEC : 0))
+ 
++#ifdef XEN
++#define __flush_tlb() do {} while(0);
++#endif
++
+ #endif /* _ASM_IA64_PAGE_H */

xen/arch/ia64/patch/linux-2.6.11/pal.S

@@ -0,0 +1,31 @@
+ pal.S |    8 ++++++++
+ 1 files changed, 8 insertions(+)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/pal.S
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/pal.S	2005-03-02 01:38:33.000000000 -0600
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/pal.S	2005-04-06 22:43:53.817885390 -0500
+@@ -166,7 +166,11 @@ GLOBAL_ENTRY(ia64_pal_call_phys_static)
+ 	adds r8  = 1f-1b,r8		// calculate return address for call
+ 	;;
+ 	mov loc4=ar.rsc			// save RSE configuration
++#ifdef XEN
++	dep.z loc2=loc2,0,60		// convert pal entry point to physical
++#else // XEN
+ 	dep.z loc2=loc2,0,61		// convert pal entry point to physical
++#endif // XEN
+ 	tpa r8=r8			// convert rp to physical
+ 	;;
+ 	mov b7 = loc2			// install target to branch reg
+@@ -225,7 +229,11 @@ GLOBAL_ENTRY(ia64_pal_call_phys_stacked)
+ 	mov loc3 = psr		// save psr
+ 	;;
+ 	mov loc4=ar.rsc			// save RSE configuration
++#ifdef XEN
++	dep.z loc2=loc2,0,60		// convert pal entry point to physical
++#else // XEN
+ 	dep.z loc2=loc2,0,61		// convert pal entry point to physical
++#endif // XEN
+ 	;;
+ 	mov ar.rsc=0			// put RSE in enforced lazy, LE mode
+ 	movl r16=PAL_PSR_BITS_TO_CLEAR

xen/arch/ia64/patch/linux-2.6.11/pgalloc.h

@@ -0,0 +1,78 @@
+ pgalloc.h |   17 +++++++++++------
+ 1 files changed, 11 insertions(+), 6 deletions(-)
+
+Index: linux-2.6.11-xendiffs/include/asm-ia64/pgalloc.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/include/asm-ia64/pgalloc.h	2005-04-08 11:57:30.909774800 -0500
++++ linux-2.6.11-xendiffs/include/asm-ia64/pgalloc.h	2005-04-08 11:58:08.102711219 -0500
+@@ -18,6 +18,7 @@
+ #include <linux/compiler.h>
+ #include <linux/mm.h>
+ #include <linux/page-flags.h>
++#include <linux/preempt.h>
+ #include <linux/threads.h>
+ 
+ #include <asm/mmu_context.h>
+@@ -34,6 +35,10 @@
+ #define pmd_quicklist		(local_cpu_data->pmd_quick)
+ #define pgtable_cache_size	(local_cpu_data->pgtable_cache_sz)
+ 
++/* FIXME: Later 3 level page table should be over, to create 
++ * new interface upon xen memory allocator. To simplify first
++ * effort moving to xen allocator, use xenheap pages temporarily. 
++ */
+ static inline pgd_t*
+ pgd_alloc_one_fast (struct mm_struct *mm)
+ {
+@@ -61,7 +66,7 @@ pgd_alloc (struct mm_struct *mm)
+ 	pgd_t *pgd = pgd_alloc_one_fast(mm);
+ 
+ 	if (unlikely(pgd == NULL)) {
+-		pgd = (pgd_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
++		pgd = (pgd_t *)alloc_xenheap_page();
+ 	}
+ 	return pgd;
+ }
+@@ -104,7 +109,7 @@ pmd_alloc_one_fast (struct mm_struct *mm
+ static inline pmd_t*
+ pmd_alloc_one (struct mm_struct *mm, unsigned long addr)
+ {
+-	pmd_t *pmd = (pmd_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
++	pmd_t *pmd = (pmd_t *)alloc_xenheap_page();
+ 
+ 	return pmd;
+ }
+@@ -136,7 +141,7 @@ pmd_populate_kernel (struct mm_struct *m
+ static inline struct page *
+ pte_alloc_one (struct mm_struct *mm, unsigned long addr)
+ {
+-	struct page *pte = alloc_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, 0);
++	struct page *pte = alloc_xenheap_page();
+ 
+ 	return pte;
+ }
+@@ -144,7 +149,7 @@ pte_alloc_one (struct mm_struct *mm, uns
+ static inline pte_t *
+ pte_alloc_one_kernel (struct mm_struct *mm, unsigned long addr)
+ {
+-	pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
++	pte_t *pte = (pte_t *)alloc_xenheap_page();
+ 
+ 	return pte;
+ }
+@@ -152,13 +157,13 @@ pte_alloc_one_kernel (struct mm_struct *
+ static inline void
+ pte_free (struct page *pte)
+ {
+-	__free_page(pte);
++	free_xenheap_page(pte);
+ }
+ 
+ static inline void
+ pte_free_kernel (pte_t *pte)
+ {
+-	free_page((unsigned long) pte);
++	free_xenheap_page((unsigned long) pte);
+ }
+ 
+ #define __pte_free_tlb(tlb, pte)	tlb_remove_page((tlb), (pte))

xen/arch/ia64/patch/linux-2.6.11/processor.h

@@ -0,0 +1,24 @@
+ processor.h |    4 ++++
+ 1 files changed, 4 insertions(+)
+
+Index: linux-2.6.11/include/asm-ia64/processor.h
+===================================================================
+--- linux-2.6.11.orig/include/asm-ia64/processor.h	2005-03-02 01:37:58.000000000 -0600
++++ linux-2.6.11/include/asm-ia64/processor.h	2005-03-19 14:26:01.062135543 -0600
+@@ -408,12 +408,16 @@ extern void ia64_setreg_unknown_kr (void
+  */
+ 
+ /* Return TRUE if task T owns the fph partition of the CPU we're running on. */
++#ifdef XEN
++#define ia64_is_local_fpu_owner(t) 0
++#else
+ #define ia64_is_local_fpu_owner(t)								\
+ ({												\
+ 	struct task_struct *__ia64_islfo_task = (t);						\
+ 	(__ia64_islfo_task->thread.last_fph_cpu == smp_processor_id()				\
+ 	 && __ia64_islfo_task == (struct task_struct *) ia64_get_kr(IA64_KR_FPU_OWNER));	\
+ })
++#endif
+ 
+ /* Mark task T as owning the fph partition of the CPU we're running on. */
+ #define ia64_set_local_fpu_owner(t) do {						\

xen/arch/ia64/patch/linux-2.6.11/sal.h

@@ -0,0 +1,39 @@
+ sal.h |   17 +++++++++++++++++
+ 1 files changed, 17 insertions(+)
+
+Index: linux-2.6.11-xendiffs/include/asm-ia64/sal.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/include/asm-ia64/sal.h	2005-04-08 12:00:53.510988510 -0500
++++ linux-2.6.11-xendiffs/include/asm-ia64/sal.h	2005-04-08 12:02:17.778587216 -0500
+@@ -36,6 +36,7 @@
+ #ifndef __ASSEMBLY__
+ 
+ #include <linux/bcd.h>
++#include <linux/preempt.h>
+ #include <linux/spinlock.h>
+ #include <linux/efi.h>
+ 
+@@ -650,7 +651,23 @@ ia64_sal_freq_base (unsigned long which,
+ {
+ 	struct ia64_sal_retval isrv;
+ 
++//#ifdef XEN
++#if 0
++	unsigned long *x = (unsigned long *)ia64_sal;
++	unsigned long *inst = (unsigned long *)*x;
++	unsigned long __ia64_sc_flags;
++	struct ia64_fpreg __ia64_sc_fr[6];
++printf("ia64_sal_freq_base: about to save_scratch_fpregs\n");
++	ia64_save_scratch_fpregs(__ia64_sc_fr);
++	spin_lock_irqsave(&sal_lock, __ia64_sc_flags);
++printf("ia64_sal_freq_base: about to call, ia64_sal=%p, ia64_sal[0]=%p, ia64_sal[1]=%p\n",x,x[0],x[1]);
++printf("first inst=%p,%p\n",inst[0],inst[1]);
++	isrv = (*ia64_sal)(SAL_FREQ_BASE, which, 0, 0, 0, 0, 0, 0);
++	spin_unlock_irqrestore(&sal_lock, __ia64_sc_flags);
++	ia64_load_scratch_fpregs(__ia64_sc_fr);
++#else
+ 	SAL_CALL(isrv, SAL_FREQ_BASE, which, 0, 0, 0, 0, 0, 0);
++#endif
+ 	*ticks_per_second = isrv.v0;
+ 	*drift_info = isrv.v1;
+ 	return isrv.status;

xen/arch/ia64/patch/linux-2.6.11/series

@@ -0,0 +1,40 @@
+bootmem.h
+current.h
+efi.c
+efi.h
+entry.S
+gcc_intrin.h
+hardirq.h
+head.S
+hpsim_irq.c
+hpsim_ssc.h
+hw_irq.h
+ide.h
+init_task.c
+init_task.h
+interrupt.h
+io.h
+irq.h
+irq_ia64.c
+ivt.S
+kregs.h
+lds.S
+linuxtime.h
+minstate.h
+mm_bootmem.c
+mm_contig.c
+mmzone.h
+page_alloc.c
+page.h
+processor.h
+sal.h
+setup.c
+slab.c
+slab.h
+system.h
+time.c
+kernel-time.c
+tlb.c
+types.h
+unaligned.c
+wait.h

xen/arch/ia64/patch/linux-2.6.11/setup.c

@@ -0,0 +1,214 @@
+ setup.c |   72 +++++++++++++++++++++++++++++++++++++++++++++++++++-------------
+ 1 files changed, 58 insertions(+), 14 deletions(-)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/setup.c
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/setup.c	2005-04-07 17:44:13.294980153 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/setup.c	2005-04-07 17:46:37.157717072 -0500
+@@ -21,6 +21,9 @@
+ #include <linux/init.h>
+ 
+ #include <linux/acpi.h>
++#ifdef XEN
++#include <xen/sched.h>
++#endif
+ #include <linux/bootmem.h>
+ #include <linux/console.h>
+ #include <linux/delay.h>
+@@ -30,13 +33,17 @@
+ #include <linux/seq_file.h>
+ #include <linux/string.h>
+ #include <linux/threads.h>
++#ifndef XEN
+ #include <linux/tty.h>
+ #include <linux/serial.h>
+ #include <linux/serial_core.h>
++#endif
+ #include <linux/efi.h>
+ #include <linux/initrd.h>
+ 
++#ifndef XEN
+ #include <asm/ia32.h>
++#endif
+ #include <asm/machvec.h>
+ #include <asm/mca.h>
+ #include <asm/meminit.h>
+@@ -51,6 +58,12 @@
+ #include <asm/smp.h>
+ #include <asm/system.h>
+ #include <asm/unistd.h>
++#ifdef XEN
++#include <linux/mm.h>
++#include <asm/mmu_context.h>
++extern unsigned long loops_per_jiffy;		// from linux/init/main.c
++char saved_command_line[COMMAND_LINE_SIZE];	// from linux/init/main.c
++#endif
+ 
+ #if defined(CONFIG_SMP) && (IA64_CPU_SIZE > PAGE_SIZE)
+ # error "struct cpuinfo_ia64 too big!"
+@@ -66,7 +79,9 @@ DEFINE_PER_CPU(unsigned long, local_per_
+ DEFINE_PER_CPU(unsigned long, ia64_phys_stacked_size_p8);
+ unsigned long ia64_cycles_per_usec;
+ struct ia64_boot_param *ia64_boot_param;
++#ifndef XEN
+ struct screen_info screen_info;
++#endif
+ 
+ unsigned long ia64_max_cacheline_size;
+ unsigned long ia64_iobase;	/* virtual address for I/O accesses */
+@@ -95,7 +110,6 @@ EXPORT_SYMBOL(ia64_max_iommu_merge_mask)
+ struct rsvd_region rsvd_region[IA64_MAX_RSVD_REGIONS + 1];
+ int num_rsvd_regions;
+ 
+-
+ /*
+  * Filter incoming memory segments based on the primitive map created from the boot
+  * parameters. Segments contained in the map are removed from the memory ranges. A
+@@ -125,9 +139,12 @@ filter_rsvd_memory (unsigned long start,
+ 	for (i = 0; i < num_rsvd_regions; ++i) {
+ 		range_start = max(start, prev_start);
+ 		range_end   = min(end, rsvd_region[i].start);
+-
+-		if (range_start < range_end)
+-			call_pernode_memory(__pa(range_start), range_end - range_start, func);
++		/* init_boot_pages requires "ps, pe" */
++		if (range_start < range_end) {
++			printk("Init boot pages: 0x%lx -> 0x%lx.\n",
++				__pa(range_start), __pa(range_end));
++			(*func)(__pa(range_start), __pa(range_end), 0);
++		}
+ 
+ 		/* nothing more available in this segment */
+ 		if (range_end == end) return 0;
+@@ -184,17 +201,17 @@ reserve_memory (void)
+ 				+ strlen(__va(ia64_boot_param->command_line)) + 1);
+ 	n++;
+ 
++	/* Reserve xen image/bitmap/xen-heap */
+ 	rsvd_region[n].start = (unsigned long) ia64_imva((void *)KERNEL_START);
+-	rsvd_region[n].end   = (unsigned long) ia64_imva(_end);
++	rsvd_region[n].end   = rsvd_region[n].start + xenheap_size;
+ 	n++;
+ 
+-#ifdef CONFIG_BLK_DEV_INITRD
++	/* This is actually dom0 image */
+ 	if (ia64_boot_param->initrd_start) {
+ 		rsvd_region[n].start = (unsigned long)__va(ia64_boot_param->initrd_start);
+ 		rsvd_region[n].end   = rsvd_region[n].start + ia64_boot_param->initrd_size;
+ 		n++;
+ 	}
+-#endif
+ 
+ 	/* end of memory marker */
+ 	rsvd_region[n].start = ~0UL;
+@@ -204,6 +221,16 @@ reserve_memory (void)
+ 	num_rsvd_regions = n;
+ 
+ 	sort_regions(rsvd_region, num_rsvd_regions);
++
++	{
++		int i;
++		printk("Reserved regions: \n");
++		for (i = 0; i < num_rsvd_regions; i++)
++			printk("  [%d] -> [0x%lx, 0x%lx]\n",
++				i,
++				rsvd_region[i].start,
++				rsvd_region[i].end);
++	}
+ }
+ 
+ /**
+@@ -298,18 +325,17 @@ mark_bsp_online (void)
+ #endif
+ }
+ 
++#ifdef XEN
+ void __init
+-setup_arch (char **cmdline_p)
++early_setup_arch (char **cmdline_p)
+ {
+ 	unw_init();
+ 
+-	ia64_patch_vtop((u64) __start___vtop_patchlist, (u64) __end___vtop_patchlist);
+-
+ 	*cmdline_p = __va(ia64_boot_param->command_line);
+ 	strlcpy(saved_command_line, *cmdline_p, COMMAND_LINE_SIZE);
++	cmdline_parse(*cmdline_p);
+ 
+ 	efi_init();
+-	io_port_init();
+ 
+ #ifdef CONFIG_IA64_GENERIC
+ 	{
+@@ -339,6 +365,10 @@ setup_arch (char **cmdline_p)
+ 	if (early_console_setup(*cmdline_p) == 0)
+ 		mark_bsp_online();
+ 
++#ifdef XEN
++#undef CONFIG_ACPI_BOOT
++#endif
++
+ #ifdef CONFIG_ACPI_BOOT
+ 	/* Initialize the ACPI boot-time table parser */
+ 	acpi_table_init();
+@@ -350,9 +380,13 @@ setup_arch (char **cmdline_p)
+ 	smp_build_cpu_map();	/* happens, e.g., with the Ski simulator */
+ # endif
+ #endif /* CONFIG_APCI_BOOT */
++	io_port_init();
++}
++#endif
+ 
+-	find_memory();
+-
++void __init
++setup_arch (void)
++{
+ 	/* process SAL system table: */
+ 	ia64_sal_init(efi.sal_systab);
+ 
+@@ -388,7 +422,6 @@ setup_arch (char **cmdline_p)
+ 	if (!strstr(saved_command_line, "nomca"))
+ 		ia64_mca_init();
+ 
+-	platform_setup(cmdline_p);
+ 	paging_init();
+ }
+ 
+@@ -448,6 +481,9 @@ show_cpuinfo (struct seq_file *m, void *
+ 		sprintf(cp, " 0x%lx", mask);
+ 	}
+ 
++#ifdef XEN
++#define seq_printf(a,b...) printf(b)
++#endif
+ 	seq_printf(m,
+ 		   "processor  : %d\n"
+ 		   "vendor     : %s\n"
+@@ -659,11 +695,17 @@ cpu_init (void)
+ 					| IA64_DCR_DA | IA64_DCR_DD | IA64_DCR_LC));
+ 	atomic_inc(&init_mm.mm_count);
+ 	current->active_mm = &init_mm;
++#ifdef XEN
++	if (current->domain->arch.mm)
++#else
+ 	if (current->mm)
++#endif
+ 		BUG();
+ 
+ 	ia64_mmu_init(ia64_imva(cpu_data));
++#ifndef XEN
+ 	ia64_mca_cpu_init(ia64_imva(cpu_data));
++#endif
+ 
+ #ifdef CONFIG_IA32_SUPPORT
+ 	ia32_cpu_init();
+@@ -711,6 +753,8 @@ cpu_init (void)
+ void
+ check_bugs (void)
+ {
++#ifndef XEN
+ 	ia64_patch_mckinley_e9((unsigned long) __start___mckinley_e9_bundles,
+ 			       (unsigned long) __end___mckinley_e9_bundles);
++#endif
+ }

xen/arch/ia64/patch/linux-2.6.11/slab.h

@@ -0,0 +1,19 @@
+ slab.h |    4 ++++
+ 1 files changed, 4 insertions(+)
+
+Index: linux-2.6.11/include/linux/slab.h
+===================================================================
+--- linux-2.6.11.orig/include/linux/slab.h	2005-03-02 01:38:33.000000000 -0600
++++ linux-2.6.11/include/linux/slab.h	2005-03-19 14:35:19.301871922 -0600
+@@ -91,7 +91,11 @@ static inline void *kmalloc(size_t size,
+ 			goto found; \
+ 		else \
+ 			i++;
++#ifdef XEN
++#include <linux/kmalloc_sizes.h>
++#else
+ #include "kmalloc_sizes.h"
++#endif
+ #undef CACHE
+ 		{
+ 			extern void __you_cannot_kmalloc_that_much(void);

xen/arch/ia64/patch/linux-2.6.11/swiotlb.c

@@ -0,0 +1,77 @@
+ swiotlb.c |   21 +++++++++++++--------
+ 1 files changed, 13 insertions(+), 8 deletions(-)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/lib/swiotlb.c
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/lib/swiotlb.c	2005-04-08 12:13:54.040202667 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/lib/swiotlb.c	2005-04-08 12:19:09.170367318 -0500
+@@ -124,8 +124,11 @@ swiotlb_init_with_default_size (size_t d
+ 	/*
+ 	 * Get IO TLB memory from the low pages
+ 	 */
+-	io_tlb_start = alloc_bootmem_low_pages(io_tlb_nslabs *
+-					       (1 << IO_TLB_SHIFT));
++	/* FIXME: Do we really need swiotlb in HV? If all memory trunks
++	 * presented to guest as <4G, are actually <4G in machine range,
++	 * no DMA intevention from HV...
++	 */
++	io_tlb_start = alloc_xenheap_pages(get_order(io_tlb_nslabs * (1 << IO_TLB_SHIFT)));
+ 	if (!io_tlb_start)
+ 		panic("Cannot allocate SWIOTLB buffer");
+ 	io_tlb_end = io_tlb_start + io_tlb_nslabs * (1 << IO_TLB_SHIFT);
+@@ -135,16 +138,16 @@ swiotlb_init_with_default_size (size_t d
+ 	 * to find contiguous free memory regions of size up to IO_TLB_SEGSIZE
+ 	 * between io_tlb_start and io_tlb_end.
+ 	 */
+-	io_tlb_list = alloc_bootmem(io_tlb_nslabs * sizeof(int));
++	io_tlb_list = alloc_xenheap_pages(get_order(io_tlb_nslabs * sizeof(int)));
+ 	for (i = 0; i < io_tlb_nslabs; i++)
+  		io_tlb_list[i] = IO_TLB_SEGSIZE - OFFSET(i, IO_TLB_SEGSIZE);
+ 	io_tlb_index = 0;
+-	io_tlb_orig_addr = alloc_bootmem(io_tlb_nslabs * sizeof(char *));
++	io_tlb_orig_addr = alloc_xenheap_pages(get_order(io_tlb_nslabs * sizeof(char *)));
+ 
+ 	/*
+ 	 * Get the overflow emergency buffer
+ 	 */
+-	io_tlb_overflow_buffer = alloc_bootmem_low(io_tlb_overflow);
++	io_tlb_overflow_buffer = alloc_xenheap_pages(get_order(io_tlb_overflow));
+ 	printk(KERN_INFO "Placing software IO TLB between 0x%lx - 0x%lx\n",
+ 	       virt_to_phys(io_tlb_start), virt_to_phys(io_tlb_end));
+ }
+@@ -328,13 +331,13 @@ swiotlb_alloc_coherent(struct device *hw
+ 	 */
+ 	flags |= GFP_DMA;
+ 
+-	ret = (void *)__get_free_pages(flags, order);
++	ret = (void *)alloc_xenheap_pages(get_order(size));
+ 	if (ret && address_needs_mapping(hwdev, virt_to_phys(ret))) {
+ 		/*
+ 		 * The allocated memory isn't reachable by the device.
+ 		 * Fall back on swiotlb_map_single().
+ 		 */
+-		free_pages((unsigned long) ret, order);
++		free_xenheap_pages((unsigned long) ret, order);
+ 		ret = NULL;
+ 	}
+ 	if (!ret) {
+@@ -372,7 +375,7 @@ swiotlb_free_coherent(struct device *hwd
+ {
+ 	if (!(vaddr >= (void *)io_tlb_start
+                     && vaddr < (void *)io_tlb_end))
+-		free_pages((unsigned long) vaddr, get_order(size));
++		free_xenheap_pages((unsigned long) vaddr, get_order(size));
+ 	else
+ 		/* DMA_TO_DEVICE to avoid memcpy in unmap_single */
+ 		swiotlb_unmap_single (hwdev, dma_handle, size, DMA_TO_DEVICE);
+@@ -388,8 +391,10 @@ swiotlb_full(struct device *dev, size_t 
+ 	 * When the mapping is small enough return a static buffer to limit
+ 	 * the damage, or panic when the transfer is too big.
+ 	 */
++#ifndef XEN
+ 	printk(KERN_ERR "PCI-DMA: Out of SW-IOMMU space for %lu bytes at "
+ 	       "device %s\n", size, dev ? dev->bus_id : "?");
++#endif
+ 
+ 	if (size > io_tlb_overflow && do_panic) {
+ 		if (dir == PCI_DMA_FROMDEVICE || dir == PCI_DMA_BIDIRECTIONAL)

xen/arch/ia64/patch/linux-2.6.11/system.h

@@ -0,0 +1,48 @@
+ system.h |   15 +++++++++++++++
+ 1 files changed, 15 insertions(+)
+
+Index: linux-2.6.11-xendiffs/include/asm-ia64/system.h
+===================================================================
+--- linux-2.6.11-xendiffs.orig/include/asm-ia64/system.h	2005-04-07 10:39:11.066701457 -0500
++++ linux-2.6.11-xendiffs/include/asm-ia64/system.h	2005-04-07 10:40:19.540544127 -0500
+@@ -24,8 +24,16 @@
+  * 0xa000000000000000+2*PERCPU_PAGE_SIZE
+  * - 0xa000000000000000+3*PERCPU_PAGE_SIZE remain unmapped (guard page)
+  */
++#ifdef XEN
++//#define KERNEL_START		 0xf000000100000000
++#define KERNEL_START		 0xf000000004000000
++#define PERCPU_ADDR		 0xf100000000000000-PERCPU_PAGE_SIZE
++#define SHAREDINFO_ADDR		 0xf100000000000000
++#define VHPT_ADDR		 0xf200000000000000
++#else
+ #define KERNEL_START		 __IA64_UL_CONST(0xa000000100000000)
+ #define PERCPU_ADDR		(-PERCPU_PAGE_SIZE)
++#endif
+ 
+ #ifndef __ASSEMBLY__
+ 
+@@ -218,9 +226,13 @@ extern void ia64_load_extra (struct task
+ # define PERFMON_IS_SYSWIDE() (0)
+ #endif
+ 
++#ifdef XEN
++#define IA64_HAS_EXTRA_STATE(t) 0
++#else
+ #define IA64_HAS_EXTRA_STATE(t)							\
+ 	((t)->thread.flags & (IA64_THREAD_DBG_VALID|IA64_THREAD_PM_VALID)	\
+ 	 || IS_IA32_PROCESS(ia64_task_regs(t)) || PERFMON_IS_SYSWIDE())
++#endif
+ 
+ #define __switch_to(prev,next,last) do {							 \
+ 	if (IA64_HAS_EXTRA_STATE(prev))								 \
+@@ -249,6 +261,9 @@ extern void ia64_load_extra (struct task
+ #else
+ # define switch_to(prev,next,last)	__switch_to(prev, next, last)
+ #endif
++//#ifdef XEN
++//#undef switch_to
++//#endif
+ 
+ /*
+  * On IA-64, we don't want to hold the runqueue's lock during the low-level context-switch,

xen/arch/ia64/patch/linux-2.6.11/time.c

@@ -0,0 +1,302 @@
+ time.c |  158 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 files changed, 158 insertions(+)
+
+Index: linux-2.6.11-xendiffs/arch/ia64/kernel/time.c
+===================================================================
+--- linux-2.6.11-xendiffs.orig/arch/ia64/kernel/time.c	2005-04-07 17:02:39.634985144 -0500
++++ linux-2.6.11-xendiffs/arch/ia64/kernel/time.c	2005-04-07 17:23:52.777723222 -0500
+@@ -10,16 +10,22 @@
+  */
+ #include <linux/config.h>
+ 
++#ifndef XEN
+ #include <linux/cpu.h>
++#endif
+ #include <linux/init.h>
+ #include <linux/kernel.h>
+ #include <linux/module.h>
++#ifndef XEN
+ #include <linux/profile.h>
++#endif
+ #include <linux/sched.h>
+ #include <linux/time.h>
+ #include <linux/interrupt.h>
+ #include <linux/efi.h>
++#ifndef XEN
+ #include <linux/profile.h>
++#endif
+ #include <linux/timex.h>
+ 
+ #include <asm/machvec.h>
+@@ -29,10 +35,19 @@
+ #include <asm/sal.h>
+ #include <asm/sections.h>
+ #include <asm/system.h>
++#ifdef XEN
++#include <asm/ia64_int.h>
++#endif
+ 
+ extern unsigned long wall_jiffies;
+ 
++#ifndef XEN
+ u64 jiffies_64 __cacheline_aligned_in_smp = INITIAL_JIFFIES;
++#else
++#define INITIAL_JIFFIES 0
++u64 jiffies_64 = INITIAL_JIFFIES;
++#define CPU_PROFILING 0
++#endif
+ 
+ EXPORT_SYMBOL(jiffies_64);
+ 
+@@ -45,33 +60,154 @@ EXPORT_SYMBOL(last_cli_ip);
+ 
+ #endif
+ 
++#ifdef XEN
++volatile unsigned long last_nsec_offset;
++extern rwlock_t xtime_lock;
++unsigned long cpu_khz;  /* Detected as we calibrate the TSC */
++static s_time_t        stime_irq;       /* System time at last 'time update' */
++
++static inline u64 get_time_delta(void)
++{
++	return ia64_get_itc();
++}
++
++s_time_t get_s_time(void)
++{
++    s_time_t now;
++    unsigned long flags;
++
++    read_lock_irqsave(&xtime_lock, flags);
++
++    now = stime_irq + get_time_delta();
++
++    /* Ensure that the returned system time is monotonically increasing. */
++    {
++        static s_time_t prev_now = 0;
++        if ( unlikely(now < prev_now) )
++            now = prev_now;
++        prev_now = now;
++    }
++
++    read_unlock_irqrestore(&xtime_lock, flags);
++
++    return now; 
++}
++
++void update_dom_time(struct exec_domain *ed)
++{
++// FIXME: implement this?
++//	printf("update_dom_time: called, not implemented, skipping\n");
++	return;
++}
++
++/* Set clock to <secs,usecs> after 00:00:00 UTC, 1 January, 1970. */
++void do_settime(unsigned long secs, unsigned long usecs, u64 system_time_base)
++{
++// FIXME: Should this be do_settimeofday (from linux)???
++	printf("do_settime: called, not implemented, stopping\n");
++	dummy();
++}
++#endif
++
++#if 0	/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
++#endif	/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
++ 
++#ifndef XEN
+ static struct time_interpolator itc_interpolator = {
+ 	.shift = 16,
+ 	.mask = 0xffffffffffffffffLL,
+ 	.source = TIME_SOURCE_CPU
+ };
++#endif
++
++#ifdef XEN
++unsigned long domain0_ready = 0;	// FIXME (see below)
++#define typecheck(a,b)	1
++/* FROM linux/include/linux/jiffies.h */
++/*
++ *	These inlines deal with timer wrapping correctly. You are 
++ *	strongly encouraged to use them
++ *	1. Because people otherwise forget
++ *	2. Because if the timer wrap changes in future you won't have to
++ *	   alter your driver code.
++ *
++ * time_after(a,b) returns true if the time a is after time b.
++ *
++ * Do this with "<0" and ">=0" to only test the sign of the result. A
++ * good compiler would generate better code (and a really good compiler
++ * wouldn't care). Gcc is currently neither.
++ */
++#define time_after(a,b)		\
++	(typecheck(unsigned long, a) && \
++	 typecheck(unsigned long, b) && \
++	 ((long)(b) - (long)(a) < 0))
++#define time_before(a,b)	time_after(b,a)
++
++#define time_after_eq(a,b)	\
++	(typecheck(unsigned long, a) && \
++	 typecheck(unsigned long, b) && \
++	 ((long)(a) - (long)(b) >= 0))
++#define time_before_eq(a,b)	time_after_eq(b,a)
++#endif
+ 
+ static irqreturn_t
+ timer_interrupt (int irq, void *dev_id, struct pt_regs *regs)
+ {
+ 	unsigned long new_itm;
+ 
++#ifndef XEN
+ 	if (unlikely(cpu_is_offline(smp_processor_id()))) {
+ 		return IRQ_HANDLED;
+ 	}
++#endif
++#ifdef XEN
++	if (current->domain == dom0) {
++		// FIXME: there's gotta be a better way of doing this...
++		// We have to ensure that domain0 is launched before we
++		// call vcpu_timer_expired on it
++		//domain0_ready = 1; // moved to xensetup.c
++	}
++	if (domain0_ready && vcpu_timer_expired(dom0->exec_domain[0])) {
++		vcpu_pend_timer(dom0->exec_domain[0]);
++		//vcpu_set_next_timer(dom0->exec_domain[0]);
++		domain_wake(dom0->exec_domain[0]);
++	}
++	if (!is_idle_task(current->domain) && current->domain != dom0) {
++		if (vcpu_timer_expired(current)) {
++			vcpu_pend_timer(current);
++			// ensure another timer interrupt happens even if domain doesn't
++			vcpu_set_next_timer(current);
++			domain_wake(current);
++		}
++	}
++	raise_actimer_softirq();
++#endif
+ 
++#ifndef XEN
+ 	platform_timer_interrupt(irq, dev_id, regs);
++#endif
+ 
+ 	new_itm = local_cpu_data->itm_next;
+ 
+ 	if (!time_after(ia64_get_itc(), new_itm))
++#ifdef XEN
++		return;
++#else
+ 		printk(KERN_ERR "Oops: timer tick before it's due (itc=%lx,itm=%lx)\n",
+ 		       ia64_get_itc(), new_itm);
++#endif
+ 
++#ifdef XEN
++//	printf("GOT TO HERE!!!!!!!!!!!\n");
++	//while(1);
++#else
+ 	profile_tick(CPU_PROFILING, regs);
++#endif
+ 
+ 	while (1) {
++#ifndef XEN
+ 		update_process_times(user_mode(regs));
++#endif
+ 
+ 		new_itm += local_cpu_data->itm_delta;
+ 
+@@ -82,10 +218,16 @@ timer_interrupt (int irq, void *dev_id, 
+ 			 * another CPU. We need to avoid to SMP race by acquiring the
+ 			 * xtime_lock.
+ 			 */
++#ifdef TURN_ME_OFF_FOR_NOW_IA64_XEN
+ 			write_seqlock(&xtime_lock);
++#endif
++#ifdef TURN_ME_OFF_FOR_NOW_IA64_XEN
+ 			do_timer(regs);
++#endif
+ 			local_cpu_data->itm_next = new_itm;
++#ifdef TURN_ME_OFF_FOR_NOW_IA64_XEN
+ 			write_sequnlock(&xtime_lock);
++#endif
+ 		} else
+ 			local_cpu_data->itm_next = new_itm;
+ 
+@@ -105,7 +247,12 @@ timer_interrupt (int irq, void *dev_id, 
+ 		 */
+ 		while (!time_after(new_itm, ia64_get_itc() + local_cpu_data->itm_delta/2))
+ 			new_itm += local_cpu_data->itm_delta;
++//#ifdef XEN
++//		vcpu_set_next_timer(current);
++//#else
++//printf("***** timer_interrupt: Setting itm to %lx\n",new_itm);
+ 		ia64_set_itm(new_itm);
++//#endif
+ 		/* double check, in case we got hit by a (slow) PMI: */
+ 	} while (time_after_eq(ia64_get_itc(), new_itm));
+ 	return IRQ_HANDLED;
+@@ -120,6 +267,7 @@ ia64_cpu_local_tick (void)
+ 	int cpu = smp_processor_id();
+ 	unsigned long shift = 0, delta;
+ 
++printf("ia64_cpu_local_tick: about to call ia64_set_itv\n");
+ 	/* arrange for the cycle counter to generate a timer interrupt: */
+ 	ia64_set_itv(IA64_TIMER_VECTOR);
+ 
+@@ -133,6 +281,7 @@ ia64_cpu_local_tick (void)
+ 		shift = (2*(cpu - hi) + 1) * delta/hi/2;
+ 	}
+ 	local_cpu_data->itm_next = ia64_get_itc() + delta + shift;
++printf("***** ia64_cpu_local_tick: Setting itm to %lx\n",local_cpu_data->itm_next);
+ 	ia64_set_itm(local_cpu_data->itm_next);
+ }
+ 
+@@ -160,6 +309,7 @@ ia64_init_itm (void)
+ 	 * frequency and then a PAL call to determine the frequency ratio between the ITC
+ 	 * and the base frequency.
+ 	 */
++
+ 	status = ia64_sal_freq_base(SAL_FREQ_BASE_PLATFORM,
+ 				    &platform_base_freq, &platform_base_drift);
+ 	if (status != 0) {
+@@ -212,6 +362,7 @@ ia64_init_itm (void)
+ 					+ itc_freq/2)/itc_freq;
+ 
+ 	if (!(sal_platform_features & IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT)) {
++#ifndef XEN
+ 		itc_interpolator.frequency = local_cpu_data->itc_freq;
+ 		itc_interpolator.drift = itc_drift;
+ #ifdef CONFIG_SMP
+@@ -228,6 +379,7 @@ ia64_init_itm (void)
+ 		if (!nojitter) itc_interpolator.jitter = 1;
+ #endif
+ 		register_time_interpolator(&itc_interpolator);
++#endif
+ 	}
+ 
+ 	/* Setup the CPU local timer tick */
+@@ -236,7 +388,9 @@ ia64_init_itm (void)
+ 
+ static struct irqaction timer_irqaction = {
+ 	.handler =	timer_interrupt,
++#ifndef XEN
+ 	.flags =	SA_INTERRUPT,
++#endif
+ 	.name =		"timer"
+ };
+ 
+@@ -244,12 +398,16 @@ void __init
+ time_init (void)
+ {
+ 	register_percpu_irq(IA64_TIMER_VECTOR, &timer_irqaction);
++#ifndef XEN
+ 	efi_gettimeofday(&xtime);
++#endif
+ 	ia64_init_itm();
+ 
++#ifndef XEN
+ 	/*
+ 	 * Initialize wall_to_monotonic such that adding it to xtime will yield zero, the
+ 	 * tv_nsec field must be normalized (i.e., 0 <= nsec < NSEC_PER_SEC).
+ 	 */
+ 	set_normalized_timespec(&wall_to_monotonic, -xtime.tv_sec, -xtime.tv_nsec);
++#endif
+ }

xen/arch/ia64/patch/linux-2.6.11/tlb.c

@@ -0,0 +1,53 @@
+ tlb.c |   10 ++++++++++
+ 1 files changed, 10 insertions(+)
+
+Index: linux-2.6.11/arch/ia64/mm/tlb.c
+===================================================================
+--- linux-2.6.11.orig/arch/ia64/mm/tlb.c	2005-03-02 01:38:38.000000000 -0600
++++ linux-2.6.11/arch/ia64/mm/tlb.c	2005-03-19 14:58:43.978400822 -0600
+@@ -21,7 +21,9 @@
+ #include <asm/mmu_context.h>
+ #include <asm/pgalloc.h>
+ #include <asm/pal.h>
++#ifndef XEN
+ #include <asm/tlbflush.h>
++#endif
+ 
+ static struct {
+ 	unsigned long mask;	/* mask of supported purge page-sizes */
+@@ -43,6 +45,9 @@ DEFINE_PER_CPU(u8, ia64_need_tlb_flush);
+ void
+ wrap_mmu_context (struct mm_struct *mm)
+ {
++#ifdef XEN
++printf("wrap_mmu_context: called, not implemented\n");
++#else
+ 	unsigned long tsk_context, max_ctx = ia64_ctx.max_ctx;
+ 	struct task_struct *tsk;
+ 	int i;
+@@ -83,6 +88,7 @@ wrap_mmu_context (struct mm_struct *mm)
+ 		put_cpu();
+ 	}
+ 	local_flush_tlb_all();
++#endif
+ }
+ 
+ void
+@@ -132,6 +138,9 @@ EXPORT_SYMBOL(local_flush_tlb_all);
+ void
+ flush_tlb_range (struct vm_area_struct *vma, unsigned long start, unsigned long end)
+ {
++#ifdef XEN
++printf("flush_tlb_range: called, not implemented\n");
++#else
+ 	struct mm_struct *mm = vma->vm_mm;
+ 	unsigned long size = end - start;
+ 	unsigned long nbits;
+@@ -163,6 +172,7 @@ flush_tlb_range (struct vm_area_struct *
+ # endif
+ 
+ 	ia64_srlz_i();			/* srlz.i implies srlz.d */
++#endif
+ }
+ EXPORT_SYMBOL(flush_tlb_range);
+ 

xen/arch/ia64/patch/linux-2.6.11/types.h

@@ -0,0 +1,20 @@
+ types.h |    7 +++++++
+ 1 files changed, 7 insertions(+)
+
+Index: linux-2.6.11/include/asm-ia64/types.h
+===================================================================
+--- linux-2.6.11.orig/include/asm-ia64/types.h	2005-03-02 01:37:49.000000000 -0600
++++ linux-2.6.11/include/asm-ia64/types.h	2005-03-19 14:58:47.628750770 -0600
+@@ -1,5 +1,12 @@
+ #ifndef _ASM_IA64_TYPES_H
+ #define _ASM_IA64_TYPES_H
++#ifdef XEN
++#ifndef __ASSEMBLY__
++typedef unsigned long ssize_t;
++typedef unsigned long size_t;
++typedef long long loff_t;
++#endif
++#endif
+ 
+ /*
+  * This file is never included by application software unless explicitly requested (e.g.,

xen/arch/ia64/patch/linux-2.6.11/unaligned.c

@@ -0,0 +1,102 @@
+ unaligned.c |   27 +++++++++++++++++++++++++++
+ 1 files changed, 27 insertions(+)
+
+Index: linux-2.6.11/arch/ia64/kernel/unaligned.c
+===================================================================
+--- linux-2.6.11.orig/arch/ia64/kernel/unaligned.c	2005-03-02 01:38:25.000000000 -0600
++++ linux-2.6.11/arch/ia64/kernel/unaligned.c	2005-03-19 14:58:51.269335202 -0600
+@@ -15,8 +15,10 @@
+  */
+ #include <linux/kernel.h>
+ #include <linux/sched.h>
++#ifndef XEN
+ #include <linux/smp_lock.h>
+ #include <linux/tty.h>
++#endif
+ 
+ #include <asm/intrinsics.h>
+ #include <asm/processor.h>
+@@ -24,7 +26,16 @@
+ #include <asm/uaccess.h>
+ #include <asm/unaligned.h>
+ 
++#ifdef XEN
++#define	ia64_peek(x...)	printk("ia64_peek: called, not implemented\n")
++#define	ia64_poke(x...)	printk("ia64_poke: called, not implemented\n")
++#define	ia64_sync_fph(x...) printk("ia64_sync_fph: called, not implemented\n")
++#define	ia64_flush_fph(x...) printk("ia64_flush_fph: called, not implemented\n")
++#define	die_if_kernel(x...) printk("die_if_kernel: called, not implemented\n")
++#define jiffies 0
++#else
+ extern void die_if_kernel(char *str, struct pt_regs *regs, long err) __attribute__ ((noreturn));
++#endif
+ 
+ #undef DEBUG_UNALIGNED_TRAP
+ 
+@@ -437,7 +448,11 @@ get_rse_reg (struct pt_regs *regs, unsig
+ }
+ 
+ 
++#ifdef XEN
++void
++#else
+ static void
++#endif
+ setreg (unsigned long regnum, unsigned long val, int nat, struct pt_regs *regs)
+ {
+ 	struct switch_stack *sw = (struct switch_stack *) regs - 1;
+@@ -611,7 +626,11 @@ getfpreg (unsigned long regnum, struct i
+ }
+ 
+ 
++#ifdef XEN
++void
++#else
+ static void
++#endif
+ getreg (unsigned long regnum, unsigned long *val, int *nat, struct pt_regs *regs)
+ {
+ 	struct switch_stack *sw = (struct switch_stack *) regs - 1;
+@@ -1298,7 +1317,9 @@ ia64_handle_unaligned (unsigned long ifa
+ 	mm_segment_t old_fs = get_fs();
+ 	unsigned long bundle[2];
+ 	unsigned long opcode;
++#ifndef XEN
+ 	struct siginfo si;
++#endif
+ 	const struct exception_table_entry *eh = NULL;
+ 	union {
+ 		unsigned long l;
+@@ -1317,6 +1338,9 @@ ia64_handle_unaligned (unsigned long ifa
+ 	 * user-level unaligned accesses.  Otherwise, a clever program could trick this
+ 	 * handler into reading an arbitrary kernel addresses...
+ 	 */
++#ifdef XEN
++printk("ia64_handle_unaligned: called, not working yet\n");
++#else
+ 	if (!user_mode(regs))
+ 		eh = search_exception_tables(regs->cr_iip + ia64_psr(regs)->ri);
+ 	if (user_mode(regs) || eh) {
+@@ -1353,6 +1377,7 @@ ia64_handle_unaligned (unsigned long ifa
+ 
+ 	if (__copy_from_user(bundle, (void __user *) regs->cr_iip, 16))
+ 		goto failure;
++#endif
+ 
+ 	/*
+ 	 * extract the instruction from the bundle given the slot number
+@@ -1493,6 +1518,7 @@ ia64_handle_unaligned (unsigned long ifa
+ 		/* NOT_REACHED */
+ 	}
+   force_sigbus:
++#ifndef XEN
+ 	si.si_signo = SIGBUS;
+ 	si.si_errno = 0;
+ 	si.si_code = BUS_ADRALN;
+@@ -1501,5 +1527,6 @@ ia64_handle_unaligned (unsigned long ifa
+ 	si.si_isr = 0;
+ 	si.si_imm = 0;
+ 	force_sig_info(SIGBUS, &si, current);
++#endif
+ 	goto done;
+ }

xen/arch/ia64/patch/linux-2.6.11/wait.h

@@ -0,0 +1,35 @@
+ wait.h |    6 ++++++
+ 1 files changed, 6 insertions(+)
+
+Index: linux-2.6.11/include/linux/wait.h
+===================================================================
+--- linux-2.6.11.orig/include/linux/wait.h	2005-03-02 01:38:10.000000000 -0600
++++ linux-2.6.11/include/linux/wait.h	2005-03-19 15:00:23.691156973 -0600
+@@ -136,7 +136,11 @@ static inline void __remove_wait_queue(w
+ 	list_del(&old->task_list);
+ }
+ 
++#ifdef XEN
++void FASTCALL(__wake_up(struct task_struct *p));
++#else
+ void FASTCALL(__wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key));
++#endif
+ extern void FASTCALL(__wake_up_locked(wait_queue_head_t *q, unsigned int mode));
+ extern void FASTCALL(__wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr));
+ void FASTCALL(__wake_up_bit(wait_queue_head_t *, void *, int));
+@@ -147,6 +151,7 @@ int FASTCALL(out_of_line_wait_on_bit(voi
+ int FASTCALL(out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned));
+ wait_queue_head_t *FASTCALL(bit_waitqueue(void *, int));
+ 
++#ifndef XEN
+ #define wake_up(x)			__wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1, NULL)
+ #define wake_up_nr(x, nr)		__wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, nr, NULL)
+ #define wake_up_all(x)			__wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 0, NULL)
+@@ -155,6 +160,7 @@ wait_queue_head_t *FASTCALL(bit_waitqueu
+ #define wake_up_interruptible_all(x)	__wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
+ #define	wake_up_locked(x)		__wake_up_locked((x), TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE)
+ #define wake_up_interruptible_sync(x)   __wake_up_sync((x),TASK_INTERRUPTIBLE, 1)
++#endif
+ 
+ #define __wait_event(wq, condition) 					\
+ do {									\

xen/arch/ia64/tools/mkbuildtree

@@ -3,9 +3,8 @@
 # run in xen-X.X/xen directory after unpacking linux in same directory
 
 XEN=$PWD
-#LINUX=$XEN/linux-2.6.7
-LINUX=$XEN/../../linux-2.6.7
-LINUXPATCH=$XEN/arch/ia64/patch/linux-2.6.7
+LINUX=$XEN/../../linux-2.6.11
+LINUXPATCH=$XEN/arch/ia64/patch/linux-2.6.11
 XENPATCH=$XEN/arch/ia64/patch/xen-2.0.1
 
 cp_patch ()
@@ -99,7 +98,7 @@ cp_patch arch/ia64/kernel/vmlinux.lds.S arch/ia64/xen.lds.S lds.S
 #cp_patch mm/slab.c arch/ia64/slab.c slab.c
 
 # following renamed to avoid conflict
-softlink kernel/extable.c arch/ia64/linuxextable.c
+cp_patch kernel/extable.c arch/ia64/linuxextable.c linuxextable.c
 
 cp_patch arch/ia64/mm/contig.c arch/ia64/mm_contig.c mm_contig.c
 cp_patch arch/ia64/mm/tlb.c arch/ia64/tlb.c tlb.c
@@ -151,15 +150,16 @@ softlink arch/ia64/hp/sim/hpsim.S arch/ia64/hpsim.S
 
 # xen/include/asm-generic files
 
-softlink include/asm-generic/cpumask_const_value.h include/asm-generic/cpumask_const_value.h cpumask_const_value.h
-softlink include/asm-generic/cpumask.h include/asm-generic/cpumask.h cpumask.h
-softlink include/asm-generic/cpumask_up.h include/asm-generic/cpumask_up.h cpumask_up.h
-softlink include/asm-generic/cpumask_arith.h include/asm-generic/cpumask_arith.h cpumask_arith.h
+softlink include/asm-generic/bug.h include/asm-generic/bug.h bug.h
 softlink include/asm-generic/div64.h include/asm-generic/div64.h div64.h
+softlink include/asm-generic/errno.h include/asm-generic/errno.h
+softlink include/asm-generic/errno-base.h include/asm-generic/errno-base.h
 softlink include/asm-generic/ide_iops.h include/asm-generic/ide_iops.h ide_iops.h
+softlink include/asm-generic/iomap.h include/asm-generic/iomap.h iomap.h
 softlink include/asm-generic/pci-dma-compat.h include/asm-generic/pci-dma-compat.h pci-dma-compat.h
 softlink include/asm-generic/pci.h include/asm-generic/pci.h pci.h
 softlink include/asm-generic/pgtable.h include/asm-generic/pgtable.h pgtable.h
+softlink include/asm-generic/pgtable-nopud.h include/asm-generic/pgtable-nopud.h pgtable-nopud.h
 softlink include/asm-generic/sections.h include/asm-generic/sections.h sections.h
 softlink include/asm-generic/topology.h include/asm-generic/topology.h topology.h
 softlink include/asm-generic/vmlinux.lds.h include/asm-generic/vmlinux.lds.h vmlinux.lds.h
@@ -170,10 +170,12 @@ softlink include/asm-generic/vmlinux.lds.h include/asm-generic/vmlinux.lds.h vml
 cp_patch arch/ia64/hp/sim/hpsim_ssc.h include/asm-ia64/hpsim_ssc.h hpsim_ssc.h
 
 cp_patch include/asm-ia64/current.h include/asm-ia64/current.h current.h
-cp_patch include/asm-ia64/gcc_intrin.h include/asm-ia64/gcc_intrin.h gcc_intrin.h
+#cp_patch include/asm-ia64/gcc_intrin.h include/asm-ia64/gcc_intrin.h gcc_intrin.h
+softlink include/asm-ia64/gcc_intrin.h include/asm-ia64/gcc_intrin.h
 cp_patch include/asm-ia64/hardirq.h include/asm-ia64/hardirq.h hardirq.h
-cp_patch include/asm-ia64/hw_irq.h include/asm-ia64/hw_irq.h hw_irq.h
-cp_patch include/asm-ia64/ide.h include/asm-ia64/ide.h ide.h
+#cp_patch include/asm-ia64/hw_irq.h include/asm-ia64/hw_irq.h hw_irq.h
+softlink include/asm-ia64/hw_irq.h include/asm-ia64/hw_irq.h
+#cp_patch include/asm-ia64/ide.h include/asm-ia64/ide.h ide.h
 cp_patch include/asm-ia64/io.h include/asm-ia64/io.h io.h
 cp_patch include/asm-ia64/irq.h include/asm-ia64/irq.h irq.h
 cp_patch include/asm-ia64/kregs.h include/asm-ia64/kregs.h kregs.h
@@ -200,11 +202,11 @@ softlink include/asm-ia64/byteorder.h include/asm-ia64/byteorder.h
 softlink include/asm-ia64/cacheflush.h include/asm-ia64/cacheflush.h
 softlink include/asm-ia64/cache.h include/asm-ia64/cache.h
 softlink include/asm-ia64/checksum.h include/asm-ia64/checksum.h
-softlink include/asm-ia64/cpumask.h include/asm-ia64/cpumask.h
 softlink include/asm-ia64/delay.h include/asm-ia64/delay.h
 softlink include/asm-ia64/div64.h include/asm-ia64/div64.h
 softlink include/asm-ia64/dma.h include/asm-ia64/dma.h
 softlink include/asm-ia64/dma-mapping.h include/asm-ia64/dma-mapping.h
+softlink include/asm-ia64/errno.h include/asm-ia64/errno.h
 softlink include/asm-ia64/fpu.h include/asm-ia64/fpu.h
 softlink include/asm-ia64/hdreg.h include/asm-ia64/hdreg.h
 softlink include/asm-ia64/ia32.h include/asm-ia64/ia32.h
@@ -235,6 +237,7 @@ softlink include/asm-ia64/rwsem.h include/asm-ia64/rwsem.h
 softlink include/asm-ia64/scatterlist.h include/asm-ia64/scatterlist.h
 softlink include/asm-ia64/sections.h include/asm-ia64/sections.h
 softlink include/asm-ia64/semaphore.h include/asm-ia64/semaphore.h
+softlink include/asm-ia64/setup.h include/asm-ia64/setup.h
 softlink include/asm-ia64/sigcontext.h include/asm-ia64/sigcontext.h
 softlink include/asm-ia64/signal.h include/asm-ia64/signal.h
 softlink include/asm-ia64/smp.h include/asm-ia64/smp.h
@@ -256,7 +259,12 @@ softlink include/asm-ia64/ustack.h include/asm-ia64/ustack.h
 # xen/include/asm-ia64/linux/*.h (== linux/include/linux/*.h)
 
 cp_patch include/linux/bootmem.h include/asm-ia64/linux/bootmem.h bootmem.h
-cp_patch include/linux/efi.h include/asm-ia64/linux/efi.h efi.h
+cp_patch include/linux/cpumask.h include/asm-ia64/linux/cpumask.h cpumask.h
+#cp_patch include/linux/dma-mapping.h include/asm-ia64/linux/dma-mapping.h dma-mapping.h
+softlink include/linux/dma-mapping.h include/asm-ia64/linux/dma-mapping.h
+#cp_patch include/linux/efi.h include/asm-ia64/linux/efi.h efi.h
+softlink include/linux/efi.h include/asm-ia64/linux/efi.h
+cp_patch include/linux/hardirq.h include/asm-ia64/linux/hardirq.h linuxhardirq.h
 #cp_patch include/linux/init_task.h include/asm-ia64/linux/init_task.h init_task.h
 cp_patch include/linux/interrupt.h include/asm-ia64/linux/interrupt.h interrupt.h
 cp_patch include/linux/mmzone.h include/asm-ia64/linux/mmzone.h mmzone.h
@@ -271,8 +279,7 @@ cp_patch include/linux/time.h include/xen/linuxtime.h linuxtime.h
 softlink include/linux/bcd.h include/asm-ia64/linux/bcd.h
 softlink include/linux/bitmap.h include/asm-ia64/linux/bitmap.h
 softlink include/linux/bitops.h include/asm-ia64/linux/bitops.h
-softlink include/linux/cpumask.h include/asm-ia64/linux/cpumask.h
-softlink include/linux/dma-mapping.h include/asm-ia64/linux/dma-mapping.h
+softlink include/linux/err.h include/asm-ia64/linux/err.h
 softlink include/linux/gfp.h include/asm-ia64/linux/gfp.h
 softlink include/linux/initrd.h include/asm-ia64/linux/initrd.h
 softlink include/linux/kmalloc_sizes.h include/asm-ia64/linux/kmalloc_sizes.h
@@ -295,6 +302,10 @@ softlink include/linux/tty.h include/asm-ia64/linux/tty.h
 null include/asm-ia64/linux/file.h
 null include/asm-ia64/linux/module.h
 null include/asm-ia64/linux/swap.h
+null include/asm-ia64/linux/device.h
+null include/asm-ia64/linux/proc_fs.h
+null include/asm-ia64/linux/rtc.h
+null include/asm-ia64/linux/profile.h
 
 softlink include/linux/byteorder/generic.h include/asm-ia64/linux/byteorder/generic.h
 softlink include/linux/byteorder/little_endian.h include/asm-ia64/linux/byteorder/little_endian.h

xen/arch/ia64/xenasm.S

@@ -132,9 +132,9 @@ GLOBAL_ENTRY(ia64_new_rr7)
 (p7)	br.cond.sptk	.stack_overlaps
 	;;
 	movl r25=PAGE_KERNEL
-	dep r20=0,r13,60,4		// physical address of "current"
+	dep r21=0,r13,60,4		// physical address of "current"
 	;;
-	or r23=r25,r20			// construct PA | page properties
+	or r23=r25,r21			// construct PA | page properties
 	mov r25=IA64_GRANULE_SHIFT<<2
 	;;
 	ptr.d	r13,r25
@@ -152,9 +152,9 @@ GLOBAL_ENTRY(ia64_new_rr7)
 	;;
 	movl r25=PAGE_KERNEL
 	;;
-	mov r20=loc2			// saved percpu physical address
+	mov r21=loc2			// saved percpu physical address
 	;;
-	or r23=r25,r20			// construct PA | page properties
+	or r23=r25,r21			// construct PA | page properties
 	mov r24=PERCPU_PAGE_SHIFT<<2
 	;;
 	ptr.d	r22,r24
@@ -172,9 +172,9 @@ GLOBAL_ENTRY(ia64_new_rr7)
 	;;
 	movl r25=PAGE_KERNEL
 	;;
-	mov r20=loc6			// saved vhpt physical address
+	mov r21=loc6			// saved vhpt physical address
 	;;
-	or r23=r25,r20			// construct PA | page properties
+	or r23=r25,r21			// construct PA | page properties
 	mov r24=VHPT_PAGE_SHIFT<<2
 	;;
 	ptr.d	r22,r24
@@ -192,9 +192,9 @@ GLOBAL_ENTRY(ia64_new_rr7)
 	;;
 	movl r25=PAGE_KERNEL
 	;;
-	mov r20=loc5			// saved sharedinfo physical address
+	mov r21=loc5			// saved sharedinfo physical address
 	;;
-	or r23=r25,r20			// construct PA | page properties
+	or r23=r25,r21			// construct PA | page properties
 	mov r24=PAGE_SHIFT<<2
 	;;
 	ptr.d	r22,r24

xen/arch/ia64/xenmisc.c

@@ -93,6 +93,17 @@ int reprogram_ac_timer(s_time_t timeout)
 DEFINE_PER_CPU(struct page_state, page_states) = {0};
 unsigned long totalram_pages;
 
+void __mod_page_state(unsigned offset, unsigned long delta)
+{
+	unsigned long flags;
+	void* ptr;
+
+	local_irq_save(flags);
+	ptr = &__get_cpu_var(page_states);
+	*(unsigned long*)(ptr + offset) += delta;
+	local_irq_restore(flags);
+}
+
 ///////////////////////////////
 // from arch/x86/flushtlb.c
 ///////////////////////////////

xen/include/asm-ia64/config.h

@@ -39,9 +39,6 @@ typedef int pid_t;
 #define CLEAR_BITMAP(name,bits) \
 	memset(name, 0, BITS_TO_LONGS(bits)*sizeof(unsigned long))
 
-// from linux/include/linux/compiler.h
-#define __user
-
 // FIXME?: x86-ism used in xen/mm.h
 #define LOCK_PREFIX
 
@@ -57,6 +54,21 @@ extern char _end[]; /* standard ELF symbol */
 
 // linux/include/linux/compiler.h
 #define __attribute_const__
+#define __user
+//#define __kernel
+//#define __safe
+#define __force
+#define __iomem
+#define __chk_user_ptr(x) (void)0
+//#define __chk_io_ptr(x) (void)0
+//#define __builtin_warning(x, y...) (1)
+//#define __acquires(x)
+//#define __releases(x)
+//#define __acquire(x) (void)0
+//#define __release(x) (void)0
+//#define __cond_lock(x) (x)
+#define __must_check
+#define __deprecated
 
 // xen/include/asm/config.h
 #define HZ 100
@@ -66,6 +78,9 @@ extern char _end[]; /* standard ELF symbol */
 //#define CONFIG_NR_CPUS 16
 #define barrier() __asm__ __volatile__("": : :"memory")
 
+// linux/include/spinlock.h
+#define DEFINE_SPINLOCK(x) spinlock_t x = SPIN_LOCK_UNLOCKED
+
 ///////////////////////////////////////////////////////////////
 // xen/include/asm/config.h
 // Natural boundary upon TR size to define xenheap space

xen/include/asm-ia64/mm.h

@@ -25,25 +25,6 @@
 
 typedef unsigned long page_flags_t;
 
-// from linux/include/linux/mm.h
-
-extern pmd_t *FASTCALL(__pmd_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address));
-extern pte_t *FASTCALL(pte_alloc_kernel(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
-extern pte_t *FASTCALL(pte_alloc_map(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
-
-/*
- * On a two-level page table, this ends up being trivial. Thus the
- * inlining and the symmetry break with pte_alloc_map() that does all
- * of this out-of-line.
- */
-static inline pmd_t *pmd_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
-{
-	if (pgd_none(*pgd))
-		return __pmd_alloc(mm, pgd, address);
-	return pmd_offset(pgd, address);
-}
-
-
 /*
  * Per-page-frame information.
  */