rename packages/ to recipes/ per earlier agreement

See links below for more details: http://thread.gmane.org/gmane.comp.handhelds.openembedded/21326 http://thread.gmane.org/gmane.comp.handhelds.openembedded/21816 Signed-off-by: Denys Dmytriyenko <denis@denix.org> Acked-by: Mike Westerhof <mwester@dls.net> Acked-by: Philip Balister <philip@balister.org> Acked-by: Khem Raj <raj.khem@gmail.com> Acked-by: Marcin Juszkiewicz <hrw@openembedded.org> Acked-by: Koen Kooi <koen@openembedded.org> Acked-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>
author: Denys Dmytriyenko <denis@denix.org> 2009-03-17 14:32:59 -0400
committer: Denys Dmytriyenko <denis@denix.org> 2009-03-17 14:32:59 -0400
commit: 709c4d66e0b107ca606941b988bad717c0b45d9b (patch)
tree: 37ee08b1eb308f3b2b6426d5793545c38396b838 /recipes/linux/linux-colinux-2.6.10/colinux-0.6.2.patch
parent: fa6cd5a3b993f16c27de4ff82b42684516d433ba (diff)
1 files changed, 9069 insertions, 0 deletions
diff --git a/recipes/linux/linux-colinux-2.6.10/colinux-0.6.2.patch b/recipes/linux/linux-colinux-2.6.10/colinux-0.6.2.patch
new file mode 100644
index 0000000000..e64013e8ae
--- /dev/null
+++ b/recipes/linux/linux-colinux-2.6.10/colinux-0.6.2.patch
@@ -0,0 +1,9069 @@
+diff -urN a/CREDITS b/CREDITS
+--- a/CREDITS
++++ b/CREDITS
+@@ -52,6 +52,12 @@
+ S: Buenos Aires
+ S: Argentina
+ 
++A: Dan Aloni
++E: da-x@colinux.org
++D: Cooperative Linux
++D: Various kernel patches
++S: Israel
++
+ N: Tim Alpaerts
+ E: tim_alpaerts@toyota-motor-europe.com
+ D: 802.2 class II logical link control layer,
+diff -urN a/Makefile b/Makefile
+--- a/Makefile
++++ b/Makefile
+@@ -319,6 +319,11 @@
+ AS		= $(CROSS_COMPILE)as
+ LD		= $(CROSS_COMPILE)ld
+ CC		= $(CROSS_COMPILE)gcc
++ifeq ($(GCCTRACE),Y)
++CC              = $(CORSS_COMPILE)$(COLINUX_ROOT)/bin/tracewrapper.py gcc
++else
++CC		= $(CROSS_COMPILE)gcc
++endif
+ CPP		= $(CC) -E
+ AR		= $(CROSS_COMPILE)ar
+ NM		= $(CROSS_COMPILE)nm
+diff -urN a/arch/i386/Kconfig b/arch/i386/Kconfig
+--- a/arch/i386/Kconfig
++++ b/arch/i386/Kconfig
+@@ -205,6 +205,7 @@
+ 
+ config M586TSC
+ 	bool "Pentium-Classic"
++	depends on !COOPERATIVE
+ 	help
+ 	  Select this for a Pentium Classic processor with the RDTSC (Read
+ 	  Time Stamp Counter) instruction for benchmarking.
+@@ -543,6 +544,10 @@
+ 	  If you have a system with several CPUs, you do not need to say Y
+ 	  here: the IO-APIC will be used automatically.
+ 
++config X86_UP_COPIC
++	bool 'Cooperative PIC (COPIC) support' 
++	depends on COOPERATIVE
++
+ config X86_LOCAL_APIC
+ 	bool
+ 	depends on !SMP && X86_UP_APIC
+@@ -555,7 +560,7 @@
+ 
+ config X86_TSC
+ 	bool
+-	depends on (MWINCHIP3D || MWINCHIP2 || MCRUSOE || MEFFICEON || MCYRIXIII || MK7 || MK6 || MPENTIUM4 || MPENTIUMM || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || MK8 || MVIAC3_2) && !X86_NUMAQ
++ 	depends on (MWINCHIP3D || MWINCHIP2 || MCRUSOE || MEFFICEON || MCYRIXIII || MK7 || MK6 || MPENTIUM4 || MPENTIUMM || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || MK8 || MVIAC3_2) && !X86_NUMAQ && !COOPERATIVE
+ 	default y
+ 
+ config X86_MCE
+@@ -882,6 +887,10 @@
+ 
+ source kernel/power/Kconfig
+ 
++config COOPERATIVE
++	bool 'Cooperative Mode'
++	default y
++
+ source "drivers/acpi/Kconfig"
+ 
+ menu "APM (Advanced Power Management) BIOS Support"
+diff -urN a/arch/i386/kernel/Makefile b/arch/i386/kernel/Makefile
+--- a/arch/i386/kernel/Makefile
++++ b/arch/i386/kernel/Makefile
+@@ -17,6 +17,7 @@
+ obj-$(CONFIG_X86_MSR)		+= msr.o
+ obj-$(CONFIG_X86_CPUID)		+= cpuid.o
+ obj-$(CONFIG_MICROCODE)		+= microcode.o
++obj-$(CONFIG_COOPERATIVE)       += cooperative.o
+ obj-$(CONFIG_APM)		+= apm.o
+ obj-$(CONFIG_X86_SMP)		+= smp.o smpboot.o
+ obj-$(CONFIG_X86_TRAMPOLINE)	+= trampoline.o
+diff -urN a/arch/i386/kernel/cooperative.c b/arch/i386/kernel/cooperative.c
+--- a/arch/i386/kernel/cooperative.c
++++ b/arch/i386/kernel/cooperative.c
+@@ -0,0 +1,340 @@
++#include <linux/kernel.h>
++#include <linux/string.h>
++#include <linux/interrupt.h>
++#include <linux/mm.h>
++
++#include <linux/cooperative_internal.h>
++#include <asm/cooperative_internal.h>
++#include <asm/smp.h>
++#include <asm/desc.h>
++#include <asm/mmu_context.h>
++#include <asm/debugreg.h>
++#include <asm/i387.h>
++
++CO_TRACE_STOP;
++
++
++/*
++ * The next asm code is the first Linux code that runs in the 
++ * coLinux kernel context. It receives %ecx which contains the 
++ * address of the passage page. The passage page code sets %ecx 
++ * to this value in its context restore part.
++ */  
++
++asm(
++	""
++	".section .text\n"
++	".globl co_start\n"
++	"co_start:\n"
++	"       call co_start_arch\n"
++	".previous\n"
++	"");
++
++static int co_passage_page_holding_count = 0;
++
++static void co_early_cpu_init(void)
++{
++	/*
++	 * On the first switch to Linux we must set up a valid TR because 
++	 * the passage page code assumes such one exists. This is basically
++	 * copied code from cpu_init().
++	 *
++	 * P.S this is protected by CO_TRACE_STOP so that we don't
++	 * have a monitor context switch.
++	 */
++        int cpu = smp_processor_id();
++        struct tss_struct * t = &per_cpu(init_tss, cpu);
++        struct thread_struct *thread = &current->thread;
++
++	/*
++	 * Initialize the per-CPU GDT with the boot GDT,
++	 * and set up the GDT descriptor:
++	 */
++	memcpy(&per_cpu(cpu_gdt_table, cpu), cpu_gdt_table, GDT_SIZE);
++	cpu_gdt_descr[cpu].size = GDT_SIZE - 1;
++	cpu_gdt_descr[cpu].address = (unsigned long)&per_cpu(cpu_gdt_table, cpu);
++
++        /*
++         * Set up the per-thread TLS descriptor cache:
++         */
++        memcpy(thread->tls_array, &per_cpu(cpu_gdt_table, cpu), GDT_ENTRY_TLS_ENTRIES * 8);
++
++        __asm__ __volatile__("lgdt %0" : : "m" (cpu_gdt_descr[cpu]));
++        __asm__ __volatile__("lidt %0" : : "m" (idt_descr));
++
++        /*
++         * Delete NT
++         */
++        __asm__("pushfl ; andl $0xffffbfff,(%esp) ; popfl");
++
++        /*
++         * Set up and load the per-CPU TSS and LDT
++         */
++        atomic_inc(&init_mm.mm_count);
++        current->active_mm = &init_mm;
++        enter_lazy_tlb(&init_mm, current);
++
++        load_esp0(t, thread);
++        set_tss_desc(cpu,t);
++        per_cpu(cpu_gdt_table, cpu)[GDT_ENTRY_TSS].b &= 0xfffffdff;
++
++        load_TR_desc();
++
++        load_LDT(&init_mm.context);
++
++        /* Set up doublefault TSS pointer in the GDT */
++        __set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
++        per_cpu(cpu_gdt_table, cpu)[GDT_ENTRY_DOUBLEFAULT_TSS].b &= 0xfffffdff;
++
++        /* Clear %fs and %gs. */
++        asm volatile ("xorl %eax, %eax; movl %eax, %fs; movl %eax, %gs");
++
++	__asm__ __volatile__("movl %%cr4, %0" : "=r" (mmu_cr4_features));
++}
++
++asm(
++	""
++	".section .text\n"
++	".globl co_arch_start_kernel\n"
++	"co_arch_start_kernel:\n"
++	"       call co_startup_entry\n"
++	".previous\n"
++	"");
++
++void co_start_arch(void)
++{
++	co_early_cpu_init();
++	co_start_kernel();
++}
++
++extern void ctrl_alt_del(void);
++
++void co_handle_jiffies(long count)
++{
++	unsigned long flags;
++	struct pt_regs regs;
++
++	if (count > HZ) {
++		xtime.tv_sec += count / HZ;
++		count -= ((count / HZ) * HZ);
++	}
++		
++	while (count > 0) {
++		local_irq_save(flags);
++		regs.orig_eax = TIMER_IRQ;
++		do_IRQ(&regs);
++		local_irq_restore(flags);
++
++		count--;
++	}
++}
++
++void co_handle_incoming_message(co_message_node_t *node_message)
++{
++	unsigned long flags;
++	struct pt_regs regs;
++	co_linux_message_t *message;
++
++	message = (co_linux_message_t *)&node_message->msg.data;
++
++	switch (message->device) {
++	case CO_DEVICE_POWER: {
++		co_linux_message_power_t *type = (co_linux_message_power_t *)message->data;
++		switch (type->type) {
++		case CO_LINUX_MESSAGE_POWER_ALT_CTRL_DEL: {
++			ctrl_alt_del();
++			break;
++		}
++		}
++		co_free_message(node_message);
++		break;
++	}
++
++	case CO_DEVICE_KEYBOARD: {
++		co_queue_incoming_message(node_message);
++
++		local_irq_save(flags);
++		regs.orig_eax = KEYBOARD_IRQ;
++		do_IRQ(&regs);
++		local_irq_restore(flags);
++		break;
++	}
++	
++	case CO_DEVICE_NETWORK: {
++		co_queue_incoming_message(node_message);
++
++		local_irq_save(flags);
++		regs.orig_eax = NETWORK_IRQ;
++		do_IRQ(&regs);
++		local_irq_restore(flags);
++		break;
++	}
++
++	case CO_DEVICE_SERIAL: {
++		co_queue_incoming_message(node_message);
++
++		local_irq_save(flags);
++		cocd_interrupt();
++		local_irq_restore(flags);
++		break;
++	}
++
++	default:
++		co_free_message(node_message);
++		break;
++	}
++}
++
++void co_switch_wrapper_protected(void)
++{
++	kernel_fpu_begin();
++
++	/*
++	 * We don't trust the passage page code to safely restore %gs and %fs. 
++	 *
++	 * This wrapper ensures that if %fs or %gs are invalid, the processes
++	 * exits with a segmentation fault rather than bringing down the 
++	 * machine.
++	 **/
++	unsigned long fs = 0;
++	unsigned long gs = 0;
++
++        asm volatile("movl %%fs,%0": "=m" (fs));
++        asm volatile("movl %%gs,%0": "=m" (gs));
++
++	/*
++	 * Nullify the registers so the passage page code restores to 
++	 * null segment values on return.
++	 */
++        asm volatile("movl %0, %%fs;  movl %0, %%gs" : : "r" (0));
++
++	/* And switch... */
++	co_switch();
++
++	/*
++	 * Safely restore the registers.
++	 */
++	loadsegment(fs, fs);
++	loadsegment(gs, gs);
++
++	kernel_fpu_end();
++}
++
++void co_switch_wrapper(void)
++{
++	/* taken from irq.c: debugging check for stack overflow */
++	long esp;
++	
++	__asm__ __volatile__("andl %%esp,%0" : "=r" (esp) : "0" (THREAD_SIZE - 1));
++	if (unlikely(esp < (sizeof(struct thread_info) + STACK_WARN))) {
++		printk("co_switch_wrapper: stack overflow: %ld\n", esp - sizeof(struct thread_info));
++		co_terminate(CO_TERMINATE_STACK_OVERFLOW);
++	}
++
++	co_switch_wrapper_protected();
++}
++
++void co_passage_page_acquire(unsigned long *flags)
++{
++	local_irq_save(*flags);
++	co_passage_page_holding_count++;
++}
++
++int co_passage_page_held(void)
++{
++	return co_passage_page_holding_count;
++}
++
++void co_passage_page_release(unsigned long flags)
++{
++	co_passage_page_holding_count--;
++	local_irq_restore(flags);
++}
++
++void co_debug(const char *fmt, ...)
++{
++}
++
++#define MAX_TRACE_POINTS 1024
++
++typedef struct {	
++	unsigned char *code;
++	unsigned char original_byte;
++	int off;
++} co_tracepoint_t;
++
++co_tracepoint_t tracepoints[MAX_TRACE_POINTS];
++static int active_tracepoints = 0;
++
++void co_kernel_breakpoint(struct pt_regs * regs)
++{
++	int i = 0;
++	unsigned char *code = (unsigned char *)regs->eip;
++	if (!code)
++		return;
++
++	for (i=0; i < active_tracepoints; i++) {
++		if (tracepoints[i].code == code - 1) {
++			co_debug("TRACEPOINT: %x\n", code - 1);
++			break;
++		}
++	}
++
++	if (i == active_tracepoints) {
++		/* Bad, we don't know this tracepoint */
++		co_terminate(CO_TERMINATE_INVALID_OPERATION);
++		return;
++	}
++
++	*tracepoints[i].code = tracepoints[i].original_byte;
++	regs->eflags |= (1 << 8); /* Enable TF */
++	regs->eip = (unsigned long)(code - 1);
++	tracepoints[i].off = 1;
++}
++
++void co_kernel_set_breakpoints(void)
++{
++	int i;
++
++	for (i=0; i < active_tracepoints; i++)
++		if (tracepoints[i].code  &&  tracepoints[i].off) {
++			*tracepoints[i].code = 0xcc;
++			tracepoints[i].off = 0;
++		}
++}
++
++int co_kernel_debug(struct pt_regs *regs, long error_code, unsigned int condition)
++{
++	/* if not a single step trap */
++	if (!(condition & DR_STEP))
++		return 0;
++
++	/* if userspace */
++	if (regs->xcs & 3)
++		return 0;
++
++	regs->eflags &= ~(1 << 8); /* Disable TF */
++
++	co_kernel_set_breakpoints();
++	
++	return 1;
++}
++
++void co_kernel_tracepoint_add(unsigned char *code)
++{
++	if (active_tracepoints >= MAX_TRACE_POINTS)
++		return;
++
++	tracepoints[active_tracepoints].code = code;
++	tracepoints[active_tracepoints].original_byte = *code;
++	tracepoints[active_tracepoints].off = 0;
++	active_tracepoints++;
++	*code = 0xcc;
++}
++
++co_arch_info_t co_arch_info = {
++	.kernel_cs = __KERNEL_CS,
++	.kernel_ds = __KERNEL_DS,
++};
++
++CO_TRACE_CONTINUE;
+diff -urN a/arch/i386/kernel/cpu/common.c b/arch/i386/kernel/cpu/common.c
+--- a/arch/i386/kernel/cpu/common.c
++++ b/arch/i386/kernel/cpu/common.c
+@@ -4,6 +4,7 @@
+ #include <linux/smp.h>
+ #include <linux/module.h>
+ #include <linux/percpu.h>
++#include <linux/cooperative_internal.h>
+ #include <asm/semaphore.h>
+ #include <asm/processor.h>
+ #include <asm/i387.h>
+@@ -570,11 +571,13 @@
+ 
+ 	/* Clear all 6 debug registers: */
+ 
++	if (!cooperative_mode_enabled()) {
+ #define CD(register) __asm__("movl %0,%%db" #register ::"r"(0) );
+ 
+-	CD(0); CD(1); CD(2); CD(3); /* no db4 and db5 */; CD(6); CD(7);
++		CD(0); CD(1); CD(2); CD(3); /* no db4 and db5 */; CD(6); CD(7);
+ 
+ #undef CD
++	}
+ 
+ 	/*
+ 	 * Force FPU initialization:
+diff -urN a/arch/i386/kernel/entry.S b/arch/i386/kernel/entry.S
+--- a/arch/i386/kernel/entry.S
++++ b/arch/i386/kernel/entry.S
+@@ -158,7 +158,7 @@
+ 	ALIGN
+ ret_from_exception:
+ 	preempt_stop
+-ret_from_intr:
++ENTRY(ret_from_intr)
+ 	GET_THREAD_INFO(%ebp)
+ 	movl EFLAGS(%esp), %eax		# mix EFLAGS and CS
+ 	movb CS(%esp), %al
+diff -urN a/arch/i386/kernel/head.S b/arch/i386/kernel/head.S
+--- a/arch/i386/kernel/head.S
++++ b/arch/i386/kernel/head.S
+@@ -238,6 +238,7 @@
+ 	rep
+ 	movsl
+ 1:
++ENTRY(co_startup_entry)
+ checkCPUtype:
+ 
+ 	movl $-1,X86_CPUID		#  -1 for no CPUID initially
+@@ -425,7 +426,7 @@
+ .data
+ 
+ ENTRY(stack_start)
+-	.long init_thread_union+THREAD_SIZE
++	.long init_thread_union+THREAD_SIZE-100
+ 	.long __BOOT_DS
+ 
+ ready:	.byte 0
+diff -urN a/arch/i386/kernel/i387.c b/arch/i386/kernel/i387.c
+--- a/arch/i386/kernel/i387.c
++++ b/arch/i386/kernel/i387.c
+@@ -17,6 +17,7 @@
+ #include <asm/user.h>
+ #include <asm/ptrace.h>
+ #include <asm/uaccess.h>
++#include <linux/cooperative_internal.h>
+ 
+ #ifdef CONFIG_MATH_EMULATION
+ #define HAVE_HWFP (boot_cpu_data.hard_math)
+@@ -37,6 +38,10 @@
+ 		if (mask == 0) mask = 0x0000ffbf;
+ 	} 
+ 	mxcsr_feature_mask &= mask;
++
++	if (cooperative_mode_enabled()) 
++		return;
++
+ 	stts();
+ }
+ 
+@@ -386,6 +391,7 @@
+ 	return err;
+ }
+ 
++
+ /*
+  * ptrace request handlers.
+  */
+diff -urN a/arch/i386/kernel/i8259.c b/arch/i386/kernel/i8259.c
+--- a/arch/i386/kernel/i8259.c
++++ b/arch/i386/kernel/i8259.c
+@@ -26,9 +26,89 @@
+ #include <asm/i8259.h>
+ 
+ #include <linux/irq.h>
++#include <linux/cooperative_internal.h>
+ 
+ #include <io_ports.h>
+ 
++#ifdef CONFIG_COOPERATIVE
++
++CO_TRACE_STOP;
++
++void proxy_interrupt_handler(unsigned long interrupt, struct pt_regs regs)
++{
++	unsigned long flags;
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_FORWARD_INTERRUPT;
++	co_passage_page->params[0] = interrupt + 0x20;
++	co_passage_page->params[1] = regs.eip;
++	co_passage_page->params[2] = (unsigned long)(&((&interrupt)[10]));
++	co_passage_page->host_state.flags &= ~(1 << 9); /* Turn IF off */
++	co_switch_wrapper();
++	co_callback(flags);
++}
++
++CO_TRACE_CONTINUE;
++
++#define IRQLIST_16(x) \
++	IRQ(x,0) IRQ(x,1) IRQ(x,2) IRQ(x,3) \
++	IRQ(x,4) IRQ(x,5) IRQ(x,6) IRQ(x,7) \
++	IRQ(x,8) IRQ(x,9) IRQ(x,a) IRQ(x,b) \
++	IRQ(x,c) IRQ(x,d) IRQ(x,e) IRQ(x,f)
++
++#define IRQLIST_224 \
++	IRQLIST_16(0x0) IRQLIST_16(0x1) IRQLIST_16(0x2) IRQLIST_16(0x3) \
++	IRQLIST_16(0x4) IRQLIST_16(0x5) IRQLIST_16(0x6) IRQLIST_16(0x7) \
++	IRQLIST_16(0x8) IRQLIST_16(0x9) IRQLIST_16(0xa) IRQLIST_16(0xb) \
++	IRQLIST_16(0xc) IRQLIST_16(0xd)
++
++#define IRQ(x,y) \
++	extern asmlinkage void IRQ_proxy_##x##y##_interrupt(void);
++IRQLIST_224;
++#undef IRQ
++
++#define BIRQ(id)						\
++asm(								\
++    "\n"__ALIGN_STR"\n"						\
++    ".section .text\n"						\
++    ".globl IRQ_proxy_" #id "_interrupt\n"			\
++    "IRQ_proxy_" #id "_interrupt:\n"				\
++    "push %eax\n\t"						\
++    "cld;\n\t"							\
++    "pushl %es;\n\t"						\
++    "pushl %ds;\n\t"						\
++    "pushl %eax;\n\t"						\
++    "pushl %ebp;\n\t"						\
++    "pushl %edi;\n\t"						\
++    "pushl %esi;\n\t"						\
++    "pushl %edx;\n\t"						\
++    "pushl %ecx;\n\t"						\
++    "pushl %ebx;\n\t"						\
++    "movl $123, %edx;\n\t"			         	\
++    "movl %edx, %ds;\n\t"					\
++    "movl %edx, %es;\n\t"					\
++    "pushl $" #id "\n\t"					\
++    "call proxy_interrupt_handler\n\t"				\
++    "popl %ebx\n\t"						\
++    "jmp ret_from_intr\n"					\
++    ".previous\n"						\
++    );		                    				\
++
++#define IRQ(x,y) BIRQ(x##y)
++IRQLIST_224;
++#undef IRQ
++
++#define IRQ(x,y) &IRQ_proxy_##x##y##_interrupt,
++void (*proxy_interrupt[NR_IRQS])(void) = {
++    IRQLIST_224
++};
++#undef IRQ
++
++#undef IRQLIST_16
++#undef IRQLIST_224
++
++#endif 
++    
+ /*
+  * This is the 'legacy' 8259A Programmable Interrupt Controller,
+  * present in the majority of PC/AT boxes.
+@@ -364,6 +444,9 @@
+ {
+ 	int i;
+ 
++	if (cooperative_mode_enabled())
++		return;
++
+ #ifdef CONFIG_X86_LOCAL_APIC
+ 	init_bsp_APIC();
+ #endif
+@@ -388,6 +471,65 @@
+ 	}
+ }
+ 
++#ifdef CONFIG_X86_UP_COPIC
++
++/*
++ * Not like you have any other choice other than using
++ * COPIC in Cooperative mode.
++ */
++
++static void end_COPIC_irq(unsigned int irq)
++{
++}
++
++#define shutdown_COPIC_irq	disable_COPIC_irq
++
++static void mask_and_ack_COPIC(unsigned int irq)
++{
++}
++
++static unsigned int startup_COPIC_irq(unsigned int irq)
++{
++	return 0;
++}
++
++void disable_COPIC_irq(unsigned int irq)
++{
++}
++
++void enable_COPIC_irq(unsigned int irq)
++{
++}
++
++static struct hw_interrupt_type co_pic_irq_type = {
++	"CO-PIC",
++	startup_COPIC_irq,
++	shutdown_COPIC_irq,
++	enable_COPIC_irq,
++	disable_COPIC_irq,
++	mask_and_ack_COPIC,
++	end_COPIC_irq,
++	NULL
++};
++
++void __init init_COPIC_irqs(void)
++{
++	int i;
++
++	for (i = 0; i < NR_IRQS; i++) {
++		irq_desc[i].status = IRQ_DISABLED;
++		irq_desc[i].action = 0;
++		irq_desc[i].depth = 1;
++
++		irq_desc[i].handler = &co_pic_irq_type;
++	}
++	
++}
++
++#else
++#define init_COPIC_irqs() do {} while (0);
++#endif
++
+ void __init init_IRQ(void)
+ {
+ 	int i;
+@@ -395,6 +537,22 @@
+ 	/* all the set up before the call gates are initialised */
+ 	pre_intr_init_hook();
+ 
++	if (cooperative_mode_enabled()) {
++		printk("Setting proxy interrupt vectors\n");
++
++		init_COPIC_irqs();
++
++		for (i = 0; i < (NR_VECTORS - FIRST_EXTERNAL_VECTOR); i++) {
++			int vector = FIRST_EXTERNAL_VECTOR + i;
++			if (i >= NR_IRQS)
++				break;
++			if (vector != SYSCALL_VECTOR)
++				set_intr_gate(vector, proxy_interrupt[i]);
++		}
++		
++		return;
++	}
++
+ 	/*
+ 	 * Cover the whole vector space, no vector can escape
+ 	 * us. (some of these will be overridden and become
+diff -urN a/arch/i386/kernel/ioport.c b/arch/i386/kernel/ioport.c
+--- a/arch/i386/kernel/ioport.c
++++ b/arch/i386/kernel/ioport.c
+@@ -15,6 +15,7 @@
+ #include <linux/stddef.h>
+ #include <linux/slab.h>
+ #include <linux/thread_info.h>
++#include <linux/cooperative_internal.h>
+ 
+ /* Set EXTENT bits starting at BASE in BITMAP to value TURN_ON. */
+ static void set_bitmap(unsigned long *bitmap, unsigned int base, unsigned int extent, int new_value)
+@@ -61,6 +62,9 @@
+ 	struct tss_struct * tss;
+ 	unsigned long *bitmap;
+ 
++	if (cooperative_mode_enabled())
++		return -EPERM;	
++
+ 	if ((from + num <= from) || (from + num > IO_BITMAP_BITS))
+ 		return -EINVAL;
+ 	if (turn_on && !capable(CAP_SYS_RAWIO))
+@@ -133,6 +137,9 @@
+ 	unsigned int level = regs->ebx;
+ 	unsigned int old = (regs->eflags >> 12) & 3;
+ 
++	if (cooperative_mode_enabled())
++		return -EPERM;	
++
+ 	if (level > 3)
+ 		return -EINVAL;
+ 	/* Trying to gain more privileges? */
+diff -urN a/arch/i386/kernel/process.c b/arch/i386/kernel/process.c
+--- a/arch/i386/kernel/process.c
++++ b/arch/i386/kernel/process.c
+@@ -52,6 +52,7 @@
+ 
+ #include <linux/irq.h>
+ #include <linux/err.h>
++#include <linux/cooperative_internal.h>
+ 
+ asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
+ 
+@@ -147,21 +148,24 @@
+ 	/* endless idle loop with no priority at all */
+ 	while (1) {
+ 		while (!need_resched()) {
+-			void (*idle)(void);
+-			/*
+-			 * Mark this as an RCU critical section so that
+-			 * synchronize_kernel() in the unload path waits
+-			 * for our completion.
+-			 */
+-			rcu_read_lock();
+-			idle = pm_idle;
++			void (*idle)(void) = pm_idle;
++
++ 			/*
++ 			 * Mark this as an RCU critical section so that
++ 			 * synchronize_kernel() in the unload path waits
++ 			 * for our completion.
++ 			 */
++ 			rcu_read_lock();
++
++			if (cooperative_mode_enabled())
++				idle = co_idle_processor;
+ 
+ 			if (!idle)
+ 				idle = default_idle;
+ 
+ 			irq_stat[smp_processor_id()].idle_timestamp = jiffies;
+ 			idle();
+-			rcu_read_unlock();
++ 			rcu_read_unlock();
+ 		}
+ 		schedule();
+ 	}
+diff -urN a/arch/i386/kernel/reboot.c b/arch/i386/kernel/reboot.c
+--- a/arch/i386/kernel/reboot.c
++++ b/arch/i386/kernel/reboot.c
+@@ -13,6 +13,7 @@
+ #include <asm/uaccess.h>
+ #include <asm/apic.h>
+ #include "mach_reboot.h"
++#include <linux/cooperative_internal.h>
+ 
+ /*
+  * Power off function, if any
+@@ -217,6 +218,11 @@
+ {
+ 	unsigned long flags;
+ 
++	if (cooperative_mode_enabled()) {
++		co_terminate(CO_TERMINATE_REBOOT);
++		return;
++	}
++
+ 	local_irq_disable();
+ 
+ 	/* Write zero to CMOS register number 0x0f, which the BIOS POST
+@@ -332,8 +338,13 @@
+ 	 */
+ 	smp_send_stop();
+ #endif /* CONFIG_SMP */
+-
++ 
+ 	lapic_shutdown();
++ 
++	if (cooperative_mode_enabled()) {
++		co_terminate(CO_TERMINATE_REBOOT);
++		return;
++	}
+ 
+ #ifdef CONFIG_X86_IO_APIC
+ 	disable_IO_APIC();
+@@ -364,12 +375,18 @@
+ 
+ void machine_halt(void)
+ {
++	co_terminate(CO_TERMINATE_HALT);
+ }
+ 
+ EXPORT_SYMBOL(machine_halt);
+ 
+ void machine_power_off(void)
+ {
++	if (cooperative_mode_enabled()) {
++		co_terminate(CO_TERMINATE_POWEROFF);
++		return;
++	}
++
+ 	lapic_shutdown();
+ 
+ 	if (efi_enabled)
+diff -urN a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
+--- a/arch/i386/kernel/setup.c
++++ b/arch/i386/kernel/setup.c
+@@ -39,6 +39,7 @@
+ #include <linux/efi.h>
+ #include <linux/init.h>
+ #include <linux/edd.h>
++#include <linux/cooperative_internal.h>
+ #include <video/edid.h>
+ #include <asm/e820.h>
+ #include <asm/mpspec.h>
+@@ -668,8 +669,17 @@
+ 	int len = 0;
+ 	int userdef = 0;
+ 
+-	/* Save unparsed command line copy for /proc/cmdline */
+-	saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
++	if (cooperative_mode_enabled()) {
++		/*
++		 * Better to have 'root=/dev/cobd0' here.
++		 */
++		from = co_boot_parameters;
++		snprintf(saved_command_line, COMMAND_LINE_SIZE, "%s", 
++			 co_boot_parameters);
++	} else {
++		/* Save unparsed command line copy for /proc/cmdline */
++		saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
++	}
+ 
+ 	for (;;) {
+ 		/*
+@@ -1019,6 +1029,8 @@
+ static unsigned long __init setup_memory(void)
+ {
+ 	unsigned long bootmap_size, start_pfn, max_low_pfn;
++	extern char _end;
++	unsigned long start_va = 0;
+ 
+ 	/*
+ 	 * partially used pages are not usable - thus
+@@ -1026,9 +1038,16 @@
+ 	 */
+ 	start_pfn = PFN_UP(init_pg_tables_end);
+ 
+-	find_max_pfn();
+-
+-	max_low_pfn = find_max_low_pfn();
++	if (cooperative_mode_enabled()) {
++	     max_low_pfn = max_pfn = co_memory_size / PAGE_SIZE;
++	     start_pfn = PFN_UP(__pa((unsigned long)&_end)) + 0x10;
++	     start_va = (unsigned long)__va(start_pfn << PAGE_SHIFT);
++	     co_alloc_pages(start_va, 0x20);
++	} else {
++	     find_max_pfn();
++	     
++	     max_low_pfn = find_max_low_pfn();
++	}
+ 
+ #ifdef CONFIG_HIGHMEM
+ 	highstart_pfn = highend_pfn = max_pfn;
+@@ -1040,37 +1059,47 @@
+ #endif
+ 	printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
+ 			pages_to_mb(max_low_pfn));
+-	/*
+-	 * Initialize the boot-time allocator (with low memory only):
+-	 */
+-	bootmap_size = init_bootmem(start_pfn, max_low_pfn);
+ 
+-	register_bootmem_low_pages(max_low_pfn);
+ 
+ 	/*
+-	 * Reserve the bootmem bitmap itself as well. We do this in two
+-	 * steps (first step was init_bootmem()) because this catches
+-	 * the (very unlikely) case of us accidentally initializing the
+-	 * bootmem allocator with an invalid RAM area.
++	 * Initialize the boot-time allocator (with low memory only):
+ 	 */
+-	reserve_bootmem(HIGH_MEMORY, (PFN_PHYS(start_pfn) +
+-			 bootmap_size + PAGE_SIZE-1) - (HIGH_MEMORY));
++	bootmap_size = init_bootmem(start_pfn, max_low_pfn);
+ 
+-	/*
+-	 * reserve physical page 0 - it's a special BIOS page on many boxes,
+-	 * enabling clean reboots, SMP operation, laptop functions.
+-	 */
+-	reserve_bootmem(0, PAGE_SIZE);
+ 
+-	/* reserve EBDA region, it's a 4K region */
+-	reserve_ebda_region();
++	if (cooperative_mode_enabled()) {
++		unsigned long bootmem_end = start_va + bootmap_size + (0x10 << PAGE_SHIFT);
++		unsigned long physical_end = __PAGE_OFFSET + (max_low_pfn << PAGE_SHIFT);
++	    
++		free_bootmem(__pa(bootmem_end), physical_end - bootmem_end);
++	} else {
++		register_bootmem_low_pages(max_low_pfn); 
++		
++		/*
++		 * Reserve the bootmem bitmap itself as well. We do this in two
++		 * steps (first step was init_bootmem()) because this catches
++		 * the (very unlikely) case of us accidentally initializing the
++		 * bootmem allocator with an invalid RAM area.
++		 */
++		reserve_bootmem(HIGH_MEMORY, (PFN_PHYS(start_pfn) +
++				 bootmap_size + PAGE_SIZE-1) - (HIGH_MEMORY));
++	
++		/*
++		 * reserve physical page 0 - it's a special BIOS page on many boxes,
++		 * enabling clean reboots, SMP operation, laptop functions.
++		 */
++		reserve_bootmem(0, PAGE_SIZE);
+ 
+-    /* could be an AMD 768MPX chipset. Reserve a page  before VGA to prevent
+-       PCI prefetch into it (errata #56). Usually the page is reserved anyways,
+-       unless you have no PS/2 mouse plugged in. */
+-	if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
+-	    boot_cpu_data.x86 == 6)
+-	     reserve_bootmem(0xa0000 - 4096, 4096);
++		/* reserve EBDA region, it's a 4K region */
++		reserve_ebda_region();
++	
++	    /* could be an AMD 768MPX chipset. Reserve a page  before VGA to prevent
++	       PCI prefetch into it (errata #56). Usually the page is reserved anyways,
++	       unless you have no PS/2 mouse plugged in. */
++		if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
++		    boot_cpu_data.x86 == 6)
++		     reserve_bootmem(0xa0000 - 4096, 4096);
++	}
+ 
+ #ifdef CONFIG_SMP
+ 	/*
+@@ -1094,6 +1123,7 @@
+ #endif
+ 
+ #ifdef CONFIG_BLK_DEV_INITRD
++#ifndef CONFIG_COOPERATIVE
+ 	if (LOADER_TYPE && INITRD_START) {
+ 		if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
+ 			reserve_bootmem(INITRD_START, INITRD_SIZE);
+@@ -1109,6 +1139,17 @@
+ 			initrd_start = 0;
+ 		}
+ 	}
++#else
++	if (co_initrd != NULL) {
++		printk(KERN_INFO "initrd enabled: start: 0x%x  size: 0x%08lx)\n",
++		       (unsigned int)co_initrd, (long unsigned int)co_initrd_size);
++               
++		initrd_start = (unsigned long)co_initrd;
++		initrd_end = (unsigned long)co_initrd + co_initrd_size;
++		
++		reserve_bootmem(virt_to_phys(co_initrd), co_initrd_size);
++	}
++#endif
+ #endif
+ 	return max_low_pfn;
+ }
+@@ -1315,6 +1356,7 @@
+ 		efi_enabled = 1;
+ #endif
+ 
++	boot_cpu_data.hard_math = 1;
+  	ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
+  	drive_info = DRIVE_INFO;
+  	screen_info = SCREEN_INFO;
+@@ -1338,7 +1380,7 @@
+ 	ARCH_SETUP
+ 	if (efi_enabled)
+ 		efi_init();
+-	else {
++ 	else if (!cooperative_mode_enabled()) {
+ 		printk(KERN_INFO "BIOS-provided physical RAM map:\n");
+ 		print_memory_map(machine_specific_memory_setup());
+ 	}
+@@ -1392,8 +1434,9 @@
+ 	}
+ #endif
+ 
+-
+-	dmi_scan_machine();
++	if (!cooperative_mode_enabled()) {
++	     dmi_scan_machine();
++	}
+ 
+ #ifdef CONFIG_X86_GENERICARCH
+ 	generic_apic_probe(*cmdline_p);
+@@ -1411,9 +1454,14 @@
+ 		get_smp_config();
+ #endif
+ 
+-	register_memory(max_low_pfn);
++	if (!cooperative_mode_enabled()) {
++	     register_memory(max_low_pfn);
++	}
+ 
+ #ifdef CONFIG_VT
++#ifdef CONFIG_COOPERATIVE_CONSOLE
++	conswitchp = &colinux_con;
++#else
+ #if defined(CONFIG_VGA_CONSOLE)
+ 	if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
+ 		conswitchp = &vga_con;
+@@ -1421,6 +1469,7 @@
+ 	conswitchp = &dummy_con;
+ #endif
+ #endif
++#endif
+ }
+ 
+ #include "setup_arch_post.h"
+diff -urN a/arch/i386/kernel/sysenter.c b/arch/i386/kernel/sysenter.c
+--- a/arch/i386/kernel/sysenter.c
++++ b/arch/i386/kernel/sysenter.c
+@@ -13,6 +13,7 @@
+ #include <linux/gfp.h>
+ #include <linux/string.h>
+ #include <linux/elf.h>
++#include <linux/cooperative_internal.h>
+ 
+ #include <asm/cpufeature.h>
+ #include <asm/msr.h>
+@@ -43,11 +44,11 @@
+ 
+ static int __init sysenter_setup(void)
+ {
+-	void *page = (void *)get_zeroed_page(GFP_ATOMIC);
++	void *page = get_zeroed_page(GFP_ATOMIC);
+ 
+ 	__set_fixmap(FIX_VSYSCALL, __pa(page), PAGE_READONLY_EXEC);
+ 
+-	if (!boot_cpu_has(X86_FEATURE_SEP)) {
++	if (cooperative_mode_enabled() || !boot_cpu_has(X86_FEATURE_SEP)) {
+ 		memcpy(page,
+ 		       &vsyscall_int80_start,
+ 		       &vsyscall_int80_end - &vsyscall_int80_start);
+@@ -59,6 +60,7 @@
+ 	       &vsyscall_sysenter_end - &vsyscall_sysenter_start);
+ 
+ 	on_each_cpu(enable_sep_cpu, NULL, 1, 1);
++
+ 	return 0;
+ }
+ 
+diff -urN a/arch/i386/kernel/time.c b/arch/i386/kernel/time.c
+--- a/arch/i386/kernel/time.c
++++ b/arch/i386/kernel/time.c
+@@ -45,6 +45,7 @@
+ #include <linux/sysdev.h>
+ #include <linux/bcd.h>
+ #include <linux/efi.h>
++#include <linux/cooperative_internal.h>
+ 
+ #include <asm/io.h>
+ #include <asm/smp.h>
+@@ -94,8 +95,9 @@
+ void do_gettimeofday(struct timeval *tv)
+ {
+ 	unsigned long seq;
+-	unsigned long usec, sec;
+-	unsigned long max_ntp_tick;
++	unsigned long sec;
++	long usec;
++	long max_ntp_tick;
+ 
+ 	do {
+ 		unsigned long lost;
+@@ -129,6 +131,13 @@
+ 		sec++;
+ 	}
+ 
++	if (cooperative_mode_enabled()) {
++		while (usec < 0) {
++			usec += 1000000;
++			sec--;
++		}
++	}
++
+ 	tv->tv_sec = sec;
+ 	tv->tv_usec = usec;
+ }
+@@ -174,6 +183,9 @@
+ {
+ 	int retval;
+ 
++	if (cooperative_mode_enabled())
++		return -1;
++
+ 	/* gets recalled with irq locally disabled */
+ 	spin_lock(&rtc_lock);
+ 	if (efi_enabled)
+@@ -243,7 +255,8 @@
+ 	 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
+ 	 * called as close as possible to 500 ms before the new second starts.
+ 	 */
+-	if ((time_status & STA_UNSYNC) == 0 &&
++	if (!cooperative_mode_enabled() &&
++	    (time_status & STA_UNSYNC) == 0 &&
+ 	    xtime.tv_sec > last_rtc_update + 660 &&
+ 	    (xtime.tv_nsec / 1000)
+ 			>= USEC_AFTER - ((unsigned) TICK_SIZE) / 2 &&
+@@ -307,6 +320,9 @@
+ {
+ 	unsigned long retval;
+ 
++	if (cooperative_mode_enabled())
++		return co_get_host_time();
++
+ 	spin_lock(&rtc_lock);
+ 
+ 	if (efi_enabled)
+diff -urN a/arch/i386/kernel/timers/Makefile b/arch/i386/kernel/timers/Makefile
+--- a/arch/i386/kernel/timers/Makefile
++++ b/arch/i386/kernel/timers/Makefile
+@@ -7,3 +7,4 @@
+ obj-$(CONFIG_X86_CYCLONE_TIMER)	+= timer_cyclone.o
+ obj-$(CONFIG_HPET_TIMER)	+= timer_hpet.o
+ obj-$(CONFIG_X86_PM_TIMER)	+= timer_pm.o
++obj-$(CONFIG_COOPERATIVE)	+= timer_cooperative.o
+diff -urN a/arch/i386/kernel/timers/timer.c b/arch/i386/kernel/timers/timer.c
+--- a/arch/i386/kernel/timers/timer.c
++++ b/arch/i386/kernel/timers/timer.c
+@@ -13,6 +13,9 @@
+ #endif
+ /* list of timers, ordered by preference, NULL terminated */
+ static struct init_timer_opts* __initdata timers[] = {
++#ifdef CONFIG_COOPERATIVE
++	&timer_cooperative_init,
++#endif
+ #ifdef CONFIG_X86_CYCLONE_TIMER
+ 	&timer_cyclone_init,
+ #endif
+diff -urN a/arch/i386/kernel/timers/timer_cooperative.c b/arch/i386/kernel/timers/timer_cooperative.c
+--- a/arch/i386/kernel/timers/timer_cooperative.c
++++ b/arch/i386/kernel/timers/timer_cooperative.c
+@@ -0,0 +1,140 @@
++/*
++ *  Cooperative mode timer.
++ *
++ *  Dan Aloni <da-x@colinux.org>, 2003-2004 (C).
++ */
++
++#include <linux/init.h>
++#include <linux/errno.h>
++
++#include <asm/timer.h>
++#include <asm/cooperative.h>
++#include <asm/div64.h>
++#include <asm/param.h>
++
++#include <linux/cooperative.h>
++#include <linux/cooperative_internal.h>
++
++static unsigned long long first_time;
++static unsigned long frequencey;
++static unsigned long long last_mark, last_mark_quotient;
++static unsigned long long last_time;
++
++static unsigned long long query_host_highprec_time(void)
++{
++	unsigned long flags;
++	unsigned long long this_time;
++	unsigned long long diff;
++
++	co_passage_page_assert_valid();	
++	
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_GET_HIGH_PREC_TIME;
++	co_switch_wrapper();
++
++	this_time = *(unsigned long long *)(&co_passage_page->params[0]);
++	frequencey = *(unsigned long *)(&co_passage_page->params[2]);
++	diff = ((long long)this_time - (long long)last_time);
++	
++	/*
++	 * There shouldn't be any particularly large difference between
++	 * the current and last host timestamps. For sanity, reset the 
++         * global reference variables if we encounter any difference 
++	 * larger than one second.
++	 */
++
++	if (diff < 0 || diff > frequencey) {
++		first_time = this_time;
++		last_mark_quotient = last_mark = 0;
++	}
++
++	last_time = this_time;
++	co_passage_page_release(flags);
++
++	return this_time;
++}
++
++static unsigned long long monotonic_clock_cooperative(void)
++{
++	return 0;
++}
++
++static long get_offset_cooperative(void)
++{
++	unsigned long flags;
++
++	local_irq_save(flags);
++	
++	unsigned long long this_time = query_host_highprec_time() - first_time;
++	unsigned long reminder = 0, result;
++	long long diff, lldiff;
++	long signed_result;
++
++	diff = ((long long)this_time - (long long)(last_mark));
++	if (diff < 0)
++		lldiff = -diff;
++	else
++		lldiff = diff;
++	
++	lldiff *= 1000000;
++	result = div_ll_X_l_rem(lldiff, frequencey, &reminder);
++
++	signed_result = result;
++	if (diff < 0)
++		signed_result = -signed_result;
++
++	local_irq_restore(flags);
++	return signed_result;
++}
++
++static void mark_offset_cooperative(void)
++{
++	unsigned long flags;
++	local_irq_save(flags);
++
++	last_mark += frequencey / HZ;
++	last_mark_quotient += frequencey % HZ;
++	if (frequencey > HZ) {
++		last_mark += 1;
++		last_mark_quotient -= HZ;
++	}
++
++	local_irq_restore(flags);
++}
++
++static void delay_cooperative(unsigned long loops)
++{
++	/*
++	 * A bogos delay loop for creating BogoMIPS...
++	 */
++
++	loops = loops / 10000;
++	while (loops) {
++		query_host_highprec_time();
++		loops -= 1;
++	}
++}
++
++static int __init init_cooperative_timer(char* override)
++{
++	first_time = query_host_highprec_time();
++
++	/* Always pick this timer */
++	return 0;
++}
++
++/************************************************************/
++
++/* tsc timer_opts struct */
++struct timer_opts timer_cooperative = {
++	.name = 		"cooperative",
++	.mark_offset =		mark_offset_cooperative,
++	.get_offset =		get_offset_cooperative,
++	.monotonic_clock =	monotonic_clock_cooperative,
++	.delay = 		delay_cooperative,
++};
++
++struct init_timer_opts __initdata timer_cooperative_init = {
++	.init =	init_cooperative_timer,
++	.opts = &timer_cooperative,
++};
+diff -urN a/arch/i386/kernel/timers/timer_cyclone.c b/arch/i386/kernel/timers/timer_cyclone.c
+--- a/arch/i386/kernel/timers/timer_cyclone.c
++++ b/arch/i386/kernel/timers/timer_cyclone.c
+@@ -103,7 +103,7 @@
+ 		jiffies_64++;
+ }
+ 
+-static unsigned long get_offset_cyclone(void)
++static long get_offset_cyclone(void)
+ {
+ 	u32 offset;
+ 
+diff -urN a/arch/i386/kernel/timers/timer_hpet.c b/arch/i386/kernel/timers/timer_hpet.c
+--- a/arch/i386/kernel/timers/timer_hpet.c
++++ b/arch/i386/kernel/timers/timer_hpet.c
+@@ -73,7 +73,7 @@
+ 	return base + cycles_2_ns(this_offset - last_offset);
+ }
+ 
+-static unsigned long get_offset_hpet(void)
++static long get_offset_hpet(void)
+ {
+ 	register unsigned long eax, edx;
+ 
+diff -urN a/arch/i386/kernel/timers/timer_none.c b/arch/i386/kernel/timers/timer_none.c
+--- a/arch/i386/kernel/timers/timer_none.c
++++ b/arch/i386/kernel/timers/timer_none.c
+@@ -6,7 +6,7 @@
+ 	/* nothing needed */
+ }
+ 
+-static unsigned long get_offset_none(void)
++static long get_offset_none(void)
+ {
+ 	return 0;
+ }
+diff -urN a/arch/i386/kernel/timers/timer_pit.c b/arch/i386/kernel/timers/timer_pit.c
+--- a/arch/i386/kernel/timers/timer_pit.c
++++ b/arch/i386/kernel/timers/timer_pit.c
+@@ -89,7 +89,7 @@
+  * comp.protocols.time.ntp!
+  */
+ 
+-static unsigned long get_offset_pit(void)
++static long get_offset_pit(void)
+ {
+ 	int count;
+ 	unsigned long flags;
+diff -urN a/arch/i386/kernel/timers/timer_pm.c b/arch/i386/kernel/timers/timer_pm.c
+--- a/arch/i386/kernel/timers/timer_pm.c
++++ b/arch/i386/kernel/timers/timer_pm.c
+@@ -227,7 +227,7 @@
+  * get the offset (in microseconds) from the last call to mark_offset()
+  *	- Called holding a reader xtime_lock
+  */
+-static unsigned long get_offset_pmtmr(void)
++static long get_offset_pmtmr(void)
+ {
+ 	u32 now, offset, delta = 0;
+ 
+diff -urN a/arch/i386/kernel/timers/timer_tsc.c b/arch/i386/kernel/timers/timer_tsc.c
+--- a/arch/i386/kernel/timers/timer_tsc.c
++++ b/arch/i386/kernel/timers/timer_tsc.c
+@@ -83,7 +83,7 @@
+  */
+ static unsigned long fast_gettimeoffset_quotient;
+ 
+-static unsigned long get_offset_tsc(void)
++static long get_offset_tsc(void)
+ {
+ 	register unsigned long eax, edx;
+ 
+diff -urN a/arch/i386/kernel/traps.c b/arch/i386/kernel/traps.c
+--- a/arch/i386/kernel/traps.c
++++ b/arch/i386/kernel/traps.c
+@@ -51,6 +51,9 @@
+ #include <asm/arch_hooks.h>
+ #include <asm/kdebug.h>
+ 
++#include <linux/cooperative_internal.h>
++#include <asm/cooperative_internal.h>
++
+ #include <linux/irq.h>
+ #include <linux/module.h>
+ 
+@@ -382,6 +385,12 @@
+ 	}
+ 
+ 	kernel_trap: {
++		if (cooperative_mode_enabled()) {
++			if (trapnr == 3) {
++				co_kernel_breakpoint(regs);
++				return;
++			}
++		}
+ 		if (!fixup_exception(regs))
+ 			die(str, regs, error_code);
+ 		return;
+@@ -683,9 +692,15 @@
+ 	unsigned int condition;
+ 	struct task_struct *tsk = current;
+ 	siginfo_t info;
+-
++	
+ 	__asm__ __volatile__("movl %%db6,%0" : "=r" (condition));
+ 
++	if (cooperative_mode_enabled() && 
++	    co_kernel_debug(regs, error_code, condition))
++	{
++		return;
++	}
++
+ 	if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
+ 					SIGTRAP) == NOTIFY_STOP)
+ 		return;
+diff -urN a/arch/i386/kernel/vmlinux.lds.S b/arch/i386/kernel/vmlinux.lds.S
+--- a/arch/i386/kernel/vmlinux.lds.S
++++ b/arch/i386/kernel/vmlinux.lds.S
+@@ -14,11 +14,12 @@
+ {
+   . = __PAGE_OFFSET + 0x100000;
+   /* read-only */
++  _kernel_start = .		; 
+   _text = .;			/* Text and read-only data */
+   .text : {
+ 	*(.text)
+ 	SCHED_TEXT
+-	LOCK_TEXT
++ 	LOCK_TEXT
+ 	*(.fixup)
+ 	*(.gnu.warning)
+ 	} = 0x9090
+diff -urN a/arch/i386/mm/fault.c b/arch/i386/mm/fault.c
+--- a/arch/i386/mm/fault.c
++++ b/arch/i386/mm/fault.c
+@@ -449,7 +449,8 @@
+ 	printk(KERN_ALERT " printing eip:\n");
+ 	printk("%08lx\n", regs->eip);
+ 	asm("movl %%cr3,%0":"=r" (page));
+-	page = ((unsigned long *) __va(page))[address >> 22];
++	page = ((unsigned long *) __va(CO_P_TO_PP(page)))[address >> 22];
++	page = CO_P_TO_PP(page);
+ 	printk(KERN_ALERT "*pde = %08lx\n", page);
+ 	/*
+ 	 * We must not directly access the pte in the highpte
+@@ -462,6 +463,7 @@
+ 		page &= PAGE_MASK;
+ 		address &= 0x003ff000;
+ 		page = ((unsigned long *) __va(page))[address >> PAGE_SHIFT];
++		page = CO_P_TO_PP(page);
+ 		printk(KERN_ALERT "*pte = %08lx\n", page);
+ 	}
+ #endif
+@@ -522,7 +524,7 @@
+ 		pte_t *pte_k;
+ 
+ 		asm("movl %%cr3,%0":"=r" (pgd_paddr));
+-		pgd = index + (pgd_t *)__va(pgd_paddr);
++		pgd = index + (pgd_t *)__va(CO_P_TO_PP((unsigned long)pgd_paddr));
+ 		pgd_k = init_mm.pgd + index;
+ 
+ 		if (!pgd_present(*pgd_k))
+diff -urN a/arch/i386/mm/init.c b/arch/i386/mm/init.c
+--- a/arch/i386/mm/init.c
++++ b/arch/i386/mm/init.c
+@@ -27,6 +27,7 @@
+ #include <linux/slab.h>
+ #include <linux/proc_fs.h>
+ #include <linux/efi.h>
++#include <linux/cooperative_internal.h>
+ 
+ #include <asm/processor.h>
+ #include <asm/system.h>
+@@ -76,7 +77,7 @@
+ {
+ 	if (pmd_none(*pmd)) {
+ 		pte_t *page_table = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE);
+-		set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE));
++		set_pmd(pmd, __pmd(CO_PP_TO_P(__pa(page_table)) | _PAGE_TABLE));
+ 		if (page_table != pte_offset_kernel(pmd, 0))
+ 			BUG();	
+ 
+@@ -313,21 +314,23 @@
+ 		set_pgd(pgd_base + i, __pgd(__pa(empty_zero_page) | _PAGE_PRESENT));
+ #endif
+ 
+-	/* Enable PSE if available */
+-	if (cpu_has_pse) {
+-		set_in_cr4(X86_CR4_PSE);
+-	}
+-
+-	/* Enable PGE if available */
+-	if (cpu_has_pge) {
+-		set_in_cr4(X86_CR4_PGE);
+-		__PAGE_KERNEL |= _PAGE_GLOBAL;
+-		__PAGE_KERNEL_EXEC |= _PAGE_GLOBAL;
++ 	if (!cooperative_mode_enabled()) {
++		/* Enable PSE if available */
++		if (cpu_has_pse) {
++			set_in_cr4(X86_CR4_PSE);
++		}
++		
++		/* Enable PGE if available */
++		if (cpu_has_pge) {
++			set_in_cr4(X86_CR4_PGE);
++			__PAGE_KERNEL |= _PAGE_GLOBAL;
++			__PAGE_KERNEL_EXEC |= _PAGE_GLOBAL;
++		}
++		
++		kernel_physical_mapping_init(pgd_base);
++		remap_numa_kva();
+ 	}
+ 
+-	kernel_physical_mapping_init(pgd_base);
+-	remap_numa_kva();
+-
+ 	/*
+ 	 * Fixed mappings, only the page table structure has to be
+ 	 * created - mappings will be set by set_fixmap():
+@@ -394,19 +397,26 @@
+ 	unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
+ 	unsigned int max_dma, high, low;
+ 	
+-	max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
+-	low = max_low_pfn;
+-	high = highend_pfn;
+-	
+-	if (low < max_dma)
+-		zones_size[ZONE_DMA] = low;
+-	else {
+-		zones_size[ZONE_DMA] = max_dma;
+-		zones_size[ZONE_NORMAL] = low - max_dma;
++	if (!cooperative_mode_enabled()) {
++		max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
++		low = max_low_pfn;
++		high = highend_pfn;
++		
++		if (low < max_dma)
++			zones_size[ZONE_DMA] = low;
++		else {
++			zones_size[ZONE_DMA] = max_dma;
++			zones_size[ZONE_NORMAL] = low - max_dma;
+ #ifdef CONFIG_HIGHMEM
+-		zones_size[ZONE_HIGHMEM] = high - low;
++			zones_size[ZONE_HIGHMEM] = high - low;
+ #endif
++		}
++	} else {
++		zones_size[ZONE_DMA] = 0;
++		zones_size[ZONE_NORMAL] = max_low_pfn;
++		zones_size[ZONE_HIGHMEM] = 0;
+ 	}
++
+ 	free_area_init(zones_size);	
+ }
+ #else
+@@ -574,7 +584,6 @@
+ 	if (!mem_map)
+ 		BUG();
+ #endif
+-	
+ 	bad_ppro = ppro_with_ram_bug();
+ 
+ #ifdef CONFIG_HIGHMEM
+@@ -630,8 +639,10 @@
+ 	if (!cpu_has_pae)
+ 		panic("cannot execute a PAE-enabled kernel on a PAE-less CPU!");
+ #endif
+-	if (boot_cpu_data.wp_works_ok < 0)
+-		test_wp_bit();
++	if (!cooperative_mode_enabled()) {
++		if (boot_cpu_data.wp_works_ok < 0)
++			test_wp_bit();
++	}
+ 
+ 	/*
+ 	 * Subtle. SMP is doing it's boot stuff late (because it has to
+diff -urN a/arch/i386/mm/ioremap.c b/arch/i386/mm/ioremap.c
+--- a/arch/i386/mm/ioremap.c
++++ b/arch/i386/mm/ioremap.c
+@@ -11,6 +11,7 @@
+ #include <linux/vmalloc.h>
+ #include <linux/init.h>
+ #include <linux/slab.h>
++#include <linux/cooperative_internal.h>
+ #include <asm/io.h>
+ #include <asm/fixmap.h>
+ #include <asm/cacheflush.h>
+@@ -190,7 +191,14 @@
+ void __iomem *ioremap_nocache (unsigned long phys_addr, unsigned long size)
+ {
+ 	unsigned long last_addr;
+-	void __iomem *p = __ioremap(phys_addr, size, _PAGE_PCD);
++	void __iomem *p;
++
++	if (cooperative_mode_enabled()) {
++		panic("ioremap_nocache %ld:%ld\n", phys_addr, size);
++		return NULL;
++	}
++
++	p = __ioremap(phys_addr, size, _PAGE_PCD);
+ 	if (!p) 
+ 		return p; 
+ 
+diff -urN a/drivers/block/Kconfig b/drivers/block/Kconfig
+--- a/drivers/block/Kconfig
++++ b/drivers/block/Kconfig
+@@ -358,6 +358,15 @@
+ 	  "real" root file system, etc. See <file:Documentation/initrd.txt>
+ 	  for details.
+ 
++config BLK_DEV_COBD
++	tristate 'Cooperative block device support'
++	default y
++	depends on COOPERATIVE=y
++	help
++	  Virtual block device support for cooperative kernels.
++
++	  If unsure, say Y.
++
+ config INITRAMFS_SOURCE
+ 	string "Source directory of cpio_list"
+ 	default ""
+diff -urN a/drivers/block/Makefile b/drivers/block/Makefile
+--- a/drivers/block/Makefile
++++ b/drivers/block/Makefile
+@@ -29,6 +29,7 @@
+ obj-$(CONFIG_ATARI_SLM)		+= acsi_slm.o
+ obj-$(CONFIG_AMIGA_Z2RAM)	+= z2ram.o
+ obj-$(CONFIG_BLK_DEV_RAM)	+= rd.o
++obj-$(CONFIG_BLK_DEV_COBD)	+= cobd.o
+ obj-$(CONFIG_BLK_DEV_LOOP)	+= loop.o
+ obj-$(CONFIG_BLK_DEV_PS2)	+= ps2esdi.o
+ obj-$(CONFIG_BLK_DEV_XD)	+= xd.o
+diff -urN a/drivers/block/cobd.c b/drivers/block/cobd.c
+--- a/drivers/block/cobd.c
++++ b/drivers/block/cobd.c
+@@ -0,0 +1,540 @@
++/*
++ *  Copyright (C) 2003 Dan Aloni <da-x@colinux.org>
++ *
++ *  Cooperative Linux Block Device implementation
++ */
++
++#include <linux/major.h>
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/fs.h>
++#include <linux/errno.h>
++#include <linux/major.h>
++#include <linux/stat.h>
++#include <linux/slab.h>
++#include <linux/bio.h>
++#include <linux/blkdev.h>
++#include <linux/cooperative_internal.h>
++#include <linux/file.h>
++#include <linux/ioctl.h>
++#include <linux/ctype.h>
++
++#include <asm/uaccess.h>
++#include <asm/types.h>
++
++#include <linux/devfs_fs_kernel.h>
++
++#define PBD_BLOCK_SIZE  512
++
++static int hardsect_size = 512;
++static int hardsect_size_shift = 9;
++static spinlock_t cobd_lock = SPIN_LOCK_UNLOCKED;
++static int cobd_max;
++
++struct cobd_device {
++	int unit;
++	int refcount;
++	struct block_device *device;
++};
++
++static int cobd_request(struct cobd_device *cobd, co_block_request_type_t type, co_block_request_t *out_request)
++{
++	co_block_request_t *request;
++	unsigned long flags;
++	long rc = 0;
++
++	co_passage_page_assert_valid();
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_BLOCK;
++	co_passage_page->params[1] = cobd->unit;
++	request = (co_block_request_t *)&co_passage_page->params[2];
++	request->type = type;
++	request->rc = -1;
++	co_switch_wrapper();
++	rc = request->rc;
++	*out_request = *request;
++	co_passage_page_release(flags);
++
++	return rc;
++}
++
++static int cobd_stat(struct cobd_device *cobd, co_block_request_t *out_request)
++{
++	return cobd_request(cobd, CO_BLOCK_STAT, out_request);
++}
++
++static int cobd_get_alias(struct cobd_device *cobd, co_block_request_t *out_request)
++{
++	return cobd_request(cobd, CO_BLOCK_GET_ALIAS, out_request);
++}
++
++static int cobd_ioctl(struct inode * inode, struct file * file,
++		      unsigned int cmd, unsigned long arg)
++{
++	return -ENOTTY; /* unknown command */
++}
++
++static int cobd_open(struct inode *inode, struct file *file)
++{
++	struct cobd_device *cobd = (struct cobd_device *)(inode->i_bdev->bd_disk->private_data);
++	co_block_request_t *co_request;
++	co_block_request_t stat_request;
++	unsigned long flags;
++	int result;
++
++	if (cobd->device  &&  cobd->device != inode->i_bdev)
++		return -EBUSY;
++
++	if (cobd_stat(cobd, &stat_request))
++		return -ENODEV;
++
++	result = 0;
++
++	co_passage_page_assert_valid();
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_BLOCK;
++	co_passage_page->params[1] = cobd->unit;
++	co_request = (co_block_request_t *)&co_passage_page->params[2];
++	co_request->type = CO_BLOCK_OPEN;
++	co_switch_wrapper();
++	if (co_request->rc)
++		result = -EIO;
++	else
++		cobd->refcount++;
++	co_passage_page_release(flags);
++
++	if (result)
++		return result;
++
++	if (cobd->refcount == 1) {
++		set_capacity(inode->i_bdev->bd_disk, stat_request.disk_size >> 9);
++		cobd->device = inode->i_bdev;
++	}
++
++	return 0;
++}
++
++static int cobd_release(struct inode *inode, struct file *file)
++{
++	struct cobd_device *cobd = (struct cobd_device *)(inode->i_bdev->bd_disk->private_data);
++	co_block_request_t *co_request;
++	unsigned long flags;
++	int ret = 0;
++
++	co_passage_page_assert_valid();
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_BLOCK;
++	co_passage_page->params[1] = cobd->unit;
++	co_request = (co_block_request_t *)&co_passage_page->params[2];
++	co_request->type = CO_BLOCK_CLOSE;
++	co_switch_wrapper();
++	if (co_request->rc)
++		ret = -EIO;
++	cobd->refcount--;
++	co_passage_page_release(flags);
++
++	if (cobd->refcount == 0)
++		cobd->device = NULL;
++
++	return ret;
++}
++
++/*
++ * Handle an I/O request.
++ */
++static int cobd_transfer(struct cobd_device *cobd, unsigned long sector,
++			 unsigned long nsect, char *buffer, int write)
++{
++	co_block_request_t *co_request;
++	unsigned long flags;
++	int ret = 0;
++
++	co_passage_page_assert_valid();
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_BLOCK;
++	co_passage_page->params[1] = cobd->unit;
++	co_request = (co_block_request_t *)&co_passage_page->params[2];
++	if (!write)
++		co_request->type = CO_BLOCK_READ;
++	else
++		co_request->type = CO_BLOCK_WRITE;
++	co_request->offset = ((unsigned long long)sector) << hardsect_size_shift;
++	co_request->size = nsect << hardsect_size_shift;
++	co_request->address = buffer;
++	co_request->rc = 0;
++	co_switch_wrapper();
++
++	if (!co_request->rc)
++		ret = 1;
++
++	co_passage_page_release(flags);
++	return ret;
++}
++
++static void do_cobd_request(request_queue_t *q)
++{
++        struct request *req;
++	struct cobd_device *cobd;
++    
++        while ((req = elv_next_request(q)) != NULL) {
++		int ret;
++
++		if (!blk_fs_request(req)) {
++			end_request(req, 0);
++			continue;
++		}
++		cobd = (struct cobd_device *)(req->rq_disk->private_data);
++		
++		ret = cobd_transfer(cobd, req->sector, req->current_nr_sectors,
++				    req->buffer, rq_data_dir(req));
++		end_request(req, ret);
++        }
++}
++
++static struct block_device_operations cobd_fops = {
++	.owner   = THIS_MODULE,
++	.open    = cobd_open,
++	.release = cobd_release,
++	.ioctl   = cobd_ioctl,
++};
++
++static struct gendisk **cobd_disks;
++
++static struct cobd_device cobd_devs[CO_MODULE_MAX_COBD];
++
++static int __init cobd_drives_init(void)
++{
++	int result, i;
++
++	if (register_blkdev(COLINUX_MAJOR, "cobd")) {
++		printk(KERN_WARNING "Unable to get major number %d for cobd device\n", COLINUX_MAJOR);
++		return -EIO;
++	}
++
++	cobd_max = CO_MODULE_MAX_COBD;
++
++	result = -ENOMEM; /* for the possible errors */
++
++	cobd_disks = kmalloc(cobd_max * sizeof(struct gendisk *), GFP_KERNEL);
++	if (!cobd_disks)
++		goto fail_malloc;
++
++	for (i=0; i < cobd_max; i++) {
++		cobd_disks[i] = alloc_disk(1);
++		if (!cobd_disks[i])
++			goto fail_malloc3;
++	}
++
++	for (i=0; i < cobd_max; i++) {
++		struct cobd_device *cobd = &cobd_devs[i];
++		struct gendisk *disk = cobd_disks[i];
++
++		disk->queue = blk_init_queue(do_cobd_request, &cobd_lock);
++		if (!disk->queue)
++			goto fail_malloc4;
++
++		blk_queue_hardsect_size(disk->queue, hardsect_size);
++
++		cobd->unit = i;
++		disk->major = COLINUX_MAJOR;
++		disk->first_minor = i;
++		disk->fops = &cobd_fops;
++		sprintf(disk->disk_name, "cobd%d", i);
++		sprintf(disk->devfs_name, "cobd/%d", i);
++		disk->private_data = cobd;
++	}
++	
++	devfs_mk_dir("cobd");
++
++	for (i=0; i < cobd_max; i++)
++		add_disk(cobd_disks[i]);
++
++	printk(KERN_INFO "cobd: loaded (max %d devices)\n", cobd_max);
++	return 0;
++
++/* error path */
++fail_malloc4:
++	while (i--)
++		blk_cleanup_queue(cobd_disks[i]->queue);
++	devfs_remove("cobd");
++	i = cobd_max;
++
++fail_malloc3:
++	while (i--) 
++		if (cobd_disks[i] != NULL)
++			put_disk(cobd_disks[i]);
++
++	kfree(cobd_disks);
++
++fail_malloc:
++	if (unregister_blkdev(COLINUX_MAJOR, "cobd"))
++		printk(KERN_WARNING "cobd: cannot unregister blkdev\n");
++
++	return result;
++}
++
++struct cobd_alias_major {
++	const char *name;
++	int registered;
++	int number;
++};
++
++struct cobd_alias {
++	const char *name;
++	struct cobd_alias_major *major;
++	int minor_start;
++	int minor_count;
++	struct gendisk **gendisk;
++};
++
++struct cobd_alias_major cobd_aliases_major_ide0 = {
++	.name = "ide0",
++	.number = IDE0_MAJOR,
++};
++
++struct cobd_alias_major cobd_aliases_major_ide1 = {
++	.name = "ide1",
++	.number = IDE1_MAJOR,
++};
++
++struct cobd_alias_major cobd_aliases_major_ide2 = {
++	.name = "ide2",
++	.number = IDE2_MAJOR,
++};
++
++struct cobd_alias_major cobd_aliases_major_ide3 = {
++	.name = "ide3",
++	.number = IDE3_MAJOR,
++};
++
++struct cobd_alias_major cobd_aliases_major_sd = {
++	.name = "sd",
++	.number = SCSI_DISK0_MAJOR,
++};
++
++struct cobd_alias cobd_aliases[] = {
++	{"hda", &cobd_aliases_major_ide0, 0x00, 21, },
++	{"hdb", &cobd_aliases_major_ide0, 0x40, 21, },
++	{"hdc", &cobd_aliases_major_ide1, 0x00, 21, },
++	{"hdd", &cobd_aliases_major_ide1, 0x40, 21, },
++	{"hde", &cobd_aliases_major_ide2, 0x00, 21, },
++	{"hdf", &cobd_aliases_major_ide2, 0x40, 21, },
++	{"hdg", &cobd_aliases_major_ide3, 0x00, 21, },
++	{"hdh", &cobd_aliases_major_ide3, 0x40, 21, },
++	{"sda", &cobd_aliases_major_sd, 0x00, 0x10, },
++	{"sdb", &cobd_aliases_major_sd, 0x10, 0x10, },
++	{"sdc", &cobd_aliases_major_sd, 0x20, 0x10, },
++	{"sdd", &cobd_aliases_major_sd, 0x30, 0x10, },
++	{"sde", &cobd_aliases_major_sd, 0x40, 0x10, },
++	{"sdf", &cobd_aliases_major_sd, 0x50, 0x10, },
++	{"sdg", &cobd_aliases_major_sd, 0x60, 0x10, },
++	{"sdh", &cobd_aliases_major_sd, 0x70, 0x10, },
++	{"sdi", &cobd_aliases_major_sd, 0x80, 0x10, },
++	{"sdj", &cobd_aliases_major_sd, 0x90, 0x10, },
++	{"sdk", &cobd_aliases_major_sd, 0xa0, 0x10, },
++	{"sdl", &cobd_aliases_major_sd, 0xb0, 0x10, },
++	{"sdm", &cobd_aliases_major_sd, 0xc0, 0x10, },
++	{"sdn", &cobd_aliases_major_sd, 0xd0, 0x10, },
++	{"sdp", &cobd_aliases_major_sd, 0xe0, 0x10, },
++	{"sdq", &cobd_aliases_major_sd, 0xf0, 0x10, },
++	{NULL, },
++};
++
++static int __init skip_atoi(const char **s)
++{
++	/* lib/spprintf.h */
++
++        int i=0;
++
++        while (isdigit(**s))
++                i = i*10 + *((*s)++) - '0';
++
++        return i;	
++}
++
++static int __init cobd_spawn_alias(struct cobd_alias *alias, 
++				   const char *alias_name_requested,
++				   int cobd_unit)
++{
++	const char *index_str_start = &alias_name_requested[strlen(alias->name)];
++	const char *index_str_end = index_str_start;
++	struct cobd_device *cobd;
++	struct gendisk *disk;
++
++	int index = skip_atoi(&index_str_end);
++
++	if (!((index >= 0) && (index <= alias->minor_count))) {
++		printk(KERN_WARNING "index out of bounds for alias %s (1 - %d)\n", 
++		       alias_name_requested, alias->minor_count);
++		return -1;
++	}
++	
++	if (alias->gendisk == NULL) {
++		static struct gendisk **gendisks;
++		gendisks = kmalloc(alias->minor_count * sizeof(struct gendisk *), GFP_KERNEL);
++		memset(gendisks, 0, alias->minor_count * sizeof(struct gendisk *));
++
++		if (!gendisks) {
++			printk(KERN_WARNING "cannot allocate gendisk array for %s\n", alias->name);
++			return -ENOMEM;
++		}
++
++		if (!alias->major->registered) {
++			if (register_blkdev(alias->major->number, alias->major->name)) {
++				printk(KERN_WARNING "unable to get major number %d for cobd alias device %s\n", 
++				       alias->major->number, alias_name_requested);
++				kfree(gendisks);
++				return -EIO;
++			}
++
++			alias->major->registered = 1;
++		}
++
++		alias->gendisk = gendisks;
++		devfs_mk_dir(alias->name);
++	}
++
++	if (alias->gendisk[index] != NULL) {
++		printk(KERN_WARNING "alias %s already used\n", alias_name_requested);
++		return -1;
++	}
++	
++	disk = alloc_disk(1);
++	if (!disk) {
++		printk(KERN_WARNING "cannot allocate disk for alias %s\n", alias_name_requested);
++		return -1;
++	}
++
++	disk->queue = blk_init_queue(do_cobd_request, &cobd_lock);
++	if (!disk->queue) {
++		printk(KERN_WARNING "cannot allocate init queue for alias %s\n", alias_name_requested);
++		put_disk(disk);
++		return -1;
++	}
++
++	cobd = &cobd_devs[cobd_unit];
++	blk_queue_hardsect_size(disk->queue, hardsect_size);
++	disk->major = alias->major->number;
++	disk->first_minor = alias->minor_start + index;
++	disk->fops = &cobd_fops;
++	if (index)
++		sprintf(disk->disk_name, "%s%d", alias->name, index);
++	else
++		sprintf(disk->disk_name, "%s", alias->name);
++	sprintf(disk->devfs_name, "%s/%d", alias->name, index);
++	disk->private_data = cobd;
++	add_disk(disk);
++	alias->gendisk[index] = disk;
++
++	printk("cobd alias cobd%d -> %s created\n", cobd_unit, alias_name_requested);
++
++	return 0;
++}
++
++static int __init cobd_aliases_init(void)
++{
++	int unit;
++	co_block_request_t request;
++
++	for (unit=0; unit < cobd_max; unit++) {
++		int result = cobd_get_alias(&cobd_devs[unit], &request);
++		if (result)
++			continue;
++
++		printk("alias for cobd%d is %s\n", unit, request.alias);
++		
++		struct cobd_alias *alias = &cobd_aliases[0];
++		while (alias->name) {
++			const char *match = (strstr(request.alias, alias->name));
++			if (match == request.alias) {
++				cobd_spawn_alias(alias, request.alias, unit);
++				break;
++			}
++			alias++;
++		}
++
++		if (alias->name == NULL)
++			printk("alias %s is unknown (see cobd_aliases in cobd.c)\n", request.alias);
++	}
++
++	return 0;
++}
++
++static void cobd_drives_exit(void) 
++{
++	int i;
++
++	for (i = 0; i < cobd_max; i++) {
++		blk_cleanup_queue(cobd_disks[i]->queue);
++		del_gendisk(cobd_disks[i]);
++		put_disk(cobd_disks[i]);
++	}
++
++	devfs_remove("cobd");
++	if (unregister_blkdev(COLINUX_MAJOR, "cobd"))
++		printk(KERN_WARNING "cobd: cannot unregister blkdev\n");
++
++	kfree(cobd_disks);
++}
++
++static void cobd_aliases_exit(void) 
++{
++	struct cobd_alias *alias = &cobd_aliases[0];
++	while (alias->name != NULL) {
++		if (alias->gendisk == NULL) {
++			alias++;
++			continue;
++		}
++
++		int index;
++		for (index=0; index < alias->minor_count; index++) {
++			struct gendisk *disk = alias->gendisk[index];
++			if (!disk)
++				return;
++			
++			blk_cleanup_queue(disk->queue);
++			del_gendisk(disk);
++			put_disk(disk);
++		}
++
++		devfs_remove(alias->name);
++		if (!alias->major->registered) {
++			unregister_blkdev(alias->major->number, alias->major->name);
++			alias->major->registered = 0;
++		}
++		kfree(alias->gendisk);
++
++		alias++;
++	}
++}
++
++static int __init cobd_init(void)
++{
++	int result = cobd_drives_init();
++	if (result)
++		return result;
++
++	cobd_aliases_init();
++	
++	return result;		
++}
++
++static void cobd_exit(void) 
++{
++	cobd_aliases_exit();
++	cobd_drives_exit();
++}
++
++module_init(cobd_init);
++module_exit(cobd_exit);
++
++
+diff -urN a/drivers/char/Makefile b/drivers/char/Makefile
+--- a/drivers/char/Makefile
++++ b/drivers/char/Makefile
+@@ -27,6 +27,7 @@
+ obj-$(CONFIG_STALLION)		+= stallion.o
+ obj-$(CONFIG_ISTALLION)		+= istallion.o
+ obj-$(CONFIG_DIGI)		+= pcxx.o
++obj-$(CONFIG_COOPERATIVE)	+= cocd.o
+ obj-$(CONFIG_DIGIEPCA)		+= epca.o
+ obj-$(CONFIG_SPECIALIX)		+= specialix.o
+ obj-$(CONFIG_MOXA_INTELLIO)	+= moxa.o
+diff -urN a/drivers/char/cocd.c b/drivers/char/cocd.c
+--- a/drivers/char/cocd.c
++++ b/drivers/char/cocd.c
+@@ -0,0 +1,368 @@
++/*
++ *  Copyright (C) 2004 Dan Aloni <da-x@colinux.org>
++ *
++ *  Cooperative Linux Serial Line implementation
++ * 
++ *  Compatible with UML, also based on some code from there.
++ *  Also based on The tiny_tty.c example driver by Greg Kroah-Hartman (greg@kroah.com).
++ */
++
++/*
++ * 20040908: Ballard, Jonathan H. <jhballard@hotmail.com>
++ * 	   : Implemented cocd_task() & throttle.
++ * 20041224: Used schedule() instead of shedule_work().
++ * 20050101: Uses interruptible_sleep_on() and wake_up() instead of schedule().
++ *         : Uses list_*() for dispatched data flow to each unit.
++ *         : Handles multiple units in seperate tasks.
++ *
++*/
++
++
++#include <linux/major.h>
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/fs.h>
++#include <linux/errno.h>
++#include <linux/major.h>
++#include <linux/stat.h>
++#include <linux/file.h>
++#include <linux/ioctl.h>
++#include <linux/device.h>
++#include <linux/console.h>
++#include <linux/wait.h>
++
++#include <linux/workqueue.h>
++#include <linux/devfs_fs_kernel.h>
++#include <linux/tty.h>
++#include <linux/tty_flip.h>
++
++#include <linux/cooperative_internal.h>
++
++#include <asm/uaccess.h>
++
++struct cocd_tty {
++	struct semaphore	sem;		/* locks this structure */
++	struct tty_struct	*tty;		/* tty for this device */
++	unsigned		open_count;	/* open()/close() tally */
++	struct work_struct	work;		/* individual unit task */
++	struct list_head	inq;		/* input queue */
++	wait_queue_head_t	waitq;
++	int			throttled;	/* data flow throttle bit */
++};
++
++static struct tty_driver *cocd_driver = NULL;
++DECLARE_MUTEX(cocd_sem);
++
++static void cocd_unit_task(void *data)
++{
++	co_message_node_t *input;
++	struct cocd_tty *cocd = data;
++	co_linux_message_t *message;
++	char *p, *e, *m;
++	struct tty_struct *tty;
++
++	tty = cocd->tty;
++
++	while(cocd->open_count) {
++		down(&cocd->sem);
++		if(list_empty(&cocd->inq)) {
++			up(&cocd->sem);
++			interruptible_sleep_on(&cocd->waitq);
++			continue;
++			}
++		input = list_entry(cocd->inq.prev, co_message_node_t, node);
++		up(&cocd->sem);
++
++		message = (co_linux_message_t *)&input->msg.data;
++		e = (m = p = message->data) + message->size;
++		while(p < e && cocd->open_count) {
++			if(cocd->throttled) {
++				interruptible_sleep_on(&cocd->waitq);
++				continue;
++				}
++			if(e < (m += (TTY_FLIPBUF_SIZE - tty->flip.count)))
++				m = e;
++			while(p < m) 
++				tty_insert_flip_char(tty, *(p++), 0);
++			if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
++				tty_flip_buffer_push(tty);
++			}
++		}
++		down(&cocd->sem);
++		list_del(&input->node);
++		up(&cocd->sem);
++		co_free_message(input);
++		if(tty->flip.count && cocd->open_count) {
++			if(cocd->throttled) {
++				interruptible_sleep_on(&cocd->waitq);
++				}
++			tty_flip_buffer_push(tty);
++			continue;
++		}
++	}
++	down(&cocd->sem);
++	while(!list_empty(&cocd->inq)) {
++		input = list_entry(cocd->inq.prev, co_message_node_t, node);
++		list_del(&input->node);
++		co_free_message(input);
++		}
++	up(&cocd->sem);
++	kfree(cocd);
++}
++
++int cocd_open(struct tty_struct *tty, struct file * filp)
++{
++	struct cocd_tty *cocd =  NULL;
++
++	down(&cocd_sem);
++
++	/* MOD_INC_USE_COUNT; - Removed in 2.6, reference count is handled
++	 *   outside the module in 2.6
++	 */
++
++	if ((cocd = (struct cocd_tty *)tty->driver_data)) {
++		down (&cocd->sem);
++	} else {
++		if(!(cocd = kmalloc(sizeof(*cocd), GFP_KERNEL))) {
++			/* MOD_DEC_USE_COUNT; - Removed in 2.6, reference count
++			 *   is handled  outside the module in 2.6
++			 */
++
++			up(&cocd_sem);
++			return -ENOMEM;
++		}
++
++		init_MUTEX_LOCKED(&cocd->sem);
++		cocd->open_count = 0;
++		cocd->tty = tty;
++		cocd->throttled = 0;
++		INIT_WORK(&cocd->work, cocd_unit_task, cocd);
++		INIT_LIST_HEAD(&cocd->inq);
++		init_waitqueue_head(&cocd->waitq);
++		tty->driver_data = cocd;
++		tty->low_latency = 1;
++		schedule_work(&cocd->work);
++	}
++
++	cocd->open_count++;
++
++	up(&cocd->sem);
++	up(&cocd_sem);
++	
++	return 0;
++}
++
++void cocd_close(struct tty_struct *tty, struct file * filp)
++{
++	struct cocd_tty *cocd =  NULL;
++
++	down(&cocd_sem);
++
++	cocd = (struct cocd_tty *)tty->driver_data;
++	if (!cocd) {
++		printk("cocd: no attached struct\n");
++		goto out;
++	}
++
++	down(&cocd->sem);
++	if (cocd->open_count == 1) { /* last close */
++		tty->driver_data = NULL;
++		wake_up(&cocd->waitq);
++	}
++	cocd->open_count--;
++	up(&cocd->sem);
++
++out:
++	/* MOD_DEC_USE_COUNT; - Removed in 2.6, reference count is handled
++	 *   outside the module in 2.6
++	 */
++
++	up(&cocd_sem);
++}
++
++void cocd_interrupt(void)
++{
++	if (!cocd_driver)
++		return;
++
++	co_message_node_t *input;
++	if(!co_get_message(&input, CO_DEVICE_SERIAL))
++		return;
++	if(!input)
++		return;
++
++	co_linux_message_t *message;
++	struct tty_struct *tty;
++	struct cocd_tty *cocd;
++	message = (co_linux_message_t *)&input->msg.data;
++	down(&cocd_sem);
++	if (message->unit < CO_MODULE_MAX_SERIAL
++	 && (tty = cocd_driver->ttys[message->unit])
++	 && (cocd = (struct cocd_tty *)tty->driver_data)) {
++		up(&cocd_sem);
++		down(&cocd->sem);
++		list_add_tail(&input->node,&cocd->inq);
++		up(&cocd->sem);
++		wake_up(&cocd->waitq);
++		return;
++		}
++	up(&cocd_sem);
++	co_free_message(input);
++}
++
++int cocd_write(struct tty_struct * tty,
++	       const unsigned char *buf, int count)
++{
++	const char *kbuf_scan = NULL;
++	int count_left;
++
++	kbuf_scan = buf;
++	count_left = count;
++
++	while (count_left > 0) {
++		int count_partial = count_left;
++		if (count_partial > 1000)
++			count_partial = 1000;
++
++		co_send_message(CO_MODULE_LINUX,
++				CO_MODULE_SERIAL0 + tty->index,
++				CO_PRIORITY_DISCARDABLE,
++				CO_MESSAGE_TYPE_STRING,
++				count_partial,
++				kbuf_scan);
++		
++		count_left -= count_partial;
++		kbuf_scan += count_partial;
++	}
++
++	return count;
++}
++
++int cocd_write_room(struct tty_struct *tty)
++{
++	struct cocd_tty *cocd = NULL;
++
++	cocd = (struct cocd_tty *)tty->driver_data;
++	if (!cocd)
++		return 0;
++
++	down(&cocd->sem);
++	if (cocd->open_count == 0) {
++		/* port was not opened */
++		up(&cocd->sem);
++		return 0;
++	}
++
++	up(&cocd->sem);
++	return 255;
++}
++
++void cocd_hangup(struct tty_struct *tty)
++{
++}
++
++void cocd_throttle(struct tty_struct * tty)
++{
++	struct cocd_tty *cocd;
++	cocd = (struct cocd_tty *)tty->driver_data;
++	if (!cocd)
++		return;
++	down(&cocd->sem);
++	cocd->throttled = 1;
++	up(&cocd->sem);
++}
++
++void cocd_unthrottle(struct tty_struct * tty)
++{
++	struct cocd_tty *cocd;
++	cocd = (struct cocd_tty *)tty->driver_data;
++	if (!cocd)
++		return;
++	down(&cocd->sem);
++	cocd->throttled = 0;
++	up(&cocd->sem);
++	wake_up(&cocd->waitq);
++}
++
++void cocd_flush_buffer(struct tty_struct *tty)
++{
++}
++
++void cocd_set_termios(struct tty_struct *tty, struct termios *old_termios)
++{
++}
++
++int cocd_chars_in_buffer(struct tty_struct *tty)
++{
++	return 0;
++}
++
++static struct tty_operations cocd_ops = {
++	.open = cocd_open,
++	.close = cocd_close,
++	.write = cocd_write,
++	.write_room = cocd_write_room,
++	.flush_buffer = cocd_flush_buffer,
++	.throttle = cocd_throttle,
++	.unthrottle = cocd_unthrottle,
++	.hangup = cocd_hangup, 
++	.chars_in_buffer = cocd_chars_in_buffer, 
++	.set_termios = cocd_set_termios,
++};
++
++static struct tty_driver *cocd_driver;
++
++static void cocd_console_write(struct console *c, const char *string,  unsigned len)
++{
++}
++
++static struct tty_driver *cocd_console_device(struct console *c, int *index)
++{
++        *index = c->index;
++        return cocd_driver;
++}
++
++static int cocd_console_setup(struct console *co, char *options)
++{
++        return(0);
++}
++
++static struct console cocd_cons = {
++        name:           "ttyS",
++        write:          cocd_console_write,
++        device:         cocd_console_device,
++        setup:          cocd_console_setup,
++        flags:          CON_PRINTBUFFER,
++        index:          -1,
++};
++
++static int __init cocd_init(void)
++{
++	cocd_driver = alloc_tty_driver(CO_MODULE_MAX_SERIAL);
++
++	if (!cocd_driver)
++		panic("Couldn't allocate cocd driver");
++
++	cocd_driver->owner = THIS_MODULE;
++	cocd_driver->driver_name = "Cooperative serial lines";
++	cocd_driver->name = "ttS";
++	cocd_driver->devfs_name = "tts/";
++	cocd_driver->major = TTY_MAJOR;
++	cocd_driver->minor_start = 64;
++	cocd_driver->type = TTY_DRIVER_TYPE_SERIAL;
++	cocd_driver->subtype = 0;
++	cocd_driver->init_termios = tty_std_termios;
++	cocd_driver->flags = 0;
++
++	tty_set_operations(cocd_driver, &cocd_ops);
++	
++	if (tty_register_driver(cocd_driver))
++		panic("Couldn't register cocd driver");
++	
++	register_console(&cocd_cons);
++
++	return 0;
++}
++
++module_init(cocd_init);
+diff -urN a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
+--- a/drivers/input/keyboard/Kconfig
++++ b/drivers/input/keyboard/Kconfig
+@@ -16,7 +16,7 @@
+ 	default y
+ 	depends on INPUT && INPUT_KEYBOARD
+ 	select SERIO
+-	select SERIO_I8042 if PC
++	select SERIO_I8042 if PC && !COOPERATIVE
+ 	select SERIO_GSCPS2 if GSC
+ 	help
+ 	  Say Y here if you want to use a standard AT or PS/2 keyboard. Usually
+diff -urN a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
+--- a/drivers/input/keyboard/atkbd.c
++++ b/drivers/input/keyboard/atkbd.c
+@@ -26,6 +26,7 @@
+ #include <linux/input.h>
+ #include <linux/serio.h>
+ #include <linux/workqueue.h>
++#include <linux/cooperative_internal.h>
+ 
+ #define DRIVER_DESC	"AT and PS/2 keyboard driver"
+ 
+@@ -640,6 +641,9 @@
+ {
+ 	unsigned char param[2];
+ 
++	if (cooperative_mode_enabled())
++		return 0;
++
+ /*
+  * Some systems, where the bit-twiddling when testing the io-lines of the
+  * controller may confuse the keyboard need a full reset of the keyboard. On
+diff -urN a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig
+--- a/drivers/input/mouse/Kconfig
++++ b/drivers/input/mouse/Kconfig
+@@ -14,7 +14,7 @@
+ config MOUSE_PS2
+ 	tristate "PS/2 mouse"
+ 	default y
+-	depends on INPUT && INPUT_MOUSE
++	depends on INPUT && INPUT_MOUSE && !COOPERATIVE
+ 	select SERIO
+ 	select SERIO_I8042 if PC
+ 	select SERIO_GSCPS2 if GSC
+@@ -36,9 +36,21 @@
+ 	  To compile this driver as a module, choose M here: the
+ 	  module will be called psmouse.
+ 
++config MOUSE_COOPERATIVE
++	tristate "Cooperative Mouse driver"
++	default y
++	depends on INPUT && INPUT_MOUSE && COOPERATIVE
++	---help---
++	  Virtual mouse driver for cooperative kernels.
++	  
++	  If unsure, say Y.
++
++	  To compile this driver as a module, choose M here: the
++	  module will be called psmouse.
++
+ config MOUSE_SERIAL
+ 	tristate "Serial mouse"
+-	depends on INPUT && INPUT_MOUSE
++	depends on INPUT && INPUT_MOUSE && !COOPERATIVE
+ 	select SERIO
+ 	---help---
+ 	  Say Y here if you have a serial (RS-232, COM port) mouse connected
+@@ -52,7 +64,7 @@
+ 
+ config MOUSE_INPORT
+ 	tristate "InPort/MS/ATIXL busmouse"
+-	depends on INPUT && INPUT_MOUSE && ISA
++	depends on INPUT && INPUT_MOUSE && ISA && !COOPERATIVE
+ 	help
+ 	  Say Y here if you have an InPort, Microsoft or ATI XL busmouse.
+ 	  They are rather rare these days.
+@@ -62,13 +74,13 @@
+ 
+ config MOUSE_ATIXL
+ 	bool "ATI XL variant"
+-	depends on MOUSE_INPORT
++	depends on MOUSE_INPORT && !COOPERATIVE
+ 	help
+ 	  Say Y here if your mouse is of the ATI XL variety.
+ 
+ config MOUSE_LOGIBM
+ 	tristate "Logitech busmouse"
+-	depends on INPUT && INPUT_MOUSE && ISA
++	depends on INPUT && INPUT_MOUSE && ISA && !COOPERATIVE
+ 	help
+ 	  Say Y here if you have a Logitech busmouse.
+ 	  They are rather rare these days.
+@@ -78,7 +90,7 @@
+ 
+ config MOUSE_PC110PAD
+ 	tristate "IBM PC110 touchpad"
+-	depends on INPUT && INPUT_MOUSE && ISA
++	depends on INPUT && INPUT_MOUSE && ISA && !COOPERATIVE
+ 	help
+ 	  Say Y if you have the IBM PC-110 micro-notebook and want its
+ 	  touchpad supported.
+@@ -88,7 +100,7 @@
+ 
+ config MOUSE_MAPLE
+ 	tristate "Maple bus mouse"
+-	depends on SH_DREAMCAST && INPUT && INPUT_MOUSE && MAPLE
++	depends on SH_DREAMCAST && INPUT && INPUT_MOUSE && MAPLE && !COOPERATIVE
+ 	help
+ 	  Say Y if you have a DreamCast console and a mouse attached to
+ 	  its Maple bus.
+@@ -98,7 +110,7 @@
+ 
+ config MOUSE_AMIGA
+ 	tristate "Amiga mouse"
+-	depends on AMIGA && INPUT && INPUT_MOUSE
++	depends on AMIGA && INPUT && INPUT_MOUSE && !COOPERATIVE
+ 	help
+ 	  Say Y here if you have an Amiga and want its native mouse
+ 	  supported by the kernel.
+@@ -108,7 +120,7 @@
+ 
+ config MOUSE_RISCPC
+ 	tristate "Acorn RiscPC mouse"
+-	depends on ARCH_ACORN && INPUT && INPUT_MOUSE
++	depends on ARCH_ACORN && INPUT && INPUT_MOUSE && !COOPERATIVE
+ 	help
+ 	  Say Y here if you have the Acorn RiscPC computer and want its
+ 	  native mouse supported.
+@@ -118,7 +130,7 @@
+ 
+ config MOUSE_VSXXXAA
+ 	tristate "DEC VSXXX-AA/GA mouse and VSXXX-AB tablet"
+-	depends on INPUT && INPUT_MOUSE
++	depends on INPUT && INPUT_MOUSE && !COOPERATIVE
+ 	select SERIO
+ 	help
+ 	  Say Y (or M) if you want to use a DEC VSXXX-AA (hockey
+diff -urN a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
+--- a/drivers/input/mouse/Makefile
++++ b/drivers/input/mouse/Makefile
+@@ -11,6 +11,7 @@
+ obj-$(CONFIG_MOUSE_MAPLE)	+= maplemouse.o
+ obj-$(CONFIG_MOUSE_PC110PAD)	+= pc110pad.o
+ obj-$(CONFIG_MOUSE_PS2)		+= psmouse.o
++obj-$(CONFIG_MOUSE_COOPERATIVE)	+= comouse.o
+ obj-$(CONFIG_MOUSE_SERIAL)	+= sermouse.o
+ obj-$(CONFIG_MOUSE_VSXXXAA)	+= vsxxxaa.o
+ 
+diff -urN a/drivers/input/mouse/comouse.c b/drivers/input/mouse/comouse.c
+--- a/drivers/input/mouse/comouse.c
++++ b/drivers/input/mouse/comouse.c
+@@ -0,0 +1,74 @@
++/*
++ * Virtual mouse driver for Linux
++ * 
++ * Skeleton based on:
++ *  $Id: sermouse.c,v 1.17 2002/03/13 10:03:43 vojtech Exp $
++ *
++ *  Copyright (c) 1999-2001 Vojtech Pavlik
++ *
++ * Copyright (c) 2004 Dan Aloni
++ */
++
++#include <linux/module.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/input.h>
++#include <linux/config.h>
++#include <linux/serio.h>
++#include <linux/init.h>
++
++MODULE_AUTHOR("Dan Aloni <da-x@colinux.org>");
++MODULE_DESCRIPTION("Virtual mouse driver");
++MODULE_LICENSE("GPL");
++
++/*
++ * comouse_interrupt() handles incoming characters, either gathering them into
++ * packets or passing them to the command routine as command output.
++ */
++
++static irqreturn_t comouse_interrupt(struct serio *serio,
++				     unsigned char data, unsigned int flags, struct pt_regs *regs)
++{
++	return IRQ_HANDLED;
++}
++
++/*
++ * comouse_disconnect() cleans up after we don't want talk
++ * to the mouse anymore.
++ */
++
++static void comouse_disconnect(struct serio *serio)
++{
++}
++
++/*
++ * comouse_connect() is a callback form the serio module when
++ * an unhandled serio port is found.
++ */
++
++static void comouse_connect(struct serio *serio, struct serio_driver *dev)
++{
++}
++
++static struct serio_driver comouse_dev = {
++	.interrupt =	comouse_interrupt,
++	.connect =	comouse_connect,
++	.disconnect =	comouse_disconnect,
++	.driver		= {
++		.name	= "comouse",
++	},
++};
++
++int __init comouse_init(void)
++{
++	serio_register_driver(&comouse_dev); 
++	return 0;
++}
++
++void __exit comouse_exit(void)
++{
++	serio_unregister_driver(&comouse_dev); 
++}
++
++module_init(comouse_init);
++module_exit(comouse_exit);
+diff -urN a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
+--- a/drivers/input/serio/Kconfig
++++ b/drivers/input/serio/Kconfig
+@@ -20,7 +20,7 @@
+ 	tristate "i8042 PC Keyboard controller" if EMBEDDED || !X86
+ 	default y
+ 	select SERIO
+-	depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && !M68K
++	depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && !M68K && !COOPERATIVE
+ 	---help---
+ 	  i8042 is the chip over which the standard AT keyboard and PS/2
+ 	  mouse are connected to the computer. If you use these devices,
+@@ -132,17 +132,22 @@
+ 	  module will be called maceps2.
+ 
+ config SERIO_RAW
+-	tristate "Raw access to serio ports"
+-	depends on SERIO
+-	help
+-	  Say Y here if you want to have raw access to serio ports, such as
+-	  AUX ports on i8042 keyboard controller. Each serio port that is
+-	  bound to this driver will be accessible via a char device with
+-	  major 10 and dynamically allocated minor. The driver will try
+-	  allocating minor 1 (that historically corresponds to /dev/psaux)
+-	  first. To bind this driver to a serio port use sysfs interface:
+-
+-	      echo -n "serio_raw" > /sys/bus/serio/devices/serioX/driver
+-
+-	  To compile this driver as a module, choose M here: the
+-	  module will be called serio_raw.
++ 	tristate "Raw access to serio ports"
++ 	depends on SERIO
++ 	help
++ 	  Say Y here if you want to have raw access to serio ports, such as
++ 	  AUX ports on i8042 keyboard controller. Each serio port that is
++ 	  bound to this driver will be accessible via a char device with
++ 	  major 10 and dynamically allocated minor. The driver will try
++ 	  allocating minor 1 (that historically corresponds to /dev/psaux)
++ 	  first. To bind this driver to a serio port use sysfs interface:
++ 
++ 	      echo -n "serio_raw" > /sys/bus/serio/devices/serioX/driver
++ 
++ 	  To compile this driver as a module, choose M here: the
++ 	  module will be called serio_raw.
++
++config SERIO_COKBD
++	tristate "Cooperative Linux virtual keyboard controller driver"
++	depends on COOPERATIVE
++	default y
+diff -urN a/drivers/input/serio/Makefile b/drivers/input/serio/Makefile
+--- a/drivers/input/serio/Makefile
++++ b/drivers/input/serio/Makefile
+@@ -18,3 +18,4 @@
+ obj-$(CONFIG_SERIO_PCIPS2)	+= pcips2.o
+ obj-$(CONFIG_SERIO_MACEPS2)	+= maceps2.o
+ obj-$(CONFIG_SERIO_RAW)		+= serio_raw.o
++obj-$(CONFIG_SERIO_COKBD)	+= cokbd.o
+\ No newline at end of file
+diff -urN a/drivers/input/serio/cokbd.c b/drivers/input/serio/cokbd.c
+--- a/drivers/input/serio/cokbd.c
++++ b/drivers/input/serio/cokbd.c
+@@ -0,0 +1,155 @@
++/*
++ *  Cooperative Linux virtual keyboard controller driver
++ *
++ *  Copyright (c) 1999-2002 Dan Aloni <da-x@colinux.org)
++ *    Based on 98kbd-io.c written by Osamu Tomita>
++ */
++
++/*
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 as published by
++ * the Free Software Foundation.
++ */
++
++#include <linux/config.h>
++#include <linux/delay.h>
++#include <linux/module.h>
++#include <linux/interrupt.h>
++#include <linux/ioport.h>
++#include <linux/init.h>
++#include <linux/serio.h>
++#include <linux/sched.h>
++#include <linux/cooperative_internal.h>
++
++#include <asm/io.h>
++
++MODULE_AUTHOR("Dan Aloni <da-x@colinux.org>");
++MODULE_DESCRIPTION("Cooperative Linux virtual keyboard controller driver");
++MODULE_LICENSE("GPL");
++
++/*
++ * Names.
++ */
++
++#define COKBD_PHYS_DESC        "cokbd"
++
++static struct serio cokbd_port;
++
++static irqreturn_t cokbdio_interrupt(int irq, void *dev_id, struct pt_regs *regs);
++
++/*
++ * cokbd_flush() flushes all data that may be in the keyboard buffers
++ */
++
++static int cokbd_flush(void)
++{
++#if (0)	
++	co_linux_message_t *message;
++
++	while (co_get_message(&message, CO_DEVICE_KEYBOARD)) {
++		co_free_message(message);
++	}
++#endif
++	return 0;
++}
++
++/*
++ * cokbd_write() sends a byte out through the keyboard interface.
++ */
++
++#define ATKBD_CMD_GETID		0x02f2
++
++static void cokbd_receive(struct serio *port, unsigned char c)
++{
++	struct pt_regs regs= {0, };
++
++	serio_interrupt(port, c, 0, &regs);
++}
++
++static int cokbd_write(struct serio *port, unsigned char c)
++{
++	return 0;
++}
++
++/*
++ * cokbd_open() is called when a port is open by the higher layer.
++ * It allocates the interrupt and enables in in the chip.
++ */
++
++static int cokbd_open(struct serio *port)
++{
++	cokbd_flush();
++
++	if (request_irq(KEYBOARD_IRQ, cokbdio_interrupt, 0, "cokbd", NULL)) {
++		printk(KERN_ERR "cobkd.c: Can't get irq %d for %s, unregistering the port.\n", KEYBOARD_IRQ, "KBD");
++		serio_unregister_port(port);
++		return -1;
++	}
++
++	return 0;
++}
++
++static void cokbd_close(struct serio *port)
++{
++	printk(KERN_INFO "cokbd closed\n");
++
++	free_irq(KEYBOARD_IRQ, NULL);
++
++	cokbd_flush();
++}
++
++/*
++ * Structures for registering the devices in the serio.c module.
++ */
++
++static struct serio cokbd_port =
++{
++	.type =		SERIO_8042_XL,
++	.write =	cokbd_write,
++	.open =		cokbd_open,
++	.close =	cokbd_close,
++	.name =		"cokbd port",
++	.phys =		COKBD_PHYS_DESC,
++};
++
++/*
++ * cokbdio_interrupt() is the most important function in this driver -
++ * it handles the interrupts from keyboard, and sends incoming bytes
++ * to the upper layers.
++ */
++
++static irqreturn_t cokbdio_interrupt(int irq, void *dev_id, struct pt_regs *regs)
++{
++	co_message_node_t *node_message;
++	while (co_get_message(&node_message, CO_DEVICE_KEYBOARD)) {
++		co_linux_message_t *message = (co_linux_message_t *)&node_message->msg.data;
++		co_scan_code_t *sc = (co_scan_code_t *)message->data;
++		unsigned long scancode = sc->code;
++		
++		if (!sc->down)
++			scancode |= 0x80;
++		
++		cokbd_receive(&cokbd_port, scancode);
++		
++		co_free_message(node_message);
++	}
++	
++	return IRQ_HANDLED;
++}
++
++int __init cokbdio_init(void)
++{
++	serio_register_port(&cokbd_port);
++
++	printk(KERN_INFO "serio: cokbd at irq %d\n", KEYBOARD_IRQ);
++
++	return 0;
++}
++
++void __exit cokbdio_exit(void)
++{
++	serio_unregister_port(&cokbd_port);
++}
++
++module_init(cokbdio_init);
++module_exit(cokbdio_exit);
+diff -urN a/drivers/net/Kconfig b/drivers/net/Kconfig
+--- a/drivers/net/Kconfig
++++ b/drivers/net/Kconfig
+@@ -127,6 +127,10 @@
+ 
+ 	  If you don't know what to use this for, you don't need it.
+ 
++config COOPERATIVE_CONET
++	tristate 'Cooperative Virtual Ethernet driver support'
++	depends on COOPERATIVE
++
+ config NET_SB1000
+ 	tristate "General Instruments Surfboard 1000"
+ 	depends on NETDEVICES && PNP
+diff -urN a/drivers/net/Makefile b/drivers/net/Makefile
+--- a/drivers/net/Makefile
++++ b/drivers/net/Makefile
+@@ -152,6 +152,7 @@
+ 
+ # This is also a 82596 and should probably be merged
+ obj-$(CONFIG_LP486E) += lp486e.o
++obj-$(CONFIG_COOPERATIVE_CONET) += conet.o
+ 
+ obj-$(CONFIG_ETH16I) += eth16i.o
+ obj-$(CONFIG_ZORRO8390) += zorro8390.o 8390.o
+diff -urN a/drivers/net/conet.c b/drivers/net/conet.c
+--- a/drivers/net/conet.c
++++ b/drivers/net/conet.c
+@@ -0,0 +1,305 @@
++/*
++ *  Copyright (C) 2003-2004 Dan Aloni <da-x@gmx.net>
++ *  Copyright (C) 2004 Pat Erley
++ *  Copyright (C) 2004 George Boutwell
++ *
++ *  Cooperative Linux Network Device implementation
++ */
++
++#include <linux/config.h>
++#include <linux/version.h>
++#include <linux/module.h>
++
++#include <linux/kernel.h>
++
++#include <linux/netdevice.h>
++#include <linux/etherdevice.h>
++#include <linux/skbuff.h>
++#include <linux/ethtool.h>
++
++#include <linux/cooperative_internal.h>
++#include <asm/irq.h>
++
++struct conet_priv {
++	struct net_device_stats stats;
++	int status;
++	int unit;
++	int enabled;
++	int handling;
++};
++
++struct net_device *conet_dev[CO_MODULE_MAX_CONET];
++
++irqreturn_t conet_interrupt(int irq, void *dev_id, struct pt_regs *reg_ptr);
++
++static int conet_get_mac(int unit, char *address)
++{
++	unsigned long flags = 0;
++	co_network_request_t *net_request;
++	int result = 0;
++
++	co_passage_page_assert_valid();
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_NETWORK;
++	net_request = (typeof(net_request))&co_passage_page->params[1];
++	net_request->unit = unit;
++	net_request->type = CO_NETWORK_GET_MAC;
++	co_switch_wrapper();
++	memcpy(address, net_request->mac_address, ETH_ALEN);
++	result = net_request->result;
++	co_passage_page_release(flags);
++
++	return result;
++}
++
++int conet_open(struct net_device *dev)
++{
++	struct conet_priv *priv = (struct conet_priv *)dev->priv;
++
++	if (priv->enabled)
++		return 0;
++
++	conet_get_mac(priv->unit, dev->dev_addr);
++
++	priv->enabled = 1;
++	
++	netif_start_queue(dev);
++
++	return 0;
++}
++
++int conet_stop(struct net_device *dev)
++{
++	struct conet_priv *priv = (struct conet_priv *)dev->priv;
++
++	priv->enabled = 0;
++
++	netif_stop_queue(dev); /* can't transmit any more */
++
++	return 0;
++}
++
++int conet_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
++{
++	int len;
++	char *data;
++	struct conet_priv *priv = (struct conet_priv *)dev->priv;
++
++	len = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len;
++	data = skb->data;
++
++	dev->trans_start = jiffies; /* save the timestamp */
++
++	co_send_message(CO_MODULE_LINUX, 
++			CO_MODULE_CONET0 + priv->unit,
++			CO_PRIORITY_DISCARDABLE,
++			CO_MESSAGE_TYPE_OTHER,
++			len,
++			data);
++
++	priv->stats.tx_bytes+=skb->len;
++	priv->stats.tx_packets++;
++
++	dev_kfree_skb(skb);
++
++	return 0;
++}
++
++static void conet_rx(struct net_device *dev, co_linux_message_t *message)
++{
++	struct sk_buff *skb;
++	struct conet_priv *priv = (struct conet_priv *)dev->priv;
++	int len;
++	unsigned char *buf;
++	
++	len = message->size;
++	buf = message->data;
++
++	/*
++	 * The packet has been retrieved from the transmission
++	 * medium. Build an skb around it, so upper layers can handle it
++	 */
++	skb = dev_alloc_skb(len+2);
++	if (!skb) {
++		printk("conet rx: low on mem - packet dropped\n");
++		priv->stats.rx_dropped++;
++		return;
++	}
++
++	memcpy(skb_put(skb, len), buf, len);
++
++	/* Write metadata, and then pass to the receive level */
++	skb->dev = dev;
++	skb->protocol = eth_type_trans(skb, dev);
++	skb->ip_summed = CHECKSUM_NONE; /* make the kernel calculate and verify
++                                           the checksum */
++
++	priv->stats.rx_bytes += len;
++	priv->stats.rx_packets++;
++
++	netif_rx(skb);
++	return;
++}
++
++irqreturn_t conet_interrupt(int irq, void *dev_id, struct pt_regs *reg_ptr)
++{	
++	co_message_node_t *node_message;
++	while (co_get_message(&node_message, CO_DEVICE_NETWORK)) {
++		struct net_device *dev;
++		struct conet_priv *priv;
++		co_linux_message_t *message;
++
++		message = (co_linux_message_t *)&node_message->msg.data;
++		if (message->unit < 0  ||  message->unit >= CO_MODULE_MAX_CONET) {
++			printk("conet intrrupt: buggy network reception\n");
++			return IRQ_HANDLED;
++		}
++
++		dev = conet_dev[message->unit];
++		if (!dev) {
++			co_free_message(node_message);
++			continue;
++		}
++
++		if (!netif_running(dev)) {
++			co_free_message(node_message);
++			continue;
++		}
++
++		priv = (struct conet_priv *)dev->priv;
++		if (priv->handling) {
++			co_free_message(node_message);
++			continue;
++		}
++		
++		priv->handling = 1;
++		conet_rx(dev, message); 
++		co_free_message(node_message);
++		priv->handling = 0;
++	}
++
++	return IRQ_HANDLED;
++}
++
++struct net_device_stats* conet_get_stats(struct net_device *dev)
++{
++	return (struct net_device_stats *)dev->priv;
++}
++
++int conet_init(struct net_device *dev)
++{
++	struct conet_priv *priv = (struct conet_priv *)dev->priv;
++
++	memset(&priv->stats, 0, sizeof(priv->stats));
++	
++	ether_setup(dev);
++
++	dev->open            = conet_open;
++	dev->stop            = conet_stop;
++	dev->hard_start_xmit = conet_hard_start_xmit;
++	dev->get_stats       = conet_get_stats;
++	dev->irq             = NETWORK_IRQ;
++
++	SET_MODULE_OWNER(dev);
++
++	return 0;
++}
++
++void conet_uninit(struct net_device *dev)
++{
++}
++
++static struct net_device *conet_create(int unit)
++{
++	struct net_device *dev;
++	struct conet_priv *priv;
++	int result = 0;
++
++	dev = kmalloc(sizeof(struct net_device), GFP_KERNEL);
++	if (!dev) {
++		return ERR_PTR(-ENOMEM);
++	}
++
++	memset(dev, 0, sizeof(struct net_device));
++
++	priv = kmalloc(sizeof(struct conet_priv), GFP_KERNEL);
++	if (priv == NULL) {
++		kfree(dev);
++		return ERR_PTR(-ENOMEM);
++	}
++
++	memset(priv, 0, sizeof(struct conet_priv));
++	priv->unit = unit;
++
++	dev->priv = priv;
++	dev->init = conet_init;
++	dev->uninit = conet_uninit;
++	strcpy(dev->name, "eth%d");
++
++	result = register_netdev(dev);
++	if (result) {
++		printk("conet: error %d registering device \"%s\"\n", result, dev->name);
++		kfree(dev->priv);
++		kfree(dev);
++		return ERR_PTR(-ENODEV);
++	}
++
++	printk("conet%d: initialized\n", priv->unit);
++
++	return dev;
++}
++
++static void conet_destroy(struct net_device *dev)
++{
++	struct conet_priv *priv = (struct conet_priv *) dev->priv;
++
++	printk("conet%d: freed\n", priv->unit);
++
++	unregister_netdev(dev);
++	kfree(dev->priv);
++	kfree(dev);
++}
++
++static int __init conet_init_module(void)
++{
++	int unit = 0, result;
++	struct net_device *dev;
++	char mac_address[6];
++
++	result = request_irq(NETWORK_IRQ, &conet_interrupt, 0, "conet", NULL);
++	
++	printk("conet: loaded (max %d devices)\n", CO_MODULE_MAX_CONET);
++
++	for (unit=0; unit < CO_MODULE_MAX_CONET; unit++) {
++		conet_dev[unit] = NULL;
++		
++		result = conet_get_mac(unit, mac_address);
++		if (!result)
++			continue;
++		
++		dev = conet_create(unit);
++		if (!IS_ERR(dev)) 
++			conet_dev[unit] = dev;
++	}
++
++	return result;
++}
++
++static void __exit conet_cleanup_module(void)
++{
++	int unit = 0;
++
++	free_irq(NETWORK_IRQ, NULL);
++
++	for (unit=0; unit < CO_MODULE_MAX_CONET; unit++) {
++		if (!conet_dev[unit])
++			continue;
++
++		conet_destroy(conet_dev[unit]);
++	}
++}
++
++module_init(conet_init_module);
++module_exit(conet_cleanup_module);
+diff -urN a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
+--- a/drivers/video/console/Kconfig
++++ b/drivers/video/console/Kconfig
+@@ -6,7 +6,7 @@
+ 
+ config VGA_CONSOLE
+ 	bool "VGA text console" if EMBEDDED || !X86
+-	depends on !ARCH_ACORN && !ARCH_EBSA110 && !4xx && !8xx && !SPARC32 && !SPARC64 && !M68K && !PARISC
++ 	depends on !COOPERATIVE && !ARCH_ACORN && !ARCH_EBSA110 && !4xx && !8xx && !SPARC32 && !SPARC64 && !M68K && !PARISC
+ 	default y
+ 	help
+ 	  Saying Y here will allow you to use Linux in text mode through a
+@@ -26,6 +26,14 @@
+ #	   fi
+ #	fi
+ 
++config COOPERATIVE_CONSOLE
++	bool 'coLinux Pseudo-VGA text console' if COOPERATIVE
++	depends on !VGA_CONSOLE && COOPERATIVE
++	default y
++	help
++	  You need to say Y here if you compile a Linux kernel in cooperative 
++	  mode.
++
+ config VIDEO_SELECT
+ 	bool "Video mode selection support"
+ 	depends on  (X86 || X86_64) && VGA_CONSOLE
+@@ -99,7 +107,7 @@
+ 
+ config DUMMY_CONSOLE
+ 	bool
+-	depends on PROM_CONSOLE!=y || VGA_CONSOLE!=y || SGI_NEWPORT_CONSOLE!=y 
++	depends on PROM_CONSOLE!=y || (COOPERATIVE_CONSOLE!=y && VGA_CONSOLE!=y) || SGI_NEWPORT_CONSOLE!=y 
+ 	default y
+ 
+ config FRAMEBUFFER_CONSOLE
+diff -urN a/drivers/video/console/Makefile b/drivers/video/console/Makefile
+--- a/drivers/video/console/Makefile
++++ b/drivers/video/console/Makefile
+@@ -23,6 +23,7 @@
+ obj-$(CONFIG_PROM_CONSOLE)        += promcon.o promcon_tbl.o
+ obj-$(CONFIG_STI_CONSOLE)         += sticon.o sticore.o
+ obj-$(CONFIG_VGA_CONSOLE)         += vgacon.o
++obj-$(CONFIG_COOPERATIVE_CONSOLE) += cocon.o
+ obj-$(CONFIG_MDA_CONSOLE)         += mdacon.o
+ obj-$(CONFIG_FRAMEBUFFER_CONSOLE) += fbcon.o bitblit.o font.o
+ obj-$(CONFIG_FB_TILEBLITTING)     += tileblit.o
+diff -urN a/drivers/video/console/cocon.c b/drivers/video/console/cocon.c
+--- a/drivers/video/console/cocon.c
++++ b/drivers/video/console/cocon.c
+@@ -0,0 +1,464 @@
++/*
++ *  linux/drivers/video/cocon.c -- Cooperative Linux console VGA driver
++ *
++ *  This file is subject to the terms and conditions of the GNU General Public
++ *  License.  See the file COPYING in the main directory of this archive for
++ *  more details.
++ *
++ *  Based on code copied from vgacon.c.
++ *
++ *  Dan Aloni <da-x@gmx.net>, 2003-2004 (c)
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/types.h>
++#include <linux/sched.h>
++#include <linux/fs.h>
++#include <linux/kernel.h>
++#include <linux/tty.h>
++#include <linux/console.h>
++#include <linux/string.h>
++#include <linux/kd.h>
++#include <linux/slab.h>
++#include <linux/vt_kern.h>
++#include <linux/selection.h>
++#include <linux/init.h>
++
++#include <linux/cooperative_internal.h>
++
++/*
++ *  Interface used by the world
++ */
++
++static const char *cocon_startup(void);
++static void cocon_init(struct vc_data *c, int init);
++static void cocon_deinit(struct vc_data *c);
++static void cocon_clear(struct vc_data *c, int, int, int, int);
++static void cocon_cursor(struct vc_data *c, int mode);
++static int cocon_switch(struct vc_data *c);
++static int cocon_blank(struct vc_data *c, int blank, int mode_switch);
++/* static int cocon_font_op(struct vc_data *c, struct console_font_op *op); */
++static int cocon_set_palette(struct vc_data *c, unsigned char *table);
++static int cocon_scrolldelta(struct vc_data *c, int lines);
++static int cocon_set_origin(struct vc_data *c);
++static void cocon_save_screen(struct vc_data *c);
++static int cocon_scroll(struct vc_data *c, int t, int b, int dir, int lines);
++static u8 cocon_build_attr(struct vc_data *c, u8 color, u8 intensity, u8 blink, u8 underline, u8 reverse);
++static void cocon_invert_region(struct vc_data *c, u16 *p, int count);
++
++static const char __init *cocon_startup(void)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_STARTUP;
++	co_send_message_restore(flags);
++
++	return "CoCON";
++}
++
++static void cocon_init(struct vc_data *c, int init)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	/* We cannot be loaded as a module, therefore init is always 1 */
++	c->vc_can_do_color = 1;
++	c->vc_cols = 80;
++	c->vc_rows = 25;
++	c->vc_complement_mask = 0x7700;
++	c->vc_visible_origin = 0;
++	c->vc_origin = 0;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_INIT;
++	co_send_message_restore(flags);
++}
++
++static void cocon_deinit(struct vc_data *c)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_DEINIT;
++	co_send_message_restore(flags);
++
++}
++
++static void cocon_clear(struct vc_data *c, int top, int left, int rows, int cols)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->clear + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_CLEAR;
++	message->clear.top = top;
++	message->clear.left = left;
++	message->clear.bottom = top + rows - 1;
++	message->clear.right = left + cols - 1;
++	message->clear.charattr = c->vc_video_erase_char;
++	co_send_message_restore(flags);
++}
++
++static void cocon_putc(struct vc_data *c, int charattr, int y, int x)
++{
++	unsigned long flags;
++	co_message_t *co_message;
++	co_console_message_t *message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->putc + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_PUTC;
++	message->putc.x = x;
++	message->putc.y = y;
++	message->putc.charattr = charattr;
++	co_send_message_restore(flags);
++}
++
++
++static void cocon_putcs(struct vc_data *conp, 
++			const unsigned short *s, int count, int yy, int xx)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	if (count > CO_MAX_PARAM_SIZE/2 - 16) 
++		return;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->putcs + 1)) - ((char *)message) + 
++		count * sizeof(unsigned short);
++	message->type = CO_OPERATION_CONSOLE_PUTCS;
++	message->putcs.x = xx;
++	message->putcs.y = yy;
++	message->putcs.count = count;
++	memcpy(&message->putcs.data, s, count * sizeof(unsigned short));
++	co_send_message_restore(flags);
++}
++
++static u8 cocon_build_attr(struct vc_data *c, u8 color, u8 intensity, u8 blink, u8 underline, u8 reverse)
++{
++	u8 attr = color;
++
++	if (underline)
++		attr = (attr & 0xf0) | c->vc_ulcolor;
++	else if (intensity == 0)
++		attr = (attr & 0xf0) | c->vc_halfcolor;
++	if (reverse)
++		attr = ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) & 0x77);
++	if (blink)
++		attr ^= 0x80;
++	if (intensity == 2)
++		attr ^= 0x08;
++
++	return attr;
++}
++
++static void cocon_invert_region(struct vc_data *c, u16 *p, int count)
++{
++	unsigned long flags;
++	co_message_t *co_message;
++	co_console_message_t *message;
++	unsigned long x = (unsigned long)(p - c->vc_origin);  // UPDATE: vc_origin = 0; but not yet
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->invert + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_INVERT_REGION;
++	message->invert.y = ((unsigned)x)/c->vc_cols;
++	message->invert.x = ((unsigned)x)-(message->invert.y);
++	message->invert.count = count;
++	co_send_message_restore(flags);
++
++	while (count--) {
++		u16 a = scr_readw(p);
++		a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) | (((a) & 0x0700) << 4);
++		scr_writew(a, p++);
++        }
++
++}
++
++static void cocon_cursor(struct vc_data *c, int mode)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->cursor + 1)) - ((char *)message);;
++	if (mode==CM_ERASE) {
++		message->type = CO_OPERATION_CONSOLE_CURSOR_ERASE;
++		message->cursor.height = 0;
++		co_send_message_restore(flags);
++		return;
++	}
++
++	if(mode==CM_MOVE) {
++		message->type = CO_OPERATION_CONSOLE_CURSOR_MOVE;
++	} else /*(mode==CM_DRAW)*/ {
++		message->type = CO_OPERATION_CONSOLE_CURSOR_DRAW;
++	}
++	message->cursor.x = c->vc_x;
++	message->cursor.y = c->vc_y;
++
++	switch (c->vc_cursor_type & CUR_HWMASK) {
++	case CUR_UNDERLINE:
++		message->cursor.height = 5;
++		break;
++	case CUR_TWO_THIRDS:
++		message->cursor.height = 66;
++		break;
++	case CUR_LOWER_THIRD:
++		message->cursor.height = 33;
++		break;
++	case CUR_LOWER_HALF:
++		message->cursor.height = 50;
++		break;
++	case CUR_NONE:
++		message->cursor.height = 0;
++		break;
++          default:
++		message->cursor.height = 5;
++		break;
++	}
++
++	co_send_message_restore(flags);
++}
++
++static int cocon_switch(struct vc_data *c)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_SWITCH;
++	co_send_message_restore(flags);
++
++	return 1;	/* Redrawing not needed */
++}
++
++static int cocon_set_palette(struct vc_data *c, unsigned char *table)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_SET_PALETTE;
++	co_send_message_restore(flags);
++
++	return 1;
++}
++
++static int cocon_blank(struct vc_data *c, int blank, int mode_switchg)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_BLANK;
++	co_send_message_restore(flags);
++
++	return 1;
++}
++
++
++static int cocon_scrolldelta(struct vc_data *c, int lines)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_SCROLLDELTA;
++	co_send_message_restore(flags);
++
++	return 1;
++}
++
++static int cocon_set_origin(struct vc_data *c)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_SET_ORIGIN;
++	co_send_message_restore(flags);
++
++	return 1;
++}
++
++static void cocon_save_screen(struct vc_data *c)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->type + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_SAVE_SCREEN;
++	co_send_message_restore(flags);
++}
++
++static int cocon_scroll(struct vc_data *c, int t, int b, int dir, int lines)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->scroll + 1)) - ((char *)message);
++	if (dir == SM_UP)
++		message->type = CO_OPERATION_CONSOLE_SCROLL_UP;
++	else
++		message->type = CO_OPERATION_CONSOLE_SCROLL_DOWN;
++	message->scroll.top = t;
++	message->scroll.bottom = b-1;
++	message->scroll.lines = lines;
++	co_send_message_restore(flags);
++
++	return 0;
++}
++
++static void cocon_bmove(struct vc_data *c, int sy, int sx, int dy, int dx, int h, int w)
++{
++	unsigned long flags;
++	co_console_message_t *message;
++	co_message_t *co_message;
++
++	co_message = co_send_message_save(&flags);
++	message = (co_console_message_t *)co_message->data;
++	co_message->from = CO_MODULE_LINUX;
++	co_message->to = CO_MODULE_CONSOLE;
++	co_message->priority = CO_PRIORITY_DISCARDABLE;
++	co_message->type = CO_MESSAGE_TYPE_STRING;
++	co_message->size = ((char *)(&message->bmove + 1)) - ((char *)message);
++	message->type = CO_OPERATION_CONSOLE_BMOVE;
++	message->bmove.row = dy;
++	message->bmove.column = dx;
++	message->bmove.top = sy;
++	message->bmove.left = sx;
++	message->bmove.bottom = sy + h - 1;
++	message->bmove.right = sx + w - 1;
++	co_send_message_restore(flags);
++}
++
++/*
++ *  The console `switch' structure for the VGA based console
++ */
++
++const struct consw colinux_con = {
++	con_startup:		cocon_startup,
++	con_init:		cocon_init,
++	con_deinit:		cocon_deinit,
++	con_clear:		cocon_clear,
++	con_putc:		cocon_putc,
++	con_putcs:		cocon_putcs,
++	con_cursor:		cocon_cursor,
++	con_scroll:		cocon_scroll,
++	con_bmove:		cocon_bmove,
++	con_switch:		cocon_switch,
++	con_blank:		cocon_blank,
++	con_set_palette:	cocon_set_palette,
++	con_scrolldelta:	cocon_scrolldelta,
++	con_set_origin:		cocon_set_origin,
++	con_save_screen:	cocon_save_screen,
++	con_build_attr:		cocon_build_attr,
++	con_invert_region:	cocon_invert_region,
++};
++
++MODULE_LICENSE("GPL");
+diff -urN a/fs/Kconfig b/fs/Kconfig
+--- a/fs/Kconfig
++++ b/fs/Kconfig
+@@ -1098,6 +1098,19 @@
+ 	  containing the directory /) cannot be compiled as a module.
+ 
+ 
++config COFUSE_FS
++	tristate "Cooperative Host file system support (COFUSE)"
++	depends on COOPERATIVE
++	default y
++	help
++	  In Cooperative mode, this file system allows you to mount an host 
++	  directory structure to a local mountpoint. 
++	  COFUSE (Cooperative FUSE) is based on the original FUSE 
++	  (File System in User Space). 
++
++	  To compile the cofuse support as a module, choose M here: the
++	  module will be called cofusefs.
++
+ 
+ config EFS_FS
+ 	tristate "EFS file system support (read only) (EXPERIMENTAL)"
+diff -urN a/fs/Makefile b/fs/Makefile
+--- a/fs/Makefile
++++ b/fs/Makefile
+@@ -94,3 +94,5 @@
+ obj-$(CONFIG_BEFS_FS)		+= befs/
+ obj-$(CONFIG_HOSTFS)		+= hostfs/
+ obj-$(CONFIG_HPPFS)		+= hppfs/
++obj-$(CONFIG_COFUSE_FS)		+= cofusefs/
++
+diff -urN a/fs/cofusefs/Makefile b/fs/cofusefs/Makefile
+--- a/fs/cofusefs/Makefile
++++ b/fs/cofusefs/Makefile
+@@ -0,0 +1,8 @@
++#
++# Makefile for the Linux cofuse filesystem routines.
++#
++
++obj-$(CONFIG_COFUSE_FS) += cofusefs.o
++
++cofusefs-objs := inode.o dir.o file.o util.o dev.o
++
+diff -urN a/fs/cofusefs/dev.c b/fs/cofusefs/dev.c
+--- a/fs/cofusefs/dev.c
++++ b/fs/cofusefs/dev.c
+@@ -0,0 +1,889 @@
++/*
++    FUSE: Filesystem in Userspace
++    Copyright (C) 2001-2004  Miklos Szeredi <miklos@szeredi.hu>
++
++    This program can be distributed under the terms of the GNU GPL.
++    See the file COPYING.
++*/
++
++#include "fuse_i.h"
++
++#include <linux/poll.h>
++#include <linux/proc_fs.h>
++#include <linux/file.h>
++
++#ifndef CONFIG_COOPERATIVE
++
++/* If more requests are outstanding, then the operation will block */
++#define MAX_OUTSTANDING 10
++
++static struct proc_dir_entry *proc_fs_fuse;
++struct proc_dir_entry *proc_fuse_dev;
++static kmem_cache_t *fuse_req_cachep;
++
++static struct fuse_req *request_new(void)
++{
++	struct fuse_req *req;
++
++	req = (struct fuse_req *) kmem_cache_alloc(fuse_req_cachep, SLAB_NOFS);
++	if(req) {
++		INIT_LIST_HEAD(&req->list);
++		req->issync = 0;
++		req->locked = 0;
++		req->interrupted = 0;
++		req->sent = 0;
++		req->finished = 0;
++		req->in = NULL;
++		req->out = NULL;
++		init_waitqueue_head(&req->waitq);
++	}
++
++	return req;
++}
++
++static void request_free(struct fuse_req *req)
++{
++	kmem_cache_free(fuse_req_cachep, req);
++}
++
++static int request_restartable(enum fuse_opcode opcode)
++{
++	switch(opcode) {
++	case FUSE_LOOKUP:
++	case FUSE_GETATTR:
++	case FUSE_READLINK:
++	case FUSE_GETDIR:
++	case FUSE_OPEN:
++	case FUSE_READ:
++	case FUSE_WRITE:
++		return 1;
++
++	default:
++		return 0;
++	}
++}
++
++/* Called with fuse_lock held.  Releases, and then reaquires it. */
++static void request_wait_answer(struct fuse_req *req)
++{
++	int intr;
++	
++	spin_unlock(&fuse_lock);
++	intr = wait_event_interruptible(req->waitq, req->finished);
++	spin_lock(&fuse_lock);
++	if(!intr)
++		return;
++
++	/* Request interrupted... Wait for it to be unlocked */
++	if(req->locked) {
++		req->interrupted = 1;
++		spin_unlock(&fuse_lock);
++		wait_event(req->waitq, !req->locked);
++		spin_lock(&fuse_lock);
++	}
++	
++	/* Operations which modify the filesystem cannot safely be
++	   restarted, because it is uncertain whether the operation has
++	   completed or not... */
++	if(req->sent && !request_restartable(req->in->h.opcode))
++		req->out->h.error = -EINTR;
++	else
++		req->out->h.error = -ERESTARTSYS;
++}
++
++static int get_unique(struct fuse_conn *fc)
++{
++	do fc->reqctr++;
++	while(!fc->reqctr);
++	return fc->reqctr;
++}
++
++/* Must be called with fuse_lock held, and unlocks it */
++static void request_end(struct fuse_conn *fc, struct fuse_req *req)
++{
++	fuse_reqend_t endfunc = req->end;
++
++	if(!endfunc) {
++		wake_up(&req->waitq);
++		spin_unlock(&fuse_lock);
++	} else {
++		spin_unlock(&fuse_lock);
++		endfunc(fc, req->in, req->out, req->data);
++		request_free(req);
++		up(&fc->outstanding);
++	}
++}
++
++void request_send(struct fuse_conn *fc, struct fuse_in *in,
++		  struct fuse_out *out)
++{
++	struct fuse_req *req;
++
++	out->h.error = -ERESTARTSYS;
++	if(down_interruptible(&fc->outstanding))
++		return;
++
++	out->h.error = -ENOMEM;
++	req = request_new();
++	if(req) {
++		req->in = in;
++		req->out = out;
++		req->issync = 1;
++		req->end = NULL;
++		
++		spin_lock(&fuse_lock);
++		out->h.error = -ENOTCONN;
++		if(fc->file) {
++			in->h.unique = get_unique(fc);		
++			list_add_tail(&req->list, &fc->pending);
++			wake_up(&fc->waitq);
++			request_wait_answer(req);
++			list_del(&req->list);
++		}
++		spin_unlock(&fuse_lock);
++		request_free(req);
++	}
++
++	up(&fc->outstanding);
++}
++
++
++static inline void destroy_request(struct fuse_req *req)
++{
++	if(req) {
++		kfree(req->in);
++		request_free(req);
++	}
++}
++
++/* This one is currently only used for sending FORGET and RELEASE,
++   which are kernel initiated request.  So the outstanding semaphore
++   is not used.  */
++int request_send_noreply(struct fuse_conn *fc, struct fuse_in *in)
++{
++	struct fuse_req *req;
++
++	req = request_new();
++	if(!req)
++		return -ENOMEM;
++
++	req->in = in;
++	req->issync = 0;
++
++	spin_lock(&fuse_lock);
++	if(!fc->file) {
++		spin_unlock(&fuse_lock);
++		request_free(req);
++		return -ENOTCONN;
++	}
++
++	list_add_tail(&req->list, &fc->pending);
++	wake_up(&fc->waitq);
++	spin_unlock(&fuse_lock);
++	return 0;
++}
++
++int request_send_nonblock(struct fuse_conn *fc, struct fuse_in *in,
++			  struct fuse_out *out, fuse_reqend_t end, void *data)
++{
++	int err;
++	struct fuse_req *req;
++
++	BUG_ON(!end);
++
++	if(down_trylock(&fc->outstanding))
++		return -EWOULDBLOCK;
++
++	err = -ENOMEM;
++	req = request_new();
++	if(req) {
++		req->in = in;
++		req->out = out;
++		req->issync = 1;
++		req->end = end;
++		req->data = data;
++
++		spin_lock(&fuse_lock);
++		err = -ENOTCONN;
++		if(fc->file) {
++			in->h.unique = get_unique(fc);		
++			list_add_tail(&req->list, &fc->pending);
++			wake_up(&fc->waitq);
++			spin_unlock(&fuse_lock);
++			return 0;
++		}
++		spin_unlock(&fuse_lock);
++		request_free(req);
++	}
++	up(&fc->outstanding);
++	return err;
++}
++
++static void request_wait(struct fuse_conn *fc)
++{
++	DECLARE_WAITQUEUE(wait, current);
++
++	add_wait_queue_exclusive(&fc->waitq, &wait);
++	while(fc->sb != NULL && list_empty(&fc->pending)) {
++		set_current_state(TASK_INTERRUPTIBLE);
++		if(signal_pending(current))
++			break;
++
++		spin_unlock(&fuse_lock);
++		schedule();
++		spin_lock(&fuse_lock);
++	}
++	set_current_state(TASK_RUNNING);
++	remove_wait_queue(&fc->waitq, &wait);
++}
++
++static inline int copy_in_one(const void *src, size_t srclen, char **dstp,
++			      size_t *dstlenp)
++{
++	if(*dstlenp < srclen) {
++		printk("fuse_dev_read: buffer too small\n");
++		return -EINVAL;
++	}
++			
++	if(copy_to_user(*dstp, src, srclen))
++		return -EFAULT;
++
++	*dstp += srclen;
++	*dstlenp -= srclen;
++
++	return 0;
++}
++
++static inline int copy_in_args(struct fuse_in *in, char *buf, size_t nbytes)
++{
++	int err;
++	int i;
++	size_t orignbytes = nbytes;
++		
++	err = copy_in_one(&in->h, sizeof(in->h), &buf, &nbytes);
++	if(err)
++		return err;
++
++	for(i = 0; i < in->numargs; i++) {
++		struct fuse_in_arg *arg = &in->args[i];
++		err = copy_in_one(arg->value, arg->size, &buf, &nbytes);
++		if(err)
++			return err;
++	}
++
++	return orignbytes - nbytes;
++}
++
++static ssize_t fuse_dev_read(struct file *file, char *buf, size_t nbytes,
++			     loff_t *off)
++{
++	ssize_t ret;
++	struct fuse_conn *fc = DEV_FC(file);
++	struct fuse_req *req = NULL;
++
++	spin_lock(&fuse_lock);
++	request_wait(fc);
++	if(fc->sb != NULL && !list_empty(&fc->pending)) {
++		req = list_entry(fc->pending.next, struct fuse_req, list);
++		list_del_init(&req->list);
++		req->locked = 1;
++	}
++	spin_unlock(&fuse_lock);
++	if(fc->sb == NULL)
++		return -ENODEV;
++	if(req == NULL)
++		return -EINTR;
++
++	ret = copy_in_args(req->in, buf, nbytes);
++	spin_lock(&fuse_lock);
++	if(req->issync) {
++		if(ret < 0) {
++			req->out->h.error = -EPROTO;
++			req->finished = 1;
++		} else {
++			list_add_tail(&req->list, &fc->processing);
++			req->sent = 1;
++		}
++		req->locked = 0;
++		if(ret < 0 || req->interrupted)
++			/* Unlocks fuse_lock: */
++			request_end(fc, req);
++		else
++			spin_unlock(&fuse_lock);
++	} else {
++		spin_unlock(&fuse_lock);
++		destroy_request(req);
++	}
++	return ret;
++}
++
++static struct fuse_req *request_find(struct fuse_conn *fc, unsigned int unique)
++{
++	struct list_head *entry;
++	struct fuse_req *req = NULL;
++
++	list_for_each(entry, &fc->processing) {
++		struct fuse_req *tmp;
++		tmp = list_entry(entry, struct fuse_req, list);
++		if(tmp->in->h.unique == unique) {
++			req = tmp;
++			break;
++		}
++	}
++
++	return req;
++}
++
++static void process_getdir(struct fuse_req *req)
++{
++	struct fuse_getdir_out *arg;
++	arg = (struct fuse_getdir_out *) req->out->args[0].value;
++	arg->file = fget(arg->fd);
++}
++
++static inline int copy_out_one(struct fuse_out_arg *arg, const char **srcp,
++			       size_t *srclenp, int allowvar)
++{
++	size_t dstlen = arg->size;
++	if(*srclenp < dstlen) {
++		if(!allowvar) {
++			printk("fuse_dev_write: write is short\n");
++			return -EINVAL;
++		}
++		dstlen = *srclenp;
++	}
++
++	if(dstlen) {
++		if(copy_from_user(arg->value, *srcp, dstlen))
++			return -EFAULT;
++	}
++
++	*srcp += dstlen;
++	*srclenp -= dstlen;
++	arg->size = dstlen;
++
++	return 0;
++}
++
++static inline int copy_out_args(struct fuse_out *out, const char *buf,
++				size_t nbytes)
++{
++	int err;
++	int i;
++
++	buf += sizeof(struct fuse_out_header);
++	nbytes -= sizeof(struct fuse_out_header);
++		
++	if(!out->h.error) {
++		for(i = 0; i < out->numargs; i++) {
++			struct fuse_out_arg *arg = &out->args[i];
++			int allowvar;
++
++			if(out->argvar && i == out->numargs - 1)
++				allowvar = 1;
++			else
++				allowvar = 0;
++
++			err = copy_out_one(arg, &buf, &nbytes, allowvar);
++			if(err)
++				return err;
++		}
++	}
++
++	if(nbytes != 0) {
++		printk("fuse_dev_write: write is long\n");
++		return -EINVAL;
++	}
++
++	return 0;
++}
++
++static inline int copy_out_header(struct fuse_out_header *oh, const char *buf,
++				  size_t nbytes)
++{
++	if(nbytes < sizeof(struct fuse_out_header)) {
++		printk("fuse_dev_write: write is short\n");
++		return -EINVAL;
++	}
++	
++	if(copy_from_user(oh, buf, sizeof(struct fuse_out_header)))
++		return -EFAULT;
++
++	return 0;
++}
++
++#ifdef KERNEL_2_6
++static int fuse_invalidate(struct fuse_conn *fc, struct fuse_user_header *uh)
++{
++	struct inode *inode = ilookup(fc->sb, uh->ino);
++	if (!inode)
++		return -ENOENT;
++	invalidate_inode_pages(inode->i_mapping);
++	iput(inode);
++	return 0;
++}
++#else 
++static int fuse_invalidate(struct fuse_conn *fc, struct fuse_user_header *uh)
++{
++	struct inode *inode = iget(fc->sb, uh->ino);
++	int err = -ENOENT;
++	if(inode) {
++		if(inode->u.generic_ip) {
++			invalidate_inode_pages(inode);
++			err = 0;
++		}
++		iput(inode);
++	}
++	return err;
++}
++#endif
++
++static int fuse_user_request(struct fuse_conn *fc, const char *buf,
++			     size_t nbytes)
++{
++	struct fuse_user_header uh;
++	int err;
++
++	if (nbytes < sizeof(struct fuse_user_header)) {
++		printk("fuse_dev_write: write is short\n");
++		return -EINVAL;
++	}
++
++	if(copy_from_user(&uh, buf, sizeof(struct fuse_out_header)))
++		return -EFAULT;
++	
++	switch(uh.opcode) {
++	case FUSE_INVALIDATE:
++		err = fuse_invalidate(fc, &uh);
++		break;
++
++	default:
++		err = -ENOSYS;
++	}
++	return err;
++}
++    
++
++static ssize_t fuse_dev_write(struct file *file, const char *buf,
++			      size_t nbytes, loff_t *off)
++{
++	int err;
++	struct fuse_conn *fc = DEV_FC(file);
++	struct fuse_req *req;
++	struct fuse_out_header oh;
++
++	if(!fc->sb)
++		return -EPERM;
++
++	err = copy_out_header(&oh, buf, nbytes);
++	if(err)
++		return err;
++
++	if (!oh.unique)	{
++		err = fuse_user_request(fc, buf, nbytes);
++		goto out;
++	}     
++
++        if (oh.error <= -512 || oh.error > 0) {
++                printk("fuse_dev_write: bad error value\n");
++                return -EINVAL;
++        }
++
++	spin_lock(&fuse_lock);
++	req = request_find(fc, oh.unique);
++	if(req != NULL) {
++		list_del_init(&req->list);
++		req->locked = 1;
++	}
++	spin_unlock(&fuse_lock);
++	if(!req)
++		return -ENOENT;
++
++	req->out->h = oh;
++	err = copy_out_args(req->out, buf, nbytes);
++
++	spin_lock(&fuse_lock);
++	if(err)
++		req->out->h.error = -EPROTO;
++	else {
++		/* fget() needs to be done in this context */
++		if(req->in->h.opcode == FUSE_GETDIR && !oh.error)
++			process_getdir(req);
++	}	
++	req->finished = 1;
++	req->locked = 0;
++	/* Unlocks fuse_lock: */
++	request_end(fc, req);
++
++  out:
++	if(!err)
++		return nbytes;
++	else
++		return err;
++}
++
++
++static unsigned int fuse_dev_poll(struct file *file, poll_table *wait)
++{
++	struct fuse_conn *fc = DEV_FC(file);
++	unsigned int mask = POLLOUT | POLLWRNORM;
++
++	if(!fc->sb)
++		return -EPERM;
++
++	poll_wait(file, &fc->waitq, wait);
++
++	spin_lock(&fuse_lock);
++	if (!list_empty(&fc->pending))
++                mask |= POLLIN | POLLRDNORM;
++	spin_unlock(&fuse_lock);
++
++	return mask;
++}
++
++static struct fuse_conn *new_conn(void)
++{
++	struct fuse_conn *fc;
++
++	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
++	if(fc != NULL) {
++		fc->sb = NULL;
++		fc->file = NULL;
++		fc->flags = 0;
++		fc->uid = 0;
++		fc->oldrelease = 0;
++		init_waitqueue_head(&fc->waitq);
++		INIT_LIST_HEAD(&fc->pending);
++		INIT_LIST_HEAD(&fc->processing);
++		sema_init(&fc->outstanding, MAX_OUTSTANDING);
++		fc->reqctr = 1;
++	}
++	return fc;
++}
++
++static int fuse_dev_open(struct inode *inode, struct file *file)
++{
++	struct fuse_conn *fc;
++
++	fc = new_conn();
++	if(!fc)
++		return -ENOMEM;
++
++	fc->file = file;
++	file->private_data = fc;
++
++	return 0;
++}
++
++static void end_requests(struct fuse_conn *fc, struct list_head *head)
++{
++	while(!list_empty(head)) {
++		struct fuse_req *req;
++		req = list_entry(head->next, struct fuse_req, list);
++		list_del_init(&req->list);
++		if(req->issync) {
++			req->out->h.error = -ECONNABORTED;
++			req->finished = 1;
++			/* Unlocks fuse_lock: */
++			request_end(fc, req);
++			spin_lock(&fuse_lock);
++		} else
++			destroy_request(req);
++	}
++}
++
++static int fuse_dev_release(struct inode *inode, struct file *file)
++{
++	struct fuse_conn *fc = DEV_FC(file);
++
++	spin_lock(&fuse_lock);
++	fc->file = NULL;
++	end_requests(fc, &fc->pending);
++	end_requests(fc, &fc->processing);
++	release_conn(fc);
++	spin_unlock(&fuse_lock);
++	return 0;
++}
++
++static struct file_operations fuse_dev_operations = {
++	.owner		= THIS_MODULE,
++	.read		= fuse_dev_read,
++	.write		= fuse_dev_write,
++	.poll		= fuse_dev_poll,
++	.open		= fuse_dev_open,
++	.release	= fuse_dev_release,
++};
++
++int fuse_dev_init()
++{
++	int ret;
++
++	proc_fs_fuse = NULL;
++	proc_fuse_dev = NULL;
++
++	fuse_req_cachep = kmem_cache_create("cofuser_request",
++					     sizeof(struct fuse_req),
++					     0, 0, NULL, NULL);
++	if(!fuse_req_cachep)
++		return -ENOMEM;
++
++	ret = -ENOMEM;
++	proc_fs_fuse = proc_mkdir("fuse", proc_root_fs);
++	if(!proc_fs_fuse) {
++		printk("fuse: failed to create directory in /proc/fs\n");
++		goto err;
++	}
++
++	proc_fs_fuse->owner = THIS_MODULE;
++	proc_fuse_dev = create_proc_entry("dev", S_IFSOCK | 0600, proc_fs_fuse);
++	if(!proc_fuse_dev) {
++		printk("fuse: failed to create entry in /proc/fs/fuse\n");
++		goto err;
++	}
++
++	proc_fuse_dev->proc_fops = &fuse_dev_operations;
++
++	return 0;
++
++  err:
++	fuse_dev_cleanup();
++	return ret;
++}
++
++void fuse_dev_cleanup()
++{
++	if (cooperative_mode_enabled()) {
++		kmem_cache_destroy(fuse_req_cachep);
++		return;
++	}
++
++	if(proc_fs_fuse) {
++		remove_proc_entry("dev", proc_fs_fuse);
++		remove_proc_entry("fuse", proc_root_fs);
++	}
++	
++	kmem_cache_destroy(fuse_req_cachep);
++}
++
++#else
++
++struct fuse_conn *cofs_volumes[CO_MODULE_MAX_COFS] = {NULL, };
++
++static void cofuse_request_start(unsigned long *flags, struct fuse_conn *fc, struct fuse_in *in)
++{
++	co_passage_page_assert_valid();
++	
++	co_passage_page_acquire(flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_FILESYSTEM;
++	co_passage_page->params[1] = fc->cofs_unit;
++	co_passage_page->params[2] = in->h.opcode;
++	co_passage_page->params[3] = in->h.ino;
++	co_passage_page->params[4] = 0;
++}
++
++static void cofuse_request_end(unsigned long flags, struct fuse_out *out)
++{
++	unsigned long ret;
++	ret = co_passage_page->params[4];
++	co_passage_page_release(flags);
++	out->h.error = ret;
++}
++
++void request_send(struct fuse_conn *fc, struct fuse_in *in,
++		  struct fuse_out *out)
++{
++	unsigned long flags;
++	char *str;
++
++	switch ((unsigned long)in->h.opcode) {
++	case FUSE_STATFS: {
++		struct fuse_statfs_out *arg;
++
++		arg = (struct fuse_statfs_out *)out->args[0].value;
++
++		cofuse_request_start(&flags, fc, in);
++		co_switch_wrapper();
++		*arg = *(struct fuse_statfs_out *)&co_passage_page->params[5];
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_OPEN: {
++		struct fuse_open_in *opin = (struct fuse_open_in *)in->args[0].value;
++
++		cofuse_request_start(&flags, fc, in);
++		co_passage_page->params[5] = opin->flags;
++		co_switch_wrapper();
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_WRITE: {
++		struct fuse_write_in *write_in = (struct fuse_write_in *)in->args[0].value;
++		unsigned long long *offset_passage = (unsigned long long *)&co_passage_page->params[5];
++
++		cofuse_request_start(&flags, fc, in);
++		*offset_passage = write_in->offset;
++		co_passage_page->params[7] = write_in->size;
++		co_passage_page->params[8] = (unsigned long)in->args[1].value;
++		co_switch_wrapper();
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_READ: {
++		struct fuse_read_in *read_in = (struct fuse_read_in *)in->args[0].value;
++		unsigned long long *offset_passage = (unsigned long long *)&co_passage_page->params[5];
++
++		cofuse_request_start(&flags, fc, in);
++		*offset_passage = read_in->offset;
++		co_passage_page->params[7] = read_in->size;
++		co_passage_page->params[8] = (unsigned long)out->args[0].value;
++		co_switch_wrapper();
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_LOOKUP: {
++		struct fuse_lookup_out *arg;
++
++		arg = (struct fuse_lookup_out *)out->args[0].value;
++		str = (char *)&co_passage_page->params[30];
++
++		cofuse_request_start(&flags, fc, in);
++		memcpy(str, (char *)in->args[0].value, in->args[0].size);
++		co_switch_wrapper();
++		*arg = *(struct fuse_lookup_out *)&co_passage_page->params[5];
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_RENAME: {
++		struct fuse_rename_in *arg;
++		char *str2;
++
++		arg = (struct fuse_rename_in *)in->args[0].value;
++		str = (char *)(&co_passage_page->params[30]);
++		str2 = str + in->args[1].size;
++
++		cofuse_request_start(&flags, fc, in);
++		co_passage_page->params[5] = arg->newdir;
++		memcpy(str, (char *)in->args[1].value, in->args[1].size);
++		memcpy(str2, (char *)in->args[2].value, in->args[2].size);
++		co_switch_wrapper();
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_MKNOD: {
++		struct fuse_mknod_in *inarg;
++		struct fuse_mknod_out *outarg;
++		char *str;
++
++		inarg = (struct fuse_mknod_in *)(in->args[0].value);
++		outarg = (struct fuse_mknod_out *)(out->args[0].value);
++
++		cofuse_request_start(&flags, fc, in);
++		co_passage_page->params[5] = inarg->mode;
++		co_passage_page->params[6] = inarg->rdev;
++		str = (char *)&co_passage_page->params[30];
++		memcpy(str, (char *)in->args[1].value, in->args[1].size);
++		co_switch_wrapper();
++		outarg->ino = co_passage_page->params[7];
++		outarg->attr = *(struct fuse_attr *)(&co_passage_page->params[8]);
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_SETATTR: {
++		struct fuse_setattr_in *inarg;
++		struct fuse_setattr_out *outarg;
++		struct fuse_attr *attr;
++
++		inarg = (struct fuse_setattr_in *)(in->args[0].value);
++		outarg = (struct fuse_setattr_out *)(out->args[0].value);
++		attr = (struct fuse_attr *)(&co_passage_page->params[6]);
++
++		cofuse_request_start(&flags, fc, in);
++		co_passage_page->params[5] = inarg->valid;
++		*attr = inarg->attr;
++		co_switch_wrapper();
++		outarg->attr = *attr;
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_MKDIR: {
++		struct fuse_mkdir_in *arg;
++
++		arg = (struct fuse_mkdir_in *)(in->args[0].value);
++		str = (char *)&co_passage_page->params[30];
++
++		cofuse_request_start(&flags, fc, in);
++		co_passage_page->params[5] = arg->mode;
++		memcpy(str, (char *)in->args[1].value, in->args[1].size);
++		co_switch_wrapper();
++		cofuse_request_end(flags, out);
++		return;
++	}
++
++	case FUSE_UNLINK: 
++	case FUSE_RMDIR: {
++		str = (char *)&co_passage_page->params[30];
++
++		cofuse_request_start(&flags, fc, in);
++		memcpy(str, (char *)in->args[0].value, in->args[0].size);
++		co_switch_wrapper();
++		cofuse_request_end(flags, out);
++		return;
++	}
++		
++	case FUSE_GETATTR: {
++		struct fuse_getattr_out *arg;
++		arg = (struct fuse_getattr_out *)out->args[0].value;
++
++		co_passage_page_assert_valid();
++		cofuse_request_start(&flags, fc, in);
++		co_switch_wrapper();
++		*arg = *(struct fuse_getattr_out *)&co_passage_page->params[5];
++		cofuse_request_end(flags, out);
++		return;
++	}
++	}
++
++	/* printk("cofuse: request_send %d\n", in->h.opcode); */
++	out->h.error = -EIO;
++}
++
++int request_send_noreply(struct fuse_conn *fc, struct fuse_in *in)
++{
++	return -EIO;
++}
++
++int request_send_nonblock(struct fuse_conn *fc, struct fuse_in *in,
++			  struct fuse_out *out, fuse_reqend_t end, void *data)
++{
++	/* printk("cofuse: request_send_nonblock %d\n", in->h.opcode); */
++	request_send(fc, in, out);
++	end(fc, in, out, data);
++	return 0;
++}
++
++int fuse_dev_init()
++{
++	return 0;
++}
++
++void fuse_dev_cleanup()
++{
++}
++
++#endif
++
++/* 
++ * Local Variables:
++ * indent-tabs-mode: t
++ * c-basic-offset: 8
++ * End:
++ */
+diff -urN a/fs/cofusefs/dir.c b/fs/cofusefs/dir.c
+--- a/fs/cofusefs/dir.c
++++ b/fs/cofusefs/dir.c
+@@ -0,0 +1,961 @@
++/*
++    FUSE: Filesystem in Userspace
++    Copyright (C) 2001-2004  Miklos Szeredi <miklos@szeredi.hu>
++
++    This program can be distributed under the terms of the GNU GPL.
++    See the file COPYING.
++*/
++
++#include "fuse_i.h"
++
++#include <linux/pagemap.h>
++#include <linux/slab.h>
++#include <linux/file.h>
++
++static struct inode_operations fuse_dir_inode_operations;
++static struct inode_operations fuse_file_inode_operations;
++static struct inode_operations fuse_symlink_inode_operations;
++
++static struct file_operations fuse_dir_operations;
++
++static struct dentry_operations fuse_dentry_operations;
++
++/* FIXME: This should be user configurable */
++#define FUSE_REVALIDATE_TIME (1 * HZ)
++
++#ifndef KERNEL_2_6
++#define new_decode_dev(x) (x)
++#define new_encode_dev(x) (x)
++#endif
++
++static void change_attributes(struct inode *inode, struct fuse_attr *attr)
++{
++	if(S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size) {
++#ifdef KERNEL_2_6
++		invalidate_inode_pages(inode->i_mapping);
++#else
++		invalidate_inode_pages(inode);
++#endif
++	}
++
++	inode->i_mode    = (inode->i_mode & S_IFMT) + (attr->mode & 07777);
++	inode->i_nlink   = attr->nlink;
++	inode->i_uid     = attr->uid;
++	inode->i_gid     = attr->gid;
++	i_size_write(inode, attr->size);
++	inode->i_blksize = PAGE_CACHE_SIZE;
++	inode->i_blocks  = attr->blocks;
++#ifdef KERNEL_2_6
++	inode->i_atime.tv_sec   = attr->atime;
++	inode->i_atime.tv_nsec  = 0;
++	inode->i_mtime.tv_sec   = attr->mtime;
++	inode->i_mtime.tv_nsec  = 0;
++	inode->i_ctime.tv_sec   = attr->ctime;
++	inode->i_ctime.tv_nsec  = 0;
++#else
++	inode->i_atime   = attr->atime;
++	inode->i_mtime   = attr->mtime;
++	inode->i_ctime   = attr->ctime;
++#endif
++}
++
++static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
++{
++	inode->i_mode = attr->mode & S_IFMT;
++	i_size_write(inode, attr->size);
++	if(S_ISREG(inode->i_mode)) {
++		inode->i_op = &fuse_file_inode_operations;
++		fuse_init_file_inode(inode);
++	}
++	else if(S_ISDIR(inode->i_mode)) {
++		inode->i_op = &fuse_dir_inode_operations;
++		inode->i_fop = &fuse_dir_operations;
++	}
++	else if(S_ISLNK(inode->i_mode)) {
++		inode->i_op = &fuse_symlink_inode_operations;
++	}
++	else {
++		inode->i_op = &fuse_file_inode_operations;
++		init_special_inode(inode, inode->i_mode,
++				   new_decode_dev(attr->rdev));
++	}
++	inode->u.generic_ip = inode;
++}
++
++struct inode *fuse_iget(struct super_block *sb, ino_t ino,
++			struct fuse_attr *attr, int version)
++{
++	struct inode *inode;
++
++	inode = iget(sb, ino);
++	if(inode) {
++		if(!inode->u.generic_ip)
++			fuse_init_inode(inode, attr);
++
++		change_attributes(inode, attr);
++		inode->i_version = version;
++	}
++
++	return inode;
++}
++
++static int fuse_do_lookup(struct inode *dir, struct dentry *entry,
++			  struct fuse_lookup_out *outarg, int *version)
++{
++	struct fuse_conn *fc = INO_FC(dir);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++
++	if (entry->d_name.len > FUSE_NAME_MAX)
++		return -ENAMETOOLONG;
++
++	in.h.opcode = FUSE_LOOKUP;
++	in.h.ino = dir->i_ino;
++	in.numargs = 1;
++	in.args[0].size = entry->d_name.len + 1;
++	in.args[0].value = entry->d_name.name;
++	out.numargs = 1;
++	out.args[0].size = sizeof(struct fuse_lookup_out);
++	out.args[0].value = outarg;
++	request_send(fc, &in, &out);
++
++	*version = out.h.unique;
++	return out.h.error;
++}
++
++static int fuse_lookup_iget(struct inode *dir, struct dentry *entry,
++			    struct inode **inodep)
++{
++	int err;
++	struct fuse_lookup_out outarg;
++	int version;
++	struct inode *inode = NULL;
++
++	err = fuse_do_lookup(dir, entry, &outarg, &version);
++	if(!err) {
++		inode = fuse_iget(dir->i_sb, outarg.ino, &outarg.attr, version);
++		if(!inode)
++			return -ENOMEM;
++	} else if(err != -ENOENT)
++		return err;
++
++	entry->d_time = jiffies;
++	entry->d_op = &fuse_dentry_operations;
++	*inodep = inode;
++	return 0;
++}
++
++static void uncache_dir(struct inode *dir)
++{
++	struct dentry *entry = d_find_alias(dir);
++	if (!entry)
++		dir->i_nlink = 0;
++	else {
++		entry->d_time = jiffies - FUSE_REVALIDATE_TIME - 1;
++		dput(entry);
++	}
++}
++
++/* create needs to return a positive entry, so this is actually an
++   mknod+lookup */
++static int _fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
++		      dev_t rdev)
++{
++	struct fuse_conn *fc = INO_FC(dir);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_mknod_in inarg;
++	struct fuse_mknod_out outarg;
++	struct inode *inode;
++
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.mode = mode;
++	inarg.rdev = new_encode_dev(rdev);
++
++	in.h.opcode = FUSE_MKNOD;
++	in.h.ino = dir->i_ino;
++	in.numargs = 2;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	in.args[1].size = entry->d_name.len + 1;
++	in.args[1].value = entry->d_name.name;
++	out.numargs = 1;
++	out.args[0].size = sizeof(outarg);
++	out.args[0].value = &outarg;
++	request_send(fc, &in, &out);
++
++	if(out.h.error) 
++		return out.h.error;
++
++	inode = fuse_iget(dir->i_sb, outarg.ino, &outarg.attr, out.h.unique);
++	if(!inode) 
++		return -ENOMEM;
++
++	/* Don't allow userspace to do really stupid things... */
++	if((inode->i_mode ^ mode) & S_IFMT) {
++		iput(inode);
++		printk("fuse_mknod: inode has wrong type\n");
++		return -EPROTO;
++	}
++
++	d_instantiate(entry, inode);
++	uncache_dir(dir);
++	return 0;
++}
++
++static int _fuse_create(struct inode *dir, struct dentry *entry, int mode)
++{
++	return _fuse_mknod(dir, entry, mode, 0);
++}
++
++/* knfsd needs the new entry instantiated in mkdir/symlink/link. this
++   should rather be done like mknod: attributes returned in out arg to
++   save a call to userspace */
++static int lookup_new_entry(struct inode *dir, struct dentry *entry)
++{
++	struct inode *inode;
++	int err = fuse_lookup_iget(dir, entry, &inode);
++	if(err || !inode) {
++		printk("fuse_mkdir: failed to look up new entry\n");
++		return err ? err : -ENOENT;
++	}
++	d_instantiate(entry, inode);
++	uncache_dir(dir);
++	return 0;
++}
++
++static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
++{
++	struct fuse_conn *fc = INO_FC(dir);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_mkdir_in inarg;
++
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.mode = mode;
++
++	in.h.opcode = FUSE_MKDIR;
++	in.h.ino = dir->i_ino;
++	in.numargs = 2;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	in.args[1].size = entry->d_name.len + 1;
++	in.args[1].value = entry->d_name.name;
++	request_send(fc, &in, &out);
++	if(out.h.error)
++		return out.h.error;
++
++	return lookup_new_entry(dir, entry);
++}
++
++static int fuse_symlink(struct inode *dir, struct dentry *entry,
++			const char *link)
++{
++	struct fuse_conn *fc = INO_FC(dir);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	unsigned int len = strlen(link) + 1;
++	
++	if (len > FUSE_SYMLINK_MAX)
++		return -ENAMETOOLONG;
++
++	in.h.opcode = FUSE_SYMLINK;
++	in.h.ino = dir->i_ino;
++	in.numargs = 2;
++	in.args[0].size = entry->d_name.len + 1;
++	in.args[0].value = entry->d_name.name;
++	in.args[1].size = len;
++	in.args[1].value = link;
++	request_send(fc, &in, &out);
++	if(out.h.error)
++		return out.h.error;
++
++	return lookup_new_entry(dir, entry);
++}
++
++static int fuse_remove(struct inode *dir, struct dentry *entry, 
++		       enum fuse_opcode op)
++{
++	struct fuse_conn *fc = INO_FC(dir);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++
++	in.h.opcode = op;
++	in.h.ino = dir->i_ino;
++	in.numargs = 1;
++	in.args[0].size = entry->d_name.len + 1;
++	in.args[0].value = entry->d_name.name;
++	request_send(fc, &in, &out);
++
++	return out.h.error;
++}
++
++static int fuse_unlink(struct inode *dir, struct dentry *entry)
++{
++	int err = fuse_remove(dir, entry, FUSE_UNLINK);
++	if(!err) {
++		/* FIXME: the new i_nlink could be returned by the
++                   unlink operation */
++		err = fuse_do_getattr(entry->d_inode);
++		if(err == -ENOENT)
++			entry->d_inode->i_nlink = 0;
++
++		uncache_dir(dir);
++		return 0;
++	}
++	return err;
++}
++
++static int fuse_rmdir(struct inode *dir, struct dentry *entry)
++{
++	int err = fuse_remove(dir, entry, FUSE_RMDIR);
++	if(!err) {
++		entry->d_inode->i_nlink = 0;
++		uncache_dir(dir);
++	}
++	return err;
++}
++
++static int fuse_rename(struct inode *olddir, struct dentry *oldent,
++		       struct inode *newdir, struct dentry *newent)
++{
++	struct fuse_conn *fc = INO_FC(olddir);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_rename_in inarg;
++	
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.newdir = newdir->i_ino;
++
++	in.h.opcode = FUSE_RENAME;
++	in.h.ino = olddir->i_ino;
++	in.numargs = 3;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	in.args[1].size = oldent->d_name.len + 1;
++	in.args[1].value = oldent->d_name.name;
++	in.args[2].size = newent->d_name.len + 1;
++	in.args[2].value = newent->d_name.name;
++	request_send(fc, &in, &out);
++
++	if (!out.h.error) {
++		uncache_dir(olddir);
++		if (olddir != newdir)
++			uncache_dir(newdir);
++	}
++
++	return out.h.error;
++}
++
++static int fuse_link(struct dentry *entry, struct inode *newdir,
++		     struct dentry *newent)
++{
++	struct inode *inode = entry->d_inode;
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_link_in inarg;
++	
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.newdir = newdir->i_ino;
++
++	in.h.opcode = FUSE_LINK;
++	in.h.ino = inode->i_ino;
++	in.numargs = 2;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	in.args[1].size = newent->d_name.len + 1;
++	in.args[1].value = newent->d_name.name;
++	request_send(fc, &in, &out);
++	if(out.h.error)
++		return out.h.error;
++
++	/* Invalidate old entry, so attributes are refreshed */
++	d_invalidate(entry);
++	return lookup_new_entry(newdir, newent);
++}
++
++int fuse_do_getattr(struct inode *inode)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_getattr_out arg;
++	
++	in.h.opcode = FUSE_GETATTR;
++	in.h.ino = inode->i_ino;
++	out.numargs = 1;
++	out.args[0].size = sizeof(arg);
++	out.args[0].value = &arg;
++	request_send(fc, &in, &out);
++	
++	if(!out.h.error)
++		change_attributes(inode, &arg.attr);
++	
++	return out.h.error;
++}
++
++static int fuse_revalidate(struct dentry *entry)
++{
++	struct inode *inode = entry->d_inode;
++	struct fuse_conn *fc = INO_FC(inode);
++
++	if(inode->i_ino == FUSE_ROOT_INO) {
++		if(!(fc->flags & FUSE_ALLOW_OTHER) &&
++		   current->fsuid != fc->uid)
++			return -EACCES;
++	} else if(time_before_eq(jiffies, entry->d_time + FUSE_REVALIDATE_TIME))
++		return 0;
++
++	return fuse_do_getattr(inode);
++}
++
++static int _fuse_permission(struct inode *inode, int mask)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++
++	if(!(fc->flags & FUSE_ALLOW_OTHER) && current->fsuid != fc->uid)
++		return -EACCES;
++	else if(fc->flags & FUSE_DEFAULT_PERMISSIONS) {
++		int err = generic_permission(inode, mask, NULL);
++
++		/* If permission is denied, try to refresh file
++		   attributes.  This is also needed, because the root
++		   node will at first have no permissions */
++
++		if(err == -EACCES) {
++		 	err = fuse_do_getattr(inode);
++			if(!err)
++			 	err = generic_permission(inode, mask, NULL);
++		}
++
++		/* FIXME: Need some mechanism to revoke permissions:
++		   currently if the filesystem suddenly changes the
++		   file mode, we will not be informed abot that, and
++		   continue to allow access to the file/directory.
++		   
++		   This is actually not so grave, since the user can
++		   simply keep access to the file/directory anyway by
++		   keeping it open... */
++
++		return err;
++	}
++	else
++		return 0;
++}
++
++static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
++			 void *dstbuf, filldir_t filldir)
++{
++	while(nbytes >= FUSE_NAME_OFFSET) {
++		struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
++		size_t reclen = FUSE_DIRENT_SIZE(dirent);
++		int over;
++
++		if(dirent->namelen > NAME_MAX) {
++			printk("fuse_readdir: name too long\n");
++			return -EPROTO;
++		}
++		if(reclen > nbytes)
++			break;
++
++		over = filldir(dstbuf, dirent->name, dirent->namelen,
++			      file->f_pos, dirent->ino, dirent->type);
++		if(over)
++			break;
++
++		buf += reclen;
++		file->f_pos += reclen;
++		nbytes -= reclen;
++	}
++
++	return 0;
++}
++
++#ifndef CONFIG_COOPERATIVE
++
++#define DIR_BUFSIZE 2048
++static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
++{
++	struct file *cfile = file->private_data;
++	char *buf;
++	int ret;
++
++	if(!cfile)
++		return -EISDIR;
++
++	buf = kmalloc(DIR_BUFSIZE, GFP_KERNEL);
++	if(!buf)
++		return -ENOMEM;
++	
++	ret = kernel_read(cfile, file->f_pos, buf, DIR_BUFSIZE);
++	if(ret < 0)
++		printk("fuse_readdir: failed to read container file\n");
++	else 
++		ret = parse_dirfile(buf, ret, file, dstbuf, filldir);
++
++	kfree(buf);	
++	return ret;
++}
++
++#else
++
++#define DIR_BUFSIZE 4096
++
++typedef struct {
++	struct fuse_conn *fc;
++	int inode;
++} readdir_data_t;
++
++static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
++{
++	readdir_data_t *rd = file->private_data;
++	unsigned long flags;
++	int ret, size;
++	char *buf;
++
++	buf = kmalloc(DIR_BUFSIZE, GFP_KERNEL);
++	if (!buf)
++		return -ENOMEM;
++
++	co_passage_page_assert_valid();
++		
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_FILESYSTEM;
++	co_passage_page->params[1] = rd->fc->cofs_unit;
++	co_passage_page->params[2] = FUSE_DIR_READ;
++	co_passage_page->params[3] = rd->inode;
++	co_passage_page->params[5] = DIR_BUFSIZE;
++	co_passage_page->params[6] = (unsigned long)buf;
++	co_passage_page->params[8] = file->f_pos;
++	
++	co_switch_wrapper();
++	
++	ret = co_passage_page->params[4];
++	size = co_passage_page->params[7];
++	
++	co_passage_page_release(flags);
++	
++	if (ret) {
++		printk("fuse_readdir: host returned error: %x\n", ret);
++		kfree(buf);	
++		return ret;
++	}
++	
++	parse_dirfile(buf, size, file, dstbuf, filldir);
++		
++	ret = 0;
++	kfree(buf);	
++	return ret;
++}
++
++#endif
++
++static char *read_link(struct dentry *dentry)
++{
++	struct inode *inode = dentry->d_inode;
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	char *link;
++
++	link = (char *) __get_free_page(GFP_KERNEL);
++	if(!link)
++		return ERR_PTR(-ENOMEM);
++
++	in.h.opcode = FUSE_READLINK;
++	in.h.ino = inode->i_ino;
++	out.argvar = 1;
++	out.numargs = 1;
++	out.args[0].size = PAGE_SIZE - 1;
++	out.args[0].value = link;
++	request_send(fc, &in, &out);
++	if(out.h.error) {
++		free_page((unsigned long) link);
++		return ERR_PTR(out.h.error);
++	}
++
++	link[out.args[0].size] = '\0';
++	return link;
++}
++
++static void free_link(char *link)
++{
++	if(!IS_ERR(link))
++		free_page((unsigned long) link);
++}
++
++static int fuse_readlink(struct dentry *dentry, char *buffer, int buflen)
++{
++	int ret;
++	char *link;
++
++	link = read_link(dentry);
++	ret = vfs_readlink(dentry, buffer, buflen, link);
++	free_link(link);
++	return ret;
++}
++
++static int fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
++{
++	int ret;
++	char *link;
++
++	link = read_link(dentry);
++	ret = vfs_follow_link(nd, link);
++	free_link(link);
++	return ret;
++}
++
++#ifndef CONFIG_COOPERATIVE
++
++static int fuse_dir_open(struct inode *inode, struct file *file)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_getdir_out outarg;
++
++	in.h.opcode = FUSE_GETDIR;
++	in.h.ino = inode->i_ino;
++	out.numargs = 1;
++	out.args[0].size = sizeof(outarg);
++	out.args[0].value = &outarg;
++	request_send(fc, &in, &out);
++	if(!out.h.error) {
++		struct file *cfile = outarg.file;
++		struct inode *inode;
++		if(!cfile) {
++			printk("fuse_getdir: invalid file\n");
++			return -EPROTO;
++		}
++		inode = cfile->f_dentry->d_inode;
++		if(!S_ISREG(inode->i_mode)) {
++			printk("fuse_getdir: not a regular file\n");
++			fput(cfile);
++			return -EPROTO;
++		}
++
++		file->private_data = cfile;
++	}
++
++	return out.h.error;
++}
++
++static int fuse_dir_release(struct inode *inode, struct file *file)
++{
++	struct file *cfile = file->private_data;
++
++	if(cfile)
++		fput(cfile);
++
++	return 0;
++}
++
++#else
++
++static int fuse_dir_open(struct inode *inode, struct file *file)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++	unsigned long flags;
++	readdir_data_t *rd;
++	int ret;
++
++	rd = kmalloc(sizeof(*rd), GFP_KERNEL);
++	if (!rd)
++		return -ENOMEM;
++
++	rd->fc = fc;
++	rd->inode = inode->i_ino;
++
++	co_passage_page_assert_valid();
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_FILESYSTEM;
++	co_passage_page->params[1] = fc->cofs_unit;
++	co_passage_page->params[2] = FUSE_DIR_OPEN;
++	co_passage_page->params[3] = inode->i_ino;
++	co_passage_page->params[4] = 0;
++
++	co_switch_wrapper();
++
++	ret = co_passage_page->params[4];
++
++	co_passage_page_release(flags);
++
++	if (ret) {
++		printk("fuse_readdir: host returned error: %x\n", ret);
++		kfree(rd);
++	} else {
++		file->private_data = (void *)rd;
++	}
++
++	return ret;
++}
++
++static int fuse_dir_release(struct inode *inode, struct file *file)
++{
++	readdir_data_t *rd = file->private_data;
++	unsigned long flags;
++	int ret;
++
++	co_passage_page_assert_valid();
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_FILESYSTEM;
++	co_passage_page->params[1] = rd->fc->cofs_unit;
++	co_passage_page->params[2] = FUSE_DIR_RELEASE;
++	co_passage_page->params[3] = rd->inode;
++	co_passage_page->params[4] = 0;
++
++	co_switch_wrapper();
++
++	ret = co_passage_page->params[4];
++
++	co_passage_page_release(flags);
++
++	if (ret) {
++		printk("fuse_readdir: host returned error: %x\n", ret);
++	} 
++
++	kfree(rd);
++
++	return ret;
++}
++
++#endif
++
++static unsigned int iattr_to_fattr(struct iattr *iattr,
++				   struct fuse_attr *fattr)
++{
++	unsigned int ivalid = iattr->ia_valid;
++	unsigned int fvalid = 0;
++	
++	memset(fattr, 0, sizeof(*fattr));
++	
++	if(ivalid & ATTR_MODE)
++		fvalid |= FATTR_MODE,   fattr->mode = iattr->ia_mode;
++	if(ivalid & ATTR_UID)
++		fvalid |= FATTR_UID,    fattr->uid = iattr->ia_uid;
++	if(ivalid & ATTR_GID)
++		fvalid |= FATTR_GID,    fattr->gid = iattr->ia_gid;
++	if(ivalid & ATTR_SIZE)
++		fvalid |= FATTR_SIZE,   fattr->size = iattr->ia_size;
++	/* You can only _set_ these together (they may change by themselves) */
++	if((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
++		fvalid |= FATTR_UTIME;
++#ifdef KERNEL_2_6
++		fattr->atime = iattr->ia_atime.tv_sec;
++		fattr->mtime = iattr->ia_mtime.tv_sec;
++#else
++		fattr->atime = iattr->ia_atime;
++		fattr->mtime = iattr->ia_mtime;
++#endif
++	}
++
++	return fvalid;
++}
++
++static int fuse_setattr(struct dentry *entry, struct iattr *attr)
++{
++	struct inode *inode = entry->d_inode;
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_setattr_in inarg;
++	struct fuse_setattr_out outarg;
++
++	/* FIXME: need to fix race between truncate and writepage */
++	if (attr->ia_valid & ATTR_SIZE)	
++		fuse_sync_inode(inode);
++
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.valid = iattr_to_fattr(attr, &inarg.attr);
++	
++	in.h.opcode = FUSE_SETATTR;
++	in.h.ino = inode->i_ino;
++	in.numargs = 1;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	out.numargs = 1;
++	out.args[0].size = sizeof(outarg);
++	out.args[0].value = &outarg;
++	request_send(fc, &in, &out);
++
++	if(!out.h.error) {
++		if(attr->ia_valid & ATTR_SIZE &&
++		   outarg.attr.size < i_size_read(inode))
++			vmtruncate(inode, outarg.attr.size);
++
++		change_attributes(inode, &outarg.attr);
++	} 
++	return out.h.error;
++}
++
++static int _fuse_dentry_revalidate(struct dentry *entry)
++{
++	if(!entry->d_inode)
++		return 0;
++	else if(time_after(jiffies, entry->d_time + FUSE_REVALIDATE_TIME)) {
++		struct inode *inode = entry->d_inode;
++		struct fuse_lookup_out outarg;
++		int version;
++		int ret;
++		
++		ret = fuse_do_lookup(entry->d_parent->d_inode, entry, &outarg,
++				     &version);
++		if(ret)
++			return 0;
++		
++		if(outarg.ino != inode->i_ino)
++			return 0;
++		
++		change_attributes(inode, &outarg.attr);
++		inode->i_version = version;
++		entry->d_time = jiffies;
++	}
++	return 1;
++}
++
++#ifdef KERNEL_2_6
++
++#define fuse_mknod _fuse_mknod
++
++static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
++			struct kstat *stat)
++{
++	struct inode *inode = entry->d_inode;
++	int err = fuse_revalidate(entry);
++	if(!err)
++		generic_fillattr(inode, stat);
++	
++	return err;
++}
++
++static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
++				   struct nameidata *nd)
++{
++	struct inode *inode;
++	int err = fuse_lookup_iget(dir, entry, &inode);
++	if (err)
++		return ERR_PTR(err);
++	return d_splice_alias(inode, entry);
++}
++
++static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
++		       struct nameidata *nd)
++{
++	return _fuse_create(dir, entry, mode);
++}
++
++static int fuse_permission(struct inode *inode, int mask,
++			    struct nameidata *nd)
++{
++	return _fuse_permission(inode, mask);
++}
++
++static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
++{
++	return _fuse_dentry_revalidate(entry);
++}
++#else /* KERNEL_2_6 */
++
++#define fuse_create _fuse_create
++#define fuse_permission _fuse_permission
++
++static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry)
++{
++	struct inode *inode;
++	struct dentry *alias;
++
++	int err = fuse_lookup_iget(dir, entry, &inode);
++	if(err)
++		return ERR_PTR(err);
++
++	if(inode && S_ISDIR(inode->i_mode) &&
++	   (alias = d_find_alias(inode)) != NULL) {
++		dput(alias);
++		iput(inode);
++		printk("fuse: cannot assign an existing directory\n");
++		return ERR_PTR(-EPROTO);
++	}
++
++	d_add(entry, inode);
++	return NULL;
++}
++
++static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
++		      int rdev)
++{
++	return _fuse_mknod(dir, entry, mode, rdev);
++}
++
++static int fuse_dentry_revalidate(struct dentry *entry, int flags)
++{
++	return _fuse_dentry_revalidate(entry);
++}
++#endif /* KERNEL_2_6 */
++
++
++static struct inode_operations fuse_dir_inode_operations =
++{
++	.lookup		= fuse_lookup,
++	.create		= fuse_create,
++	.mknod		= fuse_mknod,
++	.mkdir		= fuse_mkdir,
++	.symlink	= fuse_symlink,
++	.unlink		= fuse_unlink,
++	.rmdir		= fuse_rmdir,
++	.rename		= fuse_rename,
++	.link		= fuse_link,
++	.setattr	= fuse_setattr,
++	.permission	= fuse_permission,
++#ifdef KERNEL_2_6
++	.getattr	= fuse_getattr,
++#else
++	.revalidate	= fuse_revalidate,
++#endif
++};
++
++static struct file_operations fuse_dir_operations = {
++	.read		= generic_read_dir,
++	.readdir	= fuse_readdir,
++	.open		= fuse_dir_open,
++	.release	= fuse_dir_release,
++};
++
++static struct inode_operations fuse_file_inode_operations = {
++	.setattr	= fuse_setattr,
++	.permission	= fuse_permission,
++#ifdef KERNEL_2_6
++	.getattr	= fuse_getattr,
++#else
++	.revalidate	= fuse_revalidate,
++#endif
++};
++
++static struct inode_operations fuse_symlink_inode_operations =
++{
++	.setattr	= fuse_setattr,
++	.readlink	= fuse_readlink,
++	.follow_link	= fuse_follow_link,
++#ifdef KERNEL_2_6
++	.getattr	= fuse_getattr,
++#else
++	.revalidate	= fuse_revalidate,
++#endif
++};
++
++static struct dentry_operations fuse_dentry_operations = {
++	.d_revalidate	= fuse_dentry_revalidate,
++};
++
++/* 
++ * Local Variables:
++ * indent-tabs-mode: t
++ * c-basic-offset: 8
++ * End:
++ */
+diff -urN a/fs/cofusefs/file.c b/fs/cofusefs/file.c
+--- a/fs/cofusefs/file.c
++++ b/fs/cofusefs/file.c
+@@ -0,0 +1,542 @@
++/*
++    FUSE: Filesystem in Userspace
++    Copyright (C) 2001-2004  Miklos Szeredi <miklos@szeredi.hu>
++
++    This program can be distributed under the terms of the GNU GPL.
++    See the file COPYING.
++*/
++#include "fuse_i.h"
++
++#include <linux/pagemap.h>
++#include <linux/slab.h>
++#ifdef KERNEL_2_6
++#include <linux/backing-dev.h>
++#include <linux/writeback.h>
++#endif
++
++#ifndef KERNEL_2_6
++#define PageUptodate(page) Page_Uptodate(page)
++#endif
++
++static int fuse_open(struct inode *inode, struct file *file)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_open_in inarg;
++	int err;
++
++	err = generic_file_open(inode, file);
++	if(err)
++		return err;
++
++	/* If opening the root node, no lookup has been performed on
++	   it, so the attributes must be refreshed */
++	if(inode->i_ino == FUSE_ROOT_INO) {
++		int err = fuse_do_getattr(inode);
++		if(err)
++		 	return err;
++	}
++
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.flags = file->f_flags & ~O_EXCL;
++
++	in.h.opcode = FUSE_OPEN;
++	in.h.ino = inode->i_ino;
++	in.numargs = 1;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	request_send(fc, &in, &out);
++	if(!out.h.error && !(fc->flags & FUSE_KERNEL_CACHE)) {
++#ifdef KERNEL_2_6
++		invalidate_inode_pages(inode->i_mapping);
++#else
++		invalidate_inode_pages(inode);
++#endif
++	}
++
++	return out.h.error;
++}
++
++void fuse_sync_inode(struct inode *inode)
++{
++#ifdef KERNEL_2_6
++	filemap_fdatawrite(inode->i_mapping);
++	filemap_fdatawait(inode->i_mapping);
++#else
++#ifndef NO_MM
++	filemap_fdatasync(inode->i_mapping);
++	filemap_fdatawait(inode->i_mapping);
++#endif
++#endif
++}
++
++static int fuse_release_old(struct inode *inode, struct file *file)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in *in = NULL;
++	struct fuse_open_in *inarg = NULL;
++	unsigned int s = sizeof(struct fuse_in) + sizeof(struct fuse_open_in);
++
++	in = kmalloc(s, GFP_NOFS);
++	if(!in)
++		return -ENOMEM;
++	memset(in, 0, s);
++	inarg = (struct fuse_open_in *) (in + 1);
++	inarg->flags = file->f_flags & ~O_EXCL;
++
++	in->h.opcode = FUSE_RELEASE;
++	in->h.ino = inode->i_ino;
++	in->numargs = 1;
++	in->args[0].size = sizeof(struct fuse_open_in);
++	in->args[0].value = inarg;
++	if(!request_send_noreply(fc, in))
++		return 0;
++
++	kfree(in);
++	return 0;
++}
++
++static int fuse_release(struct inode *inode, struct file *file)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_open_in inarg;
++
++	if(file->f_mode & FMODE_WRITE)
++		fuse_sync_inode(inode);
++
++	if (fc->oldrelease)
++		return fuse_release_old(inode, file);
++
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.flags = file->f_flags & ~O_EXCL;
++
++	in.h.opcode = FUSE_RELEASE2;
++	in.h.ino = inode->i_ino;
++	in.numargs = 1;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	request_send(fc, &in, &out);
++	if (out.h.error == -ENOSYS) {
++		fc->oldrelease = 1;
++		return fuse_release_old(inode, file);
++	}
++	return 0;
++}
++
++static int fuse_fsync(struct file *file, struct dentry *de, int datasync)
++{
++	struct inode *inode = de->d_inode;
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_fsync_in inarg;
++	
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.datasync = datasync;
++
++	in.h.opcode = FUSE_FSYNC;
++	in.h.ino = inode->i_ino;
++	in.numargs = 1;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	request_send(fc, &in, &out);
++	return out.h.error;
++
++	/* FIXME: need to ensure, that all write requests issued
++           before this request are completed.  Should userspace take
++           care of this? */
++}
++
++static int fuse_readpage(struct file *file, struct page *page)
++{
++	struct inode *inode = page->mapping->host;
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_read_in inarg;
++	char *buffer;
++
++	buffer = kmap(page);
++	
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.offset = (unsigned long long) page->index << PAGE_CACHE_SHIFT;
++	inarg.size = PAGE_CACHE_SIZE;
++
++	in.h.opcode = FUSE_READ;
++	in.h.ino = inode->i_ino;
++	in.numargs = 1;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	out.argvar = 1;
++	out.numargs = 1;
++	out.args[0].size = PAGE_CACHE_SIZE;
++	out.args[0].value = buffer;
++
++	request_send(fc, &in, &out);
++	if(!out.h.error) {
++		size_t outsize = out.args[0].size;
++		if(outsize < PAGE_CACHE_SIZE) 
++			memset(buffer + outsize, 0, PAGE_CACHE_SIZE - outsize);
++		flush_dcache_page(page);
++		SetPageUptodate(page);
++	}
++
++	kunmap(page);
++	unlock_page(page);
++
++	return out.h.error;
++}
++
++static int fuse_is_block_uptodate(struct address_space *mapping,
++		struct inode *inode, size_t bl_index)
++{
++	size_t index = bl_index << FUSE_BLOCK_PAGE_SHIFT;
++	size_t end_index = ((bl_index + 1) << FUSE_BLOCK_PAGE_SHIFT) - 1;
++	size_t file_end_index = i_size_read(inode) >> PAGE_CACHE_SHIFT;
++
++	if (end_index > file_end_index)
++		end_index = file_end_index;
++
++	for (; index <= end_index; index++) {
++		struct page *page = find_get_page(mapping, index);
++
++		if (!page)
++			return 0;
++
++		if (!PageUptodate(page)) {
++			page_cache_release(page);
++			return 0;
++		}
++
++		page_cache_release(page);
++	}
++
++	return 1;
++}
++
++
++static int fuse_cache_block(struct address_space *mapping,
++		struct inode *inode, char *bl_buf,
++		size_t bl_index)
++{
++	size_t start_index = bl_index << FUSE_BLOCK_PAGE_SHIFT;
++	size_t end_index = ((bl_index + 1) << FUSE_BLOCK_PAGE_SHIFT) - 1;
++	size_t file_end_index = i_size_read(inode) >> PAGE_CACHE_SHIFT;
++
++	int i;
++
++	if (end_index > file_end_index)
++		end_index = file_end_index;
++
++	for (i = 0; start_index + i <= end_index; i++) {
++		size_t index = start_index + i;
++		struct page *page;
++		char *buffer;
++
++		page = grab_cache_page(mapping, index);
++		if (!page)
++			return -1;
++
++		if (!PageUptodate(page)) {
++			buffer = kmap(page);
++			memcpy(buffer, bl_buf + i * PAGE_CACHE_SIZE,
++					PAGE_CACHE_SIZE);
++			flush_dcache_page(page);
++			SetPageUptodate(page);
++			kunmap(page);
++		}
++
++		unlock_page(page);
++		page_cache_release(page);
++	}
++
++	return 0;
++} 
++
++static int fuse_file_read_block(struct inode *inode, char *bl_buf,
++		size_t bl_index)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_read_in inarg;
++
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.offset = (unsigned long long) bl_index << FUSE_BLOCK_SHIFT;
++	inarg.size = FUSE_BLOCK_SIZE;
++
++	in.h.opcode = FUSE_READ;
++	in.h.ino = inode->i_ino;
++	in.numargs = 1;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	out.argvar = 1;
++	out.numargs = 1;
++	out.args[0].size = FUSE_BLOCK_SIZE;
++	out.args[0].value = bl_buf;
++
++	request_send(fc, &in, &out);
++
++	if (!out.h.error) {
++		size_t outsize = out.args[0].size;
++		if (outsize < FUSE_BLOCK_SIZE)
++			memset(bl_buf + outsize, 0, FUSE_BLOCK_SIZE - outsize);
++	}
++
++	return out.h.error;
++}   
++
++static void fuse_file_bigread(struct address_space *mapping,
++			      struct inode *inode, loff_t pos, size_t count)
++{
++	size_t bl_index = pos >> FUSE_BLOCK_SHIFT;
++	size_t bl_end_index = (pos + count) >> FUSE_BLOCK_SHIFT;
++	size_t bl_file_end_index = i_size_read(inode) >> FUSE_BLOCK_SHIFT;
++	
++	if (bl_end_index > bl_file_end_index)
++		bl_end_index = bl_file_end_index;
++	
++	while (bl_index <= bl_end_index) {
++		int res;
++		char *bl_buf = kmalloc(FUSE_BLOCK_SIZE, GFP_NOFS);
++		if (!bl_buf)
++			break;
++		res = fuse_is_block_uptodate(mapping, inode, bl_index);
++		if (!res)
++			res = fuse_file_read_block(inode, bl_buf, bl_index);
++		if (!res)
++			fuse_cache_block(mapping, inode, bl_buf, bl_index);
++		kfree(bl_buf);
++		bl_index++;
++	}
++}
++
++static ssize_t fuse_file_read(struct file *filp, char *buf,
++		size_t count, loff_t * ppos)
++{
++	struct address_space *mapping = filp->f_dentry->d_inode->i_mapping;
++	struct inode *inode = mapping->host;
++	struct fuse_conn *fc = INO_FC(inode);
++
++	if(fc->flags & FUSE_LARGE_READ) {
++		/* Don't allow this to get mixed up with writes */
++		down(&inode->i_sem);
++		fuse_file_bigread(mapping, inode, *ppos, count);
++		up(&inode->i_sem);
++	}
++
++	return generic_file_read(filp, buf, count, ppos);
++}  
++
++static int write_buffer(struct inode *inode, struct page *page,
++			unsigned offset, size_t count)
++{
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_write_in inarg;
++	char *buffer;
++
++	buffer = kmap(page);
++
++	memset(&inarg, 0, sizeof(inarg));
++	inarg.offset = ((unsigned long long) page->index << PAGE_CACHE_SHIFT) +
++		offset;
++	inarg.size = count;
++	
++	in.h.opcode = FUSE_WRITE;
++	in.h.ino = inode->i_ino;
++	in.numargs = 2;
++	in.args[0].size = sizeof(inarg);
++	in.args[0].value = &inarg;
++	in.args[1].size = count;
++	in.args[1].value = buffer + offset;
++	request_send(fc, &in, &out);
++	kunmap(page);
++	if(out.h.error)
++		SetPageError(page);
++
++	return out.h.error;
++}
++
++static int get_write_count(struct inode *inode, struct page *page)
++{
++	unsigned long end_index;
++	loff_t size = i_size_read(inode);
++	int count;
++	
++	end_index = size >> PAGE_CACHE_SHIFT;
++	if(page->index < end_index)
++		count = PAGE_CACHE_SIZE;
++	else {
++		count = size & (PAGE_CACHE_SIZE - 1);
++		if(page->index > end_index || count == 0)
++			return 0;
++	}
++	return count;
++}
++
++#ifdef KERNEL_2_6
++
++static void write_buffer_end(struct fuse_conn *fc, struct fuse_in *in,
++			     struct fuse_out *out, void *_page)
++{
++	struct page *page = (struct page *) _page;
++	
++	if(out->h.error) {
++		SetPageError(page);
++		if(out->h.error == -ENOSPC)
++			set_bit(AS_ENOSPC, &page->mapping->flags);
++		else
++			set_bit(AS_EIO, &page->mapping->flags);
++	}
++	end_page_writeback(page);
++	kunmap(page);
++	kfree(in);	
++}
++
++static int write_buffer_nonblock(struct inode *inode, struct page *page,
++				 unsigned offset, size_t count)
++{
++	int err;
++	struct fuse_conn *fc = INO_FC(inode);
++	struct fuse_in *in = NULL;
++	struct fuse_out *out = NULL;
++	struct fuse_write_in *inarg = NULL;
++	char *buffer;
++	unsigned int s = sizeof(struct fuse_in) + sizeof(struct fuse_out) +
++		sizeof(struct fuse_write_in);
++
++	in = kmalloc(s, GFP_NOFS);
++	if(!in)
++		return -ENOMEM;
++	memset(in, 0, s);
++	out = (struct fuse_out *)(in + 1);
++	inarg = (struct fuse_write_in *)(out + 1);
++	
++	buffer = kmap(page);
++
++	inarg->offset = ((unsigned long long) page->index << PAGE_CACHE_SHIFT) + offset;
++	inarg->size = count;
++	
++	in->h.opcode = FUSE_WRITE;
++	in->h.ino = inode->i_ino;
++	in->numargs = 2;
++	in->args[0].size = sizeof(struct fuse_write_in);
++	in->args[0].value = inarg;
++	in->args[1].size = count;
++	in->args[1].value = buffer + offset;
++	err = request_send_nonblock(fc, in, out, write_buffer_end, page);
++	if(err) {
++		if(err != -EWOULDBLOCK)
++			SetPageError(page);
++		kunmap(page);
++		kfree(in);
++	}
++	return err;
++}
++
++static int fuse_writepage(struct page *page, struct writeback_control *wbc)
++{
++	int err;
++	struct inode *inode = page->mapping->host;
++	unsigned count = get_write_count(inode, page);
++
++	err = -EINVAL;
++	if(count) {
++		/* FIXME: check sync_mode, and wait for previous writes (or
++		   signal userspace to do this) */
++		if(wbc->nonblocking) {
++			SetPageWriteback(page);
++			err = write_buffer_nonblock(inode, page, 0, count);
++			if (err)
++				ClearPageWriteback(page);
++			if(err == -EWOULDBLOCK) {
++				__set_page_dirty_nobuffers(page);
++				err = 0;
++			}
++		} else
++			err = write_buffer(inode, page, 0, count);
++	}
++
++	unlock_page(page);
++	return err;
++}
++#else
++static int fuse_writepage(struct page *page)
++{
++	int err;
++	struct inode *inode = page->mapping->host;
++	int count = get_write_count(inode, page);
++	err = -EINVAL;
++	if(count)
++		err = write_buffer(inode, page, 0, count);
++
++	unlock_page(page);
++	return err;
++}
++#endif
++
++static int fuse_prepare_write(struct file *file, struct page *page,
++			      unsigned offset, unsigned to)
++{
++	/* No op */
++	return 0;
++}
++
++static int fuse_commit_write(struct file *file, struct page *page,
++			     unsigned offset, unsigned to)
++{
++	int err;
++	struct inode *inode = page->mapping->host;
++
++	err = write_buffer(inode, page, offset, to - offset);
++	if(!err) {
++		loff_t pos = (page->index << PAGE_CACHE_SHIFT) + to;
++		if(pos > i_size_read(inode))
++			i_size_write(inode, pos);
++	}
++	return err;
++}
++
++static struct file_operations fuse_file_operations = {
++	.read		= fuse_file_read,
++	.write		= generic_file_write,
++	.mmap		= generic_file_mmap,
++	.open		= fuse_open,
++	.release	= fuse_release,
++	.fsync		= fuse_fsync,
++#ifdef KERNEL_2_6
++	.sendfile	= generic_file_sendfile,
++#endif
++};
++
++static struct address_space_operations fuse_file_aops  = {
++	.readpage =		fuse_readpage,
++	.writepage =		fuse_writepage,
++	.prepare_write =	fuse_prepare_write,
++	.commit_write =		fuse_commit_write,
++};
++
++void fuse_init_file_inode(struct inode *inode)
++{
++#ifdef KERNEL_2_6
++	struct fuse_conn *fc = INO_FC(inode);
++	/* Readahead somehow defeats big reads on 2.6 (says Michael
++           Grigoriev) */
++	if(fc->flags & FUSE_LARGE_READ)
++		inode->i_mapping->backing_dev_info->ra_pages = 0;
++#endif
++	inode->i_fop = &fuse_file_operations;
++	inode->i_data.a_ops = &fuse_file_aops;
++}
++
++/* 
++ * Local Variables:
++ * indent-tabs-mode: t
++ * c-basic-offset: 8
++ * End:
++ */
+diff -urN a/fs/cofusefs/fuse_i.h b/fs/cofusefs/fuse_i.h
+--- a/fs/cofusefs/fuse_i.h
++++ b/fs/cofusefs/fuse_i.h
+@@ -0,0 +1,297 @@
++/*
++    COFUSE: Filesystem in an host of Cooperative Linux
++    Copyright (C) 2004 Dan Aloni <da-x@colinux.org>
++
++    based on FUSE: Filesystem in Userspace
++    Copyright (C) 2001-2004  Miklos Szeredi <miklos@szeredi.hu>
++
++    This program can be distributed under the terms of the GNU GPL.
++    See the file COPYING.
++*/
++
++
++#include <linux/version.h>
++#include <linux/config.h>
++
++#ifndef CONFIG_COOPERATIVE
++#include <linux/cofuse.h>
++#else
++#include <linux/cooperative_internal.h>
++#endif
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) && LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
++#error Kernel version 2.5.* not supported
++#endif
++
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
++#define KERNEL_2_6
++#endif
++
++#ifndef KERNEL_2_6
++#include <linux/config.h>
++#ifdef CONFIG_MODVERSIONS
++#define MODVERSIONS
++#include <linux/modversions.h>
++#endif
++#include <config.h>
++#ifndef HAVE_I_SIZE_FUNC
++#define i_size_read(inode) ((inode)->i_size)
++#define i_size_write(inode, size) do { (inode)->i_size = size; } while(0)
++#endif
++#endif 
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/fs.h>
++#include <linux/list.h>
++#include <linux/spinlock.h>
++
++/** Read combining parameters */
++#define FUSE_BLOCK_SHIFT 16
++#define FUSE_BLOCK_SIZE 65536
++#define FUSE_BLOCK_MASK 0xffff0000
++
++#define FUSE_BLOCK_PAGE_SHIFT (FUSE_BLOCK_SHIFT - PAGE_CACHE_SHIFT)
++
++/**
++ * A Fuse connection.
++ *
++ * This structure is created, when the client device is opened, and is
++ * destroyed, when the client device is closed _and_ the filesystem is
++ * unmounted.
++ */
++struct fuse_conn {
++	/** The superblock of the mounted filesystem */
++	struct super_block *sb;
++
++#ifndef CONFIG_COOPERATIVE	
++	/** The opened client device */
++	struct file *file;
++#else
++	int cofs_unit;
++#endif
++	/** The user id for this mount */
++	uid_t uid;
++
++	/** The fuse mount flags for this mount */
++	unsigned int flags;
++
++	/** Is the new (synchronous) release not supported by
++	    userspace? */
++	unsigned int oldrelease;
++
++	char opt_pathname[0x80];
++
++#ifndef CONFIG_COOPERATIVE	
++	/** Readers of the connection are waiting on this */
++	wait_queue_head_t waitq;
++
++	/** The list of pending requests */
++	struct list_head pending;
++
++	/** The list of requests being processed */
++	struct list_head processing;
++
++	/** Controls the maximum number of outstanding requests */
++	struct semaphore outstanding;
++	
++	/** The next unique request id */
++	int reqctr;
++#endif
++};
++
++/** One input argument of a request */
++struct fuse_in_arg {
++	unsigned int size;
++	const void *value;
++};
++
++/** The request input */
++struct fuse_in {
++	struct fuse_in_header h;
++	unsigned int numargs;
++	struct fuse_in_arg args[3];
++};
++
++/** One output argument of a request */
++struct fuse_out_arg {
++	unsigned int size;
++	void *value;
++};
++
++/** The request output */
++struct fuse_out {
++	struct fuse_out_header h;
++	unsigned int argvar;
++	unsigned int numargs;
++	struct fuse_out_arg args[3];
++};
++
++#define FUSE_IN_INIT { {0, 0, 0, current->fsuid, current->fsgid}, 0}
++#define FUSE_OUT_INIT { {0, 0}, 0, 0}
++
++struct fuse_req;
++typedef void (*fuse_reqend_t)(struct fuse_conn *, struct fuse_in *,
++			      struct fuse_out *, void *data);
++
++/**
++ * A request to the client
++ */
++struct fuse_req {
++	/** The request list */
++	struct list_head list;
++
++	/** True if the request is synchronous */
++	unsigned int issync:1;
++
++	/** The request is locked */
++	unsigned int locked:1;
++
++	/** The request has been interrupted while it was locked */
++	unsigned int interrupted:1;
++
++	/* The request has been sent to the client */
++	unsigned int sent:1;
++
++	/* The request is finished */
++	unsigned int finished:1;
++
++	/** The request input */
++	struct fuse_in *in;
++
++	/** The request output */
++	struct fuse_out *out;
++
++	/** Used to wake up the task waiting for completion of request*/
++	wait_queue_head_t waitq;
++
++	/** Request completion callback */
++	fuse_reqend_t end;
++
++	/** User data */
++	void *data;
++};
++
++#ifdef KERNEL_2_6
++#define SB_FC(sb) ((sb)->s_fs_info)
++#else
++#define SB_FC(sb) ((sb)->u.generic_sbp)
++#endif
++#define INO_FC(inode) SB_FC((inode)->i_sb)
++#define DEV_FC(file) ((struct fuse_conn *) (file)->private_data)
++
++
++/**
++ * The proc entry for the client device ("/proc/fs/fuse/dev")
++ */
++extern struct proc_dir_entry *proc_fuse_dev;
++
++/**
++ * The lock to protect fuses structures
++ */
++extern spinlock_t cofuse_lock;
++
++
++/**
++ * Get a filled in inode
++ */
++struct inode *cofuse_iget(struct super_block *sb, ino_t ino,
++	   	  	  struct fuse_attr *attr, int version);
++
++
++/**
++ * Initialise operations on regular file
++ */
++void cofuse_init_file_inode(struct inode *inode);
++
++/**
++ * Check if the connection can be released, and if yes, then free the
++ * connection structure
++ */
++void cofuse_release_conn(struct fuse_conn *fc);
++
++/**
++ * Initialize the client device
++ */
++int cofuse_dev_init(void);
++
++/**
++ * Cleanup the client device
++ */
++void cofuse_dev_cleanup(void);
++
++/**
++ * Initialize the fuse filesystem 
++ */
++int cofuse_fs_init(void);
++
++/**
++ * Cleanup the fuse filesystem
++ */
++void cofuse_fs_cleanup(void);
++
++/**
++ * Send a request
++ *
++ */
++void cofuse_request_send(struct fuse_conn *fc, struct fuse_in *in,
++    			 struct fuse_out *out);
++
++/**
++ * Send a request for which a reply is not expected
++ */
++int cofuse_request_send_noreply(struct fuse_conn *fc, struct fuse_in *in);
++
++
++/**
++ * Send a synchronous request without blocking
++ */
++int cofuse_request_send_nonblock(struct fuse_conn *fc, struct fuse_in *in,
++	  		         struct fuse_out *out, fuse_reqend_t end, void *data);
++
++/**
++ * Get the attributes of a file
++ */
++int cofuse_do_getattr(struct inode *inode);
++
++/**
++ * Write dirty pages
++ */
++void cofuse_sync_inode(struct inode *inode);
++
++/*
++ * Local Variables:
++ * indent-tabs-mode: t
++ * c-basic-offset: 8
++ * End:
++ */
++
++#define COFUSE_VERSION "0.1"
++#define FUSE_VERSION COFUSE_VERSION
++
++#define fuse_init_file_inode cofuse_init_file_inode
++#define fuse_do_getattr cofuse_do_getattr
++#define fuse_sync_inode cofuse_sync_inode
++#define fuse_lock cofuse_lock
++
++#define request_send cofuse_request_send
++#define request_send_noreply cofuse_request_send_noreply
++#define request_send_nonblock cofuse_request_send_nonblock
++#define release_conn cofuse_release_conn
++#define fuse_iget cofuse_iget 
++#define fuse_dev_init cofuse_dev_init
++#define fuse_dev_cleanup cofuse_dev_cleanup
++#define fuse_fs_init cofuse_fs_init
++#define fuse_fs_cleanup cofuse_fs_cleanup
++
++extern struct fuse_conn *cofs_volumes[CO_MODULE_MAX_COFS];
++
++/** Data passed to mount */
++struct cofuse_mount_data {
++	struct fuse_mount_data *fuse;
++	int uid;
++	int gid;
++	unsigned long file_mode;
++	unsigned long dir_mode;
++	unsigned long flags;
++	char name[0x80];
++};
+diff -urN a/fs/cofusefs/inode.c b/fs/cofusefs/inode.c
+--- a/fs/cofusefs/inode.c
++++ b/fs/cofusefs/inode.c
+@@ -0,0 +1,545 @@
++/*
++    FUSE: Filesystem in Userspace
++    Copyright (C) 2001	Miklos Szeredi (miklos@szeredi.hu)
++
++    This program can be distributed under the terms of the GNU GPL.
++    See the file COPYING.
++*/
++
++#include "fuse_i.h"
++
++#include <linux/pagemap.h>
++#include <linux/sched.h>
++#include <linux/slab.h>
++#include <linux/file.h>
++#include <linux/ctype.h>
++#include <linux/proc_fs.h>
++#ifdef KERNEL_2_6
++#include <linux/statfs.h>
++#endif
++
++#define FUSE_SUPER_MAGIC 0x65735546
++
++#ifndef KERNEL_2_6
++#define kstatfs statfs
++#endif
++
++#ifndef FS_BINARY_MOUNTDATA
++#define FS_BINARY_MOUNTDATA 0
++#endif
++
++static void fuse_read_inode(struct inode *inode)
++{
++	/* No op */
++}
++
++static void fuse_clear_inode(struct inode *inode)
++{
++	unsigned long flags;
++	struct fuse_conn *fc = INO_FC(inode);
++
++#ifndef CONFIG_COOPERATIVE
++	struct fuse_in *in = NULL;
++	struct fuse_forget_in *inarg = NULL;
++	unsigned int s = sizeof(struct fuse_in) + sizeof(struct fuse_forget_in);
++
++	if(fc == NULL)
++		return;
++
++	in = kmalloc(s, GFP_NOFS);
++	if(!in)
++		return;
++	memset(in, 0, s);
++	inarg = (struct fuse_forget_in *) (in + 1);
++	inarg->version = inode->i_version;
++		
++	in->h.opcode = FUSE_FORGET;
++	in->h.ino = inode->i_ino;
++	in->numargs = 1;
++	in->args[0].size = sizeof(struct fuse_forget_in);
++	in->args[0].value = inarg;
++		
++	if(!request_send_noreply(fc, in))
++		return;
++
++	kfree(in);
++#else
++	if (FUSE_ROOT_INO == inode->i_ino)
++		return;
++
++	co_passage_page_assert_valid();
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_FILESYSTEM;
++	co_passage_page->params[1] = fc->cofs_unit;
++	co_passage_page->params[2] = FUSE_FORGET;
++	co_passage_page->params[3] = inode->i_ino;
++	co_switch_wrapper();
++	co_passage_page_release(flags);
++#endif
++}
++
++static void fuse_put_super(struct super_block *sb)
++{
++	struct fuse_conn *fc = SB_FC(sb);
++
++	spin_lock(&fuse_lock);
++	fc->sb = NULL;
++	fc->uid = 0;
++	fc->flags = 0;
++	/* Flush all readers on this fs */
++#ifndef CONFIG_COOPERATIVE
++	wake_up_all(&fc->waitq);
++#endif
++	release_conn(fc);
++	SB_FC(sb) = NULL;
++	spin_unlock(&fuse_lock);
++}
++
++static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
++{
++	stbuf->f_type	 = FUSE_SUPER_MAGIC;
++	stbuf->f_bsize	 = attr->block_size;
++	stbuf->f_blocks	 = attr->blocks;
++	stbuf->f_bfree	 = stbuf->f_bavail = attr->blocks_free;
++	stbuf->f_files	 = attr->files;
++	stbuf->f_ffree	 = attr->files_free;
++	/* Is this field necessary?  Most filesystems ignore it...
++	stbuf->f_fsid.val[0] = (FUSE_SUPER_MAGIC>>16)&0xffff;
++	stbuf->f_fsid.val[1] =	FUSE_SUPER_MAGIC     &0xffff; */
++	stbuf->f_namelen = attr->namelen;
++}
++
++static int fuse_statfs(struct super_block *sb, struct kstatfs *buf)
++{
++	struct fuse_conn *fc = SB_FC(sb);
++	struct fuse_in in = FUSE_IN_INIT;
++	struct fuse_out out = FUSE_OUT_INIT;
++	struct fuse_statfs_out outarg;
++	
++	in.numargs = 0;
++	in.h.opcode = FUSE_STATFS;
++	out.numargs = 1;
++	out.args[0].size = sizeof(outarg);
++	out.args[0].value = &outarg;
++	request_send(fc, &in, &out);
++	if(!out.h.error)
++		convert_fuse_statfs(buf, &outarg.st);
++	
++	return out.h.error;
++}
++
++#ifndef CONFIG_COOPERATIVE
++
++static struct fuse_conn *get_conn(struct fuse_mount_data *d)
++{
++	struct fuse_conn *fc = NULL;
++	struct file *file;
++	struct inode *ino;
++
++	if(d == NULL) {
++		printk("fuse_read_super: Bad mount data\n");
++		return NULL;
++	}
++
++	if(d->version != FUSE_KERNEL_VERSION) {
++		printk("fuse_read_super: Bad version: %i\n", d->version);
++		return NULL;
++	}
++
++	file = fget(d->fd);
++	ino = NULL;
++	if(file)
++		ino = file->f_dentry->d_inode;
++	
++	if(!ino || !proc_fuse_dev || proc_fuse_dev->low_ino != ino->i_ino) {
++		printk("fuse_read_super: Bad file: %i\n", d->fd);
++		goto out;
++	}
++
++	fc = file->private_data;
++
++  out:
++	fput(file);
++	return fc;
++}
++
++#else
++
++static int _atoi(const char *s, const char **out)
++{
++	/* lib/spprintf.h */
++
++        int i=0;
++
++        while (isdigit(*s))
++                i = i*10 + *(s++) - '0';
++
++	*out = s;
++
++        return i;	
++}
++
++static struct fuse_conn *co_get_conn(struct cofuse_mount_data *d)
++{
++	int index;
++	int ret;
++	unsigned long flags;
++	struct fuse_conn *conn = NULL;
++	const char *name, *next;
++
++	if (d == NULL) {
++		printk("cofuse_read_super: Bad mount data\n");
++		return NULL;
++	}
++
++	name = d->name;
++
++	if (strncmp("cofs", name, 4) == 0)
++		name += 4;
++
++	index = _atoi(name, &next);
++	if (index < 0  || index >= CO_MODULE_MAX_COFS) {
++		printk("cofuse_read_super: Invalid index %d\n", index);
++		return NULL;
++	}
++	
++	if (cofs_volumes[index])
++		return cofs_volumes[index];
++
++	conn = kmalloc(sizeof(struct fuse_conn), GFP_KERNEL);
++	if (!conn)
++		return NULL;
++
++	memset(conn, 0, sizeof(*conn));
++
++	if (*next == ':') {
++		snprintf(conn->opt_pathname, sizeof(conn->opt_pathname), "%s", next+1);
++	}
++
++	conn->cofs_unit = index;
++
++	co_passage_page_assert_valid();
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_DEVICE;
++	co_passage_page->params[0] = CO_DEVICE_FILESYSTEM;
++	co_passage_page->params[1] = conn->cofs_unit;
++	co_passage_page->params[2] = FUSE_MOUNT;
++	co_passage_page->params[5] = d->uid;
++	co_passage_page->params[6] = d->gid;
++	co_passage_page->params[7] = d->dir_mode;
++	co_passage_page->params[8] = d->file_mode;
++	memcpy(&co_passage_page->params[30], conn->opt_pathname, strlen(conn->opt_pathname) + 1);
++	co_switch_wrapper();
++	ret = co_passage_page->params[4];
++	co_passage_page_release(flags);
++	
++	if (ret) {
++		kfree(conn);
++		conn = NULL;
++	}
++
++	return conn; 
++}
++
++#endif
++
++static struct inode *get_root_inode(struct super_block *sb, unsigned int mode)
++{
++	struct fuse_attr attr;
++	memset(&attr, 0, sizeof(attr));
++
++	attr.mode = mode;
++	return fuse_iget(sb, 1, &attr, 0);
++}
++
++
++#ifdef KERNEL_2_6
++
++static struct dentry *fuse_get_dentry(struct super_block *sb, void *vobjp)
++{
++	__u32 *objp = vobjp;
++	unsigned long ino = objp[0];
++	/* __u32 generation = objp[1]; */
++	struct inode *inode;
++	struct dentry *entry;
++
++	if(ino == 0)
++		return ERR_PTR(-ESTALE);
++
++	inode = ilookup(sb, ino);
++	if(!inode)
++		return ERR_PTR(-ESTALE);
++
++	entry = d_alloc_anon(inode);
++	if(!entry) {
++		iput(inode);
++		return ERR_PTR(-ENOMEM);
++	}
++
++	return entry;
++}
++
++static struct export_operations fuse_export_operations = {
++	.get_dentry	= fuse_get_dentry,
++};
++#endif
++
++static struct super_operations fuse_super_operations = {
++	.read_inode	= fuse_read_inode,
++	.clear_inode	= fuse_clear_inode,
++	.put_super	= fuse_put_super,
++	.statfs		= fuse_statfs,
++};
++
++static int fuse_read_super(struct super_block *sb, void *data, int silent)
++{	
++	struct fuse_conn *fc;
++	struct inode *root;
++#ifndef CONFIG_COOPERATIVE
++	struct fuse_mount_data *d = data;
++#else
++	struct cofuse_mount_data *co_d = data;
++	struct fuse_mount_data *d = co_d->fuse;
++#endif
++	sb->s_blocksize = PAGE_CACHE_SIZE;
++	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
++	sb->s_magic = FUSE_SUPER_MAGIC;
++	sb->s_op = &fuse_super_operations;
++	sb->s_maxbytes = MAX_LFS_FILESIZE;
++#ifdef KERNEL_2_6
++	sb->s_export_op = &fuse_export_operations;
++#endif
++
++#ifndef CONFIG_COOPERATIVE
++	fc = get_conn(d);
++#else
++	fc = co_get_conn(co_d);
++#endif
++	if(fc == NULL)
++		return -EINVAL;
++	spin_lock(&fuse_lock);
++	if(fc->sb != NULL) {
++		printk("fuse_read_super: connection already mounted\n");
++		spin_unlock(&fuse_lock);
++		return -EINVAL;
++	}
++	fc->sb = sb;
++	fc->flags = d->flags;
++	fc->uid = d->uid;
++	spin_unlock(&fuse_lock);
++	
++	/* fc is needed in fuse_init_file_inode which could be called
++	   from get_root_inode */
++	SB_FC(sb) = fc;
++
++	root = get_root_inode(sb, d->rootmode);
++	if(root == NULL) {
++		printk("fuse_read_super: failed to get root inode\n");
++		return -EINVAL;
++	}
++
++	sb->s_root = d_alloc_root(root);
++	if(!sb->s_root) {
++		printk("fuse_read_super: failed to allocate root\n");
++		return -EINVAL;
++	}
++
++	return 0;
++}
++
++#ifdef CONFIG_COOPERATIVE
++/*
++ * cofuse_getopt and cofuse_parse_options were
++ * addopted from smb
++ */ 
++
++struct option {
++	const char *name;
++	unsigned long flag;
++	int val;
++};
++
++/**
++ *      cofuse_getopt - option parser
++ *      based on smb_getopt from fs/smbfs
++ *
++ *      @caller: name of the caller, for error messages
++ *      @options: the options string
++ *      @opts: an array of &struct option entries controlling parser operations
++ *      @optopt: output; will contain the current option
++ *      @optarg: output; will contain the value (if one exists)
++ *      @flag: output; may be NULL; should point to a long for or'ing flags
++ *      @value: output; may be NULL; will be overwritten with the integer value
++ *              of the current argument.
++ *
++ *      Helper to parse options on the format used by mount ("a=b,c=d,e,f").
++ *      Returns opts->val if a matching entry in the 'opts' array is found,
++ *      0 when no more tokens are found, -1 if an error is encountered.
++ */
++static int cofuse_getopt(char *caller, char **options, struct option *opts,
++			 char **optopt, char **optarg, unsigned long *flag,
++			 unsigned long *value)
++{
++        char *token;
++        char *val;
++        int i;
++
++        do {
++                if ((token = strsep(options, ",")) == NULL)
++                        return 0;
++        } while (*token == '\0');
++        *optopt = token;
++
++        *optarg = NULL;
++        if ((val = strchr (token, '=')) != NULL) {
++                *val++ = 0;
++                if (value)
++                        *value = simple_strtoul(val, NULL, 0);
++                *optarg = val;
++        }
++
++        for (i = 0; opts[i].name != NULL; i++) {
++                if (!strcmp(opts[i].name, token)) {
++                        if (!opts[i].flag && (!val || !*val)) {
++                                printk("%s: the %s option requires an argument\n",
++                                       caller, token);
++                                return -1;
++                        }
++
++                        if (flag && opts[i].flag)
++                                *flag |= opts[i].flag;
++
++                        return opts[i].val;
++                }
++        }
++        printk("%s: Unrecognized mount option %s\n", caller, token);
++        return -1;
++}
++
++static struct option opts[] = {
++	{ "uid",	0, 'u' },
++	{ "gid",	0, 'g' },
++	{ "fmask",	0, 'f' },
++	{ "dmask",	0, 'd' },
++	{ NULL,		0, 0}
++};
++
++/*
++ * parse_options - based on parse_options from fs/smbfs
++ */
++static int parse_options(struct cofuse_mount_data *mnt, char *options)
++{
++        int c;
++        unsigned long flags;
++        unsigned long value;
++        char *optarg;
++        char *optopt;
++
++        flags = 0;
++        while ((c = cofuse_getopt("cofuse", &options, opts,
++				  &optopt, &optarg, &flags, &value)) > 0)
++	{
++                switch (c) {
++                case 1:
++                        /* got a "flag" option */
++                        break;
++                case 'u':
++                        mnt->uid = value;
++                        break;
++                case 'g':
++                        mnt->gid = value;
++                        break;
++                case 'f':
++                        mnt->file_mode = (value & S_IRWXUGO) | S_IFREG;
++                        break;
++                case 'd':
++                        mnt->dir_mode = (value & S_IRWXUGO) | S_IFDIR;
++                        break;
++                default:
++                        printk("cofs: Unrecognized mount option %s\n", optopt);
++                        return -1;
++                }
++        }
++
++        mnt->flags = flags;
++        return c;
++}
++#endif
++
++#ifdef KERNEL_2_6
++static struct super_block *fuse_get_sb(struct file_system_type *fs_type,
++				       int flags, const char *dev_name,
++				       void *raw_data)
++{
++#ifdef CONFIG_COOPERATIVE
++	struct cofuse_mount_data co_md = {0, };
++	struct fuse_mount_data md = {0, };
++	int ret;
++
++	co_md.uid = current->uid;
++	co_md.gid = current->gid;
++	co_md.dir_mode = FUSE_S_IRWXU | FUSE_S_IRGRP | FUSE_S_IXGRP | 
++		FUSE_S_IROTH | FUSE_S_IXOTH | S_IFDIR;
++	co_md.file_mode = FUSE_S_IRWXU | FUSE_S_IRGRP | FUSE_S_IXGRP | 
++		FUSE_S_IROTH | FUSE_S_IXOTH | S_IFREG;
++
++	ret = parse_options(&co_md, raw_data);
++	if (ret == -1)
++		return ERR_PTR(-EINVAL);
++
++	md.rootmode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
++	md.flags = FUSE_ALLOW_OTHER | FUSE_DEFAULT_PERMISSIONS;
++
++	co_md.fuse = &md;
++	snprintf(co_md.name, sizeof(co_md.name), "%s", dev_name);
++
++	return get_sb_nodev(fs_type, flags, &co_md, fuse_read_super);
++#else
++	return get_sb_nodev(fs_type, flags, raw_data, fuse_read_super);
++#endif
++}
++
++static struct file_system_type fuse_fs_type = {
++	.owner		= THIS_MODULE,
++	.name		= "cofs",
++	.get_sb		= fuse_get_sb,
++	.kill_sb	= kill_anon_super,
++	.fs_flags	= FS_BINARY_MOUNTDATA,
++};
++#else
++static struct super_block *fuse_read_super_compat(struct super_block *sb,
++						  void *data, int silent)
++{
++	int err = fuse_read_super(sb, data, silent);
++	if(err)
++		return NULL;
++	else
++		return sb;
++}
++
++static DECLARE_FSTYPE(fuse_fs_type, "cofs", fuse_read_super_compat, 0);
++#endif
++
++int fuse_fs_init()
++{
++	int res;
++
++	res = register_filesystem(&fuse_fs_type);
++	if(res)
++		printk("fuse: failed to register filesystem\n");
++
++	return res;
++}
++
++void fuse_fs_cleanup()
++{
++	unregister_filesystem(&fuse_fs_type);
++}
++
++/* 
++ * Local Variables:
++ * indent-tabs-mode: t
++ * c-basic-offset: 8
++ * End:
++ */
+diff -urN a/fs/cofusefs/util.c b/fs/cofusefs/util.c
+--- a/fs/cofusefs/util.c
++++ b/fs/cofusefs/util.c
+@@ -0,0 +1,78 @@
++/*
++    FUSE: Filesystem in Userspace
++    Copyright (C) 2001-2004  Miklos Szeredi <miklos@szeredi.hu>
++
++    This program can be distributed under the terms of the GNU GPL.
++    See the file COPYING.
++*/
++
++#include "fuse_i.h"
++
++#include <linux/init.h>
++#include <linux/slab.h>
++
++MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
++MODULE_DESCRIPTION("Filesystem in Userspace");
++#ifdef MODULE_LICENSE
++MODULE_LICENSE("GPL");
++#endif
++
++spinlock_t fuse_lock = SPIN_LOCK_UNLOCKED;
++
++/* Must be called with the fuse lock held */
++void release_conn(struct fuse_conn *fc)
++{
++#ifdef CONFIG_COOPERATIVE
++	if (cooperative_mode_enabled()) {
++		cofs_volumes[fc->cofs_unit] = NULL;
++		kfree(fc);
++		return;
++	}
++#else
++	if(fc->sb == NULL && fc->file == NULL) {
++		kfree(fc);
++	}
++#endif
++}
++
++int __init cofuse_init(void)
++{
++	int res;
++
++	printk(KERN_DEBUG "cofuse init %s (API version %i.%i)\n",
++	       FUSE_VERSION,
++	       FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
++
++	res = fuse_fs_init();
++	if(res)
++		goto err;
++	
++	res = fuse_dev_init();
++	if(res)
++		goto err_fs_cleanup;
++	
++	return 0;
++
++  err_fs_cleanup:
++	fuse_fs_cleanup();
++  err:
++	return res;
++}
++
++void __exit cofuse_exit(void)
++{
++	printk(KERN_DEBUG "cofuse exit\n");
++	
++	fuse_fs_cleanup();
++	fuse_dev_cleanup();
++}
++
++module_init(cofuse_init);
++module_exit(cofuse_exit);
++
++/*
++ * Local Variables:
++ * indent-tabs-mode: t
++ * c-basic-offset: 8
++ * End:
++ */
+diff -urN a/fs/namespace.c b/fs/namespace.c
+--- a/fs/namespace.c
++++ b/fs/namespace.c
+@@ -1015,7 +1015,7 @@
+ 	/* Discard magic */
+ 	if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
+ 		flags &= ~MS_MGC_MSK;
+-
++	
+ 	/* Basic sanity checks */
+ 
+ 	if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE))
+diff -urN a/include/asm-i386/bug.h b/include/asm-i386/bug.h
+--- a/include/asm-i386/bug.h
++++ b/include/asm-i386/bug.h
+@@ -10,11 +10,17 @@
+  */
+ 
+ #if 1	/* Set to zero for a slightly smaller kernel */
++#ifdef CONFIG_COOPERATIVE
++#include <linux/cooperative.h>
++extern void co_terminate(co_termination_reason_t reason);
++#define BUG() do { co_terminate(CO_TERMINATE_BUG); } while(0)
++#else
+ #define BUG()				\
+  __asm__ __volatile__(	"ud2\n"		\
+ 			"\t.word %c0\n"	\
+ 			"\t.long %c1\n"	\
+ 			 : : "i" (__LINE__), "i" (__FILE__))
++#endif
+ #else
+ #define BUG() __asm__ __volatile__("ud2\n")
+ #endif
+diff -urN a/include/asm-i386/cooperative.h b/include/asm-i386/cooperative.h
+--- a/include/asm-i386/cooperative.h
++++ b/include/asm-i386/cooperative.h
+@@ -0,0 +1,184 @@
++/*
++ *  linux/include/asm/cooperative.h
++ *
++ *  Copyright (C) 2004 Dan Aloni
++ *
++ *  This file defines the lower level interfaces between the Cooperative Linux 
++ *  kernel and the host OS driver. It's for both external inclusion from the 
++ *  and internal inclusion in the kernel sources.
++ */
++
++#ifndef __LINUX_ASM_COOPERATIVE_H__
++#define __LINUX_ASM_COOPERATIVE_H__
++
++typedef struct {
++	unsigned short size;
++	struct x86_idt_entry *table;
++} __attribute__((packed)) x86_idt_t;
++
++typedef struct {
++	unsigned short limit;
++	struct x86_dt_entry *base;
++} __attribute__((packed)) x86_gdt_t;
++
++typedef struct {
++	unsigned char border2[0x4];
++
++	unsigned long cs;
++        #define CO_ARCH_STATE_STACK_CS "0x04"
++
++	unsigned long ds;
++        #define CO_ARCH_STATE_STACK_DS "0x08"
++
++	unsigned long es;
++        #define CO_ARCH_STATE_STACK_ES "0x0C"
++
++	unsigned long cr3;   
++        #define CO_ARCH_STATE_STACK_CR3 "0x10"
++
++	unsigned long cr4;  
++        #define CO_ARCH_STATE_STACK_CR4 "0x14"
++
++	unsigned long cr2;
++        #define CO_ARCH_STATE_STACK_CR2 "0x18"
++
++	unsigned long cr0;
++        #define CO_ARCH_STATE_STACK_CR0 "0x1C"
++
++	x86_gdt_t gdt;
++        #define CO_ARCH_STATE_STACK_GDT "0x20"
++
++	unsigned long fs;    
++        #define CO_ARCH_STATE_STACK_FS  "0x26"
++
++	unsigned long gs;
++        #define CO_ARCH_STATE_STACK_GS  "0x2A"
++
++	unsigned short ldt;
++        #define CO_ARCH_STATE_STACK_LDT "0x2E"
++
++	x86_idt_t idt;
++        #define CO_ARCH_STATE_STACK_IDT "0x30"
++
++	unsigned short tr;   
++        #define CO_ARCH_STATE_STACK_TR  "0x36"
++
++	unsigned long return_eip; 
++        #define CO_ARCH_STATE_STACK_RETURN_EIP  "0x38"
++
++	unsigned long flags;     
++        #define CO_ARCH_STATE_STACK_FLAGS "0x3C"
++
++	unsigned long esp;        
++        #define CO_ARCH_STATE_STACK_ESP "0x40"
++
++	unsigned long ss;    
++        #define CO_ARCH_STATE_STACK_SS "0x44"
++
++	unsigned long dr0;        
++        #define CO_ARCH_STATE_STACK_DR0 "0x48"
++
++	unsigned long dr1;      
++        #define CO_ARCH_STATE_STACK_DR1 "0x4C"
++
++	unsigned long dr2;       
++        #define CO_ARCH_STATE_STACK_DR2 "0x50"
++
++	unsigned long dr3;
++        #define CO_ARCH_STATE_STACK_DR3 "0x54"
++
++	unsigned long dr6;
++        #define CO_ARCH_STATE_STACK_DR6 "0x58"
++
++	unsigned long dr7;
++        #define CO_ARCH_STATE_STACK_DR7 "0x5C"
++
++	unsigned long temp_cr3;
++        #define CO_ARCH_STATE_STACK_TEMP_CR3 "0x60"
++
++	unsigned long relocate_eip; 
++        #define CO_ARCH_STATE_STACK_RELOCATE_EIP "0x64"
++
++	unsigned long pad1;
++        #define CO_ARCH_STATE_STACK_RELOCATE_EIP_AFTER "0x68"
++
++	unsigned long va;
++        #define CO_ARCH_STATE_STACK_VA "0x6C"
++
++	unsigned char fxstate[0x200];
++        #define CO_ARCH_STATE_STACK_FXSTATE "0x70"
++} __attribute__((packed)) co_arch_state_stack_t;
++
++#define CO_MAX_PARAM_SIZE 0x400
++
++typedef struct co_arch_passage_page_normal_address_space {
++	unsigned long pgd[0x400];
++	unsigned long pte[2][0x400];
++} co_arch_passage_page_normal_address_space_t;
++
++typedef struct co_arch_passage_page_pae_address_space {
++	unsigned long long main[0x200];
++	unsigned long long pgd[2][0x200];
++	unsigned long long pte[2][0x200];
++} co_arch_passage_page_pae_address_space_t;
++
++typedef struct co_arch_passage_page {
++	union {
++		struct {
++			union {
++				struct {
++					unsigned long self_physical_address;
++					unsigned long dr0;
++					unsigned long dr1;
++					unsigned long dr2;
++					unsigned long dr3;
++					unsigned long dr6;
++					unsigned long dr7; 
++					unsigned char code[0x230];
++				} __attribute__((packed));
++				unsigned char pad[0x250]; /* Be careful! see NOTE below */
++			} __attribute__((packed));
++			
++			/* Machine states */
++
++			/* 
++			 * NOTE: *_state fields must be aligned at 16 bytes boundary since
++			 * the fxsave/fxload instructions expect an aligned arugment.
++			 */
++
++			co_arch_state_stack_t host_state; 
++			co_arch_state_stack_t linuxvm_state;
++			
++			/* Control parameters */
++			unsigned long operation;
++			unsigned long params[];
++		} __attribute__((packed));
++		unsigned char first_page[0x1000];
++	};
++
++	/* page tables for passage address spaces */
++	co_arch_passage_page_normal_address_space_t guest_normal;
++	union {
++		co_arch_passage_page_normal_address_space_t host_normal;
++		co_arch_passage_page_pae_address_space_t host_pae;
++	} __attribute__((packed));
++} co_arch_passage_page_t;
++
++/*
++ * Address space layout:
++ */
++
++#define CO_VPTR_BASE                         (0xffc00000)
++#define CO_VPTR_PHYSICAL_TO_PSEUDO_PFN_MAP   (CO_VPTR_BASE - 0x1000000)
++#define CO_VPTR_PSEUDO_RAM_PAGE_TABLES       (CO_VPTR_BASE - 0x1100000)
++#define CO_VPTR_PASSAGE_PAGE                 (CO_VPTR_BASE - 0x1101000)
++#define CO_VPTR_IO_AREA_SIZE                 (0x10000)
++#define CO_VPTR_IO_AREA_START                (CO_VPTR_BASE - 0x1200000)
++#define CO_VPTR_SELF_MAP                     (CO_VPTR_BASE - 0x1400000)
++
++typedef struct {
++	unsigned long kernel_cs;
++	unsigned long kernel_ds;
++} __attribute__((packed)) co_arch_info_t;
++
++#endif
+diff -urN a/include/asm-i386/cooperative_internal.h b/include/asm-i386/cooperative_internal.h
+--- a/include/asm-i386/cooperative_internal.h
++++ b/include/asm-i386/cooperative_internal.h
+@@ -0,0 +1,33 @@
++/*
++ *  linux/include/asm/cooperative_internal.h
++ *
++ *  Copyright (C) 2004 Dan Aloni
++ */
++
++#ifndef __LINUX_ASM_COOPERATIVE_INTERNAL_H__
++#define __LINUX_ASM_COOPERATIVE_INTERNAL_H__
++
++#include <linux/config.h>
++#include <asm/ptrace.h>
++
++#ifdef CONFIG_COOPERATIVE
++
++extern void co_kernel_breakpoint(struct pt_regs * regs);
++extern int co_kernel_debug(struct pt_regs * regs, long error_code, unsigned int condition);
++
++fastcall unsigned int do_IRQ(struct pt_regs *regs);
++
++#else
++
++static inline void co_kernel_breakpoint(struct pt_regs * regs)
++{
++}
++
++static inline int co_kernel_debug(struct pt_regs * regs, long error_code, unsigned int condition)
++{
++	return 0;
++}
++
++#endif
++
++#endif
+diff -urN a/include/asm-i386/dma.h b/include/asm-i386/dma.h
+--- a/include/asm-i386/dma.h
++++ b/include/asm-i386/dma.h
+@@ -268,6 +268,7 @@
+  *
+  * Assumes DMA flip-flop is clear.
+  */
++#ifndef CONFIG_COOPERATIVE
+ static __inline__ int get_dma_residue(unsigned int dmanr)
+ {
+ 	unsigned int io_port = (dmanr<=3)? ((dmanr&3)<<1) + 1 + IO_DMA1_BASE
+@@ -281,6 +282,7 @@
+ 	
+ 	return (dmanr<=3)? count : (count<<1);
+ }
++#endif
+ 
+ 
+ /* These are in kernel/dma.c: */
+diff -urN a/include/asm-i386/fixmap.h b/include/asm-i386/fixmap.h
+--- a/include/asm-i386/fixmap.h
++++ b/include/asm-i386/fixmap.h
+@@ -31,6 +31,7 @@
+ #include <linux/threads.h>
+ #include <asm/kmap_types.h>
+ #endif
++#include <asm/cooperative.h>
+ 
+ /*
+  * Here we define all the compile-time 'special' virtual
+diff -urN a/include/asm-i386/io.h b/include/asm-i386/io.h
+--- a/include/asm-i386/io.h
++++ b/include/asm-i386/io.h
+@@ -104,12 +104,15 @@
+  * address. 
+  */
+ 
+-static inline void __iomem * ioremap(unsigned long offset, unsigned long size)
++static inline void * __iomem ioremap (unsigned long offset, unsigned long size)
+ {
++#ifdef CONFIG_COOPERATIVE
++	panic("ioremap %ld:%ld\n", offset, size);
++#endif
+ 	return __ioremap(offset, size, 0);
+ }
+ 
+-extern void __iomem * ioremap_nocache(unsigned long offset, unsigned long size);
++extern void * __iomem ioremap_nocache (unsigned long offset, unsigned long size);
+ extern void iounmap(volatile void __iomem *addr);
+ 
+ /*
+@@ -280,7 +283,7 @@
+ 
+ #endif /* __KERNEL__ */
+ 
+-#ifdef SLOW_IO_BY_JUMPING
++#if SLOW_IO_BY_JUMPING || CONFIG_COOPERATIVE
+ #define __SLOW_DOWN_IO "jmp 1f; 1: jmp 1f; 1:"
+ #else
+ #define __SLOW_DOWN_IO "outb %%al,$0x80;"
+diff -urN a/include/asm-i386/mach-default/irq_vectors.h b/include/asm-i386/mach-default/irq_vectors.h
+--- a/include/asm-i386/mach-default/irq_vectors.h
++++ b/include/asm-i386/mach-default/irq_vectors.h
+@@ -67,6 +67,11 @@
+ 
+ #define TIMER_IRQ 0
+ 
++#ifdef CONFIG_COOPERATIVE
++#define KEYBOARD_IRQ 1
++#define NETWORK_IRQ 2
++#endif
++
+ /*
+  * 16 8259A IRQ's, 208 potential APIC interrupt sources.
+  * Right now the APIC is mostly only used for SMP.
+diff -urN a/include/asm-i386/mach-default/irq_vectors_limits.h b/include/asm-i386/mach-default/irq_vectors_limits.h
+--- a/include/asm-i386/mach-default/irq_vectors_limits.h
++++ b/include/asm-i386/mach-default/irq_vectors_limits.h
+@@ -5,7 +5,7 @@
+ #define NR_IRQS FIRST_SYSTEM_VECTOR
+ #define NR_IRQ_VECTORS NR_IRQS
+ #else
+-#ifdef CONFIG_X86_IO_APIC
++#if defined(CONFIG_X86_IO_APIC) || defined(CONFIG_X86_UP_COPIC)
+ #define NR_IRQS 224
+ # if (224 >= 32 * NR_CPUS)
+ # define NR_IRQ_VECTORS NR_IRQS
+diff -urN a/include/asm-i386/mc146818rtc.h b/include/asm-i386/mc146818rtc.h
+--- a/include/asm-i386/mc146818rtc.h
++++ b/include/asm-i386/mc146818rtc.h
+@@ -4,6 +4,7 @@
+ #ifndef _ASM_MC146818RTC_H
+ #define _ASM_MC146818RTC_H
+ 
++#include <linux/config.h>
+ #include <asm/io.h>
+ 
+ #ifndef RTC_PORT
+@@ -11,6 +12,8 @@
+ #define RTC_ALWAYS_BCD	1	/* RTC operates in binary mode */
+ #endif
+ 
++#ifndef CONFIG_COOPERATIVE
++
+ /*
+  * The yet supported machines all access the RTC index register via
+  * an ISA port access but the way to access the date register differs ...
+@@ -24,6 +27,11 @@
+ outb_p((val),RTC_PORT(1)); \
+ })
+ 
++#else
++#define CMOS_READ(addr) (0)
++#define CMOS_WRITE(val, addr) do {} while(0)
++#endif
++
+ #define RTC_IRQ 8
+ 
+ #endif /* _ASM_MC146818RTC_H */
+diff -urN a/include/asm-i386/mmzone.h b/include/asm-i386/mmzone.h
+--- a/include/asm-i386/mmzone.h
++++ b/include/asm-i386/mmzone.h
+@@ -6,7 +6,9 @@
+ #ifndef _ASM_MMZONE_H_
+ #define _ASM_MMZONE_H_
+ 
++#include <linux/config.h>
+ #include <asm/smp.h>
++#include <asm/cooperative.h>
+ 
+ #ifdef CONFIG_DISCONTIGMEM
+ 
+@@ -116,7 +118,8 @@
+ 	(unsigned long)(__page - __zone->zone_mem_map)			\
+ 		+ __zone->zone_start_pfn;				\
+ })
+-#define pmd_page(pmd)		(pfn_to_page(pmd_val(pmd) >> PAGE_SHIFT))
++
++#define pmd_page(pmd)		(pfn_to_page(CO_P_TO_PP(pmd_val(pmd)) >> PAGE_SHIFT))
+ 
+ #ifdef CONFIG_X86_NUMAQ            /* we have contiguous memory on NUMA-Q */
+ #define pfn_valid(pfn)          ((pfn) < num_physpages)
+diff -urN a/include/asm-i386/page.h b/include/asm-i386/page.h
+--- a/include/asm-i386/page.h
++++ b/include/asm-i386/page.h
+@@ -13,6 +13,7 @@
+ #ifndef __ASSEMBLY__
+ 
+ #include <linux/config.h>
++#include <asm/cooperative.h>
+ 
+ #ifdef CONFIG_X86_USE_3DNOW
+ 
+@@ -126,6 +127,19 @@
+ #define __PAGE_OFFSET		(0xC0000000UL)
+ #endif
+ 
++#ifdef CONFIG_COOPERATIVE
++#define CO_PA(pfn)		(((unsigned long *)CO_VPTR_PSEUDO_RAM_PAGE_TABLES)[pfn])
++#define CO_VA_PFN(pa)		(((unsigned long *)CO_VPTR_PHYSICAL_TO_PSEUDO_PFN_MAP)[((pa) >> PAGE_SHIFT)])
++#define CO_PFN_PP_TO_P(pfn)	(CO_PA(pfn) >> PAGE_SHIFT)
++#define CO_PFN_P_TO_PP(pfn)	(CO_VA_PFN(pfn << PAGE_SHIFT))
++#define CO_PP_TO_P(pa)	        ((CO_PFN_PP_TO_P(pa >> PAGE_SHIFT) << PAGE_SHIFT) | (pa & ~PAGE_MASK))
++#define CO_P_TO_PP(pa)	        ((CO_PFN_P_TO_PP(pa >> PAGE_SHIFT) << PAGE_SHIFT) | (pa & ~PAGE_MASK))
++#else
++#define CO_PFN_P_TO_PP(pfn)	pfn
++#define CO_PFN_PP_TO_P(pfn)	pfn
++#define CO_PP_TO_P(pa)        	pa
++#define CO_P_TO_PP(pa)	        pa
++#endif
+ 
+ #define PAGE_OFFSET		((unsigned long)__PAGE_OFFSET)
+ #define VMALLOC_RESERVE		((unsigned long)__VMALLOC_RESERVE)
+diff -urN a/include/asm-i386/param.h b/include/asm-i386/param.h
+--- a/include/asm-i386/param.h
++++ b/include/asm-i386/param.h
+@@ -2,8 +2,12 @@
+ #define _ASMi386_PARAM_H
+ 
+ #ifdef __KERNEL__
++# include <linux/config.h>
++# ifndef CONFIG_COOPERATIVE
+ # define HZ		1000		/* Internal kernel timer frequency */
++# else
+ # define USER_HZ	100		/* .. some user interfaces are in "ticks" */
++# endif
+ # define CLOCKS_PER_SEC		(USER_HZ)	/* like times() */
+ #endif
+ 
+diff -urN a/include/asm-i386/pgalloc.h b/include/asm-i386/pgalloc.h
+--- a/include/asm-i386/pgalloc.h
++++ b/include/asm-i386/pgalloc.h
+@@ -6,15 +6,16 @@
+ #include <asm/fixmap.h>
+ #include <linux/threads.h>
+ #include <linux/mm.h>		/* for struct page */
++#include <asm/cooperative.h>
+ 
+ #define pmd_populate_kernel(mm, pmd, pte) \
+-		set_pmd(pmd, __pmd(_PAGE_TABLE + __pa(pte)))
++		set_pmd(pmd, __pmd(_PAGE_TABLE + CO_PP_TO_P(__pa(pte))))
+ 
+ static inline void pmd_populate(struct mm_struct *mm, pmd_t *pmd, struct page *pte)
+ {
+ 	set_pmd(pmd, __pmd(_PAGE_TABLE +
+-		((unsigned long long)page_to_pfn(pte) <<
+-			(unsigned long long) PAGE_SHIFT)));
++			   ((CO_PFN_PP_TO_P((unsigned long long)page_to_pfn(pte))) <<
++			    (unsigned long long) PAGE_SHIFT)));
+ }
+ /*
+  * Allocate and free page tables.
+diff -urN a/include/asm-i386/pgtable-2level.h b/include/asm-i386/pgtable-2level.h
+--- a/include/asm-i386/pgtable-2level.h
++++ b/include/asm-i386/pgtable-2level.h
+@@ -8,6 +8,9 @@
+ #define pgd_ERROR(e) \
+ 	printk("%s:%d: bad pgd %08lx.\n", __FILE__, __LINE__, pgd_val(e))
+ 
++#include <linux/config.h>
++#include <asm/cooperative.h>
++
+ /*
+  * The "pgd_xxx()" functions here are trivial for a folded two-level
+  * setup: the pgd is never bad, and a pmd always exists (as it's folded
+@@ -33,19 +36,21 @@
+ #define set_pgd(pgdptr, pgdval) (*(pgdptr) = pgdval)
+ 
+ #define pgd_page(pgd) \
+-((unsigned long) __va(pgd_val(pgd) & PAGE_MASK))
++	((unsigned long) __va(CO_P_TO_PP(pgd_val(pgd)) & PAGE_MASK))
+ 
+ static inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
+ {
+ 	return (pmd_t *) dir;
+ }
++
+ #define ptep_get_and_clear(xp)	__pte(xchg(&(xp)->pte_low, 0))
+ #define pte_same(a, b)		((a).pte_low == (b).pte_low)
++
+ #define pte_page(x)		pfn_to_page(pte_pfn(x))
++#define pte_pfn(x)		CO_PFN_P_TO_PP((unsigned long)(((x).pte_low >> PAGE_SHIFT)))
++#define pfn_pte(pfn, prot)	__pte((CO_PFN_PP_TO_P(pfn) << PAGE_SHIFT) | pgprot_val(prot))
++#define pfn_pmd(pfn, prot)	__pmd((CO_PFN_PP_TO_P(pfn) << PAGE_SHIFT) | pgprot_val(prot))
+ #define pte_none(x)		(!(x).pte_low)
+-#define pte_pfn(x)		((unsigned long)(((x).pte_low >> PAGE_SHIFT)))
+-#define pfn_pte(pfn, prot)	__pte(((pfn) << PAGE_SHIFT) | pgprot_val(prot))
+-#define pfn_pmd(pfn, prot)	__pmd(((pfn) << PAGE_SHIFT) | pgprot_val(prot))
+ 
+ /*
+  * All present user pages are user-executable:
+diff -urN a/include/asm-i386/pgtable.h b/include/asm-i386/pgtable.h
+--- a/include/asm-i386/pgtable.h
++++ b/include/asm-i386/pgtable.h
+@@ -25,6 +25,8 @@
+ #include <linux/list.h>
+ #include <linux/spinlock.h>
+ 
++#include <asm/cooperative.h>
++
+ /*
+  * ZERO_PAGE is a global shared page that is always zero: used
+  * for zero-mapped memory areas etc..
+@@ -294,10 +296,10 @@
+ #define page_pte(page) page_pte_prot(page, __pgprot(0))
+ 
+ #define pmd_page_kernel(pmd) \
+-((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
++((unsigned long) __va(CO_P_TO_PP(pmd_val(pmd)) & PAGE_MASK))
+ 
+ #ifndef CONFIG_DISCONTIGMEM
+-#define pmd_page(pmd) (pfn_to_page(pmd_val(pmd) >> PAGE_SHIFT))
++#define pmd_page(pmd) (pfn_to_page(CO_PFN_P_TO_PP(pmd_val(pmd) >> PAGE_SHIFT)))
+ #endif /* !CONFIG_DISCONTIGMEM */
+ 
+ #define pmd_large(pmd) \
+diff -urN a/include/asm-i386/processor.h b/include/asm-i386/processor.h
+--- a/include/asm-i386/processor.h
++++ b/include/asm-i386/processor.h
+@@ -182,8 +182,7 @@
+ }
+ 
+ #define load_cr3(pgdir) \
+-	asm volatile("movl %0,%%cr3": :"r" (__pa(pgdir)))
+-
++	asm volatile("movl %0,%%cr3": :"r" (CO_PP_TO_P(__pa(pgdir))))
+ 
+ /*
+  * Intel CPU features in CR4
+diff -urN a/include/asm-i386/timer.h b/include/asm-i386/timer.h
+--- a/include/asm-i386/timer.h
++++ b/include/asm-i386/timer.h
+@@ -19,7 +19,7 @@
+ struct timer_opts {
+ 	char* name;
+ 	void (*mark_offset)(void);
+-	unsigned long (*get_offset)(void);
++	long (*get_offset)(void);
+ 	unsigned long long (*monotonic_clock)(void);
+ 	void (*delay)(unsigned long);
+ };
+@@ -50,6 +50,9 @@
+ #ifdef CONFIG_X86_CYCLONE_TIMER
+ extern struct init_timer_opts timer_cyclone_init;
+ #endif
++#ifdef CONFIG_COOPERATIVE
++extern struct init_timer_opts timer_cooperative_init;
++#endif
+ 
+ extern unsigned long calibrate_tsc(void);
+ extern void init_cpu_khz(void);
+diff -urN a/include/linux/console.h b/include/linux/console.h
+--- a/include/linux/console.h
++++ b/include/linux/console.h
+@@ -61,6 +61,7 @@
+ extern const struct consw dummy_con;	/* dummy console buffer */
+ extern const struct consw fb_con;	/* frame buffer based console */
+ extern const struct consw vga_con;	/* VGA text console */
++extern const struct consw colinux_con;	/* coLinux Mode text console */
+ extern const struct consw newport_con;	/* SGI Newport console  */
+ extern const struct consw prom_con;	/* SPARC PROM console */
+ 
+diff -urN a/include/linux/cooperative.h b/include/linux/cooperative.h
+--- a/include/linux/cooperative.h
++++ b/include/linux/cooperative.h
+@@ -0,0 +1,322 @@
++/*
++ *  linux/include/linux/cooperative.h
++ *
++ *  Copyright (C) 2004 Dan Aloni
++ *
++ *  This file defines the interfaces between the Cooperative Linux kernel
++ *  and the host OS driver. It's for both external inclusion from the 
++ *  and internal inclusion in the kernel sources.
++ */
++
++#ifndef __LINUX_COOPERATIVE_H__
++#define __LINUX_COOPERATIVE_H__
++
++#ifdef __KERNEL__
++#ifndef CO_KERNEL
++#define CO_COLINUX_KERNEL
++#define CO_KERNEL
++#endif
++#endif
++
++#include <asm/cooperative.h>
++
++#define CO_LINUX_API_VERSION    8
++
++#pragma pack(0)
++
++#define CO_BOOTPARAM_STRING_LENGTH 0x100
++
++typedef enum {
++	CO_OPERATION_EMPTY=0,
++	CO_OPERATION_START,
++	CO_OPERATION_IDLE,
++	CO_OPERATION_TERMINATE,
++	CO_OPERATION_MESSAGE_TO_MONITOR,
++	CO_OPERATION_MESSAGE_FROM_MONITOR,
++	CO_OPERATION_FORWARD_INTERRUPT,
++	CO_OPERATION_DEVICE,
++	CO_OPERATION_GET_TIME,
++	CO_OPERATION_DEBUG_LINE,
++	CO_OPERATION_GET_HIGH_PREC_TIME,
++	CO_OPERATION_TRACE_POINT,
++	CO_OPERATION_FREE_PAGES,
++	CO_OPERATION_ALLOC_PAGES,
++} co_operation_t;
++
++#define CO_MODULE_MAX_CONET    16
++#define CO_MODULE_MAX_COBD     32
++#define CO_MODULE_MAX_COFS     32
++#define CO_MODULE_MAX_SERIAL   64
++
++typedef enum {
++	CO_MODULE_LINUX,
++	CO_MODULE_MONITOR,
++	CO_MODULE_DAEMON,
++	CO_MODULE_IDLE,
++	CO_MODULE_KERNEL_SWITCH,
++	CO_MODULE_USER_SWITCH,
++	CO_MODULE_CONSOLE,
++	CO_MODULE_PRINTK,
++
++	CO_MODULE_CONET0,
++	CO_MODULE_CONET_END=CO_MODULE_CONET0+CO_MODULE_MAX_CONET-1,
++
++	CO_MODULE_COBD0,
++	CO_MODULE_COBD_END=CO_MODULE_COBD0+CO_MODULE_MAX_COBD-1,
++
++	CO_MODULE_COFS0,
++	CO_MODULE_COFS_END=CO_MODULE_COFS0+CO_MODULE_MAX_COFS-1,
++	
++	CO_MODULE_SERIAL0,
++	CO_MODULE_SERIAL_END=CO_MODULE_SERIAL0+CO_MODULE_MAX_SERIAL-1,
++} co_module_t;
++
++typedef enum {
++	CO_PRIORITY_DISCARDABLE=0,
++	CO_PRIORITY_IMPORTANT,
++} co_priority_t;
++
++typedef enum {
++	CO_MESSAGE_TYPE_STRING=0,
++	CO_MESSAGE_TYPE_OTHER=1,
++} co_message_type_t;
++
++typedef struct {
++	co_module_t from;
++	co_module_t to;
++	co_priority_t priority;
++	co_message_type_t type;
++	unsigned long size;
++	char data[0];
++} __attribute__((packed)) co_message_t;
++
++typedef enum {
++	CO_DEVICE_BLOCK=0,
++	CO_DEVICE_CONSOLE,
++	CO_DEVICE_KEYBOARD,
++	CO_DEVICE_NETWORK,
++	CO_DEVICE_TIMER,
++	CO_DEVICE_POWER,
++	CO_DEVICE_SERIAL,
++	CO_DEVICE_FILESYSTEM,
++
++	CO_DEVICES_TOTAL,
++} co_device_t;
++
++typedef struct {
++	unsigned char code;
++	int down;
++} co_scan_code_t;
++
++typedef enum {
++	CO_LINUX_MESSAGE_POWER_ALT_CTRL_DEL=0,
++} co_linux_message_power_type_t;
++
++typedef struct {
++	co_linux_message_power_type_t type;
++} __attribute__((packed)) co_linux_message_power_t;
++
++typedef struct {
++	unsigned long tick_count;
++} __attribute__((packed)) co_linux_message_idle_t;
++
++typedef struct {
++	co_device_t device;
++	unsigned long unit;
++	unsigned long size;
++	char data[];
++} __attribute__((packed)) co_linux_message_t;
++
++typedef enum {
++	CO_TERMINATE_END=0,
++	CO_TERMINATE_REBOOT,
++	CO_TERMINATE_POWEROFF,
++	CO_TERMINATE_PANIC,
++	CO_TERMINATE_HALT,
++	CO_TERMINATE_FORCED_OFF,
++	CO_TERMINATE_FORCED_END,
++	CO_TERMINATE_INVALID_OPERATION,
++	CO_TERMINATE_STACK_OVERFLOW,
++	CO_TERMINATE_BUG,
++} co_termination_reason_t;
++
++typedef void (*co_switcher_t)(co_arch_passage_page_t *page, 
++			      unsigned char *from,
++			      unsigned char *to);
++
++#define co_passage_page_func_low(_from_,_to_)	\
++	(((co_switcher_t)(co_passage_page->code))	\
++	 (co_passage_page,				\
++	  (char *)&_from_.border2,			\
++	  (char *)&_to_.border2))
++
++#define co_passage_page_func(_from_,_to_)				\
++	co_passage_page_func_low(co_passage_page->_from_, co_passage_page->_to_)
++
++#ifdef CO_KERNEL
++# ifdef CO_COLINUX_KERNEL
++#  define co_passage_page  ((co_arch_passage_page_t *)(CO_VPTR_PASSAGE_PAGE))
++#  define co_current (co_passage_page->linuxvm_state)
++#  define co_other (co_passage_page->host_state)
++# else
++#  define co_passage_page  (cmon->passage_page)
++#  define co_other (co_passage_page->linuxvm_state)
++#  define co_current (co_passage_page->host_state)
++# endif
++
++# define co_switch() co_passage_page_func_low(co_current, co_other)
++#endif
++
++/*
++ * Defines operations on various virtual devices.
++ */
++
++typedef enum {
++	CO_OPERATION_CONSOLE_STARTUP=0,
++	CO_OPERATION_CONSOLE_INIT=1,
++	CO_OPERATION_CONSOLE_DEINIT,
++	CO_OPERATION_CONSOLE_CLEAR,
++	CO_OPERATION_CONSOLE_PUTC,
++	CO_OPERATION_CONSOLE_PUTCS,
++	CO_OPERATION_CONSOLE_CURSOR_DRAW,
++	CO_OPERATION_CONSOLE_CURSOR_ERASE,
++	CO_OPERATION_CONSOLE_CURSOR_MOVE,
++	CO_OPERATION_CONSOLE_SCROLL_UP,
++	CO_OPERATION_CONSOLE_SCROLL_DOWN,
++	CO_OPERATION_CONSOLE_BMOVE,
++	CO_OPERATION_CONSOLE_SWITCH,
++	CO_OPERATION_CONSOLE_BLANK,
++	CO_OPERATION_CONSOLE_FONT_OP,
++	CO_OPERATION_CONSOLE_SET_PALETTE,
++	CO_OPERATION_CONSOLE_SCROLLDELTA,
++	CO_OPERATION_CONSOLE_SET_ORIGIN,
++	CO_OPERATION_CONSOLE_SAVE_SCREEN,
++	CO_OPERATION_CONSOLE_INVERT_REGION,
++} co_operation_console_t;
++
++
++typedef char co_console_code;
++typedef unsigned short co_console_character;
++typedef unsigned short co_console_unit;
++
++typedef struct {
++	co_console_unit x;
++	co_console_unit y;
++	co_console_unit height;
++} __attribute__((packed)) co_cursor_pos_t;
++
++typedef struct {
++	co_operation_console_t type;
++	union {
++		struct {
++			co_console_unit top;  
++			co_console_unit bottom;
++			co_console_unit lines;
++		} scroll;
++		struct {
++			co_console_unit y;
++			co_console_unit x;
++			co_console_unit count;
++			co_console_character data[];
++		} putcs;
++		struct {
++			co_console_unit x;
++			co_console_unit y;
++			co_console_character charattr;
++		} putc;
++		struct {
++			co_console_unit top;
++			co_console_unit left;
++			co_console_unit bottom;
++			co_console_unit right;
++			co_console_character charattr;
++		} clear;
++		struct {
++			co_console_unit y;
++			co_console_unit x;
++			co_console_unit count;
++		} invert;
++		struct {
++			co_console_unit row;
++			co_console_unit column;
++			co_console_unit top;
++			co_console_unit left;
++			co_console_unit bottom;
++			co_console_unit right;
++		} bmove;
++		co_cursor_pos_t cursor;
++	};
++} __attribute__((packed)) co_console_message_t;
++
++typedef struct {	
++	unsigned long index;
++	unsigned long flags;
++	unsigned long func;
++	unsigned long pid;
++} __attribute__((packed)) co_trace_point_info_t;
++
++typedef enum {
++	CO_BLOCK_OPEN=0,
++	CO_BLOCK_STAT,
++	CO_BLOCK_READ,
++	CO_BLOCK_WRITE,
++	CO_BLOCK_CLOSE,
++	CO_BLOCK_GET_ALIAS,
++} co_block_request_type_t;
++
++typedef enum {
++	CO_NETWORK_GET_MAC=0,
++} co_network_request_type_t;
++
++#ifdef CO_KERNEL
++/* If we are compiling kernel code (Linux or Host Driver) */
++# ifdef CO_COLINUX_KERNEL
++/* Inside Linux, vm_ptr_t considered a valid pointer in its virtual address space */
++typedef void *vm_ptr_t;
++#  else
++/* But inside the host, the type is considered not to be a pointer in its own address space */
++typedef unsigned long vm_ptr_t;
++# endif
++
++typedef struct {
++	co_block_request_type_t type;
++	long rc;
++	union {
++		struct {
++			unsigned long long offset;
++			unsigned long long size;
++			unsigned long long disk_size;
++			vm_ptr_t address;
++		};
++		struct {
++			char alias[20];
++		};
++	};
++} __attribute__((packed)) co_block_request_t;
++
++typedef struct {
++	co_network_request_type_t type;
++	unsigned long unit;
++	char mac_address[6];
++	char _pad[2];
++	int result;
++} __attribute__((packed)) co_network_request_t;
++
++#endif
++
++typedef struct {
++	unsigned long api_version;
++	unsigned long compiler_major;
++	unsigned long compiler_minor;
++} __attribute__((packed)) co_info_t;
++
++#ifndef COLINUX_TRACE
++#define CO_TRACE_STOP
++#define CO_TRACE_CONTINUE
++#endif
++
++#pragma pack()
++
++#include "cooperative_fs.h"
++
++#endif
+diff -urN a/include/linux/cooperative_fs.h b/include/linux/cooperative_fs.h
+--- a/include/linux/cooperative_fs.h
++++ b/include/linux/cooperative_fs.h
+@@ -0,0 +1,267 @@
++/*
++    FUSE: Filesystem in Userspace
++    Copyright (C) 2001-2004  Miklos Szeredi <miklos@szeredi.hu>
++
++    This program can be distributed under the terms of the GNU GPL.
++    See the file COPYING.
++*/
++
++/* This file defines the kernel interface of FUSE */
++
++#pragma pack(0)
++
++/** Version number of this interface */
++#define FUSE_KERNEL_VERSION 2
++
++/** Minor version number of this interface */
++#define FUSE_KERNEL_MINOR_VERSION 2
++
++/** The inode number of the root inode */
++#define FUSE_ROOT_INO 1
++
++/** Data passed to mount */
++struct fuse_mount_data {
++	/** The file type of the root inode */
++	unsigned int rootmode;
++
++	/** The user ID of the user initiating this mount */
++	unsigned int uid;
++	
++	/** FUSE specific mount flags */
++	unsigned int flags;
++};
++
++/* FUSE mount flags: */
++
++/** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem
++module will check permissions based on the file mode.  Otherwise no
++permission checking is done in the kernel */
++#define FUSE_DEFAULT_PERMISSIONS (1 << 0)
++
++/** If the FUSE_ALLOW_OTHER flag is given, then not only the user
++    doing the mount will be allowed to access the filesystem */
++#define FUSE_ALLOW_OTHER         (1 << 1)
++
++/** If the FUSE_KERNEL_CACHE flag is given, then files will be cached
++    until the INVALIDATE operation is invoked */
++#define FUSE_KERNEL_CACHE        (1 << 2)
++
++/** Allow FUSE to combine reads into 64k chunks.  This is useful if
++    the filesystem is better at handling large chunks.  NOTE: in
++    current implementation the raw throughput is worse for large reads
++    than for small. */
++#define FUSE_LARGE_READ          (1 << 3)
++
++struct fuse_attr {
++	unsigned long long  size;
++	unsigned int        mode;
++	unsigned int        nlink;
++	unsigned int        uid;
++	unsigned int        gid;
++	unsigned int        rdev;
++	unsigned long       _dummy;
++	unsigned long       blocks;
++	unsigned long       atime;
++	unsigned long       mtime;
++	unsigned long       ctime;
++};
++
++struct fuse_kstatfs {
++    long block_size;
++    long blocks;
++    long blocks_free;
++    long files;
++    long files_free;
++    long namelen;
++};
++
++#define FATTR_MODE	(1 << 0)
++#define FATTR_UID	(1 << 1)
++#define FATTR_GID	(1 << 2)
++#define FATTR_SIZE	(1 << 3)
++#define FATTR_UTIME	(1 << 4)
++
++enum fuse_opcode {
++	FUSE_LOOKUP	= 1,
++	FUSE_FORGET	= 2,  /* no reply */
++	FUSE_GETATTR	= 3,
++	FUSE_SETATTR	= 4,
++	FUSE_READLINK	= 5,
++	FUSE_SYMLINK	= 6,
++	FUSE_GETDIR	= 7,
++	FUSE_MKNOD	= 8,
++	FUSE_MKDIR	= 9,
++	FUSE_UNLINK	= 10,
++	FUSE_RMDIR	= 11,
++	FUSE_RENAME	= 12,
++	FUSE_LINK	= 13,
++	FUSE_OPEN	= 14,
++	FUSE_READ	= 15,
++	FUSE_WRITE	= 16,
++	FUSE_STATFS	= 17,
++	FUSE_RELEASE    = 18, /* no reply */
++	FUSE_INVALIDATE = 19, /* user initiated */
++	FUSE_FSYNC      = 20,
++	FUSE_RELEASE2   = 21,  /* reply needed after all */
++
++	/* Cooperative Linux does things a little differently: */
++	FUSE_DIR_OPEN    = 22, 
++	FUSE_DIR_READ    = 23, 
++	FUSE_DIR_RELEASE = 24, 
++
++	FUSE_MOUNT       = 25,
++};
++
++/* Conservative buffer size for the client */
++#define FUSE_MAX_IN 8192
++
++#define FUSE_NAME_MAX 1024
++#define FUSE_SYMLINK_MAX 4096
++
++struct fuse_lookup_out {
++	struct fuse_attr attr;
++	unsigned long ino;
++};
++
++struct fuse_forget_in {
++	int version;
++};
++
++struct fuse_getattr_out {
++	struct fuse_attr attr;
++};
++
++struct fuse_getdir_out {
++	int fd;
++	void *file; /* Used by kernel only */
++};
++
++/* FIXME: 2.6 needs 32 bit rdev */
++struct fuse_mknod_in {
++	unsigned short mode;
++	unsigned short rdev;
++};
++
++struct fuse_mknod_out {
++	struct fuse_attr attr;
++	unsigned long ino;
++};
++
++struct fuse_mkdir_in {
++	unsigned short mode;
++};
++
++struct fuse_rename_in {
++	unsigned long newdir;
++};
++
++struct fuse_link_in {
++	unsigned long newdir;
++};
++
++struct fuse_setattr_in {
++	struct fuse_attr attr;
++	unsigned int valid;
++};
++
++struct fuse_setattr_out {
++	struct fuse_attr attr;
++};
++
++struct fuse_open_in {
++	unsigned int flags;
++};
++
++struct fuse_read_in {
++	unsigned long long offset;
++	unsigned int size;
++};
++
++struct fuse_write_in {
++	unsigned long long offset;
++	unsigned int size;
++};
++
++struct fuse_statfs_out {
++	struct fuse_kstatfs st;
++};
++
++struct fuse_fsync_in {
++	int datasync;
++};
++
++struct fuse_in_header {
++	int unique;
++	enum fuse_opcode opcode;
++	unsigned long ino;
++	unsigned int uid;
++	unsigned int gid;
++};
++
++struct fuse_out_header {
++	int unique;
++	int error;
++};
++
++struct fuse_user_header {
++	int unique; /* zero */
++	enum fuse_opcode opcode;
++	unsigned long ino;
++};
++
++struct fuse_dirent {
++	unsigned long ino;
++	unsigned short namelen;
++	unsigned char type;
++	char name[256];
++};
++
++#define FUSE_S_IFMT   00170000
++#define FUSE_S_IFSOCK 0140000
++#define FUSE_S_IFLNK  0120000
++#define FUSE_S_IFREG  0100000
++#define FUSE_S_IFBLK  0060000
++#define FUSE_S_IFDIR  0040000
++#define FUSE_S_IFCHR  0020000
++#define FUSE_S_IFIFO  0010000
++#define FUSE_S_ISUID  0004000
++#define FUSE_S_ISGID  0002000
++#define FUSE_S_ISVTX  0001000
++
++#define FUSE_S_IRWXU 00700
++#define FUSE_S_IRUSR 00400
++#define FUSE_S_IWUSR 00200
++#define FUSE_S_IXUSR 00100
++
++#define FUSE_S_IRWXG 00070
++#define FUSE_S_IRGRP 00040
++#define FUSE_S_IWGRP 00020
++#define FUSE_S_IXGRP 00010
++
++#define FUSE_S_IRWXO 00007
++#define FUSE_S_IROTH 00004
++#define FUSE_S_IWOTH 00002
++#define FUSE_S_IXOTH 00001
++
++#define FUSE_DT_UNKNOWN	        0
++#define FUSE_DT_FIFO		1
++#define FUSE_DT_CHR		2
++#define FUSE_DT_DIR		4
++#define FUSE_DT_BLK		6
++#define FUSE_DT_REG		8
++#define FUSE_DT_LNK		10
++#define FUSE_DT_SOCK		12
++#define FUSE_DT_WHT		14
++
++#define FUSE_NAME_OFFSET ((unsigned int) ((struct fuse_dirent *) 0)->name)
++#define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(long) - 1) & ~(sizeof(long) - 1))
++#define FUSE_DIRENT_SIZE(d) \
++	FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
++#pragma pack()
++
++/* 
++ * Local Variables:
++ * indent-tabs-mode: t
++ * c-basic-offset: 8
++ * End:
++ */
+diff -urN a/include/linux/cooperative_internal.h b/include/linux/cooperative_internal.h
+--- a/include/linux/cooperative_internal.h
++++ b/include/linux/cooperative_internal.h
+@@ -0,0 +1,80 @@
++/*
++ *  linux/include/linux/cooperative.h
++ *
++ *  Copyright (C) 2004 Dan Aloni
++ *
++ *  This header gathers the functions and variables in Cooperative Mode 
++ *  when CONFIG_COOPERATIVE is defined.
++ */
++#ifndef __LINUX_COOPERATIVE_LINUX_H__
++#define __LINUX_COOPERATIVE_LINUX_H__
++
++#include <linux/config.h>
++#include <linux/cooperative.h>
++#include <linux/list.h>
++
++#ifdef CONFIG_COOPERATIVE
++
++typedef struct {
++	struct list_head node;
++	co_message_t msg;
++} co_message_node_t;
++
++extern void co_debug(const char *fmt, ...);
++extern void co_printk(const char *line);
++
++extern void co_callback(unsigned long flags);
++extern void co_switch_wrapper(void);
++extern void co_idle_processor(void);
++extern void co_terminate(co_termination_reason_t reason);
++extern void co_free_pages(unsigned long vaddr, int order);
++extern int co_alloc_pages(unsigned long vaddr, int order);
++extern void co_start_kernel(void);
++extern void co_arch_start_kernel(void);
++extern void co_handle_jiffies(long count);
++
++extern void co_send_message(co_module_t from, 
++			    co_module_t to,
++			    co_priority_t priority,
++			    co_message_type_t type,
++			    unsigned long size,
++			    const char *data);
++extern unsigned long co_get_host_time(void);
++extern co_message_t *co_send_message_save(unsigned long *flags);
++extern co_message_t *co_get_message_save(unsigned long *flags);
++extern void co_send_message_restore(unsigned long flags);
++
++extern void cocd_interrupt(void);
++
++extern void co_handle_incoming_messages(void);
++extern void co_handle_incoming_message(co_message_node_t *message);
++extern void co_queue_incoming_message(co_message_node_t *message);
++extern int co_get_message(co_message_node_t **message, co_device_t device);
++extern void co_free_message(co_message_node_t *message);
++
++extern int co_passage_page_held(void);
++extern void co_passage_page_acquire(unsigned long *flags);
++extern void co_passage_page_release(unsigned long flags);
++
++#define co_passage_page_assert_valid() do {	\
++	if (co_passage_page_held())		\
++            BUG();				\
++} while (0);
++
++extern char co_boot_parameters[CO_BOOTPARAM_STRING_LENGTH];
++extern unsigned long co_core_end;
++extern unsigned long co_memory_size;
++extern void *co_initrd;
++extern unsigned long co_initrd_size;
++
++#define cooperative_mode_enabled()     1
++
++#else
++
++#define co_printk(line)                do {} while (0)
++#define co_terminate(reason)           do {} while (0)
++#define cooperative_mode_enabled()     0
++
++#endif
++
++#endif
+diff -urN a/include/linux/major.h b/include/linux/major.h
+--- a/include/linux/major.h
++++ b/include/linux/major.h
+@@ -130,6 +130,7 @@
+ #define VIOCD_MAJOR		113
+ 
+ #define ATARAID_MAJOR		114
++#define COLINUX_MAJOR		117
+ 
+ #define SCSI_DISK8_MAJOR	128
+ #define SCSI_DISK9_MAJOR	129
+diff -urN a/init/do_mounts.c b/init/do_mounts.c
+--- a/init/do_mounts.c
++++ b/init/do_mounts.c
+@@ -175,6 +175,7 @@
+ 	for (p = s; *p; p++)
+ 		if (*p == '/')
+ 			*p = '!';
++
+ 	res = try_name(s, 0);
+ 	if (res)
+ 		goto done;
+diff -urN a/init/main.c b/init/main.c
+--- a/init/main.c
++++ b/init/main.c
+@@ -537,6 +537,7 @@
+ 		panic(panic_later, panic_param);
+ 	profile_init();
+ 	local_irq_enable();
++
+ #ifdef CONFIG_BLK_DEV_INITRD
+ 	if (initrd_start && !initrd_below_start_ok &&
+ 			initrd_start < min_low_pfn << PAGE_SHIFT) {
+diff -urN a/kernel/Makefile b/kernel/Makefile
+--- a/kernel/Makefile
++++ b/kernel/Makefile
+@@ -26,6 +26,7 @@
+ obj-$(CONFIG_KPROBES) += kprobes.o
+ obj-$(CONFIG_SYSFS) += ksysfs.o
+ obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
++obj-$(CONFIG_COOPERATIVE) += cooperative.o
+ 
+ ifneq ($(CONFIG_IA64),y)
+ # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
+diff -urN a/kernel/cooperative.c b/kernel/cooperative.c
+--- a/kernel/cooperative.c
++++ b/kernel/cooperative.c
+@@ -0,0 +1,354 @@
++/*
++ *  linux/kernel/cooperative.c
++ *
++ *  Cooperative mode (coLinux) support routines.
++ *
++ *  Dan Aloni <da-x@colinux.org>, 2003-2004 (C).
++ *
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/string.h>
++#include <linux/interrupt.h>
++#include <linux/mm.h>
++#include <linux/slab.h>
++#include <linux/cooperative_internal.h>
++
++CO_TRACE_STOP;
++
++void start_kernel(void);
++extern char _kernel_start, _end;
++
++
++unsigned long co_core_end = 0;
++unsigned long co_memory_size = 0;
++void *co_initrd = NULL;
++unsigned long co_initrd_size = 0;
++char co_boot_parameters[CO_BOOTPARAM_STRING_LENGTH];
++
++
++typedef struct {
++	struct list_head list;
++	int num_messages;
++} co_message_queue_t;
++
++int co_messages_active = 0;
++co_message_queue_t co_outgoing_messages;
++co_message_queue_t co_incoming_messages;
++co_message_queue_t *co_incoming_queued_messages;
++
++void co_start_kernel(void)
++{
++        co_core_end = co_passage_page->params[0];
++        co_memory_size = co_passage_page->params[1];
++        co_initrd = (void *)co_passage_page->params[2];
++        co_initrd_size = co_passage_page->params[3];
++
++        memcpy(co_boot_parameters, &co_passage_page->params[10], 
++               sizeof(co_boot_parameters));
++
++	co_arch_start_kernel();
++
++	/* should never be reached */
++	co_terminate(CO_TERMINATE_END);
++}
++
++co_message_t *co_send_message_save(unsigned long *flags)
++{
++	co_passage_page_assert_valid();	
++	co_passage_page_acquire(flags);
++	co_passage_page->operation = CO_OPERATION_MESSAGE_TO_MONITOR;
++	return ((co_message_t *)CO_VPTR_IO_AREA_START);
++}
++
++void co_send_message_restore(unsigned long flags)
++{
++	co_switch_wrapper();
++	co_passage_page_release(flags);
++}
++
++void co_send_message_s(co_message_t *message, const char *data)
++{
++	if ((sizeof(co_message_t) + message->size) > CO_VPTR_IO_AREA_SIZE)
++		return;
++	
++	if (co_passage_page_held())
++		return;
++	
++	unsigned long flags;
++	co_message_t *buffer = ((co_message_t *)CO_VPTR_IO_AREA_START);
++	
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_MESSAGE_TO_MONITOR;
++	*buffer = *message;
++	memcpy(buffer->data, data, message->size);
++	co_switch_wrapper();
++	co_passage_page_release(flags);
++}
++
++void co_send_message(co_module_t from, 
++		     co_module_t to,
++		     co_priority_t priority,
++		     co_message_type_t type,
++		     unsigned long size,
++		     const char *data)
++{
++	co_message_t params;
++
++	params.from = from;
++	params.to = to;
++	params.priority = priority;
++	params.type = type;
++	params.size = size;
++
++	co_send_message_s(&params, data);
++}
++
++static void co_message_add_to_incoming(co_message_t *message, unsigned long size)
++{
++	co_message_node_t *message_copy;
++
++	message_copy = kmalloc(size + sizeof(co_message_node_t) - sizeof(co_message_t), 
++			       GFP_ATOMIC);
++	if (!message_copy)
++		return;
++	
++	memcpy(&message_copy->msg, message, size);
++	list_add_tail(&message_copy->node, &co_incoming_messages.list);
++}
++
++void co_callback(unsigned long flags)
++{
++	if (co_passage_page->operation != CO_OPERATION_MESSAGE_FROM_MONITOR) {
++		co_passage_page_release(flags);
++		return;
++	}
++
++	long io_size = co_passage_page->params[0];
++	unsigned long new_jiffies = co_passage_page->params[1];
++
++	if (co_messages_active  &&  io_size > 0) {
++		unsigned char *io_buffer = (char *)CO_VPTR_IO_AREA_START;
++		unsigned char *io_buffer_end = io_buffer + io_size;
++		if (!(io_size > CO_VPTR_IO_AREA_SIZE)) {
++			while (io_buffer < io_buffer_end) {
++				co_message_t *message = (co_message_t *)io_buffer;
++				unsigned long size = message->size + sizeof(*message);
++				
++				co_message_add_to_incoming(message, size);
++				io_buffer += size;
++			}
++		}
++	}
++
++	co_passage_page_release(flags);
++
++	co_handle_jiffies(new_jiffies);
++	co_handle_incoming_messages();
++}
++
++void co_handle_incoming_messages(void)
++{
++	if (!co_messages_active)
++		return;
++
++	if (list_empty(&co_incoming_messages.list))
++		return;
++
++	for (;;) {
++		unsigned long flags;
++		co_message_node_t *message = NULL;
++
++		/*
++		 * Pop a message from the incoming queue.
++		 */
++		local_irq_save(flags);
++		if (!list_empty(&co_incoming_messages.list)) {
++			message = list_entry(co_incoming_messages.list.next, 
++					     co_message_node_t, node);
++			list_del(&message->node);
++		}
++		local_irq_restore(flags);
++
++		if (!message)
++			break;
++		
++		/*
++		 * Let the interrupt routine of the arch dependant code
++		 * handle the message, and be responsible to free it.
++		 */
++		co_handle_incoming_message(message);
++	}
++}
++
++void co_idle_processor(void)
++{
++	unsigned long flags;
++
++	co_passage_page_assert_valid();	
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_IDLE;
++	co_switch_wrapper();
++	co_callback(flags);
++}
++
++void co_printk(const char *line)
++{
++	co_send_message(CO_MODULE_LINUX, 
++			CO_MODULE_PRINTK,
++			CO_PRIORITY_DISCARDABLE,
++			CO_MESSAGE_TYPE_STRING,
++			strlen(line)+1,
++			line);
++}
++
++void co_debug_line(char *line)
++{
++}
++
++void co_terminate(co_termination_reason_t reason)
++{
++	unsigned long flags;
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_TERMINATE;
++	co_passage_page->params[0] = reason;
++	co_switch_wrapper();
++	/* This doesn't really return. This code shouldn't be running. */
++	co_passage_page_release(flags);
++}
++
++unsigned long co_get_host_time(void)
++{
++	unsigned long flags;
++	unsigned long time;
++
++	co_passage_page_assert_valid();
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_GET_TIME;
++	co_switch_wrapper();
++	time = co_passage_page->params[0];
++	co_passage_page_release(flags);
++
++	return time;
++}
++
++void co_queue_incoming_message(co_message_node_t *node_message)
++{
++	if (!co_messages_active)
++		return;
++	
++	co_linux_message_t *message = (co_linux_message_t *)&node_message->msg.data;
++	if (message->device < 0 || (message->device >= CO_DEVICES_TOTAL))
++		return;
++	
++	co_message_queue_t *queue;
++	queue = &co_incoming_queued_messages[message->device];
++
++	/* Add to the queue */
++	unsigned long flags;
++	local_irq_save(flags);
++	list_add(&node_message->node, &queue->list);
++	queue->num_messages++;
++	local_irq_restore(flags);
++}
++
++int co_get_message(co_message_node_t **message, co_device_t device)
++{
++	co_message_queue_t *queue;
++	co_message_node_t *node;
++	unsigned long flags;
++
++	if (!co_messages_active)
++		return 0;
++
++	local_irq_save(flags);
++	queue = &co_incoming_queued_messages[device];
++	if (list_empty(&queue->list)) {
++		local_irq_restore(flags);
++		return 0;
++	}
++
++	node = list_entry(queue->list.prev, co_message_node_t, node);
++	list_del(&node->node);
++	queue->num_messages--;
++	local_irq_restore(flags);
++
++	*message = node;
++	return 1;
++}
++
++void co_free_message(co_message_node_t *message)
++{
++	kfree(message);
++}
++
++co_info_t co_info = {
++	.api_version = CO_LINUX_API_VERSION,
++	.compiler_major = __GNUC__,
++	.compiler_minor = __GNUC_MINOR__,
++};
++
++static int __init initcall_message_queues(void)
++{
++	int queue_index;
++
++	INIT_LIST_HEAD(&co_outgoing_messages.list);
++	INIT_LIST_HEAD(&co_incoming_messages.list);
++
++	co_incoming_queued_messages = kmalloc(sizeof(co_message_queue_t) * CO_DEVICES_TOTAL, 
++					      GFP_KERNEL);
++	if (!co_incoming_queued_messages)
++		panic("unable to allocate message queues\n");
++
++	for (queue_index=0; queue_index < CO_DEVICES_TOTAL; queue_index++) {
++		co_message_queue_t *queue = &co_incoming_queued_messages[queue_index];
++		queue->num_messages = 0;
++		INIT_LIST_HEAD(&queue->list);
++	}
++
++	co_messages_active = 1;
++
++	return 0;
++}
++
++
++void co_free_pages(unsigned long vaddr, int order)
++{
++	unsigned long flags;
++	
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_FREE_PAGES;
++	co_passage_page->params[0] = vaddr;
++	co_passage_page->params[1] = order;
++	co_switch_wrapper();
++	co_passage_page_release(flags);
++}
++
++int co_alloc_pages(unsigned long vaddr, int order)
++{
++	unsigned long flags;
++	long result;
++
++	co_passage_page_acquire(&flags);
++	co_passage_page->operation = CO_OPERATION_ALLOC_PAGES;
++	co_passage_page->params[0] = vaddr;
++	co_passage_page->params[1] = order;
++	co_switch_wrapper();
++	result = (long)co_passage_page->params[4];
++	co_passage_page_release(flags);
++
++	if (result < 0)
++		return -ENOMEM;
++
++	return 0;
++}
++
++__initcall(initcall_message_queues);
++
++EXPORT_SYMBOL(co_terminate);
++
++CO_TRACE_CONTINUE;
+diff -urN a/kernel/panic.c b/kernel/panic.c
+--- a/kernel/panic.c
++++ b/kernel/panic.c
+@@ -18,6 +18,7 @@
+ #include <linux/sysrq.h>
+ #include <linux/interrupt.h>
+ #include <linux/nmi.h>
++#include <linux/cooperative_internal.h>
+ 
+ int panic_timeout;
+ int panic_on_oops;
+@@ -71,6 +72,10 @@
+ 	printk(KERN_EMERG "Kernel panic - not syncing: %s\n",buf);
+ 	bust_spinlocks(0);
+ 
++	if (cooperative_mode_enabled()) {
++		co_terminate(CO_TERMINATE_PANIC);
++	}
++
+ #ifdef CONFIG_SMP
+ 	smp_send_stop();
+ #endif
+diff -urN a/kernel/printk.c b/kernel/printk.c
+--- a/kernel/printk.c
++++ b/kernel/printk.c
+@@ -34,6 +34,8 @@
+ 
+ #include <asm/uaccess.h>
+ 
++#include <linux/cooperative_internal.h>
++
+ #define __LOG_BUF_LEN	(1 << CONFIG_LOG_BUF_SHIFT)
+ 
+ /* printk's without a loglevel use this.. */
+@@ -538,6 +540,8 @@
+ 	/* Emit the output into the temporary buffer */
+ 	printed_len = vscnprintf(printk_buf, sizeof(printk_buf), fmt, args);
+ 
++	co_printk(printk_buf);
++
+ 	/*
+ 	 * Copy the output into log_buf.  If the caller didn't provide
+ 	 * appropriate log level tags, we insert them here
+diff -urN a/localversion-cooperative b/localversion-cooperative
+--- a/localversion-cooperative
++++ b/localversion-cooperative
+@@ -0,0 +1 @@
++-co-
+diff -urN a/mm/bootmem.c b/mm/bootmem.c
+--- a/mm/bootmem.c
++++ b/mm/bootmem.c
+@@ -17,6 +17,7 @@
+ #include <linux/bootmem.h>
+ #include <linux/mmzone.h>
+ #include <linux/module.h>
++#include <linux/cooperative_internal.h>
+ #include <asm/dma.h>
+ #include <asm/io.h>
+ 
+@@ -248,6 +249,23 @@
+ 	for (i = start; i < start+areasize; i++)
+ 		if (unlikely(test_and_set_bit(i, bdata->node_bootmem_map)))
+ 			BUG();
++
++	if (cooperative_mode_enabled()) {
++		unsigned long alloc_address = (unsigned long)ret;
++		unsigned long alloc_size = size;
++		int result;
++
++		alloc_size += (alloc_address & (~PAGE_MASK));
++		alloc_address &= PAGE_MASK;
++		alloc_size = (alloc_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
++
++		result = co_alloc_pages(alloc_address, alloc_size);
++		if (result) {
++			free_bootmem((unsigned long)ret, size);
++			return NULL;
++		}
++	}
++
+ 	memset(ret, 0, size);
+ 	return ret;
+ }
+diff -urN a/mm/page_alloc.c b/mm/page_alloc.c
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -32,7 +32,7 @@
+ #include <linux/sysctl.h>
+ #include <linux/cpu.h>
+ #include <linux/nodemask.h>
+-
++#include <linux/cooperative_internal.h>
+ #include <asm/tlbflush.h>
+ 
+ nodemask_t node_online_map = NODE_MASK_NONE;
+@@ -184,6 +184,9 @@
+ {
+ 	unsigned long page_idx, index, mask;
+ 
++	if (cooperative_mode_enabled())
++		co_free_pages((unsigned long)page_address(page), 1 << order);
++
+ 	if (order)
+ 		destroy_compound_page(page, order);
+ 	mask = (~0UL) << order;
+@@ -738,6 +741,37 @@
+ got_pg:
+ 	zone_statistics(zonelist, z);
+ 	kernel_map_pages(page, 1 << order, 1);
++
++	if (cooperative_mode_enabled()) {
++		int result, retries_left;
++
++		retries_left = 10;
++
++		while (retries_left > 0) {
++			result = co_alloc_pages((unsigned long)page_address(page), 1 << order);
++			if (result) {
++				unsigned long cache_size;
++				/* 
++				 * Whoops, we have allocated too much of the
++				 * host OS's memory, time to free some cache.
++				 * cache.
++				 */
++				cache_size = get_page_cache_size()-total_swapcache_pages;
++				cache_size /= 2;
++				if (cache_size < ((1 << order)*2))
++					cache_size = (1 << order)*2;
++				shrink_all_memory(cache_size);
++			} else
++				break;
++			retries_left--;
++		}
++
++		if (result) {
++			__free_pages(page, order);
++			return NULL;
++		}
++	}
++
+ 	return page;
+ }
+ 
+diff -urN a/mm/vmscan.c b/mm/vmscan.c
+--- a/mm/vmscan.c
++++ b/mm/vmscan.c
+@@ -1180,7 +1180,7 @@
+ 	wake_up_interruptible(&zone->zone_pgdat->kswapd_wait);
+ }
+ 
+-#ifdef CONFIG_PM
++#if defined(CONFIG_PM) || defined(CONFIG_COOPERATIVE)
+ /*
+  * Try to free `nr_pages' of memory, system-wide.  Returns the number of freed
+  * pages.
author	Denys Dmytriyenko <denis@denix.org>	2009-03-17 14:32:59 -0400
committer	Denys Dmytriyenko <denis@denix.org>	2009-03-17 14:32:59 -0400
commit	709c4d66e0b107ca606941b988bad717c0b45d9b (patch)
tree	37ee08b1eb308f3b2b6426d5793545c38396b838 /recipes/linux/linux-colinux-2.6.10/colinux-0.6.2.patch
parent	fa6cd5a3b993f16c27de4ff82b42684516d433ba (diff)