Yet another 4GB split patch

@@ -106,11 +106,12 @@ static inline int do_getname(const char 
 	int retval;
 	unsigned long len = PATH_MAX;
 
-	if ((unsigned long) filename >= TASK_SIZE) {
-		if (!segment_eq(get_fs(), KERNEL_DS))
+	if (!segment_eq(get_fs(), KERNEL_DS)) {
+		if ((unsigned long) filename >= TASK_SIZE)
 			return -EFAULT;
-	} else if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
-		len = TASK_SIZE - (unsigned long) filename;
+		if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
+			len = TASK_SIZE - (unsigned long) filename;
+	}
 
 	retval = strncpy_from_user((char *)page, filename, len);
 	if (retval > 0) {

@@ -436,6 +436,13 @@ sys_init_module(const char *name_user, s
 		printk(KERN_ERR "init_module: mod->cleanup out of bounds.\n");
 		goto err2;
 	}
+#ifdef CONFIG_4GB
+	/* indirect_xxx uaccess functions don't generate exception entries */
+	if (mod->ex_table_start || mod->ex_table_end) {
+		printk(KERN_ERR "init_module: not 4GB kernel module\n");
+		goto err2;
+	}
+#endif
 	if (mod->ex_table_start > mod->ex_table_end
 	    || (mod->ex_table_start &&
 		!((unsigned long)mod->ex_table_start >= ((unsigned long)mod + mod->size_of_struct)

@@ -402,7 +402,8 @@ void zap_page_range(struct mm_struct *mm
 /*
  * Do a quick page-table lookup for a single page. 
  */
-static struct page * follow_page(struct mm_struct *mm, unsigned long address, int write) 
+struct page * follow_page(struct mm_struct *mm, unsigned long address,
+		int write) 
 {
 	pgd_t *pgd;
 	pmd_t *pmd;

@@ -422,6 +423,15 @@ static struct page * follow_page(struct 
 
 	pte = *ptep;
 	if (pte_present(pte)) {
+#ifdef CONFIG_4GB
+		/*
+		 * this condition enables us to omit access_ok() checks in
+		 * indirect_XXX user access routines. i.e. we check here
+		 * (instead of access_ok()) that we try to access user pages.
+		 */
+		if (unlikely(!pte_user(pte)))
+			return 0;
+#endif
 		if (!write ||
 		    (pte_write(pte) && pte_dirty(pte)))
 			return pte_page(pte);

@@ -502,6 +502,8 @@ extern int ptrace_detach(struct task_str
 extern void ptrace_disable(struct task_struct *);
 extern int ptrace_check_attach(struct task_struct *task, int kill);
 
+struct page * follow_page(struct mm_struct *mm, unsigned long address,
+		int write);
 int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
 		int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
 

120 lines not on this page · raw message

146 lines not on this page · raw message

@@ -7,6 +7,7 @@ enum km_type {
 	KM_SKB_DATA_SOFTIRQ,
 	KM_USER0,
 	KM_USER1,
+	KM_USER_COPY,
 	KM_BH_IRQ,
 	KM_SOFTIRQ0,
 	KM_SOFTIRQ1,

@@ -37,8 +37,12 @@ static inline void switch_mm(struct mm_s
 		cpu_tlbstate[cpu].active_mm = next;
 #endif
 		set_bit(cpu, &next->cpu_vm_mask);
+#ifndef CONFIG_4GB
 		/* Re-load page tables */
 		load_cr3(next->pgd);
+#else
+		/* %cr3 is reloaded on returning to user space, see entry.S */
+#endif
 	 	/* load_LDT, if either the previous or next thread
 		 * has a non-default LDT.
 		 */

@@ -54,7 +58,11 @@ static inline void switch_mm(struct mm_s
 			/* We were in lazy tlb mode and leave_mm disabled 
 			 * tlb flush IPI delivery. We must reload %cr3.
 			 */
+#ifndef CONFIG_4GB
 			load_cr3(next->pgd);
+#else
+			local_flush_tlb();
+#endif
 			load_LDT(&next->context);
 		}
 	}

@@ -78,13 +78,18 @@ typedef struct { unsigned long pgprot; }
  * and CONFIG_HIGHMEM64G options in the kernel configuration.
  */
 
-#define __PAGE_OFFSET		(0xC0000000)
+#include <asm/page_offset.h>
+#define __PAGE_OFFSET          PAGE_OFFSET_RAW
 
 /*
  * This much address space is reserved for vmalloc() and iomap()
  * as well as fixmap mappings.
  */
+#ifndef CONFIG_4GB
 #define __VMALLOC_RESERVE	(128 << 20)
+#else
+#define __VMALLOC_RESERVE	(512 << 20)
+#endif
 
 #ifndef __ASSEMBLY__
 

@@ -0,0 +1,27 @@
+#ifndef __PAGE_OFFSET_H__
+#define __PAGE_OFFSET_H__
+
+#include <linux/config.h>
+
+#if   defined(CONFIG_1GB)
+#define PAGE_OFFSET_RAW 0xC0000000
+#elif defined(CONFIG_2GB)
+#define PAGE_OFFSET_RAW 0x80000000
+#elif defined(CONFIG_3GB)
+#define PAGE_OFFSET_RAW 0x40000000
+#elif defined(CONFIG_4GB)
+
+/*
+ * PAGE_OFFSET_RAW can be as low as 32Mb
+ * 4 pgds (32 Mb) are required when PAE pgd is initialized
+ */
+#define PAGE_OFFSET_RAW 0x02000000
+/*
+ * default value 0xffc00000 means the highest pgd in non-PAE kernel
+ * and the last pmd-1 in PAE-enabled kernel
+ */
+#define SPLIT_4GB_MAP_START 0xffc00000
+
+#endif
+
+#endif

@@ -158,7 +158,14 @@ extern void pgtable_cache_init(void);
  * area for the same reason. ;)
  */
 #define VMALLOC_OFFSET	(8*1024*1024)
-#define VMALLOC_START	(((unsigned long) high_memory + 2*VMALLOC_OFFSET-1) & \
+#ifdef CONFIG_4GB
+/* vmalloc has to be higher than TASK_SIZE for ldt mappings */
+#define __VMALLOC_START (((unsigned long)high_memory > TASK_SIZE) ? \
+		(unsigned long)high_memory : TASK_SIZE)
+#else
+#define __VMALLOC_START ((unsigned long)high_memory)
+#endif
+#define VMALLOC_START	((__VMALLOC_START + 2*VMALLOC_OFFSET-1) & \
 						~(VMALLOC_OFFSET-1))
 #define VMALLOC_VMADDR(x) ((unsigned long)(x))
 #if CONFIG_HIGHMEM

@@ -213,9 +220,9 @@ extern void pgtable_cache_init(void);
 	(_PAGE_PRESENT | _PAGE_DIRTY | _PAGE_ACCESSED)
 
 #ifdef CONFIG_X86_PGE
-# define MAKE_GLOBAL(x) __pgprot((x) | _PAGE_GLOBAL)
+# define _MAKE_GLOBAL(x) __pgprot((x) | _PAGE_GLOBAL)
 #else
-# define MAKE_GLOBAL(x)						\
+# define _MAKE_GLOBAL(x)						\
 	({							\
 		pgprot_t __ret;					\
 								\

@@ -227,6 +234,13 @@ extern void pgtable_cache_init(void);
 	})
 #endif
 
+#ifdef CONFIG_4GB
+/* global pages are not allowed when 4Gb kernel/user space split is used */
+#define MAKE_GLOBAL(x) __pgprot(x)
+#else
+#define MAKE_GLOBAL(x) _MAKE_GLOBAL(x)
+#endif
+
 #define PAGE_KERNEL MAKE_GLOBAL(__PAGE_KERNEL)
 #define PAGE_KERNEL_RO MAKE_GLOBAL(__PAGE_KERNEL_RO)
 #define PAGE_KERNEL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_NOCACHE)

@@ -279,6 +293,7 @@ extern unsigned long pg0[1024];
  * The following only work if pte_present() is true.
  * Undefined behaviour if not..
  */
+static inline int pte_user(pte_t pte)		{ return (pte).pte_low & _PAGE_USER; }
 static inline int pte_read(pte_t pte)		{ return (pte).pte_low & _PAGE_USER; }
 static inline int pte_exec(pte_t pte)		{ return (pte).pte_low & _PAGE_USER; }
 static inline int pte_dirty(pte_t pte)		{ return (pte).pte_low & _PAGE_DIRTY; }

@@ -324,7 +339,7 @@ static inline pte_t pte_modify(pte_t pte
 ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
 
 /* to find an entry in a page-table-directory. */
-#define pgd_index(address) ((address >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
+#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
 
 #define __pgd_offset(address) pgd_index(address)
 

@@ -259,7 +259,15 @@ extern unsigned int mca_pentium_flag;
 /*
  * User space process size: 3GB (default).
  */
+#ifdef CONFIG_4GB
+/*
+ * For 4gb split we explicitly set task size to 3Gb,
+ * since PAGE_OFFSET means kernel offset here
+ */
+#define TASK_SIZE	(0xC0000000)
+#else
 #define TASK_SIZE	(PAGE_OFFSET)
+#endif
 
 /* This decides where the kernel will search for a free chunk of vm
  * space during mmap's.

@@ -363,6 +371,13 @@ struct thread_struct {
 	unsigned long	esp;
 	unsigned long	fs;
 	unsigned long	gs;
+#ifdef CONFIG_4GB
+	unsigned long	utask;		/* U-space task_struct */
+	unsigned long	ktask;		/* kernel mapped task */
+	unsigned long	reloaddbg;	/* db regs should be reloaded on ret
+					   to user? see do_debug(), entry.S */
+	unsigned long	cr3;		/* user space cr3 value */
+#endif
 /* Hardware debugging registers */
 	unsigned long	debugreg[8];  /* %%db0-7 debug registers */
 /* fault info */

@@ -378,9 +393,18 @@ struct thread_struct {
 	unsigned long	io_bitmap[IO_BITMAP_SIZE+1];
 };
 
+#ifdef CONFIG_4GB
+#define INIT_SPLIT_4GB_THREAD_REGS				\
+	0, (unsigned long)&init_task, 0,			\
+	(unsigned long)&swapper_pg_dir - PAGE_OFFSET, /* cr3 */
+#else
+#define INIT_SPLIT_4GB_THREAD_REGS
+#endif
+
 #define INIT_THREAD  {						\
 	0,							\
 	0, 0, 0, 0, 						\
+	INIT_SPLIT_4GB_THREAD_REGS				\
 	{ [0 ... 7] = 0 },	/* debugging registers */	\
 	0, 0, 0,						\
 	{ { 0, }, },		/* 387 state */			\

@@ -62,6 +62,34 @@ __asm__ __volatile__(
 return dest;
 }
 
+/*
+ * This is a more generic variant of strncpy_count() suitable for
+ * implementing string-access routines with all sorts of return
+ * code semantics. It's used by arch/i386/mm/usercopy.c.
+ *
+ * strncpy_count returns num of bytes left = (count-strlen(src)), i.e.
+ * count=0, strlen(src)=#,   res=0
+ * count=n, strlen(src)=m<n, res=n-m (0 is not counted, but copied!)
+ * count=n, strlen(src)=n-1, res=1
+ * count=n, strlen(src)=n,   res=0
+ */
+static inline size_t strncpy_count(char * dest,const char *src,size_t count)
+{
+	__asm__ __volatile__(
+	"1:\tdecl %0\n\t"
+	"js 2f\n\t"
+	"lodsb\n\t"
+	"stosb\n\t"
+	"testb %%al,%%al\n\t"
+	"jne 1b\n\t"
+	"2:"
+	"incl %0"
+	: "=c" (count)
+	:"S" (src),"D" (dest),"0" (count) : "memory");
+
+	return count;
+}
+
 #define __HAVE_ARCH_STRCAT
 static inline char * strcat(char * dest,const char * src)
 {

215 lines not on this page · raw message

@@ -46,7 +46,7 @@ extern void kmap_init(void) __init;
  * easily, subsequent pte tables have to be allocated in one physical
  * chunk of RAM.
  */
-#define PKMAP_BASE (0xff800000UL)
+#define PKMAP_BASE (0xff400000UL)
 #ifdef CONFIG_X86_PAE
 #define LAST_PKMAP 512
 #else

@@ -17,13 +17,11 @@ search_one_table(const struct exception_
 {
         while (first <= last) {
 		const struct exception_table_entry *mid;
-		long diff;
 
 		mid = (last - first) / 2 + first;
-		diff = mid->insn - value;
-                if (diff == 0)
+		if (mid->insn == value)
                         return mid->fixup;
-                else if (diff < 0)
+		else if (mid->insn < value)
                         first = mid+1;
                 else
                         last = mid-1;

@@ -60,3 +58,33 @@ search_exception_table(unsigned long add
 	return ret;
 #endif
 }
+
+#ifdef CONFIG_4GB
+void __init extable_init(void)
+{
+	struct exception_table_entry *first =
+		(struct exception_table_entry *)__start___ex_table;
+	struct exception_table_entry *last =
+		(struct exception_table_entry *)__stop___ex_table - 1;
+	struct exception_table_entry *entry;
+	struct exception_table_entry tmp;
+	int chg = 1;
+
+	printk("Sorting kernel __ex_table entries... ");
+
+	/* simple n^2 sort algo */
+	while(chg) {
+		chg = 0;
+		for (entry = first; entry < last; entry++)
+			if (entry->insn > (entry+1)->insn) {
+				/* swap entries */
+				tmp = *entry;
+				*entry = *(entry+1);
+				*(entry+1) = tmp;
+				chg = 1;
+			}
+	}
+
+	printk("done.\n");
+}
+#endif

@@ -379,7 +379,13 @@ vmalloc_fault:
 		pmd_t *pmd, *pmd_k;
 		pte_t *pte_k;
 
+#ifdef CONFIG_4GB
+		if (!current->mm)
+			goto no_context;
+		pgd = (pgd_t *)__pa(current->mm->pgd);
+#else
 		asm("movl %%cr3,%0":"=r" (pgd));
+#endif
 		pgd = offset + (pgd_t *)__va(pgd);
 		pgd_k = init_mm.pgd + offset;
 

183 lines not on this page · raw message

@@ -2,6 +2,7 @@
  * FIXME: old compatibility stuff, will be removed soon.
  */
 
+#include <linux/config.h>
 #include <net/checksum.h>
 
 unsigned int csum_partial_copy( const char *src, char *dst, int len, int sum)

@@ -16,4 +17,39 @@ unsigned int csum_partial_copy( const ch
 	return sum;
 }
 
+#ifdef CONFIG_4GB
+unsigned int
+csum_partial_copy_generic( const char *src, char *dst, int len, int sum,
+	int *src_err_ptr, int *dst_err_ptr)
+{
+	if ((!src_err_ptr) && (!dst_err_ptr)) {
+		/* csum_partial_copy_nocheck case */
+		sum = csum_partial(src, len, sum);
+		memcpy(dst, src, len);
+		return sum;
+	} else if ((src_err_ptr) && (!dst_err_ptr)) {
+		/* csum_partial_copy_from_user */
+		/* copied from mips code */
+		int missing = copy_from_user(dst, src, len);
+		if (missing) {
+			memset(dst + len - missing, 0, missing);
+			*src_err_ptr = -EFAULT;
+		}
+		return csum_partial(dst, len, sum);
+	} else if ((!src_err_ptr) && (dst_err_ptr)) {
+		/* csum_and_copy_to_user */
+		/* csum_partial_copy_to_user */
+		/* copied from mips code */
+		sum = csum_partial(src, len, sum);
+		if (copy_to_user(dst, src, len))
+			*dst_err_ptr = -EFAULT;
+		return sum;
+	} else {
+		/* csum_partial_copy case */
+		sum = csum_partial(src, len, sum);
+		memcpy(dst, src, len);
+		return sum;
+	}
+}
+#endif /* CONFIG_4GB */
 

283 lines not on this page · raw message

@@ -92,21 +92,29 @@ EXPORT_SYMBOL(__udelay);
 EXPORT_SYMBOL(__delay);
 EXPORT_SYMBOL(__const_udelay);
 
+#ifndef CONFIG_4GB
 EXPORT_SYMBOL_NOVERS(__get_user_1);
 EXPORT_SYMBOL_NOVERS(__get_user_2);
 EXPORT_SYMBOL_NOVERS(__get_user_4);
+#endif
 
 EXPORT_SYMBOL(strtok);
 EXPORT_SYMBOL(strpbrk);
 EXPORT_SYMBOL(strstr);
 
-EXPORT_SYMBOL(strncpy_from_user);
-EXPORT_SYMBOL(__strncpy_from_user);
-EXPORT_SYMBOL(clear_user);
-EXPORT_SYMBOL(__clear_user);
+EXPORT_SYMBOL(direct_strncpy_from_user);
+EXPORT_SYMBOL(__direct_strncpy_from_user);
+EXPORT_SYMBOL(direct_clear_user);
+EXPORT_SYMBOL(__direct_clear_user);
 EXPORT_SYMBOL(__generic_copy_from_user);
 EXPORT_SYMBOL(__generic_copy_to_user);
-EXPORT_SYMBOL(strnlen_user);
+EXPORT_SYMBOL(direct_strnlen_user);
+
+EXPORT_SYMBOL(indirect_get_user_size);
+EXPORT_SYMBOL(indirect_put_user_size);
+EXPORT_SYMBOL(indirect_clear_user_size);
+EXPORT_SYMBOL(indirect_strncpy_from_user_size);
+EXPORT_SYMBOL(indirect_strnlen_user_size);
 
 EXPORT_SYMBOL(pci_alloc_consistent);
 EXPORT_SYMBOL(pci_free_consistent);

@@ -251,6 +251,7 @@ void set_fpu_mxcsr( struct task_struct *
 static inline int convert_fxsr_to_user( struct _fpstate *buf,
 					struct i387_fxsave_struct *fxsave )
 {
+	struct _fpreg tmp[8];		/* temporary storage */
 	unsigned long env[7];
 	struct _fpreg *to;
 	struct _fpxreg *from;

@@ -267,18 +268,25 @@ static inline int convert_fxsr_to_user( 
 	if ( __copy_to_user( buf, env, 7 * sizeof(unsigned long) ) )
 		return 1;
 
-	to = &buf->_st[0];
+	to = tmp;
 	from = (struct _fpxreg *) &fxsave->st_space[0];
 	for ( i = 0 ; i < 8 ; i++, to++, from++ ) {
-		if ( __copy_to_user( to, from, sizeof(*to) ) )
-			return 1;
+		unsigned long *t = (unsigned long *)to;
+		unsigned long *f = (unsigned long *)from;
+
+		*t = *f;
+		*(t+1) = *(f+1);
+		to->exponent = from->exponent;
 	}
+	if (copy_to_user(buf->_st, tmp, sizeof(tmp)))
+		return 1;
 	return 0;
 }
 
 static inline int convert_fxsr_from_user( struct i387_fxsave_struct *fxsave,
 					  struct _fpstate *buf )
 {
+	struct _fpreg tmp[8];		/* temporary storage */
 	unsigned long env[7];
 	struct _fpxreg *to;
 	struct _fpreg *from;

@@ -286,6 +294,8 @@ static inline int convert_fxsr_from_user
 
 	if ( __copy_from_user( env, buf, 7 * sizeof(long) ) )
 		return 1;
+	if (copy_from_user(tmp, buf->_st, sizeof(struct _fpreg [8])))
+		return 1;
 
 	fxsave->cwd = (unsigned short)(env[0] & 0xffff);
 	fxsave->swd = (unsigned short)(env[1] & 0xffff);

@@ -297,10 +307,14 @@ static inline int convert_fxsr_from_user
 	fxsave->fos = env[6];
 
 	to = (struct _fpxreg *) &fxsave->st_space[0];
-	from = &buf->_st[0];
+	from = tmp;
 	for ( i = 0 ; i < 8 ; i++, to++, from++ ) {
-		if ( __copy_from_user( to, from, sizeof(*from) ) )
-			return 1;
+		unsigned long *t = (unsigned long *)to;
+		unsigned long *f = (unsigned long *)from;
+
+		*t = *f;
+		*(t+1) = *(f+1);
+		to->exponent = from->exponent;
 	}
 	return 0;
 }

@@ -22,6 +22,7 @@
 #include <asm/delay.h>
 #include <asm/desc.h>
 #include <asm/apic.h>
+#include <asm/offset.h>
 
 #include <linux/irq.h>
 

@@ -29,5 +29,11 @@ union task_union init_task_union 
  * section. Since TSS's are completely CPU-local, we want them
  * on exact cacheline boundaries, to eliminate cacheline ping-pong.
  */ 
-struct tss_struct init_tss[NR_CPUS] __cacheline_aligned = { [0 ... NR_CPUS-1] = INIT_TSS };
+struct tss_struct init_tss[NR_CPUS] 
+#ifdef CONFIG_4GB
+	__attribute__((__section__(".data.tss")))
+#else
+	__cacheline_aligned
+#endif
+	= { [0 ... NR_CPUS-1] = INIT_TSS };
 

@@ -5,6 +5,7 @@
  * Copyright (C) 1999 Ingo Molnar <[email protected]>
  */
 
+#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/string.h>

@@ -37,10 +38,14 @@ static int alloc_ldt(mm_context_t *pc, i
 		return 0;
 	oldsize = pc->size;
 	mincount = (mincount+511)&(~511);
+#ifdef CONFIG_4GB
+	newldt = vmalloc(mincount*LDT_ENTRY_SIZE);
+#else
 	if (mincount*LDT_ENTRY_SIZE > PAGE_SIZE)
 		newldt = vmalloc(mincount*LDT_ENTRY_SIZE);
 	else
 		newldt = kmalloc(mincount*LDT_ENTRY_SIZE, GFP_KERNEL);
+#endif
 
 	if (!newldt)
 		return -ENOMEM;

@@ -62,10 +67,14 @@ static int alloc_ldt(mm_context_t *pc, i
 	}
 	wmb();
 	if (oldsize) {
+#ifdef CONFIG_4GB
+		vfree(oldldt);
+#else
 		if (oldsize*LDT_ENTRY_SIZE > PAGE_SIZE)
 			vfree(oldldt);
 		else
 			kfree(oldldt);
+#endif
 	}
 	return 0;
 }

@@ -110,10 +119,14 @@ int init_new_context(struct task_struct 
 void destroy_context(struct mm_struct *mm)
 {
 	if (mm->context.size) {
+#ifdef CONFIG_4GB
+		vfree(mm->context.ldt);
+#else
 		if (mm->context.size*LDT_ENTRY_SIZE > PAGE_SIZE)
 			vfree(mm->context.ldt);
 		else
 			kfree(mm->context.ldt);
+#endif
 		mm->context.size = 0;
 	}
 }

117 lines not on this page · raw message

@@ -48,7 +48,13 @@ static inline int get_stack_long(struct 
 {
 	unsigned char *stack;
 
+#ifdef CONFIG_4GB
+	/* esp0 points to U-space mapped stack, stack=addr in K-space */
+	stack = (unsigned char *)task +
+		(task->thread.esp0 - task->thread.utask);
+#else
 	stack = (unsigned char *)task->thread.esp0;
+#endif
 	stack += offset;
 	return (*((int *)stack));
 }

@@ -64,7 +70,13 @@ static inline int put_stack_long(struct 
 {
 	unsigned char * stack;
 
+#ifdef CONFIG_4GB
+	/* esp0 points to U-space mapped stack, stack=addr in K-space */
+	stack = (unsigned char *)task +
+		(task->thread.esp0 - task->thread.utask);
+#else
 	stack = (unsigned char *) task->thread.esp0;
+#endif
 	stack += offset;
 	*(unsigned long *) stack = data;
 	return 0;

143 lines not on this page · raw message

@@ -46,6 +46,7 @@
 #include <asm/mtrr.h>
 #include <asm/pgalloc.h>
 #include <asm/smpboot.h>
+#include <asm/desc.h>
 
 /* Set if we find a B stepping CPU			*/
 static int smp_b_stepping;

@@ -309,7 +309,9 @@ static void inline leave_mm (unsigned lo
 {
 	BUG_ON(cpu_tlbstate[cpu].state == TLBSTATE_OK);
 	clear_bit(cpu, &cpu_tlbstate[cpu].active_mm->cpu_vm_mask);
+#ifndef CONFIG_4GB
 	load_cr3(swapper_pg_dir);
+#endif
 }
 
 /*

154 lines not on this page · raw message

@@ -30,6 +30,7 @@
  *   
  */
 
+#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>

@@ -278,7 +279,12 @@ static void do_sys_vm86(struct kernel_vm
 	info->regs32->eax = 0;
 	tsk->thread.saved_esp0 = tsk->thread.esp0;
 	tss = init_tss + smp_processor_id();
+#ifdef CONFIG_4GB
+	tss->esp0 = tsk->thread.esp0 = tsk->thread.utask +
+		((unsigned long)&info->VM86_TSS_ESP0 & (THREAD_SIZE-1));
+#else /* CONFIG_4GB */
 	tss->esp0 = tsk->thread.esp0 = (unsigned long) &info->VM86_TSS_ESP0;
+#endif /* CONFIG_4GB */
 
 	tsk->thread.screen_bitmap = info->screen_bitmap;
 	if (info->flags & VM86_SCREEN_BITMAP)

89 lines not on this page · raw message