uml: bump to 3.18
authorNicolas Thill <nico@openwrt.org>
Sun, 22 Mar 2015 12:36:57 +0000 (12:36 +0000)
committerNicolas Thill <nico@openwrt.org>
Sun, 22 Mar 2015 12:36:57 +0000 (12:36 +0000)
Signed-off-by: Nicolas Thill <nico@openwrt.org>
SVN-Revision: 44937

target/linux/uml/Makefile
target/linux/uml/config/x86_64
target/linux/uml/patches-3.18/001-fix_make_headers_install.patch [new file with mode: 0644]
target/linux/uml/patches-3.18/101-mconsole-exec.patch [new file with mode: 0644]
target/linux/uml/patches-3.18/102-pseudo-random-mac.patch [new file with mode: 0644]

index eb4fed11e9d28c289bcb50041c772a4712af43a2..ab077036a38b2b8c4b20611e8c343efeb47dc5d2 100644 (file)
@@ -23,7 +23,7 @@ BOARDNAME:=User Mode Linux
 FEATURES:=ext4 audio
 MAINTAINER:=Florian Fainelli <florian@openwrt.org>
 
-KERNEL_PATCHVER:=3.14
+KERNEL_PATCHVER:=3.18
 
 include $(INCLUDE_DIR)/target.mk
 
index 203ba4b05c3a7105ca3b64440b6eb1706bbaee7d..d23612ea05be21e90439f4bd30803a03d64d9021 100644 (file)
@@ -21,6 +21,8 @@ CONFIG_CRYPTO_HASH=y
 CONFIG_CRYPTO_HASH2=y
 # CONFIG_CRYPTO_SALSA20_X86_64 is not set
 CONFIG_CRYPTO_SHA1=y
+# CONFIG_CRYPTO_SKEIN is not set
+# CONFIG_CRYPTO_THREEFISH is not set
 # CONFIG_CRYPTO_TWOFISH_X86_64 is not set
 CONFIG_DEBUG_BUGVERBOSE=y
 CONFIG_DEBUG_MEMORY_INIT=y
@@ -135,6 +137,7 @@ CONFIG_UML_RANDOM=y
 CONFIG_UML_SOUND=m
 CONFIG_UML_WATCHDOG=m
 CONFIG_UML_X86=y
+# CONFIG_UNISYSSPAR is not set
 # CONFIG_USB_ARCH_HAS_EHCI is not set
 # CONFIG_USB_ARCH_HAS_OHCI is not set
 # CONFIG_USB_ARCH_HAS_XHCI is not set
diff --git a/target/linux/uml/patches-3.18/001-fix_make_headers_install.patch b/target/linux/uml/patches-3.18/001-fix_make_headers_install.patch
new file mode 100644 (file)
index 0000000..f6bef02
--- /dev/null
@@ -0,0 +1,3932 @@
+From 5eac4d66049ab7d14a2b7311610c8cb85a2c1bf1 Mon Sep 17 00:00:00 2001
+From: Nicolas Thill <nico@openwrt.org>
+Date: Fri, 20 Mar 2015 00:31:06 +0100
+Subject: [PATCH] UM: fix make headers_install after UAPI header installation
+
+Signed-off-by: Nicolas Thill <nico@openwrt.org>
+---
+From faec6b6c2cc0219e74569c13f581fc11d8f3fc57 Mon Sep 17 00:00:00 2001
+From: Florian Fainelli <florian@openwrt.org>
+Date: Sun, 17 Mar 2013 20:12:10 +0100
+Subject: [PATCH] UM: fix make headers_install after UAPI header installation
+
+Commit 10b63956 (UAPI: Plumb the UAPI Kbuilds into the user
+header installation and checking) breaks UML make headers_install with
+the following:
+
+$ ARCH=um make headers_install
+  CHK     include/generated/uapi/linux/version.h
+  UPD     include/generated/uapi/linux/version.h
+  HOSTCC  scripts/basic/fixdep
+  WRAP    arch/um/include/generated/asm/bug.h
+[snip]
+  WRAP    arch/um/include/generated/asm/trace_clock.h
+  SYSHDR  arch/x86/syscalls/../include/generated/uapi/asm/unistd_32.h
+  SYSHDR  arch/x86/syscalls/../include/generated/uapi/asm/unistd_64.h
+  SYSHDR  arch/x86/syscalls/../include/generated/uapi/asm/unistd_x32.h
+  SYSTBL  arch/x86/syscalls/../include/generated/asm/syscalls_32.h
+  HOSTCC  scripts/unifdef
+Makefile:912: *** Headers not exportable for the um architecture.  Stop.
+zsh: exit 2     ARCH=um make headers_install
+
+The reason for that is because the top-level Makefile does the
+following:
+        $(if $(wildcard $(srctree)/arch/$(hdr-arch)/include/uapi/asm/Kbuild),, \
+          $(error Headers not exportable for the $(SRCARCH) architecture))
+
+we end-up in the else part of the $(if) statement because UML still uses
+the old path in arch/um/include/asm/Kbuild. This patch fixes the issue
+by moving the header files to be in arch/um/include/uapi/asm/ thus
+making headers_install (and other make targets checking for uapi) to
+succeed.
+
+Signed-off-by: Florian Fainelli <florian@openwrt.org>
+---
+Richard, this has been broken for 3.7+ onwards, if you want me to send
+you separate patches for 3.7 and 3.8 let me know. Thanks!
+
+--- a/arch/um/include/asm/Kbuild
++++ /dev/null
+@@ -1,30 +0,0 @@
+-generic-y += barrier.h
+-generic-y += bug.h
+-generic-y += clkdev.h
+-generic-y += cputime.h
+-generic-y += current.h
+-generic-y += delay.h
+-generic-y += device.h
+-generic-y += emergency-restart.h
+-generic-y += exec.h
+-generic-y += ftrace.h
+-generic-y += futex.h
+-generic-y += hardirq.h
+-generic-y += hash.h
+-generic-y += hw_irq.h
+-generic-y += io.h
+-generic-y += irq_regs.h
+-generic-y += irq_work.h
+-generic-y += kdebug.h
+-generic-y += mcs_spinlock.h
+-generic-y += mutex.h
+-generic-y += param.h
+-generic-y += pci.h
+-generic-y += percpu.h
+-generic-y += preempt.h
+-generic-y += scatterlist.h
+-generic-y += sections.h
+-generic-y += switch_to.h
+-generic-y += topology.h
+-generic-y += trace_clock.h
+-generic-y += xor.h
+--- a/arch/um/include/asm/a.out-core.h
++++ /dev/null
+@@ -1,27 +0,0 @@
+-/* a.out coredump register dumper
+- *
+- * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
+- * Written by David Howells (dhowells@redhat.com)
+- *
+- * This program is free software; you can redistribute it and/or
+- * modify it under the terms of the GNU General Public Licence
+- * as published by the Free Software Foundation; either version
+- * 2 of the Licence, or (at your option) any later version.
+- */
+-
+-#ifndef __UM_A_OUT_CORE_H
+-#define __UM_A_OUT_CORE_H
+-
+-#ifdef __KERNEL__
+-
+-#include <linux/user.h>
+-
+-/*
+- * fill in the user structure for an a.out core dump
+- */
+-static inline void aout_dump_thread(struct pt_regs *regs, struct user *u)
+-{
+-}
+-
+-#endif /* __KERNEL__ */
+-#endif /* __UM_A_OUT_CORE_H */
+--- a/arch/um/include/asm/bugs.h
++++ /dev/null
+@@ -1,6 +0,0 @@
+-#ifndef __UM_BUGS_H
+-#define __UM_BUGS_H
+-
+-void check_bugs(void);
+-
+-#endif
+--- a/arch/um/include/asm/cache.h
++++ /dev/null
+@@ -1,17 +0,0 @@
+-#ifndef __UM_CACHE_H
+-#define __UM_CACHE_H
+-
+-
+-#if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
+-# define L1_CACHE_SHIFT               (CONFIG_X86_L1_CACHE_SHIFT)
+-#elif defined(CONFIG_UML_X86) /* 64-bit */
+-# define L1_CACHE_SHIFT               6 /* Should be 7 on Intel */
+-#else
+-/* XXX: this was taken from x86, now it's completely random. Luckily only
+- * affects SMP padding. */
+-# define L1_CACHE_SHIFT               5
+-#endif
+-
+-#define L1_CACHE_BYTES                (1 << L1_CACHE_SHIFT)
+-
+-#endif
+--- a/arch/um/include/asm/common.lds.S
++++ /dev/null
+@@ -1,107 +0,0 @@
+-#include <asm-generic/vmlinux.lds.h>
+-
+-  .fini      : { *(.fini)    } =0x9090
+-  _etext = .;
+-  PROVIDE (etext = .);
+-
+-  . = ALIGN(4096);
+-  _sdata = .;
+-  PROVIDE (sdata = .);
+-
+-  RODATA
+-
+-  .unprotected : { *(.unprotected) }
+-  . = ALIGN(4096);
+-  PROVIDE (_unprotected_end = .);
+-
+-  . = ALIGN(4096);
+-  .note : { *(.note.*) }
+-  EXCEPTION_TABLE(0)
+-
+-  BUG_TABLE
+-
+-  .uml.setup.init : {
+-      __uml_setup_start = .;
+-      *(.uml.setup.init)
+-      __uml_setup_end = .;
+-  }
+-      
+-  .uml.help.init : {
+-      __uml_help_start = .;
+-      *(.uml.help.init)
+-      __uml_help_end = .;
+-  }
+-      
+-  .uml.postsetup.init : {
+-      __uml_postsetup_start = .;
+-      *(.uml.postsetup.init)
+-      __uml_postsetup_end = .;
+-  }
+-      
+-  .init.setup : {
+-      INIT_SETUP(0)
+-  }
+-
+-  PERCPU_SECTION(32)
+-      
+-  .initcall.init : {
+-      INIT_CALLS
+-  }
+-
+-  .con_initcall.init : {
+-      CON_INITCALL
+-  }
+-
+-  .uml.initcall.init : {
+-      __uml_initcall_start = .;
+-      *(.uml.initcall.init)
+-      __uml_initcall_end = .;
+-  }
+-
+-  SECURITY_INIT
+-
+-  .exitcall : {
+-      __exitcall_begin = .;
+-      *(.exitcall.exit)
+-      __exitcall_end = .;
+-  }
+-
+-  .uml.exitcall : {
+-      __uml_exitcall_begin = .;
+-      *(.uml.exitcall.exit)
+-      __uml_exitcall_end = .;
+-  }
+-
+-  . = ALIGN(4);
+-  .altinstructions : {
+-      __alt_instructions = .;
+-      *(.altinstructions)
+-      __alt_instructions_end = .;
+-  }
+-  .altinstr_replacement : { *(.altinstr_replacement) }
+-  /* .exit.text is discard at runtime, not link time, to deal with references
+-     from .altinstructions and .eh_frame */
+-  .exit.text : { *(.exit.text) }
+-  .exit.data : { *(.exit.data) }
+-
+-  .preinit_array : {
+-      __preinit_array_start = .;
+-      *(.preinit_array)
+-      __preinit_array_end = .;
+-  }
+-  .init_array : {
+-      __init_array_start = .;
+-      *(.init_array)
+-      __init_array_end = .;
+-  }
+-  .fini_array : {
+-      __fini_array_start = .;
+-      *(.fini_array)
+-      __fini_array_end = .;
+-  }
+-
+-   . = ALIGN(4096);
+-  .init.ramfs : {
+-      INIT_RAM_FS
+-  }
+-
+--- a/arch/um/include/asm/dma.h
++++ /dev/null
+@@ -1,10 +0,0 @@
+-#ifndef __UM_DMA_H
+-#define __UM_DMA_H
+-
+-#include <asm/io.h>
+-
+-extern unsigned long uml_physmem;
+-
+-#define MAX_DMA_ADDRESS (uml_physmem)
+-
+-#endif
+--- a/arch/um/include/asm/fixmap.h
++++ /dev/null
+@@ -1,60 +0,0 @@
+-#ifndef __UM_FIXMAP_H
+-#define __UM_FIXMAP_H
+-
+-#include <asm/processor.h>
+-#include <asm/kmap_types.h>
+-#include <asm/archparam.h>
+-#include <asm/page.h>
+-#include <linux/threads.h>
+-
+-/*
+- * Here we define all the compile-time 'special' virtual
+- * addresses. The point is to have a constant address at
+- * compile time, but to set the physical address only
+- * in the boot process. We allocate these special  addresses
+- * from the end of virtual memory (0xfffff000) backwards.
+- * Also this lets us do fail-safe vmalloc(), we
+- * can guarantee that these special addresses and
+- * vmalloc()-ed addresses never overlap.
+- *
+- * these 'compile-time allocated' memory buffers are
+- * fixed-size 4k pages. (or larger if used with an increment
+- * highger than 1) use fixmap_set(idx,phys) to associate
+- * physical memory with fixmap indices.
+- *
+- * TLB entries of such buffers will not be flushed across
+- * task switches.
+- */
+-
+-/*
+- * on UP currently we will have no trace of the fixmap mechanizm,
+- * no page table allocations, etc. This might change in the
+- * future, say framebuffers for the console driver(s) could be
+- * fix-mapped?
+- */
+-enum fixed_addresses {
+-#ifdef CONFIG_HIGHMEM
+-      FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */
+-      FIX_KMAP_END = FIX_KMAP_BEGIN+(KM_TYPE_NR*NR_CPUS)-1,
+-#endif
+-      __end_of_fixed_addresses
+-};
+-
+-extern void __set_fixmap (enum fixed_addresses idx,
+-                        unsigned long phys, pgprot_t flags);
+-
+-/*
+- * used by vmalloc.c.
+- *
+- * Leave one empty page between vmalloc'ed areas and
+- * the start of the fixmap, and leave one page empty
+- * at the top of mem..
+- */
+-
+-#define FIXADDR_TOP   (TASK_SIZE - 2 * PAGE_SIZE)
+-#define FIXADDR_SIZE  (__end_of_fixed_addresses << PAGE_SHIFT)
+-#define FIXADDR_START (FIXADDR_TOP - FIXADDR_SIZE)
+-
+-#include <asm-generic/fixmap.h>
+-
+-#endif
+--- a/arch/um/include/asm/irq.h
++++ /dev/null
+@@ -1,23 +0,0 @@
+-#ifndef __UM_IRQ_H
+-#define __UM_IRQ_H
+-
+-#define TIMER_IRQ             0
+-#define UMN_IRQ                       1
+-#define CONSOLE_IRQ           2
+-#define CONSOLE_WRITE_IRQ     3
+-#define UBD_IRQ                       4
+-#define UM_ETH_IRQ            5
+-#define SSL_IRQ                       6
+-#define SSL_WRITE_IRQ         7
+-#define ACCEPT_IRQ            8
+-#define MCONSOLE_IRQ          9
+-#define WINCH_IRQ             10
+-#define SIGIO_WRITE_IRQ       11
+-#define TELNETD_IRQ           12
+-#define XTERM_IRQ             13
+-#define RANDOM_IRQ            14
+-
+-#define LAST_IRQ RANDOM_IRQ
+-#define NR_IRQS (LAST_IRQ + 1)
+-
+-#endif
+--- a/arch/um/include/asm/irqflags.h
++++ /dev/null
+@@ -1,42 +0,0 @@
+-#ifndef __UM_IRQFLAGS_H
+-#define __UM_IRQFLAGS_H
+-
+-extern int get_signals(void);
+-extern int set_signals(int enable);
+-extern void block_signals(void);
+-extern void unblock_signals(void);
+-
+-static inline unsigned long arch_local_save_flags(void)
+-{
+-      return get_signals();
+-}
+-
+-static inline void arch_local_irq_restore(unsigned long flags)
+-{
+-      set_signals(flags);
+-}
+-
+-static inline void arch_local_irq_enable(void)
+-{
+-      unblock_signals();
+-}
+-
+-static inline void arch_local_irq_disable(void)
+-{
+-      block_signals();
+-}
+-
+-static inline unsigned long arch_local_irq_save(void)
+-{
+-      unsigned long flags;
+-      flags = arch_local_save_flags();
+-      arch_local_irq_disable();
+-      return flags;
+-}
+-
+-static inline bool arch_irqs_disabled(void)
+-{
+-      return arch_local_save_flags() == 0;
+-}
+-
+-#endif
+--- a/arch/um/include/asm/kmap_types.h
++++ /dev/null
+@@ -1,13 +0,0 @@
+-/* 
+- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_KMAP_TYPES_H
+-#define __UM_KMAP_TYPES_H
+-
+-/* No more #include "asm/arch/kmap_types.h" ! */
+-
+-#define KM_TYPE_NR 14
+-
+-#endif
+--- a/arch/um/include/asm/kvm_para.h
++++ /dev/null
+@@ -1 +0,0 @@
+-#include <asm-generic/kvm_para.h>
+--- a/arch/um/include/asm/mmu.h
++++ /dev/null
+@@ -1,24 +0,0 @@
+-/* 
+- * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+- * Licensed under the GPL
+- */
+-
+-#ifndef __ARCH_UM_MMU_H
+-#define __ARCH_UM_MMU_H
+-
+-#include <mm_id.h>
+-#include <asm/mm_context.h>
+-
+-typedef struct mm_context {
+-      struct mm_id id;
+-      struct uml_arch_mm_context arch;
+-      struct page *stub_pages[2];
+-} mm_context_t;
+-
+-extern void __switch_mm(struct mm_id * mm_idp);
+-
+-/* Avoid tangled inclusion with asm/ldt.h */
+-extern long init_new_ldt(struct mm_context *to_mm, struct mm_context *from_mm);
+-extern void free_ldt(struct mm_context *mm);
+-
+-#endif
+--- a/arch/um/include/asm/mmu_context.h
++++ /dev/null
+@@ -1,58 +0,0 @@
+-/* 
+- * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_MMU_CONTEXT_H
+-#define __UM_MMU_CONTEXT_H
+-
+-#include <linux/sched.h>
+-#include <asm/mmu.h>
+-
+-extern void uml_setup_stubs(struct mm_struct *mm);
+-extern void arch_exit_mmap(struct mm_struct *mm);
+-
+-#define deactivate_mm(tsk,mm) do { } while (0)
+-
+-extern void force_flush_all(void);
+-
+-static inline void activate_mm(struct mm_struct *old, struct mm_struct *new)
+-{
+-      /*
+-       * This is called by fs/exec.c and sys_unshare()
+-       * when the new ->mm is used for the first time.
+-       */
+-      __switch_mm(&new->context.id);
+-      down_write(&new->mmap_sem);
+-      uml_setup_stubs(new);
+-      up_write(&new->mmap_sem);
+-}
+-
+-static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, 
+-                           struct task_struct *tsk)
+-{
+-      unsigned cpu = smp_processor_id();
+-
+-      if(prev != next){
+-              cpumask_clear_cpu(cpu, mm_cpumask(prev));
+-              cpumask_set_cpu(cpu, mm_cpumask(next));
+-              if(next != &init_mm)
+-                      __switch_mm(&next->context.id);
+-      }
+-}
+-
+-static inline void arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
+-{
+-      uml_setup_stubs(mm);
+-}
+-
+-static inline void enter_lazy_tlb(struct mm_struct *mm, 
+-                                struct task_struct *tsk)
+-{
+-}
+-
+-extern int init_new_context(struct task_struct *task, struct mm_struct *mm);
+-
+-extern void destroy_context(struct mm_struct *mm);
+-
+-#endif
+--- a/arch/um/include/asm/page.h
++++ /dev/null
+@@ -1,127 +0,0 @@
+-/*
+- * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+- * Copyright 2003 PathScale, Inc.
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_PAGE_H
+-#define __UM_PAGE_H
+-
+-#include <linux/const.h>
+-
+-/* PAGE_SHIFT determines the page size */
+-#define PAGE_SHIFT    12
+-#define PAGE_SIZE     (_AC(1, UL) << PAGE_SHIFT)
+-#define PAGE_MASK     (~(PAGE_SIZE-1))
+-
+-#ifndef __ASSEMBLY__
+-
+-struct page;
+-
+-#include <linux/types.h>
+-#include <asm/vm-flags.h>
+-
+-/*
+- * These are used to make use of C type-checking..
+- */
+-
+-#define clear_page(page)      memset((void *)(page), 0, PAGE_SIZE)
+-#define copy_page(to,from)    memcpy((void *)(to), (void *)(from), PAGE_SIZE)
+-
+-#define clear_user_page(page, vaddr, pg)      clear_page(page)
+-#define copy_user_page(to, from, vaddr, pg)   copy_page(to, from)
+-
+-#if defined(CONFIG_3_LEVEL_PGTABLES) && !defined(CONFIG_64BIT)
+-
+-typedef struct { unsigned long pte_low, pte_high; } pte_t;
+-typedef struct { unsigned long pmd; } pmd_t;
+-typedef struct { unsigned long pgd; } pgd_t;
+-#define pte_val(x) ((x).pte_low | ((unsigned long long) (x).pte_high << 32))
+-
+-#define pte_get_bits(pte, bits) ((pte).pte_low & (bits))
+-#define pte_set_bits(pte, bits) ((pte).pte_low |= (bits))
+-#define pte_clear_bits(pte, bits) ((pte).pte_low &= ~(bits))
+-#define pte_copy(to, from) ({ (to).pte_high = (from).pte_high; \
+-                            smp_wmb(); \
+-                            (to).pte_low = (from).pte_low; })
+-#define pte_is_zero(pte) (!((pte).pte_low & ~_PAGE_NEWPAGE) && !(pte).pte_high)
+-#define pte_set_val(pte, phys, prot) \
+-      ({ (pte).pte_high = (phys) >> 32; \
+-         (pte).pte_low = (phys) | pgprot_val(prot); })
+-
+-#define pmd_val(x)    ((x).pmd)
+-#define __pmd(x) ((pmd_t) { (x) } )
+-
+-typedef unsigned long long pfn_t;
+-typedef unsigned long long phys_t;
+-
+-#else
+-
+-typedef struct { unsigned long pte; } pte_t;
+-typedef struct { unsigned long pgd; } pgd_t;
+-
+-#ifdef CONFIG_3_LEVEL_PGTABLES
+-typedef struct { unsigned long pmd; } pmd_t;
+-#define pmd_val(x)    ((x).pmd)
+-#define __pmd(x) ((pmd_t) { (x) } )
+-#endif
+-
+-#define pte_val(x)    ((x).pte)
+-
+-
+-#define pte_get_bits(p, bits) ((p).pte & (bits))
+-#define pte_set_bits(p, bits) ((p).pte |= (bits))
+-#define pte_clear_bits(p, bits) ((p).pte &= ~(bits))
+-#define pte_copy(to, from) ((to).pte = (from).pte)
+-#define pte_is_zero(p) (!((p).pte & ~_PAGE_NEWPAGE))
+-#define pte_set_val(p, phys, prot) (p).pte = (phys | pgprot_val(prot))
+-
+-typedef unsigned long pfn_t;
+-typedef unsigned long phys_t;
+-
+-#endif
+-
+-typedef struct { unsigned long pgprot; } pgprot_t;
+-
+-typedef struct page *pgtable_t;
+-
+-#define pgd_val(x)    ((x).pgd)
+-#define pgprot_val(x) ((x).pgprot)
+-
+-#define __pte(x) ((pte_t) { (x) } )
+-#define __pgd(x) ((pgd_t) { (x) } )
+-#define __pgprot(x)   ((pgprot_t) { (x) } )
+-
+-extern unsigned long uml_physmem;
+-
+-#define PAGE_OFFSET (uml_physmem)
+-#define KERNELBASE PAGE_OFFSET
+-
+-#define __va_space (8*1024*1024)
+-
+-#include <mem.h>
+-
+-/* Cast to unsigned long before casting to void * to avoid a warning from
+- * mmap_kmem about cutting a long long down to a void *.  Not sure that
+- * casting is the right thing, but 32-bit UML can't have 64-bit virtual
+- * addresses
+- */
+-#define __pa(virt) to_phys((void *) (unsigned long) (virt))
+-#define __va(phys) to_virt((unsigned long) (phys))
+-
+-#define phys_to_pfn(p) ((pfn_t) ((p) >> PAGE_SHIFT))
+-#define pfn_to_phys(pfn) ((phys_t) ((pfn) << PAGE_SHIFT))
+-
+-#define pfn_valid(pfn) ((pfn) < max_mapnr)
+-#define virt_addr_valid(v) pfn_valid(phys_to_pfn(__pa(v)))
+-
+-#include <asm-generic/memory_model.h>
+-#include <asm-generic/getorder.h>
+-
+-#endif        /* __ASSEMBLY__ */
+-
+-#ifdef CONFIG_X86_32
+-#define __HAVE_ARCH_GATE_AREA 1
+-#endif
+-
+-#endif        /* __UM_PAGE_H */
+--- a/arch/um/include/asm/pgalloc.h
++++ /dev/null
+@@ -1,61 +0,0 @@
+-/* 
+- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+- * Copyright 2003 PathScale, Inc.
+- * Derived from include/asm-i386/pgalloc.h and include/asm-i386/pgtable.h
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_PGALLOC_H
+-#define __UM_PGALLOC_H
+-
+-#include <linux/mm.h>
+-
+-#define pmd_populate_kernel(mm, pmd, pte) \
+-      set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) __pa(pte)))
+-
+-#define pmd_populate(mm, pmd, pte)                            \
+-      set_pmd(pmd, __pmd(_PAGE_TABLE +                        \
+-              ((unsigned long long)page_to_pfn(pte) <<        \
+-                      (unsigned long long) PAGE_SHIFT)))
+-#define pmd_pgtable(pmd) pmd_page(pmd)
+-
+-/*
+- * Allocate and free page tables.
+- */
+-extern pgd_t *pgd_alloc(struct mm_struct *);
+-extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
+-
+-extern pte_t *pte_alloc_one_kernel(struct mm_struct *, unsigned long);
+-extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
+-
+-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
+-{
+-      free_page((unsigned long) pte);
+-}
+-
+-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
+-{
+-      pgtable_page_dtor(pte);
+-      __free_page(pte);
+-}
+-
+-#define __pte_free_tlb(tlb,pte, address)              \
+-do {                                                  \
+-      pgtable_page_dtor(pte);                         \
+-      tlb_remove_page((tlb),(pte));                   \
+-} while (0)
+-
+-#ifdef CONFIG_3_LEVEL_PGTABLES
+-
+-static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
+-{
+-      free_page((unsigned long)pmd);
+-}
+-
+-#define __pmd_free_tlb(tlb,x, address)   tlb_remove_page((tlb),virt_to_page(x))
+-#endif
+-
+-#define check_pgt_cache()     do { } while (0)
+-
+-#endif
+-
+--- a/arch/um/include/asm/pgtable-2level.h
++++ /dev/null
+@@ -1,53 +0,0 @@
+-/*
+- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+- * Copyright 2003 PathScale, Inc.
+- * Derived from include/asm-i386/pgtable.h
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_PGTABLE_2LEVEL_H
+-#define __UM_PGTABLE_2LEVEL_H
+-
+-#include <asm-generic/pgtable-nopmd.h>
+-
+-/* PGDIR_SHIFT determines what a third-level page table entry can map */
+-
+-#define PGDIR_SHIFT   22
+-#define PGDIR_SIZE    (1UL << PGDIR_SHIFT)
+-#define PGDIR_MASK    (~(PGDIR_SIZE-1))
+-
+-/*
+- * entries per page directory level: the i386 is two-level, so
+- * we don't really have any PMD directory physically.
+- */
+-#define PTRS_PER_PTE  1024
+-#define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
+-#define PTRS_PER_PGD  1024
+-#define FIRST_USER_ADDRESS    0
+-
+-#define pte_ERROR(e) \
+-        printk("%s:%d: bad pte %p(%08lx).\n", __FILE__, __LINE__, &(e), \
+-             pte_val(e))
+-#define pgd_ERROR(e) \
+-        printk("%s:%d: bad pgd %p(%08lx).\n", __FILE__, __LINE__, &(e), \
+-             pgd_val(e))
+-
+-static inline int pgd_newpage(pgd_t pgd)      { return 0; }
+-static inline void pgd_mkuptodate(pgd_t pgd)  { }
+-
+-#define set_pmd(pmdptr, pmdval) (*(pmdptr) = (pmdval))
+-
+-#define pte_pfn(x) phys_to_pfn(pte_val(x))
+-#define pfn_pte(pfn, prot) __pte(pfn_to_phys(pfn) | pgprot_val(prot))
+-#define pfn_pmd(pfn, prot) __pmd(pfn_to_phys(pfn) | pgprot_val(prot))
+-
+-/*
+- * Bits 0 through 4 are taken
+- */
+-#define PTE_FILE_MAX_BITS     27
+-
+-#define pte_to_pgoff(pte) (pte_val(pte) >> 5)
+-
+-#define pgoff_to_pte(off) ((pte_t) { ((off) << 5) + _PAGE_FILE })
+-
+-#endif
+--- a/arch/um/include/asm/pgtable-3level.h
++++ /dev/null
+@@ -1,136 +0,0 @@
+-/*
+- * Copyright 2003 PathScale Inc
+- * Derived from include/asm-i386/pgtable.h
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_PGTABLE_3LEVEL_H
+-#define __UM_PGTABLE_3LEVEL_H
+-
+-#include <asm-generic/pgtable-nopud.h>
+-
+-/* PGDIR_SHIFT determines what a third-level page table entry can map */
+-
+-#ifdef CONFIG_64BIT
+-#define PGDIR_SHIFT   30
+-#else
+-#define PGDIR_SHIFT   31
+-#endif
+-#define PGDIR_SIZE    (1UL << PGDIR_SHIFT)
+-#define PGDIR_MASK    (~(PGDIR_SIZE-1))
+-
+-/* PMD_SHIFT determines the size of the area a second-level page table can
+- * map
+- */
+-
+-#define PMD_SHIFT     21
+-#define PMD_SIZE      (1UL << PMD_SHIFT)
+-#define PMD_MASK      (~(PMD_SIZE-1))
+-
+-/*
+- * entries per page directory level
+- */
+-
+-#define PTRS_PER_PTE 512
+-#ifdef CONFIG_64BIT
+-#define PTRS_PER_PMD 512
+-#define PTRS_PER_PGD 512
+-#else
+-#define PTRS_PER_PMD 1024
+-#define PTRS_PER_PGD 1024
+-#endif
+-
+-#define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
+-#define FIRST_USER_ADDRESS    0
+-
+-#define pte_ERROR(e) \
+-        printk("%s:%d: bad pte %p(%016lx).\n", __FILE__, __LINE__, &(e), \
+-             pte_val(e))
+-#define pmd_ERROR(e) \
+-        printk("%s:%d: bad pmd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
+-             pmd_val(e))
+-#define pgd_ERROR(e) \
+-        printk("%s:%d: bad pgd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
+-             pgd_val(e))
+-
+-#define pud_none(x)   (!(pud_val(x) & ~_PAGE_NEWPAGE))
+-#define       pud_bad(x)      ((pud_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
+-#define pud_present(x)        (pud_val(x) & _PAGE_PRESENT)
+-#define pud_populate(mm, pud, pmd) \
+-      set_pud(pud, __pud(_PAGE_TABLE + __pa(pmd)))
+-
+-#ifdef CONFIG_64BIT
+-#define set_pud(pudptr, pudval) set_64bit((u64 *) (pudptr), pud_val(pudval))
+-#else
+-#define set_pud(pudptr, pudval) (*(pudptr) = (pudval))
+-#endif
+-
+-static inline int pgd_newpage(pgd_t pgd)
+-{
+-      return(pgd_val(pgd) & _PAGE_NEWPAGE);
+-}
+-
+-static inline void pgd_mkuptodate(pgd_t pgd) { pgd_val(pgd) &= ~_PAGE_NEWPAGE; }
+-
+-#ifdef CONFIG_64BIT
+-#define set_pmd(pmdptr, pmdval) set_64bit((u64 *) (pmdptr), pmd_val(pmdval))
+-#else
+-#define set_pmd(pmdptr, pmdval) (*(pmdptr) = (pmdval))
+-#endif
+-
+-struct mm_struct;
+-extern pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address);
+-
+-static inline void pud_clear (pud_t *pud)
+-{
+-      set_pud(pud, __pud(_PAGE_NEWPAGE));
+-}
+-
+-#define pud_page(pud) phys_to_page(pud_val(pud) & PAGE_MASK)
+-#define pud_page_vaddr(pud) ((unsigned long) __va(pud_val(pud) & PAGE_MASK))
+-
+-/* Find an entry in the second-level page table.. */
+-#define pmd_offset(pud, address) ((pmd_t *) pud_page_vaddr(*(pud)) + \
+-                      pmd_index(address))
+-
+-static inline unsigned long pte_pfn(pte_t pte)
+-{
+-      return phys_to_pfn(pte_val(pte));
+-}
+-
+-static inline pte_t pfn_pte(pfn_t page_nr, pgprot_t pgprot)
+-{
+-      pte_t pte;
+-      phys_t phys = pfn_to_phys(page_nr);
+-
+-      pte_set_val(pte, phys, pgprot);
+-      return pte;
+-}
+-
+-static inline pmd_t pfn_pmd(pfn_t page_nr, pgprot_t pgprot)
+-{
+-      return __pmd((page_nr << PAGE_SHIFT) | pgprot_val(pgprot));
+-}
+-
+-/*
+- * Bits 0 through 3 are taken in the low part of the pte,
+- * put the 32 bits of offset into the high part.
+- */
+-#define PTE_FILE_MAX_BITS     32
+-
+-#ifdef CONFIG_64BIT
+-
+-#define pte_to_pgoff(p) ((p).pte >> 32)
+-
+-#define pgoff_to_pte(off) ((pte_t) { ((off) << 32) | _PAGE_FILE })
+-
+-#else
+-
+-#define pte_to_pgoff(pte) ((pte).pte_high)
+-
+-#define pgoff_to_pte(off) ((pte_t) { _PAGE_FILE, (off) })
+-
+-#endif
+-
+-#endif
+-
+--- a/arch/um/include/asm/pgtable.h
++++ /dev/null
+@@ -1,375 +0,0 @@
+-/* 
+- * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+- * Copyright 2003 PathScale, Inc.
+- * Derived from include/asm-i386/pgtable.h
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_PGTABLE_H
+-#define __UM_PGTABLE_H
+-
+-#include <asm/fixmap.h>
+-
+-#define _PAGE_PRESENT 0x001
+-#define _PAGE_NEWPAGE 0x002
+-#define _PAGE_NEWPROT 0x004
+-#define _PAGE_RW      0x020
+-#define _PAGE_USER    0x040
+-#define _PAGE_ACCESSED        0x080
+-#define _PAGE_DIRTY   0x100
+-/* If _PAGE_PRESENT is clear, we use these: */
+-#define _PAGE_FILE    0x008   /* nonlinear file mapping, saved PTE; unset:swap */
+-#define _PAGE_PROTNONE        0x010   /* if the user mapped it with PROT_NONE;
+-                                 pte_present gives true */
+-
+-#ifdef CONFIG_3_LEVEL_PGTABLES
+-#include <asm/pgtable-3level.h>
+-#else
+-#include <asm/pgtable-2level.h>
+-#endif
+-
+-extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
+-
+-/* zero page used for uninitialized stuff */
+-extern unsigned long *empty_zero_page;
+-
+-#define pgtable_cache_init() do ; while (0)
+-
+-/* Just any arbitrary offset to the start of the vmalloc VM area: the
+- * current 8MB value just means that there will be a 8MB "hole" after the
+- * physical memory until the kernel virtual memory starts.  That means that
+- * any out-of-bounds memory accesses will hopefully be caught.
+- * The vmalloc() routines leaves a hole of 4kB between each vmalloced
+- * area for the same reason. ;)
+- */
+-
+-extern unsigned long end_iomem;
+-
+-#define VMALLOC_OFFSET        (__va_space)
+-#define VMALLOC_START ((end_iomem + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
+-#define PKMAP_BASE ((FIXADDR_START - LAST_PKMAP * PAGE_SIZE) & PMD_MASK)
+-#ifdef CONFIG_HIGHMEM
+-# define VMALLOC_END  (PKMAP_BASE-2*PAGE_SIZE)
+-#else
+-# define VMALLOC_END  (FIXADDR_START-2*PAGE_SIZE)
+-#endif
+-#define MODULES_VADDR VMALLOC_START
+-#define MODULES_END   VMALLOC_END
+-#define MODULES_LEN   (MODULES_VADDR - MODULES_END)
+-
+-#define _PAGE_TABLE   (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
+-#define _KERNPG_TABLE (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
+-#define _PAGE_CHG_MASK        (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
+-#define __PAGE_KERNEL_EXEC                                              \
+-       (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
+-#define PAGE_NONE     __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
+-#define PAGE_SHARED   __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
+-#define PAGE_COPY     __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
+-#define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
+-#define PAGE_KERNEL   __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
+-#define PAGE_KERNEL_EXEC      __pgprot(__PAGE_KERNEL_EXEC)
+-
+-/*
+- * The i386 can't do page protection for execute, and considers that the same
+- * are read.
+- * Also, write permissions imply read permissions. This is the closest we can
+- * get..
+- */
+-#define __P000        PAGE_NONE
+-#define __P001        PAGE_READONLY
+-#define __P010        PAGE_COPY
+-#define __P011        PAGE_COPY
+-#define __P100        PAGE_READONLY
+-#define __P101        PAGE_READONLY
+-#define __P110        PAGE_COPY
+-#define __P111        PAGE_COPY
+-
+-#define __S000        PAGE_NONE
+-#define __S001        PAGE_READONLY
+-#define __S010        PAGE_SHARED
+-#define __S011        PAGE_SHARED
+-#define __S100        PAGE_READONLY
+-#define __S101        PAGE_READONLY
+-#define __S110        PAGE_SHARED
+-#define __S111        PAGE_SHARED
+-
+-/*
+- * ZERO_PAGE is a global shared page that is always zero: used
+- * for zero-mapped memory areas etc..
+- */
+-#define ZERO_PAGE(vaddr) virt_to_page(empty_zero_page)
+-
+-#define pte_clear(mm,addr,xp) pte_set_val(*(xp), (phys_t) 0, __pgprot(_PAGE_NEWPAGE))
+-
+-#define pmd_none(x)   (!((unsigned long)pmd_val(x) & ~_PAGE_NEWPAGE))
+-#define       pmd_bad(x)      ((pmd_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
+-
+-#define pmd_present(x)        (pmd_val(x) & _PAGE_PRESENT)
+-#define pmd_clear(xp) do { pmd_val(*(xp)) = _PAGE_NEWPAGE; } while (0)
+-
+-#define pmd_newpage(x)  (pmd_val(x) & _PAGE_NEWPAGE)
+-#define pmd_mkuptodate(x) (pmd_val(x) &= ~_PAGE_NEWPAGE)
+-
+-#define pud_newpage(x)  (pud_val(x) & _PAGE_NEWPAGE)
+-#define pud_mkuptodate(x) (pud_val(x) &= ~_PAGE_NEWPAGE)
+-
+-#define pmd_page(pmd) phys_to_page(pmd_val(pmd) & PAGE_MASK)
+-
+-#define pte_page(x) pfn_to_page(pte_pfn(x))
+-
+-#define pte_present(x)        pte_get_bits(x, (_PAGE_PRESENT | _PAGE_PROTNONE))
+-
+-/*
+- * =================================
+- * Flags checking section.
+- * =================================
+- */
+-
+-static inline int pte_none(pte_t pte)
+-{
+-      return pte_is_zero(pte);
+-}
+-
+-/*
+- * The following only work if pte_present() is true.
+- * Undefined behaviour if not..
+- */
+-static inline int pte_read(pte_t pte)
+-{ 
+-      return((pte_get_bits(pte, _PAGE_USER)) &&
+-             !(pte_get_bits(pte, _PAGE_PROTNONE)));
+-}
+-
+-static inline int pte_exec(pte_t pte){
+-      return((pte_get_bits(pte, _PAGE_USER)) &&
+-             !(pte_get_bits(pte, _PAGE_PROTNONE)));
+-}
+-
+-static inline int pte_write(pte_t pte)
+-{
+-      return((pte_get_bits(pte, _PAGE_RW)) &&
+-             !(pte_get_bits(pte, _PAGE_PROTNONE)));
+-}
+-
+-/*
+- * The following only works if pte_present() is not true.
+- */
+-static inline int pte_file(pte_t pte)
+-{
+-      return pte_get_bits(pte, _PAGE_FILE);
+-}
+-
+-static inline int pte_dirty(pte_t pte)
+-{
+-      return pte_get_bits(pte, _PAGE_DIRTY);
+-}
+-
+-static inline int pte_young(pte_t pte)
+-{
+-      return pte_get_bits(pte, _PAGE_ACCESSED);
+-}
+-
+-static inline int pte_newpage(pte_t pte)
+-{
+-      return pte_get_bits(pte, _PAGE_NEWPAGE);
+-}
+-
+-static inline int pte_newprot(pte_t pte)
+-{ 
+-      return(pte_present(pte) && (pte_get_bits(pte, _PAGE_NEWPROT)));
+-}
+-
+-static inline int pte_special(pte_t pte)
+-{
+-      return 0;
+-}
+-
+-/*
+- * =================================
+- * Flags setting section.
+- * =================================
+- */
+-
+-static inline pte_t pte_mknewprot(pte_t pte)
+-{
+-      pte_set_bits(pte, _PAGE_NEWPROT);
+-      return(pte);
+-}
+-
+-static inline pte_t pte_mkclean(pte_t pte)
+-{
+-      pte_clear_bits(pte, _PAGE_DIRTY);
+-      return(pte);
+-}
+-
+-static inline pte_t pte_mkold(pte_t pte)      
+-{ 
+-      pte_clear_bits(pte, _PAGE_ACCESSED);
+-      return(pte);
+-}
+-
+-static inline pte_t pte_wrprotect(pte_t pte)
+-{ 
+-      pte_clear_bits(pte, _PAGE_RW);
+-      return(pte_mknewprot(pte)); 
+-}
+-
+-static inline pte_t pte_mkread(pte_t pte)
+-{ 
+-      pte_set_bits(pte, _PAGE_USER);
+-      return(pte_mknewprot(pte)); 
+-}
+-
+-static inline pte_t pte_mkdirty(pte_t pte)
+-{ 
+-      pte_set_bits(pte, _PAGE_DIRTY);
+-      return(pte);
+-}
+-
+-static inline pte_t pte_mkyoung(pte_t pte)
+-{
+-      pte_set_bits(pte, _PAGE_ACCESSED);
+-      return(pte);
+-}
+-
+-static inline pte_t pte_mkwrite(pte_t pte)    
+-{
+-      pte_set_bits(pte, _PAGE_RW);
+-      return(pte_mknewprot(pte)); 
+-}
+-
+-static inline pte_t pte_mkuptodate(pte_t pte) 
+-{
+-      pte_clear_bits(pte, _PAGE_NEWPAGE);
+-      if(pte_present(pte))
+-              pte_clear_bits(pte, _PAGE_NEWPROT);
+-      return(pte); 
+-}
+-
+-static inline pte_t pte_mknewpage(pte_t pte)
+-{
+-      pte_set_bits(pte, _PAGE_NEWPAGE);
+-      return(pte);
+-}
+-
+-static inline pte_t pte_mkspecial(pte_t pte)
+-{
+-      return(pte);
+-}
+-
+-static inline void set_pte(pte_t *pteptr, pte_t pteval)
+-{
+-      pte_copy(*pteptr, pteval);
+-
+-      /* If it's a swap entry, it needs to be marked _PAGE_NEWPAGE so
+-       * fix_range knows to unmap it.  _PAGE_NEWPROT is specific to
+-       * mapped pages.
+-       */
+-
+-      *pteptr = pte_mknewpage(*pteptr);
+-      if(pte_present(*pteptr)) *pteptr = pte_mknewprot(*pteptr);
+-}
+-#define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
+-
+-#define __HAVE_ARCH_PTE_SAME
+-static inline int pte_same(pte_t pte_a, pte_t pte_b)
+-{
+-      return !((pte_val(pte_a) ^ pte_val(pte_b)) & ~_PAGE_NEWPAGE);
+-}
+-
+-/*
+- * Conversion functions: convert a page and protection to a page entry,
+- * and a page entry and page directory to the page they refer to.
+- */
+-
+-#define phys_to_page(phys) pfn_to_page(phys_to_pfn(phys))
+-#define __virt_to_page(virt) phys_to_page(__pa(virt))
+-#define page_to_phys(page) pfn_to_phys((pfn_t) page_to_pfn(page))
+-#define virt_to_page(addr) __virt_to_page((const unsigned long) addr)
+-
+-#define mk_pte(page, pgprot) \
+-      ({ pte_t pte;                                   \
+-                                                      \
+-      pte_set_val(pte, page_to_phys(page), (pgprot)); \
+-      if (pte_present(pte))                           \
+-              pte_mknewprot(pte_mknewpage(pte));      \
+-      pte;})
+-
+-static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
+-{
+-      pte_set_val(pte, (pte_val(pte) & _PAGE_CHG_MASK), newprot);
+-      return pte; 
+-}
+-
+-/*
+- * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
+- *
+- * this macro returns the index of the entry in the pgd page which would
+- * control the given virtual address
+- */
+-#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
+-
+-/*
+- * pgd_offset() returns a (pgd_t *)
+- * pgd_index() is used get the offset into the pgd page's array of pgd_t's;
+- */
+-#define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
+-
+-/*
+- * a shortcut which implies the use of the kernel's pgd, instead
+- * of a process's
+- */
+-#define pgd_offset_k(address) pgd_offset(&init_mm, address)
+-
+-/*
+- * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
+- *
+- * this macro returns the index of the entry in the pmd page which would
+- * control the given virtual address
+- */
+-#define pmd_page_vaddr(pmd) ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
+-#define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
+-
+-#define pmd_page_vaddr(pmd) \
+-      ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
+-
+-/*
+- * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
+- *
+- * this macro returns the index of the entry in the pte page which would
+- * control the given virtual address
+- */
+-#define pte_index(address) (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
+-#define pte_offset_kernel(dir, address) \
+-      ((pte_t *) pmd_page_vaddr(*(dir)) +  pte_index(address))
+-#define pte_offset_map(dir, address) \
+-      ((pte_t *)page_address(pmd_page(*(dir))) + pte_index(address))
+-#define pte_unmap(pte) do { } while (0)
+-
+-struct mm_struct;
+-extern pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr);
+-
+-#define update_mmu_cache(vma,address,ptep) do ; while (0)
+-
+-/* Encode and de-code a swap entry */
+-#define __swp_type(x)                 (((x).val >> 5) & 0x1f)
+-#define __swp_offset(x)                       ((x).val >> 11)
+-
+-#define __swp_entry(type, offset) \
+-      ((swp_entry_t) { ((type) << 5) | ((offset) << 11) })
+-#define __pte_to_swp_entry(pte) \
+-      ((swp_entry_t) { pte_val(pte_mkuptodate(pte)) })
+-#define __swp_entry_to_pte(x)         ((pte_t) { (x).val })
+-
+-#define kern_addr_valid(addr) (1)
+-
+-#include <asm-generic/pgtable.h>
+-
+-/* Clear a kernel PTE and flush it from the TLB */
+-#define kpte_clear_flush(ptep, vaddr)         \
+-do {                                          \
+-      pte_clear(&init_mm, (vaddr), (ptep));   \
+-      __flush_tlb_one((vaddr));               \
+-} while (0)
+-
+-#endif
+--- a/arch/um/include/asm/processor-generic.h
++++ /dev/null
+@@ -1,115 +0,0 @@
+-/* 
+- * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_PROCESSOR_GENERIC_H
+-#define __UM_PROCESSOR_GENERIC_H
+-
+-struct pt_regs;
+-
+-struct task_struct;
+-
+-#include <asm/ptrace.h>
+-#include <registers.h>
+-#include <sysdep/archsetjmp.h>
+-
+-#include <linux/prefetch.h>
+-
+-struct mm_struct;
+-
+-struct thread_struct {
+-      struct pt_regs regs;
+-      struct pt_regs *segv_regs;
+-      int singlestep_syscall;
+-      void *fault_addr;
+-      jmp_buf *fault_catcher;
+-      struct task_struct *prev_sched;
+-      struct arch_thread arch;
+-      jmp_buf switch_buf;
+-      struct {
+-              int op;
+-              union {
+-                      struct {
+-                              int pid;
+-                      } fork, exec;
+-                      struct {
+-                              int (*proc)(void *);
+-                              void *arg;
+-                      } thread;
+-                      struct {
+-                              void (*proc)(void *);
+-                              void *arg;
+-                      } cb;
+-              } u;
+-      } request;
+-};
+-
+-#define INIT_THREAD \
+-{ \
+-      .regs                   = EMPTY_REGS,   \
+-      .fault_addr             = NULL, \
+-      .prev_sched             = NULL, \
+-      .arch                   = INIT_ARCH_THREAD, \
+-      .request                = { 0 } \
+-}
+-
+-static inline void release_thread(struct task_struct *task)
+-{
+-}
+-
+-extern unsigned long thread_saved_pc(struct task_struct *t);
+-
+-static inline void mm_copy_segments(struct mm_struct *from_mm,
+-                                  struct mm_struct *new_mm)
+-{
+-}
+-
+-#define init_stack    (init_thread_union.stack)
+-
+-/*
+- * User space process size: 3GB (default).
+- */
+-extern unsigned long task_size;
+-
+-#define TASK_SIZE (task_size)
+-
+-#undef STACK_TOP
+-#undef STACK_TOP_MAX
+-
+-extern unsigned long stacksizelim;
+-
+-#define STACK_ROOM    (stacksizelim)
+-#define STACK_TOP     (TASK_SIZE - 2 * PAGE_SIZE)
+-#define STACK_TOP_MAX STACK_TOP
+-
+-/* This decides where the kernel will search for a free chunk of vm
+- * space during mmap's.
+- */
+-#define TASK_UNMAPPED_BASE    (0x40000000)
+-
+-extern void start_thread(struct pt_regs *regs, unsigned long entry, 
+-                       unsigned long stack);
+-
+-struct cpuinfo_um {
+-      unsigned long loops_per_jiffy;
+-      int ipi_pipe[2];
+-};
+-
+-extern struct cpuinfo_um boot_cpu_data;
+-
+-#define my_cpu_data           cpu_data[smp_processor_id()]
+-
+-#ifdef CONFIG_SMP
+-extern struct cpuinfo_um cpu_data[];
+-#define current_cpu_data cpu_data[smp_processor_id()]
+-#else
+-#define cpu_data (&boot_cpu_data)
+-#define current_cpu_data boot_cpu_data
+-#endif
+-
+-
+-#define KSTK_REG(tsk, reg) get_thread_reg(reg, &tsk->thread.switch_buf)
+-extern unsigned long get_wchan(struct task_struct *p);
+-
+-#endif
+--- a/arch/um/include/asm/ptrace-generic.h
++++ /dev/null
+@@ -1,45 +0,0 @@
+-/* 
+- * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_PTRACE_GENERIC_H
+-#define __UM_PTRACE_GENERIC_H
+-
+-#ifndef __ASSEMBLY__
+-
+-#include <asm/ptrace-abi.h>
+-#include <sysdep/ptrace.h>
+-
+-struct pt_regs {
+-      struct uml_pt_regs regs;
+-};
+-
+-#define arch_has_single_step()        (1)
+-
+-#define EMPTY_REGS { .regs = EMPTY_UML_PT_REGS }
+-
+-#define PT_REGS_IP(r) UPT_IP(&(r)->regs)
+-#define PT_REGS_SP(r) UPT_SP(&(r)->regs)
+-
+-#define PT_REGS_RESTART_SYSCALL(r) UPT_RESTART_SYSCALL(&(r)->regs)
+-
+-#define PT_REGS_SYSCALL_NR(r) UPT_SYSCALL_NR(&(r)->regs)
+-
+-#define instruction_pointer(regs) PT_REGS_IP(regs)
+-
+-struct task_struct;
+-
+-extern long subarch_ptrace(struct task_struct *child, long request,
+-      unsigned long addr, unsigned long data);
+-extern unsigned long getreg(struct task_struct *child, int regno);
+-extern int putreg(struct task_struct *child, int regno, unsigned long value);
+-
+-extern int arch_copy_tls(struct task_struct *new);
+-extern void clear_flushed_tls(struct task_struct *task);
+-extern void syscall_trace_enter(struct pt_regs *regs);
+-extern void syscall_trace_leave(struct pt_regs *regs);
+-
+-#endif
+-
+-#endif
+--- a/arch/um/include/asm/setup.h
++++ /dev/null
+@@ -1,10 +0,0 @@
+-#ifndef SETUP_H_INCLUDED
+-#define SETUP_H_INCLUDED
+-
+-/* POSIX mandated with _POSIX_ARG_MAX that we can rely on 4096 chars in the
+- * command line, so this choice is ok.
+- */
+-
+-#define COMMAND_LINE_SIZE 4096
+-
+-#endif                /* SETUP_H_INCLUDED */
+--- a/arch/um/include/asm/smp.h
++++ /dev/null
+@@ -1,32 +0,0 @@
+-#ifndef __UM_SMP_H
+-#define __UM_SMP_H
+-
+-#ifdef CONFIG_SMP
+-
+-#include <linux/bitops.h>
+-#include <asm/current.h>
+-#include <linux/cpumask.h>
+-
+-#define raw_smp_processor_id() (current_thread->cpu)
+-
+-#define cpu_logical_map(n) (n)
+-#define cpu_number_map(n) (n)
+-extern int hard_smp_processor_id(void);
+-#define NO_PROC_ID -1
+-
+-extern int ncpus;
+-
+-
+-static inline void smp_cpus_done(unsigned int maxcpus)
+-{
+-}
+-
+-extern struct task_struct *idle_threads[NR_CPUS];
+-
+-#else
+-
+-#define hard_smp_processor_id()               0
+-
+-#endif
+-
+-#endif
+--- a/arch/um/include/asm/stacktrace.h
++++ /dev/null
+@@ -1,42 +0,0 @@
+-#ifndef _ASM_UML_STACKTRACE_H
+-#define _ASM_UML_STACKTRACE_H
+-
+-#include <linux/uaccess.h>
+-#include <linux/ptrace.h>
+-
+-struct stack_frame {
+-      struct stack_frame *next_frame;
+-      unsigned long return_address;
+-};
+-
+-struct stacktrace_ops {
+-      void (*address)(void *data, unsigned long address, int reliable);
+-};
+-
+-#ifdef CONFIG_FRAME_POINTER
+-static inline unsigned long
+-get_frame_pointer(struct task_struct *task, struct pt_regs *segv_regs)
+-{
+-      if (!task || task == current)
+-              return segv_regs ? PT_REGS_BP(segv_regs) : current_bp();
+-      return KSTK_EBP(task);
+-}
+-#else
+-static inline unsigned long
+-get_frame_pointer(struct task_struct *task, struct pt_regs *segv_regs)
+-{
+-      return 0;
+-}
+-#endif
+-
+-static inline unsigned long
+-*get_stack_pointer(struct task_struct *task, struct pt_regs *segv_regs)
+-{
+-      if (!task || task == current)
+-              return segv_regs ? (unsigned long *)PT_REGS_SP(segv_regs) : current_sp();
+-      return (unsigned long *)KSTK_ESP(task);
+-}
+-
+-void dump_trace(struct task_struct *tsk, const struct stacktrace_ops *ops, void *data);
+-
+-#endif /* _ASM_UML_STACKTRACE_H */
+--- a/arch/um/include/asm/sysrq.h
++++ /dev/null
+@@ -1,7 +0,0 @@
+-#ifndef __UM_SYSRQ_H
+-#define __UM_SYSRQ_H
+-
+-struct task_struct;
+-extern void show_trace(struct task_struct* task, unsigned long *stack);
+-
+-#endif
+--- a/arch/um/include/asm/thread_info.h
++++ /dev/null
+@@ -1,78 +0,0 @@
+-/*
+- * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_THREAD_INFO_H
+-#define __UM_THREAD_INFO_H
+-
+-#ifndef __ASSEMBLY__
+-
+-#include <asm/types.h>
+-#include <asm/page.h>
+-#include <asm/uaccess.h>
+-
+-struct thread_info {
+-      struct task_struct      *task;          /* main task structure */
+-      struct exec_domain      *exec_domain;   /* execution domain */
+-      unsigned long           flags;          /* low level flags */
+-      __u32                   cpu;            /* current CPU */
+-      int                     preempt_count;  /* 0 => preemptable,
+-                                                 <0 => BUG */
+-      mm_segment_t            addr_limit;     /* thread address space:
+-                                                 0-0xBFFFFFFF for user
+-                                                 0-0xFFFFFFFF for kernel */
+-      struct restart_block    restart_block;
+-      struct thread_info      *real_thread;    /* Points to non-IRQ stack */
+-};
+-
+-#define INIT_THREAD_INFO(tsk)                 \
+-{                                             \
+-      .task =         &tsk,                   \
+-      .exec_domain =  &default_exec_domain,   \
+-      .flags =                0,              \
+-      .cpu =          0,                      \
+-      .preempt_count = INIT_PREEMPT_COUNT,    \
+-      .addr_limit =   KERNEL_DS,              \
+-      .restart_block =  {                     \
+-              .fn =  do_no_restart_syscall,   \
+-      },                                      \
+-      .real_thread = NULL,                    \
+-}
+-
+-#define init_thread_info      (init_thread_union.thread_info)
+-#define init_stack            (init_thread_union.stack)
+-
+-#define THREAD_SIZE ((1 << CONFIG_KERNEL_STACK_ORDER) * PAGE_SIZE)
+-/* how to get the thread information struct from C */
+-static inline struct thread_info *current_thread_info(void)
+-{
+-      struct thread_info *ti;
+-      unsigned long mask = THREAD_SIZE - 1;
+-      void *p;
+-
+-      asm volatile ("" : "=r" (p) : "0" (&ti));
+-      ti = (struct thread_info *) (((unsigned long)p) & ~mask);
+-      return ti;
+-}
+-
+-#define THREAD_SIZE_ORDER CONFIG_KERNEL_STACK_ORDER
+-
+-#endif
+-
+-#define TIF_SYSCALL_TRACE     0       /* syscall trace active */
+-#define TIF_SIGPENDING                1       /* signal pending */
+-#define TIF_NEED_RESCHED      2       /* rescheduling necessary */
+-#define TIF_RESTART_BLOCK     4
+-#define TIF_MEMDIE            5       /* is terminating due to OOM killer */
+-#define TIF_SYSCALL_AUDIT     6
+-#define TIF_RESTORE_SIGMASK   7
+-#define TIF_NOTIFY_RESUME     8
+-
+-#define _TIF_SYSCALL_TRACE    (1 << TIF_SYSCALL_TRACE)
+-#define _TIF_SIGPENDING               (1 << TIF_SIGPENDING)
+-#define _TIF_NEED_RESCHED     (1 << TIF_NEED_RESCHED)
+-#define _TIF_MEMDIE           (1 << TIF_MEMDIE)
+-#define _TIF_SYSCALL_AUDIT    (1 << TIF_SYSCALL_AUDIT)
+-
+-#endif
+--- a/arch/um/include/asm/timex.h
++++ /dev/null
+@@ -1,13 +0,0 @@
+-#ifndef __UM_TIMEX_H
+-#define __UM_TIMEX_H
+-
+-typedef unsigned long cycles_t;
+-
+-static inline cycles_t get_cycles (void)
+-{
+-      return 0;
+-}
+-
+-#define CLOCK_TICK_RATE (HZ)
+-
+-#endif
+--- a/arch/um/include/asm/tlb.h
++++ /dev/null
+@@ -1,134 +0,0 @@
+-#ifndef __UM_TLB_H
+-#define __UM_TLB_H
+-
+-#include <linux/pagemap.h>
+-#include <linux/swap.h>
+-#include <asm/percpu.h>
+-#include <asm/pgalloc.h>
+-#include <asm/tlbflush.h>
+-
+-#define tlb_start_vma(tlb, vma) do { } while (0)
+-#define tlb_end_vma(tlb, vma) do { } while (0)
+-#define tlb_flush(tlb) flush_tlb_mm((tlb)->mm)
+-
+-/* struct mmu_gather is an opaque type used by the mm code for passing around
+- * any data needed by arch specific code for tlb_remove_page.
+- */
+-struct mmu_gather {
+-      struct mm_struct        *mm;
+-      unsigned int            need_flush; /* Really unmapped some ptes? */
+-      unsigned long           start;
+-      unsigned long           end;
+-      unsigned int            fullmm; /* non-zero means full mm flush */
+-};
+-
+-static inline void __tlb_remove_tlb_entry(struct mmu_gather *tlb, pte_t *ptep,
+-                                        unsigned long address)
+-{
+-      if (tlb->start > address)
+-              tlb->start = address;
+-      if (tlb->end < address + PAGE_SIZE)
+-              tlb->end = address + PAGE_SIZE;
+-}
+-
+-static inline void init_tlb_gather(struct mmu_gather *tlb)
+-{
+-      tlb->need_flush = 0;
+-
+-      tlb->start = TASK_SIZE;
+-      tlb->end = 0;
+-
+-      if (tlb->fullmm) {
+-              tlb->start = 0;
+-              tlb->end = TASK_SIZE;
+-      }
+-}
+-
+-static inline void
+-tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
+-{
+-      tlb->mm = mm;
+-      tlb->start = start;
+-      tlb->end = end;
+-      tlb->fullmm = !(start | (end+1));
+-
+-      init_tlb_gather(tlb);
+-}
+-
+-extern void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
+-                             unsigned long end);
+-
+-static inline void
+-tlb_flush_mmu_tlbonly(struct mmu_gather *tlb)
+-{
+-      flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end);
+-}
+-
+-static inline void
+-tlb_flush_mmu_free(struct mmu_gather *tlb)
+-{
+-      init_tlb_gather(tlb);
+-}
+-
+-static inline void
+-tlb_flush_mmu(struct mmu_gather *tlb)
+-{
+-      if (!tlb->need_flush)
+-              return;
+-
+-      tlb_flush_mmu_tlbonly(tlb);
+-      tlb_flush_mmu_free(tlb);
+-}
+-
+-/* tlb_finish_mmu
+- *    Called at the end of the shootdown operation to free up any resources
+- *    that were required.
+- */
+-static inline void
+-tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
+-{
+-      tlb_flush_mmu(tlb);
+-
+-      /* keep the page table cache within bounds */
+-      check_pgt_cache();
+-}
+-
+-/* tlb_remove_page
+- *    Must perform the equivalent to __free_pte(pte_get_and_clear(ptep)),
+- *    while handling the additional races in SMP caused by other CPUs
+- *    caching valid mappings in their TLBs.
+- */
+-static inline int __tlb_remove_page(struct mmu_gather *tlb, struct page *page)
+-{
+-      tlb->need_flush = 1;
+-      free_page_and_swap_cache(page);
+-      return 1; /* avoid calling tlb_flush_mmu */
+-}
+-
+-static inline void tlb_remove_page(struct mmu_gather *tlb, struct page *page)
+-{
+-      __tlb_remove_page(tlb, page);
+-}
+-
+-/**
+- * tlb_remove_tlb_entry - remember a pte unmapping for later tlb invalidation.
+- *
+- * Record the fact that pte's were really umapped in ->need_flush, so we can
+- * later optimise away the tlb invalidate.   This helps when userspace is
+- * unmapping already-unmapped pages, which happens quite a lot.
+- */
+-#define tlb_remove_tlb_entry(tlb, ptep, address)              \
+-      do {                                                    \
+-              tlb->need_flush = 1;                            \
+-              __tlb_remove_tlb_entry(tlb, ptep, address);     \
+-      } while (0)
+-
+-#define pte_free_tlb(tlb, ptep, addr) __pte_free_tlb(tlb, ptep, addr)
+-
+-#define pud_free_tlb(tlb, pudp, addr) __pud_free_tlb(tlb, pudp, addr)
+-
+-#define pmd_free_tlb(tlb, pmdp, addr) __pmd_free_tlb(tlb, pmdp, addr)
+-
+-#define tlb_migrate_finish(mm) do {} while (0)
+-
+-#endif
+--- a/arch/um/include/asm/tlbflush.h
++++ /dev/null
+@@ -1,31 +0,0 @@
+-/*
+- * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_TLBFLUSH_H
+-#define __UM_TLBFLUSH_H
+-
+-#include <linux/mm.h>
+-
+-/*
+- * TLB flushing:
+- *
+- *  - flush_tlb() flushes the current mm struct TLBs
+- *  - flush_tlb_all() flushes all processes TLBs
+- *  - flush_tlb_mm(mm) flushes the specified mm context TLB's
+- *  - flush_tlb_page(vma, vmaddr) flushes one page
+- *  - flush_tlb_kernel_vm() flushes the kernel vm area
+- *  - flush_tlb_range(vma, start, end) flushes a range of pages
+- */
+-
+-extern void flush_tlb_all(void);
+-extern void flush_tlb_mm(struct mm_struct *mm);
+-extern void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, 
+-                          unsigned long end);
+-extern void flush_tlb_page(struct vm_area_struct *vma, unsigned long address);
+-extern void flush_tlb_kernel_vm(void);
+-extern void flush_tlb_kernel_range(unsigned long start, unsigned long end);
+-extern void __flush_tlb_one(unsigned long addr);
+-
+-#endif
+--- a/arch/um/include/asm/uaccess.h
++++ /dev/null
+@@ -1,178 +0,0 @@
+-/* 
+- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+- * Licensed under the GPL
+- */
+-
+-#ifndef __UM_UACCESS_H
+-#define __UM_UACCESS_H
+-
+-/* thread_info has a mm_segment_t in it, so put the definition up here */
+-typedef struct {
+-      unsigned long seg;
+-} mm_segment_t;
+-
+-#include <linux/thread_info.h>
+-#include <linux/errno.h>
+-#include <asm/processor.h>
+-#include <asm/elf.h>
+-
+-#define VERIFY_READ 0
+-#define VERIFY_WRITE 1
+-
+-/*
+- * The fs value determines whether argument validity checking should be
+- * performed or not.  If get_fs() == USER_DS, checking is performed, with
+- * get_fs() == KERNEL_DS, checking is bypassed.
+- *
+- * For historical reasons, these macros are grossly misnamed.
+- */
+-
+-#define MAKE_MM_SEG(s)        ((mm_segment_t) { (s) })
+-
+-#define KERNEL_DS     MAKE_MM_SEG(0xFFFFFFFF)
+-#define USER_DS               MAKE_MM_SEG(TASK_SIZE)
+-
+-#define get_ds()      (KERNEL_DS)
+-#define get_fs()      (current_thread_info()->addr_limit)
+-#define set_fs(x)     (current_thread_info()->addr_limit = (x))
+-
+-#define segment_eq(a, b) ((a).seg == (b).seg)
+-
+-#define __under_task_size(addr, size) \
+-      (((unsigned long) (addr) < TASK_SIZE) && \
+-       (((unsigned long) (addr) + (size)) < TASK_SIZE))
+-
+-#define __access_ok_vsyscall(type, addr, size) \
+-       ((type == VERIFY_READ) && \
+-        ((unsigned long) (addr) >= FIXADDR_USER_START) && \
+-        ((unsigned long) (addr) + (size) <= FIXADDR_USER_END) && \
+-        ((unsigned long) (addr) + (size) >= (unsigned long)(addr)))
+-
+-#define __addr_range_nowrap(addr, size) \
+-      ((unsigned long) (addr) <= ((unsigned long) (addr) + (size)))
+-
+-#define access_ok(type, addr, size) \
+-      (__addr_range_nowrap(addr, size) && \
+-       (__under_task_size(addr, size) || \
+-        __access_ok_vsyscall(type, addr, size) || \
+-        segment_eq(get_fs(), KERNEL_DS)))
+-
+-extern int copy_from_user(void *to, const void __user *from, int n);
+-extern int copy_to_user(void __user *to, const void *from, int n);
+-
+-/*
+- * strncpy_from_user: - Copy a NUL terminated string from userspace.
+- * @dst:   Destination address, in kernel space.  This buffer must be at
+- *         least @count bytes long.
+- * @src:   Source address, in user space.
+- * @count: Maximum number of bytes to copy, including the trailing NUL.
+- *
+- * Copies a NUL-terminated string from userspace to kernel space.
+- *
+- * On success, returns the length of the string (not including the trailing
+- * NUL).
+- *
+- * If access to userspace fails, returns -EFAULT (some data may have been
+- * copied).
+- *
+- * If @count is smaller than the length of the string, copies @count bytes
+- * and returns @count.
+- */
+-
+-extern int strncpy_from_user(char *dst, const char __user *src, int count);
+-
+-/*
+- * __clear_user: - Zero a block of memory in user space, with less checking.
+- * @to:   Destination address, in user space.
+- * @n:    Number of bytes to zero.
+- *
+- * Zero a block of memory in user space.  Caller must check
+- * the specified block with access_ok() before calling this function.
+- *
+- * Returns number of bytes that could not be cleared.
+- * On success, this will be zero.
+- */
+-extern int __clear_user(void __user *mem, int len);
+-
+-/*
+- * clear_user: - Zero a block of memory in user space.
+- * @to:   Destination address, in user space.
+- * @n:    Number of bytes to zero.
+- *
+- * Zero a block of memory in user space.
+- *
+- * Returns number of bytes that could not be cleared.
+- * On success, this will be zero.
+- */
+-extern int clear_user(void __user *mem, int len);
+-
+-/*
+- * strlen_user: - Get the size of a string in user space.
+- * @str: The string to measure.
+- * @n:   The maximum valid length
+- *
+- * Get the size of a NUL-terminated string in user space.
+- *
+- * Returns the size of the string INCLUDING the terminating NUL.
+- * On exception, returns 0.
+- * If the string is too long, returns a value greater than @n.
+- */
+-extern int strnlen_user(const void __user *str, int len);
+-
+-#define __copy_from_user(to, from, n) copy_from_user(to, from, n)
+-
+-#define __copy_to_user(to, from, n) copy_to_user(to, from, n)
+-
+-#define __copy_to_user_inatomic __copy_to_user
+-#define __copy_from_user_inatomic __copy_from_user
+-
+-#define __get_user(x, ptr) \
+-({ \
+-      const __typeof__(*(ptr)) __user *__private_ptr = (ptr); \
+-      __typeof__(x) __private_val;                    \
+-      int __private_ret = -EFAULT;                    \
+-      (x) = (__typeof__(*(__private_ptr)))0;                          \
+-      if (__copy_from_user((__force void *)&__private_val, (__private_ptr),\
+-                           sizeof(*(__private_ptr))) == 0) {          \
+-              (x) = (__typeof__(*(__private_ptr))) __private_val;     \
+-              __private_ret = 0;                                      \
+-      }                                                               \
+-      __private_ret;                                                  \
+-}) 
+-
+-#define get_user(x, ptr) \
+-({ \
+-        const __typeof__((*(ptr))) __user *private_ptr = (ptr); \
+-        (access_ok(VERIFY_READ, private_ptr, sizeof(*private_ptr)) ? \
+-       __get_user(x, private_ptr) : ((x) = (__typeof__(*ptr))0, -EFAULT)); \
+-})
+-
+-#define __put_user(x, ptr) \
+-({ \
+-        __typeof__(*(ptr)) __user *__private_ptr = ptr; \
+-        __typeof__(*(__private_ptr)) __private_val; \
+-        int __private_ret = -EFAULT; \
+-        __private_val = (__typeof__(*(__private_ptr))) (x); \
+-        if (__copy_to_user((__private_ptr), &__private_val, \
+-                         sizeof(*(__private_ptr))) == 0) { \
+-              __private_ret = 0; \
+-      } \
+-        __private_ret; \
+-})
+-
+-#define put_user(x, ptr) \
+-({ \
+-        __typeof__(*(ptr)) __user *private_ptr = (ptr); \
+-        (access_ok(VERIFY_WRITE, private_ptr, sizeof(*private_ptr)) ? \
+-       __put_user(x, private_ptr) : -EFAULT); \
+-})
+-
+-#define strlen_user(str) strnlen_user(str, ~0U >> 1)
+-
+-struct exception_table_entry
+-{
+-        unsigned long insn;
+-      unsigned long fixup;
+-};
+-
+-#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/Kbuild
+@@ -0,0 +1,30 @@
++generic-y += barrier.h
++generic-y += bug.h
++generic-y += clkdev.h
++generic-y += cputime.h
++generic-y += current.h
++generic-y += delay.h
++generic-y += device.h
++generic-y += emergency-restart.h
++generic-y += exec.h
++generic-y += ftrace.h
++generic-y += futex.h
++generic-y += hardirq.h
++generic-y += hash.h
++generic-y += hw_irq.h
++generic-y += io.h
++generic-y += irq_regs.h
++generic-y += irq_work.h
++generic-y += kdebug.h
++generic-y += mcs_spinlock.h
++generic-y += mutex.h
++generic-y += param.h
++generic-y += pci.h
++generic-y += percpu.h
++generic-y += preempt.h
++generic-y += scatterlist.h
++generic-y += sections.h
++generic-y += switch_to.h
++generic-y += topology.h
++generic-y += trace_clock.h
++generic-y += xor.h
+--- /dev/null
++++ b/arch/um/include/uapi/asm/a.out-core.h
+@@ -0,0 +1,27 @@
++/* a.out coredump register dumper
++ *
++ * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
++ * Written by David Howells (dhowells@redhat.com)
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public Licence
++ * as published by the Free Software Foundation; either version
++ * 2 of the Licence, or (at your option) any later version.
++ */
++
++#ifndef __UM_A_OUT_CORE_H
++#define __UM_A_OUT_CORE_H
++
++#ifdef __KERNEL__
++
++#include <linux/user.h>
++
++/*
++ * fill in the user structure for an a.out core dump
++ */
++static inline void aout_dump_thread(struct pt_regs *regs, struct user *u)
++{
++}
++
++#endif /* __KERNEL__ */
++#endif /* __UM_A_OUT_CORE_H */
+--- /dev/null
++++ b/arch/um/include/uapi/asm/bugs.h
+@@ -0,0 +1,6 @@
++#ifndef __UM_BUGS_H
++#define __UM_BUGS_H
++
++void check_bugs(void);
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/cache.h
+@@ -0,0 +1,17 @@
++#ifndef __UM_CACHE_H
++#define __UM_CACHE_H
++
++
++#if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
++# define L1_CACHE_SHIFT               (CONFIG_X86_L1_CACHE_SHIFT)
++#elif defined(CONFIG_UML_X86) /* 64-bit */
++# define L1_CACHE_SHIFT               6 /* Should be 7 on Intel */
++#else
++/* XXX: this was taken from x86, now it's completely random. Luckily only
++ * affects SMP padding. */
++# define L1_CACHE_SHIFT               5
++#endif
++
++#define L1_CACHE_BYTES                (1 << L1_CACHE_SHIFT)
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/common.lds.S
+@@ -0,0 +1,107 @@
++#include <asm-generic/vmlinux.lds.h>
++
++  .fini      : { *(.fini)    } =0x9090
++  _etext = .;
++  PROVIDE (etext = .);
++
++  . = ALIGN(4096);
++  _sdata = .;
++  PROVIDE (sdata = .);
++
++  RODATA
++
++  .unprotected : { *(.unprotected) }
++  . = ALIGN(4096);
++  PROVIDE (_unprotected_end = .);
++
++  . = ALIGN(4096);
++  .note : { *(.note.*) }
++  EXCEPTION_TABLE(0)
++
++  BUG_TABLE
++
++  .uml.setup.init : {
++      __uml_setup_start = .;
++      *(.uml.setup.init)
++      __uml_setup_end = .;
++  }
++      
++  .uml.help.init : {
++      __uml_help_start = .;
++      *(.uml.help.init)
++      __uml_help_end = .;
++  }
++      
++  .uml.postsetup.init : {
++      __uml_postsetup_start = .;
++      *(.uml.postsetup.init)
++      __uml_postsetup_end = .;
++  }
++      
++  .init.setup : {
++      INIT_SETUP(0)
++  }
++
++  PERCPU_SECTION(32)
++      
++  .initcall.init : {
++      INIT_CALLS
++  }
++
++  .con_initcall.init : {
++      CON_INITCALL
++  }
++
++  .uml.initcall.init : {
++      __uml_initcall_start = .;
++      *(.uml.initcall.init)
++      __uml_initcall_end = .;
++  }
++
++  SECURITY_INIT
++
++  .exitcall : {
++      __exitcall_begin = .;
++      *(.exitcall.exit)
++      __exitcall_end = .;
++  }
++
++  .uml.exitcall : {
++      __uml_exitcall_begin = .;
++      *(.uml.exitcall.exit)
++      __uml_exitcall_end = .;
++  }
++
++  . = ALIGN(4);
++  .altinstructions : {
++      __alt_instructions = .;
++      *(.altinstructions)
++      __alt_instructions_end = .;
++  }
++  .altinstr_replacement : { *(.altinstr_replacement) }
++  /* .exit.text is discard at runtime, not link time, to deal with references
++     from .altinstructions and .eh_frame */
++  .exit.text : { *(.exit.text) }
++  .exit.data : { *(.exit.data) }
++
++  .preinit_array : {
++      __preinit_array_start = .;
++      *(.preinit_array)
++      __preinit_array_end = .;
++  }
++  .init_array : {
++      __init_array_start = .;
++      *(.init_array)
++      __init_array_end = .;
++  }
++  .fini_array : {
++      __fini_array_start = .;
++      *(.fini_array)
++      __fini_array_end = .;
++  }
++
++   . = ALIGN(4096);
++  .init.ramfs : {
++      INIT_RAM_FS
++  }
++
+--- /dev/null
++++ b/arch/um/include/uapi/asm/dma.h
+@@ -0,0 +1,10 @@
++#ifndef __UM_DMA_H
++#define __UM_DMA_H
++
++#include <asm/io.h>
++
++extern unsigned long uml_physmem;
++
++#define MAX_DMA_ADDRESS (uml_physmem)
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/fixmap.h
+@@ -0,0 +1,60 @@
++#ifndef __UM_FIXMAP_H
++#define __UM_FIXMAP_H
++
++#include <asm/processor.h>
++#include <asm/kmap_types.h>
++#include <asm/archparam.h>
++#include <asm/page.h>
++#include <linux/threads.h>
++
++/*
++ * Here we define all the compile-time 'special' virtual
++ * addresses. The point is to have a constant address at
++ * compile time, but to set the physical address only
++ * in the boot process. We allocate these special  addresses
++ * from the end of virtual memory (0xfffff000) backwards.
++ * Also this lets us do fail-safe vmalloc(), we
++ * can guarantee that these special addresses and
++ * vmalloc()-ed addresses never overlap.
++ *
++ * these 'compile-time allocated' memory buffers are
++ * fixed-size 4k pages. (or larger if used with an increment
++ * highger than 1) use fixmap_set(idx,phys) to associate
++ * physical memory with fixmap indices.
++ *
++ * TLB entries of such buffers will not be flushed across
++ * task switches.
++ */
++
++/*
++ * on UP currently we will have no trace of the fixmap mechanizm,
++ * no page table allocations, etc. This might change in the
++ * future, say framebuffers for the console driver(s) could be
++ * fix-mapped?
++ */
++enum fixed_addresses {
++#ifdef CONFIG_HIGHMEM
++      FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */
++      FIX_KMAP_END = FIX_KMAP_BEGIN+(KM_TYPE_NR*NR_CPUS)-1,
++#endif
++      __end_of_fixed_addresses
++};
++
++extern void __set_fixmap (enum fixed_addresses idx,
++                        unsigned long phys, pgprot_t flags);
++
++/*
++ * used by vmalloc.c.
++ *
++ * Leave one empty page between vmalloc'ed areas and
++ * the start of the fixmap, and leave one page empty
++ * at the top of mem..
++ */
++
++#define FIXADDR_TOP   (TASK_SIZE - 2 * PAGE_SIZE)
++#define FIXADDR_SIZE  (__end_of_fixed_addresses << PAGE_SHIFT)
++#define FIXADDR_START (FIXADDR_TOP - FIXADDR_SIZE)
++
++#include <asm-generic/fixmap.h>
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/irq.h
+@@ -0,0 +1,23 @@
++#ifndef __UM_IRQ_H
++#define __UM_IRQ_H
++
++#define TIMER_IRQ             0
++#define UMN_IRQ                       1
++#define CONSOLE_IRQ           2
++#define CONSOLE_WRITE_IRQ     3
++#define UBD_IRQ                       4
++#define UM_ETH_IRQ            5
++#define SSL_IRQ                       6
++#define SSL_WRITE_IRQ         7
++#define ACCEPT_IRQ            8
++#define MCONSOLE_IRQ          9
++#define WINCH_IRQ             10
++#define SIGIO_WRITE_IRQ       11
++#define TELNETD_IRQ           12
++#define XTERM_IRQ             13
++#define RANDOM_IRQ            14
++
++#define LAST_IRQ RANDOM_IRQ
++#define NR_IRQS (LAST_IRQ + 1)
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/irqflags.h
+@@ -0,0 +1,42 @@
++#ifndef __UM_IRQFLAGS_H
++#define __UM_IRQFLAGS_H
++
++extern int get_signals(void);
++extern int set_signals(int enable);
++extern void block_signals(void);
++extern void unblock_signals(void);
++
++static inline unsigned long arch_local_save_flags(void)
++{
++      return get_signals();
++}
++
++static inline void arch_local_irq_restore(unsigned long flags)
++{
++      set_signals(flags);
++}
++
++static inline void arch_local_irq_enable(void)
++{
++      unblock_signals();
++}
++
++static inline void arch_local_irq_disable(void)
++{
++      block_signals();
++}
++
++static inline unsigned long arch_local_irq_save(void)
++{
++      unsigned long flags;
++      flags = arch_local_save_flags();
++      arch_local_irq_disable();
++      return flags;
++}
++
++static inline bool arch_irqs_disabled(void)
++{
++      return arch_local_save_flags() == 0;
++}
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/kmap_types.h
+@@ -0,0 +1,13 @@
++/* 
++ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_KMAP_TYPES_H
++#define __UM_KMAP_TYPES_H
++
++/* No more #include "asm/arch/kmap_types.h" ! */
++
++#define KM_TYPE_NR 14
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/kvm_para.h
+@@ -0,0 +1 @@
++#include <asm-generic/kvm_para.h>
+--- /dev/null
++++ b/arch/um/include/uapi/asm/mmu.h
+@@ -0,0 +1,24 @@
++/* 
++ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __ARCH_UM_MMU_H
++#define __ARCH_UM_MMU_H
++
++#include <mm_id.h>
++#include <asm/mm_context.h>
++
++typedef struct mm_context {
++      struct mm_id id;
++      struct uml_arch_mm_context arch;
++      struct page *stub_pages[2];
++} mm_context_t;
++
++extern void __switch_mm(struct mm_id * mm_idp);
++
++/* Avoid tangled inclusion with asm/ldt.h */
++extern long init_new_ldt(struct mm_context *to_mm, struct mm_context *from_mm);
++extern void free_ldt(struct mm_context *mm);
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/mmu_context.h
+@@ -0,0 +1,58 @@
++/* 
++ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_MMU_CONTEXT_H
++#define __UM_MMU_CONTEXT_H
++
++#include <linux/sched.h>
++#include <asm/mmu.h>
++
++extern void uml_setup_stubs(struct mm_struct *mm);
++extern void arch_exit_mmap(struct mm_struct *mm);
++
++#define deactivate_mm(tsk,mm) do { } while (0)
++
++extern void force_flush_all(void);
++
++static inline void activate_mm(struct mm_struct *old, struct mm_struct *new)
++{
++      /*
++       * This is called by fs/exec.c and sys_unshare()
++       * when the new ->mm is used for the first time.
++       */
++      __switch_mm(&new->context.id);
++      down_write(&new->mmap_sem);
++      uml_setup_stubs(new);
++      up_write(&new->mmap_sem);
++}
++
++static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, 
++                           struct task_struct *tsk)
++{
++      unsigned cpu = smp_processor_id();
++
++      if(prev != next){
++              cpumask_clear_cpu(cpu, mm_cpumask(prev));
++              cpumask_set_cpu(cpu, mm_cpumask(next));
++              if(next != &init_mm)
++                      __switch_mm(&next->context.id);
++      }
++}
++
++static inline void arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
++{
++      uml_setup_stubs(mm);
++}
++
++static inline void enter_lazy_tlb(struct mm_struct *mm, 
++                                struct task_struct *tsk)
++{
++}
++
++extern int init_new_context(struct task_struct *task, struct mm_struct *mm);
++
++extern void destroy_context(struct mm_struct *mm);
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/page.h
+@@ -0,0 +1,127 @@
++/*
++ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
++ * Copyright 2003 PathScale, Inc.
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_PAGE_H
++#define __UM_PAGE_H
++
++#include <linux/const.h>
++
++/* PAGE_SHIFT determines the page size */
++#define PAGE_SHIFT    12
++#define PAGE_SIZE     (_AC(1, UL) << PAGE_SHIFT)
++#define PAGE_MASK     (~(PAGE_SIZE-1))
++
++#ifndef __ASSEMBLY__
++
++struct page;
++
++#include <linux/types.h>
++#include <asm/vm-flags.h>
++
++/*
++ * These are used to make use of C type-checking..
++ */
++
++#define clear_page(page)      memset((void *)(page), 0, PAGE_SIZE)
++#define copy_page(to,from)    memcpy((void *)(to), (void *)(from), PAGE_SIZE)
++
++#define clear_user_page(page, vaddr, pg)      clear_page(page)
++#define copy_user_page(to, from, vaddr, pg)   copy_page(to, from)
++
++#if defined(CONFIG_3_LEVEL_PGTABLES) && !defined(CONFIG_64BIT)
++
++typedef struct { unsigned long pte_low, pte_high; } pte_t;
++typedef struct { unsigned long pmd; } pmd_t;
++typedef struct { unsigned long pgd; } pgd_t;
++#define pte_val(x) ((x).pte_low | ((unsigned long long) (x).pte_high << 32))
++
++#define pte_get_bits(pte, bits) ((pte).pte_low & (bits))
++#define pte_set_bits(pte, bits) ((pte).pte_low |= (bits))
++#define pte_clear_bits(pte, bits) ((pte).pte_low &= ~(bits))
++#define pte_copy(to, from) ({ (to).pte_high = (from).pte_high; \
++                            smp_wmb(); \
++                            (to).pte_low = (from).pte_low; })
++#define pte_is_zero(pte) (!((pte).pte_low & ~_PAGE_NEWPAGE) && !(pte).pte_high)
++#define pte_set_val(pte, phys, prot) \
++      ({ (pte).pte_high = (phys) >> 32; \
++         (pte).pte_low = (phys) | pgprot_val(prot); })
++
++#define pmd_val(x)    ((x).pmd)
++#define __pmd(x) ((pmd_t) { (x) } )
++
++typedef unsigned long long pfn_t;
++typedef unsigned long long phys_t;
++
++#else
++
++typedef struct { unsigned long pte; } pte_t;
++typedef struct { unsigned long pgd; } pgd_t;
++
++#ifdef CONFIG_3_LEVEL_PGTABLES
++typedef struct { unsigned long pmd; } pmd_t;
++#define pmd_val(x)    ((x).pmd)
++#define __pmd(x) ((pmd_t) { (x) } )
++#endif
++
++#define pte_val(x)    ((x).pte)
++
++
++#define pte_get_bits(p, bits) ((p).pte & (bits))
++#define pte_set_bits(p, bits) ((p).pte |= (bits))
++#define pte_clear_bits(p, bits) ((p).pte &= ~(bits))
++#define pte_copy(to, from) ((to).pte = (from).pte)
++#define pte_is_zero(p) (!((p).pte & ~_PAGE_NEWPAGE))
++#define pte_set_val(p, phys, prot) (p).pte = (phys | pgprot_val(prot))
++
++typedef unsigned long pfn_t;
++typedef unsigned long phys_t;
++
++#endif
++
++typedef struct { unsigned long pgprot; } pgprot_t;
++
++typedef struct page *pgtable_t;
++
++#define pgd_val(x)    ((x).pgd)
++#define pgprot_val(x) ((x).pgprot)
++
++#define __pte(x) ((pte_t) { (x) } )
++#define __pgd(x) ((pgd_t) { (x) } )
++#define __pgprot(x)   ((pgprot_t) { (x) } )
++
++extern unsigned long uml_physmem;
++
++#define PAGE_OFFSET (uml_physmem)
++#define KERNELBASE PAGE_OFFSET
++
++#define __va_space (8*1024*1024)
++
++#include <mem.h>
++
++/* Cast to unsigned long before casting to void * to avoid a warning from
++ * mmap_kmem about cutting a long long down to a void *.  Not sure that
++ * casting is the right thing, but 32-bit UML can't have 64-bit virtual
++ * addresses
++ */
++#define __pa(virt) to_phys((void *) (unsigned long) (virt))
++#define __va(phys) to_virt((unsigned long) (phys))
++
++#define phys_to_pfn(p) ((pfn_t) ((p) >> PAGE_SHIFT))
++#define pfn_to_phys(pfn) ((phys_t) ((pfn) << PAGE_SHIFT))
++
++#define pfn_valid(pfn) ((pfn) < max_mapnr)
++#define virt_addr_valid(v) pfn_valid(phys_to_pfn(__pa(v)))
++
++#include <asm-generic/memory_model.h>
++#include <asm-generic/getorder.h>
++
++#endif        /* __ASSEMBLY__ */
++
++#ifdef CONFIG_X86_32
++#define __HAVE_ARCH_GATE_AREA 1
++#endif
++
++#endif        /* __UM_PAGE_H */
+--- /dev/null
++++ b/arch/um/include/uapi/asm/pgalloc.h
+@@ -0,0 +1,61 @@
++/* 
++ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
++ * Copyright 2003 PathScale, Inc.
++ * Derived from include/asm-i386/pgalloc.h and include/asm-i386/pgtable.h
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_PGALLOC_H
++#define __UM_PGALLOC_H
++
++#include <linux/mm.h>
++
++#define pmd_populate_kernel(mm, pmd, pte) \
++      set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) __pa(pte)))
++
++#define pmd_populate(mm, pmd, pte)                            \
++      set_pmd(pmd, __pmd(_PAGE_TABLE +                        \
++              ((unsigned long long)page_to_pfn(pte) <<        \
++                      (unsigned long long) PAGE_SHIFT)))
++#define pmd_pgtable(pmd) pmd_page(pmd)
++
++/*
++ * Allocate and free page tables.
++ */
++extern pgd_t *pgd_alloc(struct mm_struct *);
++extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
++
++extern pte_t *pte_alloc_one_kernel(struct mm_struct *, unsigned long);
++extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
++
++static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
++{
++      free_page((unsigned long) pte);
++}
++
++static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
++{
++      pgtable_page_dtor(pte);
++      __free_page(pte);
++}
++
++#define __pte_free_tlb(tlb,pte, address)              \
++do {                                                  \
++      pgtable_page_dtor(pte);                         \
++      tlb_remove_page((tlb),(pte));                   \
++} while (0)
++
++#ifdef CONFIG_3_LEVEL_PGTABLES
++
++static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
++{
++      free_page((unsigned long)pmd);
++}
++
++#define __pmd_free_tlb(tlb,x, address)   tlb_remove_page((tlb),virt_to_page(x))
++#endif
++
++#define check_pgt_cache()     do { } while (0)
++
++#endif
++
+--- /dev/null
++++ b/arch/um/include/uapi/asm/pgtable-2level.h
+@@ -0,0 +1,53 @@
++/*
++ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
++ * Copyright 2003 PathScale, Inc.
++ * Derived from include/asm-i386/pgtable.h
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_PGTABLE_2LEVEL_H
++#define __UM_PGTABLE_2LEVEL_H
++
++#include <asm-generic/pgtable-nopmd.h>
++
++/* PGDIR_SHIFT determines what a third-level page table entry can map */
++
++#define PGDIR_SHIFT   22
++#define PGDIR_SIZE    (1UL << PGDIR_SHIFT)
++#define PGDIR_MASK    (~(PGDIR_SIZE-1))
++
++/*
++ * entries per page directory level: the i386 is two-level, so
++ * we don't really have any PMD directory physically.
++ */
++#define PTRS_PER_PTE  1024
++#define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
++#define PTRS_PER_PGD  1024
++#define FIRST_USER_ADDRESS    0
++
++#define pte_ERROR(e) \
++        printk("%s:%d: bad pte %p(%08lx).\n", __FILE__, __LINE__, &(e), \
++             pte_val(e))
++#define pgd_ERROR(e) \
++        printk("%s:%d: bad pgd %p(%08lx).\n", __FILE__, __LINE__, &(e), \
++             pgd_val(e))
++
++static inline int pgd_newpage(pgd_t pgd)      { return 0; }
++static inline void pgd_mkuptodate(pgd_t pgd)  { }
++
++#define set_pmd(pmdptr, pmdval) (*(pmdptr) = (pmdval))
++
++#define pte_pfn(x) phys_to_pfn(pte_val(x))
++#define pfn_pte(pfn, prot) __pte(pfn_to_phys(pfn) | pgprot_val(prot))
++#define pfn_pmd(pfn, prot) __pmd(pfn_to_phys(pfn) | pgprot_val(prot))
++
++/*
++ * Bits 0 through 4 are taken
++ */
++#define PTE_FILE_MAX_BITS     27
++
++#define pte_to_pgoff(pte) (pte_val(pte) >> 5)
++
++#define pgoff_to_pte(off) ((pte_t) { ((off) << 5) + _PAGE_FILE })
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/pgtable-3level.h
+@@ -0,0 +1,136 @@
++/*
++ * Copyright 2003 PathScale Inc
++ * Derived from include/asm-i386/pgtable.h
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_PGTABLE_3LEVEL_H
++#define __UM_PGTABLE_3LEVEL_H
++
++#include <asm-generic/pgtable-nopud.h>
++
++/* PGDIR_SHIFT determines what a third-level page table entry can map */
++
++#ifdef CONFIG_64BIT
++#define PGDIR_SHIFT   30
++#else
++#define PGDIR_SHIFT   31
++#endif
++#define PGDIR_SIZE    (1UL << PGDIR_SHIFT)
++#define PGDIR_MASK    (~(PGDIR_SIZE-1))
++
++/* PMD_SHIFT determines the size of the area a second-level page table can
++ * map
++ */
++
++#define PMD_SHIFT     21
++#define PMD_SIZE      (1UL << PMD_SHIFT)
++#define PMD_MASK      (~(PMD_SIZE-1))
++
++/*
++ * entries per page directory level
++ */
++
++#define PTRS_PER_PTE 512
++#ifdef CONFIG_64BIT
++#define PTRS_PER_PMD 512
++#define PTRS_PER_PGD 512
++#else
++#define PTRS_PER_PMD 1024
++#define PTRS_PER_PGD 1024
++#endif
++
++#define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
++#define FIRST_USER_ADDRESS    0
++
++#define pte_ERROR(e) \
++        printk("%s:%d: bad pte %p(%016lx).\n", __FILE__, __LINE__, &(e), \
++             pte_val(e))
++#define pmd_ERROR(e) \
++        printk("%s:%d: bad pmd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
++             pmd_val(e))
++#define pgd_ERROR(e) \
++        printk("%s:%d: bad pgd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
++             pgd_val(e))
++
++#define pud_none(x)   (!(pud_val(x) & ~_PAGE_NEWPAGE))
++#define       pud_bad(x)      ((pud_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
++#define pud_present(x)        (pud_val(x) & _PAGE_PRESENT)
++#define pud_populate(mm, pud, pmd) \
++      set_pud(pud, __pud(_PAGE_TABLE + __pa(pmd)))
++
++#ifdef CONFIG_64BIT
++#define set_pud(pudptr, pudval) set_64bit((u64 *) (pudptr), pud_val(pudval))
++#else
++#define set_pud(pudptr, pudval) (*(pudptr) = (pudval))
++#endif
++
++static inline int pgd_newpage(pgd_t pgd)
++{
++      return(pgd_val(pgd) & _PAGE_NEWPAGE);
++}
++
++static inline void pgd_mkuptodate(pgd_t pgd) { pgd_val(pgd) &= ~_PAGE_NEWPAGE; }
++
++#ifdef CONFIG_64BIT
++#define set_pmd(pmdptr, pmdval) set_64bit((u64 *) (pmdptr), pmd_val(pmdval))
++#else
++#define set_pmd(pmdptr, pmdval) (*(pmdptr) = (pmdval))
++#endif
++
++struct mm_struct;
++extern pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address);
++
++static inline void pud_clear (pud_t *pud)
++{
++      set_pud(pud, __pud(_PAGE_NEWPAGE));
++}
++
++#define pud_page(pud) phys_to_page(pud_val(pud) & PAGE_MASK)
++#define pud_page_vaddr(pud) ((unsigned long) __va(pud_val(pud) & PAGE_MASK))
++
++/* Find an entry in the second-level page table.. */
++#define pmd_offset(pud, address) ((pmd_t *) pud_page_vaddr(*(pud)) + \
++                      pmd_index(address))
++
++static inline unsigned long pte_pfn(pte_t pte)
++{
++      return phys_to_pfn(pte_val(pte));
++}
++
++static inline pte_t pfn_pte(pfn_t page_nr, pgprot_t pgprot)
++{
++      pte_t pte;
++      phys_t phys = pfn_to_phys(page_nr);
++
++      pte_set_val(pte, phys, pgprot);
++      return pte;
++}
++
++static inline pmd_t pfn_pmd(pfn_t page_nr, pgprot_t pgprot)
++{
++      return __pmd((page_nr << PAGE_SHIFT) | pgprot_val(pgprot));
++}
++
++/*
++ * Bits 0 through 3 are taken in the low part of the pte,
++ * put the 32 bits of offset into the high part.
++ */
++#define PTE_FILE_MAX_BITS     32
++
++#ifdef CONFIG_64BIT
++
++#define pte_to_pgoff(p) ((p).pte >> 32)
++
++#define pgoff_to_pte(off) ((pte_t) { ((off) << 32) | _PAGE_FILE })
++
++#else
++
++#define pte_to_pgoff(pte) ((pte).pte_high)
++
++#define pgoff_to_pte(off) ((pte_t) { _PAGE_FILE, (off) })
++
++#endif
++
++#endif
++
+--- /dev/null
++++ b/arch/um/include/uapi/asm/pgtable.h
+@@ -0,0 +1,375 @@
++/* 
++ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
++ * Copyright 2003 PathScale, Inc.
++ * Derived from include/asm-i386/pgtable.h
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_PGTABLE_H
++#define __UM_PGTABLE_H
++
++#include <asm/fixmap.h>
++
++#define _PAGE_PRESENT 0x001
++#define _PAGE_NEWPAGE 0x002
++#define _PAGE_NEWPROT 0x004
++#define _PAGE_RW      0x020
++#define _PAGE_USER    0x040
++#define _PAGE_ACCESSED        0x080
++#define _PAGE_DIRTY   0x100
++/* If _PAGE_PRESENT is clear, we use these: */
++#define _PAGE_FILE    0x008   /* nonlinear file mapping, saved PTE; unset:swap */
++#define _PAGE_PROTNONE        0x010   /* if the user mapped it with PROT_NONE;
++                                 pte_present gives true */
++
++#ifdef CONFIG_3_LEVEL_PGTABLES
++#include <asm/pgtable-3level.h>
++#else
++#include <asm/pgtable-2level.h>
++#endif
++
++extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
++
++/* zero page used for uninitialized stuff */
++extern unsigned long *empty_zero_page;
++
++#define pgtable_cache_init() do ; while (0)
++
++/* Just any arbitrary offset to the start of the vmalloc VM area: the
++ * current 8MB value just means that there will be a 8MB "hole" after the
++ * physical memory until the kernel virtual memory starts.  That means that
++ * any out-of-bounds memory accesses will hopefully be caught.
++ * The vmalloc() routines leaves a hole of 4kB between each vmalloced
++ * area for the same reason. ;)
++ */
++
++extern unsigned long end_iomem;
++
++#define VMALLOC_OFFSET        (__va_space)
++#define VMALLOC_START ((end_iomem + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
++#define PKMAP_BASE ((FIXADDR_START - LAST_PKMAP * PAGE_SIZE) & PMD_MASK)
++#ifdef CONFIG_HIGHMEM
++# define VMALLOC_END  (PKMAP_BASE-2*PAGE_SIZE)
++#else
++# define VMALLOC_END  (FIXADDR_START-2*PAGE_SIZE)
++#endif
++#define MODULES_VADDR VMALLOC_START
++#define MODULES_END   VMALLOC_END
++#define MODULES_LEN   (MODULES_VADDR - MODULES_END)
++
++#define _PAGE_TABLE   (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
++#define _KERNPG_TABLE (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
++#define _PAGE_CHG_MASK        (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
++#define __PAGE_KERNEL_EXEC                                              \
++       (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
++#define PAGE_NONE     __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
++#define PAGE_SHARED   __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
++#define PAGE_COPY     __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
++#define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
++#define PAGE_KERNEL   __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
++#define PAGE_KERNEL_EXEC      __pgprot(__PAGE_KERNEL_EXEC)
++
++/*
++ * The i386 can't do page protection for execute, and considers that the same
++ * are read.
++ * Also, write permissions imply read permissions. This is the closest we can
++ * get..
++ */
++#define __P000        PAGE_NONE
++#define __P001        PAGE_READONLY
++#define __P010        PAGE_COPY
++#define __P011        PAGE_COPY
++#define __P100        PAGE_READONLY
++#define __P101        PAGE_READONLY
++#define __P110        PAGE_COPY
++#define __P111        PAGE_COPY
++
++#define __S000        PAGE_NONE
++#define __S001        PAGE_READONLY
++#define __S010        PAGE_SHARED
++#define __S011        PAGE_SHARED
++#define __S100        PAGE_READONLY
++#define __S101        PAGE_READONLY
++#define __S110        PAGE_SHARED
++#define __S111        PAGE_SHARED
++
++/*
++ * ZERO_PAGE is a global shared page that is always zero: used
++ * for zero-mapped memory areas etc..
++ */
++#define ZERO_PAGE(vaddr) virt_to_page(empty_zero_page)
++
++#define pte_clear(mm,addr,xp) pte_set_val(*(xp), (phys_t) 0, __pgprot(_PAGE_NEWPAGE))
++
++#define pmd_none(x)   (!((unsigned long)pmd_val(x) & ~_PAGE_NEWPAGE))
++#define       pmd_bad(x)      ((pmd_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
++
++#define pmd_present(x)        (pmd_val(x) & _PAGE_PRESENT)
++#define pmd_clear(xp) do { pmd_val(*(xp)) = _PAGE_NEWPAGE; } while (0)
++
++#define pmd_newpage(x)  (pmd_val(x) & _PAGE_NEWPAGE)
++#define pmd_mkuptodate(x) (pmd_val(x) &= ~_PAGE_NEWPAGE)
++
++#define pud_newpage(x)  (pud_val(x) & _PAGE_NEWPAGE)
++#define pud_mkuptodate(x) (pud_val(x) &= ~_PAGE_NEWPAGE)
++
++#define pmd_page(pmd) phys_to_page(pmd_val(pmd) & PAGE_MASK)
++
++#define pte_page(x) pfn_to_page(pte_pfn(x))
++
++#define pte_present(x)        pte_get_bits(x, (_PAGE_PRESENT | _PAGE_PROTNONE))
++
++/*
++ * =================================
++ * Flags checking section.
++ * =================================
++ */
++
++static inline int pte_none(pte_t pte)
++{
++      return pte_is_zero(pte);
++}
++
++/*
++ * The following only work if pte_present() is true.
++ * Undefined behaviour if not..
++ */
++static inline int pte_read(pte_t pte)
++{ 
++      return((pte_get_bits(pte, _PAGE_USER)) &&
++             !(pte_get_bits(pte, _PAGE_PROTNONE)));
++}
++
++static inline int pte_exec(pte_t pte){
++      return((pte_get_bits(pte, _PAGE_USER)) &&
++             !(pte_get_bits(pte, _PAGE_PROTNONE)));
++}
++
++static inline int pte_write(pte_t pte)
++{
++      return((pte_get_bits(pte, _PAGE_RW)) &&
++             !(pte_get_bits(pte, _PAGE_PROTNONE)));
++}
++
++/*
++ * The following only works if pte_present() is not true.
++ */
++static inline int pte_file(pte_t pte)
++{
++      return pte_get_bits(pte, _PAGE_FILE);
++}
++
++static inline int pte_dirty(pte_t pte)
++{
++      return pte_get_bits(pte, _PAGE_DIRTY);
++}
++
++static inline int pte_young(pte_t pte)
++{
++      return pte_get_bits(pte, _PAGE_ACCESSED);
++}
++
++static inline int pte_newpage(pte_t pte)
++{
++      return pte_get_bits(pte, _PAGE_NEWPAGE);
++}
++
++static inline int pte_newprot(pte_t pte)
++{ 
++      return(pte_present(pte) && (pte_get_bits(pte, _PAGE_NEWPROT)));
++}
++
++static inline int pte_special(pte_t pte)
++{
++      return 0;
++}
++
++/*
++ * =================================
++ * Flags setting section.
++ * =================================
++ */
++
++static inline pte_t pte_mknewprot(pte_t pte)
++{
++      pte_set_bits(pte, _PAGE_NEWPROT);
++      return(pte);
++}
++
++static inline pte_t pte_mkclean(pte_t pte)
++{
++      pte_clear_bits(pte, _PAGE_DIRTY);
++      return(pte);
++}
++
++static inline pte_t pte_mkold(pte_t pte)      
++{ 
++      pte_clear_bits(pte, _PAGE_ACCESSED);
++      return(pte);
++}
++
++static inline pte_t pte_wrprotect(pte_t pte)
++{ 
++      pte_clear_bits(pte, _PAGE_RW);
++      return(pte_mknewprot(pte)); 
++}
++
++static inline pte_t pte_mkread(pte_t pte)
++{ 
++      pte_set_bits(pte, _PAGE_USER);
++      return(pte_mknewprot(pte)); 
++}
++
++static inline pte_t pte_mkdirty(pte_t pte)
++{ 
++      pte_set_bits(pte, _PAGE_DIRTY);
++      return(pte);
++}
++
++static inline pte_t pte_mkyoung(pte_t pte)
++{
++      pte_set_bits(pte, _PAGE_ACCESSED);
++      return(pte);
++}
++
++static inline pte_t pte_mkwrite(pte_t pte)    
++{
++      pte_set_bits(pte, _PAGE_RW);
++      return(pte_mknewprot(pte)); 
++}
++
++static inline pte_t pte_mkuptodate(pte_t pte) 
++{
++      pte_clear_bits(pte, _PAGE_NEWPAGE);
++      if(pte_present(pte))
++              pte_clear_bits(pte, _PAGE_NEWPROT);
++      return(pte); 
++}
++
++static inline pte_t pte_mknewpage(pte_t pte)
++{
++      pte_set_bits(pte, _PAGE_NEWPAGE);
++      return(pte);
++}
++
++static inline pte_t pte_mkspecial(pte_t pte)
++{
++      return(pte);
++}
++
++static inline void set_pte(pte_t *pteptr, pte_t pteval)
++{
++      pte_copy(*pteptr, pteval);
++
++      /* If it's a swap entry, it needs to be marked _PAGE_NEWPAGE so
++       * fix_range knows to unmap it.  _PAGE_NEWPROT is specific to
++       * mapped pages.
++       */
++
++      *pteptr = pte_mknewpage(*pteptr);
++      if(pte_present(*pteptr)) *pteptr = pte_mknewprot(*pteptr);
++}
++#define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
++
++#define __HAVE_ARCH_PTE_SAME
++static inline int pte_same(pte_t pte_a, pte_t pte_b)
++{
++      return !((pte_val(pte_a) ^ pte_val(pte_b)) & ~_PAGE_NEWPAGE);
++}
++
++/*
++ * Conversion functions: convert a page and protection to a page entry,
++ * and a page entry and page directory to the page they refer to.
++ */
++
++#define phys_to_page(phys) pfn_to_page(phys_to_pfn(phys))
++#define __virt_to_page(virt) phys_to_page(__pa(virt))
++#define page_to_phys(page) pfn_to_phys((pfn_t) page_to_pfn(page))
++#define virt_to_page(addr) __virt_to_page((const unsigned long) addr)
++
++#define mk_pte(page, pgprot) \
++      ({ pte_t pte;                                   \
++                                                      \
++      pte_set_val(pte, page_to_phys(page), (pgprot)); \
++      if (pte_present(pte))                           \
++              pte_mknewprot(pte_mknewpage(pte));      \
++      pte;})
++
++static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
++{
++      pte_set_val(pte, (pte_val(pte) & _PAGE_CHG_MASK), newprot);
++      return pte; 
++}
++
++/*
++ * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
++ *
++ * this macro returns the index of the entry in the pgd page which would
++ * control the given virtual address
++ */
++#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
++
++/*
++ * pgd_offset() returns a (pgd_t *)
++ * pgd_index() is used get the offset into the pgd page's array of pgd_t's;
++ */
++#define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
++
++/*
++ * a shortcut which implies the use of the kernel's pgd, instead
++ * of a process's
++ */
++#define pgd_offset_k(address) pgd_offset(&init_mm, address)
++
++/*
++ * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
++ *
++ * this macro returns the index of the entry in the pmd page which would
++ * control the given virtual address
++ */
++#define pmd_page_vaddr(pmd) ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
++#define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
++
++#define pmd_page_vaddr(pmd) \
++      ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
++
++/*
++ * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
++ *
++ * this macro returns the index of the entry in the pte page which would
++ * control the given virtual address
++ */
++#define pte_index(address) (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
++#define pte_offset_kernel(dir, address) \
++      ((pte_t *) pmd_page_vaddr(*(dir)) +  pte_index(address))
++#define pte_offset_map(dir, address) \
++      ((pte_t *)page_address(pmd_page(*(dir))) + pte_index(address))
++#define pte_unmap(pte) do { } while (0)
++
++struct mm_struct;
++extern pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr);
++
++#define update_mmu_cache(vma,address,ptep) do ; while (0)
++
++/* Encode and de-code a swap entry */
++#define __swp_type(x)                 (((x).val >> 5) & 0x1f)
++#define __swp_offset(x)                       ((x).val >> 11)
++
++#define __swp_entry(type, offset) \
++      ((swp_entry_t) { ((type) << 5) | ((offset) << 11) })
++#define __pte_to_swp_entry(pte) \
++      ((swp_entry_t) { pte_val(pte_mkuptodate(pte)) })
++#define __swp_entry_to_pte(x)         ((pte_t) { (x).val })
++
++#define kern_addr_valid(addr) (1)
++
++#include <asm-generic/pgtable.h>
++
++/* Clear a kernel PTE and flush it from the TLB */
++#define kpte_clear_flush(ptep, vaddr)         \
++do {                                          \
++      pte_clear(&init_mm, (vaddr), (ptep));   \
++      __flush_tlb_one((vaddr));               \
++} while (0)
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/processor-generic.h
+@@ -0,0 +1,115 @@
++/* 
++ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_PROCESSOR_GENERIC_H
++#define __UM_PROCESSOR_GENERIC_H
++
++struct pt_regs;
++
++struct task_struct;
++
++#include <asm/ptrace.h>
++#include <registers.h>
++#include <sysdep/archsetjmp.h>
++
++#include <linux/prefetch.h>
++
++struct mm_struct;
++
++struct thread_struct {
++      struct pt_regs regs;
++      struct pt_regs *segv_regs;
++      int singlestep_syscall;
++      void *fault_addr;
++      jmp_buf *fault_catcher;
++      struct task_struct *prev_sched;
++      struct arch_thread arch;
++      jmp_buf switch_buf;
++      struct {
++              int op;
++              union {
++                      struct {
++                              int pid;
++                      } fork, exec;
++                      struct {
++                              int (*proc)(void *);
++                              void *arg;
++                      } thread;
++                      struct {
++                              void (*proc)(void *);
++                              void *arg;
++                      } cb;
++              } u;
++      } request;
++};
++
++#define INIT_THREAD \
++{ \
++      .regs                   = EMPTY_REGS,   \
++      .fault_addr             = NULL, \
++      .prev_sched             = NULL, \
++      .arch                   = INIT_ARCH_THREAD, \
++      .request                = { 0 } \
++}
++
++static inline void release_thread(struct task_struct *task)
++{
++}
++
++extern unsigned long thread_saved_pc(struct task_struct *t);
++
++static inline void mm_copy_segments(struct mm_struct *from_mm,
++                                  struct mm_struct *new_mm)
++{
++}
++
++#define init_stack    (init_thread_union.stack)
++
++/*
++ * User space process size: 3GB (default).
++ */
++extern unsigned long task_size;
++
++#define TASK_SIZE (task_size)
++
++#undef STACK_TOP
++#undef STACK_TOP_MAX
++
++extern unsigned long stacksizelim;
++
++#define STACK_ROOM    (stacksizelim)
++#define STACK_TOP     (TASK_SIZE - 2 * PAGE_SIZE)
++#define STACK_TOP_MAX STACK_TOP
++
++/* This decides where the kernel will search for a free chunk of vm
++ * space during mmap's.
++ */
++#define TASK_UNMAPPED_BASE    (0x40000000)
++
++extern void start_thread(struct pt_regs *regs, unsigned long entry, 
++                       unsigned long stack);
++
++struct cpuinfo_um {
++      unsigned long loops_per_jiffy;
++      int ipi_pipe[2];
++};
++
++extern struct cpuinfo_um boot_cpu_data;
++
++#define my_cpu_data           cpu_data[smp_processor_id()]
++
++#ifdef CONFIG_SMP
++extern struct cpuinfo_um cpu_data[];
++#define current_cpu_data cpu_data[smp_processor_id()]
++#else
++#define cpu_data (&boot_cpu_data)
++#define current_cpu_data boot_cpu_data
++#endif
++
++
++#define KSTK_REG(tsk, reg) get_thread_reg(reg, &tsk->thread.switch_buf)
++extern unsigned long get_wchan(struct task_struct *p);
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/ptrace-generic.h
+@@ -0,0 +1,45 @@
++/* 
++ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_PTRACE_GENERIC_H
++#define __UM_PTRACE_GENERIC_H
++
++#ifndef __ASSEMBLY__
++
++#include <asm/ptrace-abi.h>
++#include <sysdep/ptrace.h>
++
++struct pt_regs {
++      struct uml_pt_regs regs;
++};
++
++#define arch_has_single_step()        (1)
++
++#define EMPTY_REGS { .regs = EMPTY_UML_PT_REGS }
++
++#define PT_REGS_IP(r) UPT_IP(&(r)->regs)
++#define PT_REGS_SP(r) UPT_SP(&(r)->regs)
++
++#define PT_REGS_RESTART_SYSCALL(r) UPT_RESTART_SYSCALL(&(r)->regs)
++
++#define PT_REGS_SYSCALL_NR(r) UPT_SYSCALL_NR(&(r)->regs)
++
++#define instruction_pointer(regs) PT_REGS_IP(regs)
++
++struct task_struct;
++
++extern long subarch_ptrace(struct task_struct *child, long request,
++      unsigned long addr, unsigned long data);
++extern unsigned long getreg(struct task_struct *child, int regno);
++extern int putreg(struct task_struct *child, int regno, unsigned long value);
++
++extern int arch_copy_tls(struct task_struct *new);
++extern void clear_flushed_tls(struct task_struct *task);
++extern void syscall_trace_enter(struct pt_regs *regs);
++extern void syscall_trace_leave(struct pt_regs *regs);
++
++#endif
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/setup.h
+@@ -0,0 +1,10 @@
++#ifndef SETUP_H_INCLUDED
++#define SETUP_H_INCLUDED
++
++/* POSIX mandated with _POSIX_ARG_MAX that we can rely on 4096 chars in the
++ * command line, so this choice is ok.
++ */
++
++#define COMMAND_LINE_SIZE 4096
++
++#endif                /* SETUP_H_INCLUDED */
+--- /dev/null
++++ b/arch/um/include/uapi/asm/smp.h
+@@ -0,0 +1,32 @@
++#ifndef __UM_SMP_H
++#define __UM_SMP_H
++
++#ifdef CONFIG_SMP
++
++#include <linux/bitops.h>
++#include <asm/current.h>
++#include <linux/cpumask.h>
++
++#define raw_smp_processor_id() (current_thread->cpu)
++
++#define cpu_logical_map(n) (n)
++#define cpu_number_map(n) (n)
++extern int hard_smp_processor_id(void);
++#define NO_PROC_ID -1
++
++extern int ncpus;
++
++
++static inline void smp_cpus_done(unsigned int maxcpus)
++{
++}
++
++extern struct task_struct *idle_threads[NR_CPUS];
++
++#else
++
++#define hard_smp_processor_id()               0
++
++#endif
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/stacktrace.h
+@@ -0,0 +1,42 @@
++#ifndef _ASM_UML_STACKTRACE_H
++#define _ASM_UML_STACKTRACE_H
++
++#include <linux/uaccess.h>
++#include <linux/ptrace.h>
++
++struct stack_frame {
++      struct stack_frame *next_frame;
++      unsigned long return_address;
++};
++
++struct stacktrace_ops {
++      void (*address)(void *data, unsigned long address, int reliable);
++};
++
++#ifdef CONFIG_FRAME_POINTER
++static inline unsigned long
++get_frame_pointer(struct task_struct *task, struct pt_regs *segv_regs)
++{
++      if (!task || task == current)
++              return segv_regs ? PT_REGS_BP(segv_regs) : current_bp();
++      return KSTK_EBP(task);
++}
++#else
++static inline unsigned long
++get_frame_pointer(struct task_struct *task, struct pt_regs *segv_regs)
++{
++      return 0;
++}
++#endif
++
++static inline unsigned long
++*get_stack_pointer(struct task_struct *task, struct pt_regs *segv_regs)
++{
++      if (!task || task == current)
++              return segv_regs ? (unsigned long *)PT_REGS_SP(segv_regs) : current_sp();
++      return (unsigned long *)KSTK_ESP(task);
++}
++
++void dump_trace(struct task_struct *tsk, const struct stacktrace_ops *ops, void *data);
++
++#endif /* _ASM_UML_STACKTRACE_H */
+--- /dev/null
++++ b/arch/um/include/uapi/asm/sysrq.h
+@@ -0,0 +1,7 @@
++#ifndef __UM_SYSRQ_H
++#define __UM_SYSRQ_H
++
++struct task_struct;
++extern void show_trace(struct task_struct* task, unsigned long *stack);
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/thread_info.h
+@@ -0,0 +1,78 @@
++/*
++ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_THREAD_INFO_H
++#define __UM_THREAD_INFO_H
++
++#ifndef __ASSEMBLY__
++
++#include <asm/types.h>
++#include <asm/page.h>
++#include <asm/uaccess.h>
++
++struct thread_info {
++      struct task_struct      *task;          /* main task structure */
++      struct exec_domain      *exec_domain;   /* execution domain */
++      unsigned long           flags;          /* low level flags */
++      __u32                   cpu;            /* current CPU */
++      int                     preempt_count;  /* 0 => preemptable,
++                                                 <0 => BUG */
++      mm_segment_t            addr_limit;     /* thread address space:
++                                                 0-0xBFFFFFFF for user
++                                                 0-0xFFFFFFFF for kernel */
++      struct restart_block    restart_block;
++      struct thread_info      *real_thread;    /* Points to non-IRQ stack */
++};
++
++#define INIT_THREAD_INFO(tsk)                 \
++{                                             \
++      .task =         &tsk,                   \
++      .exec_domain =  &default_exec_domain,   \
++      .flags =                0,              \
++      .cpu =          0,                      \
++      .preempt_count = INIT_PREEMPT_COUNT,    \
++      .addr_limit =   KERNEL_DS,              \
++      .restart_block =  {                     \
++              .fn =  do_no_restart_syscall,   \
++      },                                      \
++      .real_thread = NULL,                    \
++}
++
++#define init_thread_info      (init_thread_union.thread_info)
++#define init_stack            (init_thread_union.stack)
++
++#define THREAD_SIZE ((1 << CONFIG_KERNEL_STACK_ORDER) * PAGE_SIZE)
++/* how to get the thread information struct from C */
++static inline struct thread_info *current_thread_info(void)
++{
++      struct thread_info *ti;
++      unsigned long mask = THREAD_SIZE - 1;
++      void *p;
++
++      asm volatile ("" : "=r" (p) : "0" (&ti));
++      ti = (struct thread_info *) (((unsigned long)p) & ~mask);
++      return ti;
++}
++
++#define THREAD_SIZE_ORDER CONFIG_KERNEL_STACK_ORDER
++
++#endif
++
++#define TIF_SYSCALL_TRACE     0       /* syscall trace active */
++#define TIF_SIGPENDING                1       /* signal pending */
++#define TIF_NEED_RESCHED      2       /* rescheduling necessary */
++#define TIF_RESTART_BLOCK     4
++#define TIF_MEMDIE            5       /* is terminating due to OOM killer */
++#define TIF_SYSCALL_AUDIT     6
++#define TIF_RESTORE_SIGMASK   7
++#define TIF_NOTIFY_RESUME     8
++
++#define _TIF_SYSCALL_TRACE    (1 << TIF_SYSCALL_TRACE)
++#define _TIF_SIGPENDING               (1 << TIF_SIGPENDING)
++#define _TIF_NEED_RESCHED     (1 << TIF_NEED_RESCHED)
++#define _TIF_MEMDIE           (1 << TIF_MEMDIE)
++#define _TIF_SYSCALL_AUDIT    (1 << TIF_SYSCALL_AUDIT)
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/timex.h
+@@ -0,0 +1,13 @@
++#ifndef __UM_TIMEX_H
++#define __UM_TIMEX_H
++
++typedef unsigned long cycles_t;
++
++static inline cycles_t get_cycles (void)
++{
++      return 0;
++}
++
++#define CLOCK_TICK_RATE (HZ)
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/tlb.h
+@@ -0,0 +1,134 @@
++#ifndef __UM_TLB_H
++#define __UM_TLB_H
++
++#include <linux/pagemap.h>
++#include <linux/swap.h>
++#include <asm/percpu.h>
++#include <asm/pgalloc.h>
++#include <asm/tlbflush.h>
++
++#define tlb_start_vma(tlb, vma) do { } while (0)
++#define tlb_end_vma(tlb, vma) do { } while (0)
++#define tlb_flush(tlb) flush_tlb_mm((tlb)->mm)
++
++/* struct mmu_gather is an opaque type used by the mm code for passing around
++ * any data needed by arch specific code for tlb_remove_page.
++ */
++struct mmu_gather {
++      struct mm_struct        *mm;
++      unsigned int            need_flush; /* Really unmapped some ptes? */
++      unsigned long           start;
++      unsigned long           end;
++      unsigned int            fullmm; /* non-zero means full mm flush */
++};
++
++static inline void __tlb_remove_tlb_entry(struct mmu_gather *tlb, pte_t *ptep,
++                                        unsigned long address)
++{
++      if (tlb->start > address)
++              tlb->start = address;
++      if (tlb->end < address + PAGE_SIZE)
++              tlb->end = address + PAGE_SIZE;
++}
++
++static inline void init_tlb_gather(struct mmu_gather *tlb)
++{
++      tlb->need_flush = 0;
++
++      tlb->start = TASK_SIZE;
++      tlb->end = 0;
++
++      if (tlb->fullmm) {
++              tlb->start = 0;
++              tlb->end = TASK_SIZE;
++      }
++}
++
++static inline void
++tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
++{
++      tlb->mm = mm;
++      tlb->start = start;
++      tlb->end = end;
++      tlb->fullmm = !(start | (end+1));
++
++      init_tlb_gather(tlb);
++}
++
++extern void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
++                             unsigned long end);
++
++static inline void
++tlb_flush_mmu_tlbonly(struct mmu_gather *tlb)
++{
++      flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end);
++}
++
++static inline void
++tlb_flush_mmu_free(struct mmu_gather *tlb)
++{
++      init_tlb_gather(tlb);
++}
++
++static inline void
++tlb_flush_mmu(struct mmu_gather *tlb)
++{
++      if (!tlb->need_flush)
++              return;
++
++      tlb_flush_mmu_tlbonly(tlb);
++      tlb_flush_mmu_free(tlb);
++}
++
++/* tlb_finish_mmu
++ *    Called at the end of the shootdown operation to free up any resources
++ *    that were required.
++ */
++static inline void
++tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
++{
++      tlb_flush_mmu(tlb);
++
++      /* keep the page table cache within bounds */
++      check_pgt_cache();
++}
++
++/* tlb_remove_page
++ *    Must perform the equivalent to __free_pte(pte_get_and_clear(ptep)),
++ *    while handling the additional races in SMP caused by other CPUs
++ *    caching valid mappings in their TLBs.
++ */
++static inline int __tlb_remove_page(struct mmu_gather *tlb, struct page *page)
++{
++      tlb->need_flush = 1;
++      free_page_and_swap_cache(page);
++      return 1; /* avoid calling tlb_flush_mmu */
++}
++
++static inline void tlb_remove_page(struct mmu_gather *tlb, struct page *page)
++{
++      __tlb_remove_page(tlb, page);
++}
++
++/**
++ * tlb_remove_tlb_entry - remember a pte unmapping for later tlb invalidation.
++ *
++ * Record the fact that pte's were really umapped in ->need_flush, so we can
++ * later optimise away the tlb invalidate.   This helps when userspace is
++ * unmapping already-unmapped pages, which happens quite a lot.
++ */
++#define tlb_remove_tlb_entry(tlb, ptep, address)              \
++      do {                                                    \
++              tlb->need_flush = 1;                            \
++              __tlb_remove_tlb_entry(tlb, ptep, address);     \
++      } while (0)
++
++#define pte_free_tlb(tlb, ptep, addr) __pte_free_tlb(tlb, ptep, addr)
++
++#define pud_free_tlb(tlb, pudp, addr) __pud_free_tlb(tlb, pudp, addr)
++
++#define pmd_free_tlb(tlb, pmdp, addr) __pmd_free_tlb(tlb, pmdp, addr)
++
++#define tlb_migrate_finish(mm) do {} while (0)
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/tlbflush.h
+@@ -0,0 +1,31 @@
++/*
++ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_TLBFLUSH_H
++#define __UM_TLBFLUSH_H
++
++#include <linux/mm.h>
++
++/*
++ * TLB flushing:
++ *
++ *  - flush_tlb() flushes the current mm struct TLBs
++ *  - flush_tlb_all() flushes all processes TLBs
++ *  - flush_tlb_mm(mm) flushes the specified mm context TLB's
++ *  - flush_tlb_page(vma, vmaddr) flushes one page
++ *  - flush_tlb_kernel_vm() flushes the kernel vm area
++ *  - flush_tlb_range(vma, start, end) flushes a range of pages
++ */
++
++extern void flush_tlb_all(void);
++extern void flush_tlb_mm(struct mm_struct *mm);
++extern void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, 
++                          unsigned long end);
++extern void flush_tlb_page(struct vm_area_struct *vma, unsigned long address);
++extern void flush_tlb_kernel_vm(void);
++extern void flush_tlb_kernel_range(unsigned long start, unsigned long end);
++extern void __flush_tlb_one(unsigned long addr);
++
++#endif
+--- /dev/null
++++ b/arch/um/include/uapi/asm/uaccess.h
+@@ -0,0 +1,178 @@
++/* 
++ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __UM_UACCESS_H
++#define __UM_UACCESS_H
++
++/* thread_info has a mm_segment_t in it, so put the definition up here */
++typedef struct {
++      unsigned long seg;
++} mm_segment_t;
++
++#include <linux/thread_info.h>
++#include <linux/errno.h>
++#include <asm/processor.h>
++#include <asm/elf.h>
++
++#define VERIFY_READ 0
++#define VERIFY_WRITE 1
++
++/*
++ * The fs value determines whether argument validity checking should be
++ * performed or not.  If get_fs() == USER_DS, checking is performed, with
++ * get_fs() == KERNEL_DS, checking is bypassed.
++ *
++ * For historical reasons, these macros are grossly misnamed.
++ */
++
++#define MAKE_MM_SEG(s)        ((mm_segment_t) { (s) })
++
++#define KERNEL_DS     MAKE_MM_SEG(0xFFFFFFFF)
++#define USER_DS               MAKE_MM_SEG(TASK_SIZE)
++
++#define get_ds()      (KERNEL_DS)
++#define get_fs()      (current_thread_info()->addr_limit)
++#define set_fs(x)     (current_thread_info()->addr_limit = (x))
++
++#define segment_eq(a, b) ((a).seg == (b).seg)
++
++#define __under_task_size(addr, size) \
++      (((unsigned long) (addr) < TASK_SIZE) && \
++       (((unsigned long) (addr) + (size)) < TASK_SIZE))
++
++#define __access_ok_vsyscall(type, addr, size) \
++       ((type == VERIFY_READ) && \
++        ((unsigned long) (addr) >= FIXADDR_USER_START) && \
++        ((unsigned long) (addr) + (size) <= FIXADDR_USER_END) && \
++        ((unsigned long) (addr) + (size) >= (unsigned long)(addr)))
++
++#define __addr_range_nowrap(addr, size) \
++      ((unsigned long) (addr) <= ((unsigned long) (addr) + (size)))
++
++#define access_ok(type, addr, size) \
++      (__addr_range_nowrap(addr, size) && \
++       (__under_task_size(addr, size) || \
++        __access_ok_vsyscall(type, addr, size) || \
++        segment_eq(get_fs(), KERNEL_DS)))
++
++extern int copy_from_user(void *to, const void __user *from, int n);
++extern int copy_to_user(void __user *to, const void *from, int n);
++
++/*
++ * strncpy_from_user: - Copy a NUL terminated string from userspace.
++ * @dst:   Destination address, in kernel space.  This buffer must be at
++ *         least @count bytes long.
++ * @src:   Source address, in user space.
++ * @count: Maximum number of bytes to copy, including the trailing NUL.
++ *
++ * Copies a NUL-terminated string from userspace to kernel space.
++ *
++ * On success, returns the length of the string (not including the trailing
++ * NUL).
++ *
++ * If access to userspace fails, returns -EFAULT (some data may have been
++ * copied).
++ *
++ * If @count is smaller than the length of the string, copies @count bytes
++ * and returns @count.
++ */
++
++extern int strncpy_from_user(char *dst, const char __user *src, int count);
++
++/*
++ * __clear_user: - Zero a block of memory in user space, with less checking.
++ * @to:   Destination address, in user space.
++ * @n:    Number of bytes to zero.
++ *
++ * Zero a block of memory in user space.  Caller must check
++ * the specified block with access_ok() before calling this function.
++ *
++ * Returns number of bytes that could not be cleared.
++ * On success, this will be zero.
++ */
++extern int __clear_user(void __user *mem, int len);
++
++/*
++ * clear_user: - Zero a block of memory in user space.
++ * @to:   Destination address, in user space.
++ * @n:    Number of bytes to zero.
++ *
++ * Zero a block of memory in user space.
++ *
++ * Returns number of bytes that could not be cleared.
++ * On success, this will be zero.
++ */
++extern int clear_user(void __user *mem, int len);
++
++/*
++ * strlen_user: - Get the size of a string in user space.
++ * @str: The string to measure.
++ * @n:   The maximum valid length
++ *
++ * Get the size of a NUL-terminated string in user space.
++ *
++ * Returns the size of the string INCLUDING the terminating NUL.
++ * On exception, returns 0.
++ * If the string is too long, returns a value greater than @n.
++ */
++extern int strnlen_user(const void __user *str, int len);
++
++#define __copy_from_user(to, from, n) copy_from_user(to, from, n)
++
++#define __copy_to_user(to, from, n) copy_to_user(to, from, n)
++
++#define __copy_to_user_inatomic __copy_to_user
++#define __copy_from_user_inatomic __copy_from_user
++
++#define __get_user(x, ptr) \
++({ \
++      const __typeof__(*(ptr)) __user *__private_ptr = (ptr); \
++      __typeof__(x) __private_val;                    \
++      int __private_ret = -EFAULT;                    \
++      (x) = (__typeof__(*(__private_ptr)))0;                          \
++      if (__copy_from_user((__force void *)&__private_val, (__private_ptr),\
++                           sizeof(*(__private_ptr))) == 0) {          \
++              (x) = (__typeof__(*(__private_ptr))) __private_val;     \
++              __private_ret = 0;                                      \
++      }                                                               \
++      __private_ret;                                                  \
++}) 
++
++#define get_user(x, ptr) \
++({ \
++        const __typeof__((*(ptr))) __user *private_ptr = (ptr); \
++        (access_ok(VERIFY_READ, private_ptr, sizeof(*private_ptr)) ? \
++       __get_user(x, private_ptr) : ((x) = (__typeof__(*ptr))0, -EFAULT)); \
++})
++
++#define __put_user(x, ptr) \
++({ \
++        __typeof__(*(ptr)) __user *__private_ptr = ptr; \
++        __typeof__(*(__private_ptr)) __private_val; \
++        int __private_ret = -EFAULT; \
++        __private_val = (__typeof__(*(__private_ptr))) (x); \
++        if (__copy_to_user((__private_ptr), &__private_val, \
++                         sizeof(*(__private_ptr))) == 0) { \
++              __private_ret = 0; \
++      } \
++        __private_ret; \
++})
++
++#define put_user(x, ptr) \
++({ \
++        __typeof__(*(ptr)) __user *private_ptr = (ptr); \
++        (access_ok(VERIFY_WRITE, private_ptr, sizeof(*private_ptr)) ? \
++       __put_user(x, private_ptr) : -EFAULT); \
++})
++
++#define strlen_user(str) strnlen_user(str, ~0U >> 1)
++
++struct exception_table_entry
++{
++        unsigned long insn;
++      unsigned long fixup;
++};
++
++#endif
diff --git a/target/linux/uml/patches-3.18/101-mconsole-exec.patch b/target/linux/uml/patches-3.18/101-mconsole-exec.patch
new file mode 100644 (file)
index 0000000..fc0b5fc
--- /dev/null
@@ -0,0 +1,211 @@
+#
+# Minimalist mconsole exec patch 
+#
+# 3.10 version (with bit more synchronous behavior) by fingon at iki dot fi
+# Adaptation to kernel 3.3.8 made by David Fernández (david at dit.upm.es) for 
+# Starting point: mconsole-exec-2.6.30.patch for kernel 2.6.30
+# Author of original patch: Paolo Giarrusso, aka Blaisorblade 
+#                           (http://www.user-mode-linux.org/~blaisorblade)
+#
+# Known misfeatures:
+#
+# - If output is too long, blocks (and breaks horribly) 
+# (this misfeature from 3.10 patches, when minimalizing the patch;
+#  workaround: redirect to a shared filesystem if long output is expected)
+#
+# - Nothing useful is done with stdin
+#
+--- a/arch/um/drivers/mconsole.h
++++ b/arch/um/drivers/mconsole.h
+@@ -85,6 +85,7 @@ extern void mconsole_cad(struct mc_reque
+ extern void mconsole_stop(struct mc_request *req);
+ extern void mconsole_go(struct mc_request *req);
+ extern void mconsole_log(struct mc_request *req);
++extern void mconsole_exec(struct mc_request *req);
+ extern void mconsole_proc(struct mc_request *req);
+ extern void mconsole_stack(struct mc_request *req);
+--- a/arch/um/drivers/mconsole_kern.c
++++ b/arch/um/drivers/mconsole_kern.c
+@@ -4,6 +4,7 @@
+  * Licensed under the GPL
+  */
++#include "linux/kmod.h"
+ #include <linux/console.h>
+ #include <linux/ctype.h>
+ #include <linux/string.h>
+@@ -24,6 +25,7 @@
+ #include <linux/fs.h>
+ #include <linux/mount.h>
+ #include <linux/file.h>
++#include <linux/completion.h>
+ #include <asm/uaccess.h>
+ #include <asm/switch_to.h>
+@@ -121,6 +123,59 @@ void mconsole_log(struct mc_request *req
+       mconsole_reply(req, "", 0, 0);
+ }
++void mconsole_exec(struct mc_request *req)
++{
++  struct subprocess_info *sub_info;
++  int res, len;
++  struct file *out;
++  char buf[MCONSOLE_MAX_DATA];
++
++  char *envp[] = {
++    "HOME=/", "TERM=linux",
++    "PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin",
++    NULL
++  };
++  char *argv[] = {
++    "/bin/sh", "-c",
++    req->request.data + strlen("exec "),
++    NULL
++  };
++
++  sub_info = call_usermodehelper_setup("/bin/sh", argv, envp, GFP_ATOMIC, NULL, NULL, NULL);
++  if (sub_info == NULL) {
++    mconsole_reply(req, "call_usermodehelper_setup failed", 1, 0);
++    return;
++  }
++  res = call_usermodehelper_stdoutpipe(sub_info, &out);
++  if (res < 0) {
++    kfree(sub_info);
++    mconsole_reply(req, "call_usermodehelper_stdoutpipe failed", 1, 0);
++    return;
++  }
++
++  res = call_usermodehelper_exec(sub_info, UMH_WAIT_PROC);
++  if (res < 0) {
++    kfree(sub_info);
++    mconsole_reply(req, "call_usermodehelper_exec failed", 1, 0);
++    return;
++  }
++
++  for (;;) {
++    len = out->f_op->read(out, buf, sizeof(buf), &out->f_pos);
++    if (len < 0) {
++      mconsole_reply(req, "reading output failed", 1, 0);
++      break;
++    }
++    if (len == 0)
++      break;
++    mconsole_reply_len(req, buf, len, 0, 1);
++  }
++  fput(out);
++
++  mconsole_reply_len(req, NULL, 0, 0, 0);
++}
++
++
+ void mconsole_proc(struct mc_request *req)
+ {
+       struct vfsmount *mnt = task_active_pid_ns(current)->proc_mnt;
+@@ -187,6 +242,7 @@ void mconsole_proc(struct mc_request *re
+     stop - pause the UML; it will do nothing until it receives a 'go' \n\
+     go - continue the UML after a 'stop' \n\
+     log <string> - make UML enter <string> into the kernel log\n\
++    exec <string> - pass <string> to /bin/sh -c synchronously\n\
+     proc <file> - returns the contents of the UML's /proc/<file>\n\
+     stack <pid> - returns the stack of the specified pid\n\
+ "
+--- a/arch/um/drivers/mconsole_user.c
++++ b/arch/um/drivers/mconsole_user.c
+@@ -30,6 +30,7 @@ static struct mconsole_command commands[
+       { "stop", mconsole_stop, MCONSOLE_PROC },
+       { "go", mconsole_go, MCONSOLE_INTR },
+       { "log", mconsole_log, MCONSOLE_INTR },
++      { "exec", mconsole_exec, MCONSOLE_PROC },
+       { "proc", mconsole_proc, MCONSOLE_PROC },
+       { "stack", mconsole_stack, MCONSOLE_INTR },
+ };
+--- a/arch/um/os-Linux/file.c
++++ b/arch/um/os-Linux/file.c
+@@ -534,6 +534,8 @@ int os_create_unix_socket(const char *fi
+       addr.sun_family = AF_UNIX;
++      if (len > sizeof(addr.sun_path))
++              len = sizeof(addr.sun_path);
+       snprintf(addr.sun_path, len, "%s", file);
+       err = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
+--- a/include/linux/kmod.h
++++ b/include/linux/kmod.h
+@@ -62,6 +62,7 @@ struct subprocess_info {
+       int wait;
+       int retval;
+       int (*init)(struct subprocess_info *info, struct cred *new);
++      struct file *stdout;
+       void (*cleanup)(struct subprocess_info *info);
+       void *data;
+ };
+@@ -104,4 +105,6 @@ extern int usermodehelper_read_trylock(v
+ extern long usermodehelper_read_lock_wait(long timeout);
+ extern void usermodehelper_read_unlock(void);
++int call_usermodehelper_stdoutpipe(struct subprocess_info *sub_info, struct file **filp);
++
+ #endif /* __LINUX_KMOD_H__ */
+--- a/kernel/kmod.c
++++ b/kernel/kmod.c
+@@ -39,6 +39,7 @@
+ #include <linux/rwsem.h>
+ #include <linux/ptrace.h>
+ #include <linux/async.h>
++#include <linux/pipe_fs_i.h>
+ #include <asm/uaccess.h>
+ #include <trace/events/module.h>
+@@ -231,6 +232,28 @@ static int ____call_usermodehelper(void
+       flush_signal_handlers(current, 1);
+       spin_unlock_irq(&current->sighand->siglock);
++        /* Install output when needed */
++        if (sub_info->stdout) {
++                struct files_struct *f = current->files;
++                struct fdtable *fdt;
++
++                sys_close(1);
++                sys_close(2);
++                get_file(sub_info->stdout);
++                fd_install(1, sub_info->stdout);
++                fd_install(2, sub_info->stdout);
++                spin_lock(&f->file_lock);
++                fdt = files_fdtable(f);
++                __set_bit(1, fdt->open_fds);
++                __clear_bit(1, fdt->close_on_exec);
++                __set_bit(2, fdt->open_fds);
++                __clear_bit(2, fdt->close_on_exec);
++                spin_unlock(&f->file_lock);
++
++                /* disallow core files */
++                current->signal->rlim[RLIMIT_CORE] = (struct rlimit){0, 0};
++        }
++
+       /* We can run anywhere, unlike our parent keventd(). */
+       set_cpus_allowed_ptr(current, cpu_all_mask);
+@@ -544,6 +567,20 @@ struct subprocess_info *call_usermodehel
+ }
+ EXPORT_SYMBOL(call_usermodehelper_setup);
++int call_usermodehelper_stdoutpipe(struct subprocess_info *sub_info,
++                                 struct file **filp)
++{
++  struct file *f[2];
++
++  if (create_pipe_files(f, 0)<0)
++    return PTR_ERR(f);
++  sub_info->stdout = f[1];
++  *filp = f[0];
++  return 0;
++}
++EXPORT_SYMBOL(call_usermodehelper_stdoutpipe);
++
++
+ /**
+  * call_usermodehelper_exec - start a usermode application
+  * @sub_info: information about the subprocessa
diff --git a/target/linux/uml/patches-3.18/102-pseudo-random-mac.patch b/target/linux/uml/patches-3.18/102-pseudo-random-mac.patch
new file mode 100644 (file)
index 0000000..fc54f60
--- /dev/null
@@ -0,0 +1,124 @@
+===============================================================================
+
+This patch makes MAC addresses of network interfaces predictable. In
+particular, it adds a small routine that computes MAC addresses of based on
+a SHA1 hash of the virtual machine name and interface ID.
+
+TECHNICAL INFORMATION:
+
+Applies to vanilla kernel 3.9.4.
+
+===============================================================================
+--- a/arch/um/Kconfig.net
++++ b/arch/um/Kconfig.net
+@@ -21,6 +21,19 @@ config UML_NET
+         enable at least one of the following transport options to actually
+         make use of UML networking.
++config UML_NET_RANDOM_MAC
++      bool "Use random MAC addresses for network interfaces"
++      default n
++      depends on UML_NET
++      help
++        Virtual network devices inside a User-Mode Linux instance must be
++        assigned a MAC (Ethernet) address. If none is specified on the UML
++        command line, one must be automatically computed. If this option is
++        enabled, a randomly generated address is used. Otherwise, if this
++        option is disabled, the address is generated from a SHA1 hash of
++        the umid of the UML instance and the interface name. The latter choice
++        is useful to make MAC addresses predictable.
++
+ config UML_NET_ETHERTAP
+       bool "Ethertap transport"
+       depends on UML_NET
+--- a/arch/um/drivers/net_kern.c
++++ b/arch/um/drivers/net_kern.c
+@@ -25,6 +25,13 @@
+ #include <net_kern.h>
+ #include <net_user.h>
++#include <crypto/sha.h>
++#include <linux/string.h>
++#include <linux/crypto.h>
++#include <linux/err.h>
++#include <linux/scatterlist.h>
++#include "os.h"
++
+ #define DRIVER_NAME "uml-netdev"
+ static DEFINE_SPINLOCK(opened_lock);
+@@ -295,11 +302,47 @@ static void uml_net_user_timer_expire(un
+ #endif
+ }
++#ifndef CONFIG_UML_NET_RANDOM_MAC
++
++/* Compute a SHA1 hash of the UML instance's id and
++ *  * an interface name. */
++static int compute_hash(const char *umid, const char *ifname, char *hash) {
++      char vmif[1024];
++      struct scatterlist sg;
++      struct crypto_hash *tfm;
++      struct hash_desc desc;
++
++      strcpy (vmif, umid);
++      strcat (vmif, ifname);
++
++      tfm = crypto_alloc_hash("sha1", 0, CRYPTO_ALG_ASYNC);
++      if (IS_ERR(tfm))
++              return 1;
++
++      desc.tfm = tfm;
++      desc.flags = 0;
++
++      sg_init_table(&sg, 1);
++      sg_set_buf(&sg, vmif, strlen(vmif));
++
++      if (crypto_hash_digest(&desc, &sg, strlen(vmif), hash)) {
++              crypto_free_hash(tfm);
++              return 1;
++      }
++
++      crypto_free_hash(tfm);
++
++      return 0;
++}
++
++#endif
++
+ static void setup_etheraddr(struct net_device *dev, char *str)
+ {
+       unsigned char *addr = dev->dev_addr;
+       char *end;
+       int i;
++      u8 hash[SHA1_DIGEST_SIZE];
+       if (str == NULL)
+               goto random;
+@@ -340,9 +383,26 @@ static void setup_etheraddr(struct net_d
+       return;
+ random:
++#ifdef CONFIG_UML_NET_RANDOM_MAC
+       printk(KERN_INFO
+              "Choosing a random ethernet address for device %s\n", dev->name);
+       eth_hw_addr_random(dev);
++#else
++      printk(KERN_INFO
++             "Computing a digest to use as ethernet address for device %s\n", dev->name);
++      if (compute_hash(get_umid(), dev->name, hash)) {
++              printk(KERN_WARNING
++                     "Could not compute digest to use as ethernet address for device %s. "
++                     "Using random address instead.\n", dev->name);
++              random_ether_addr(addr);
++      }
++      else {
++              for (i=0; i < 6; i++)
++                      addr[i] = (hash[i] + hash[i+6]) % 0x100;
++      }
++      addr [0] &= 0xfe; /* clear multicast bit */
++      addr [0] |= 0x02; /* set local assignment bit (IEEE802) */
++#endif
+ }
+ static DEFINE_SPINLOCK(devices_lock);