target/linux/uml/patches-3.14/001-fix_make_headers_install.patch

   1 From faec6b6c2cc0219e74569c13f581fc11d8f3fc57 Mon Sep 17 00:00:00 2001
   2 From: Florian Fainelli <florian@openwrt.org>
   3 Date: Sun, 17 Mar 2013 20:12:10 +0100
   4 Subject: [PATCH] UM: fix make headers_install after UAPI header installation
   5
   6 Commit 10b63956 (UAPI: Plumb the UAPI Kbuilds into the user
   7 header installation and checking) breaks UML make headers_install with
   8 the following:
   9
  10 $ ARCH=um make headers_install
  11   CHK     include/generated/uapi/linux/version.h
  12   UPD     include/generated/uapi/linux/version.h
  13   HOSTCC  scripts/basic/fixdep
  14   WRAP    arch/um/include/generated/asm/bug.h
  15 [snip]
  16   WRAP    arch/um/include/generated/asm/trace_clock.h
  17   SYSHDR  arch/x86/syscalls/../include/generated/uapi/asm/unistd_32.h
  18   SYSHDR  arch/x86/syscalls/../include/generated/uapi/asm/unistd_64.h
  19   SYSHDR  arch/x86/syscalls/../include/generated/uapi/asm/unistd_x32.h
  20   SYSTBL  arch/x86/syscalls/../include/generated/asm/syscalls_32.h
  21   HOSTCC  scripts/unifdef
  22 Makefile:912: *** Headers not exportable for the um architecture.  Stop.
  23 zsh: exit 2     ARCH=um make headers_install
  24
  25 The reason for that is because the top-level Makefile does the
  26 following:
  27         $(if $(wildcard $(srctree)/arch/$(hdr-arch)/include/uapi/asm/Kbuild),, \
  28           $(error Headers not exportable for the $(SRCARCH) architecture))
  29
  30 we end-up in the else part of the $(if) statement because UML still uses
  31 the old path in arch/um/include/asm/Kbuild. This patch fixes the issue
  32 by moving the header files to be in arch/um/include/uapi/asm/ thus
  33 making headers_install (and other make targets checking for uapi) to
  34 succeed.
  35
  36 Signed-off-by: Florian Fainelli <florian@openwrt.org>
  37 ---
  38 Richard, this has been broken for 3.7+ onwards, if you want me to send
  39 you separate patches for 3.7 and 3.8 let me know. Thanks!
  40
  41  arch/um/include/{ => uapi}/asm/Kbuild              |    0
  42  arch/um/include/{ => uapi}/asm/a.out-core.h        |    0
  43  arch/um/include/{ => uapi}/asm/bugs.h              |    0
  44  arch/um/include/{ => uapi}/asm/cache.h             |    0
  45  arch/um/include/{ => uapi}/asm/common.lds.S        |    0
  46  arch/um/include/{ => uapi}/asm/dma.h               |    0
  47  arch/um/include/{ => uapi}/asm/fixmap.h            |    0
  48  arch/um/include/{ => uapi}/asm/irq.h               |    0
  49  arch/um/include/{ => uapi}/asm/irqflags.h          |    0
  50  arch/um/include/{ => uapi}/asm/kmap_types.h        |    0
  51  arch/um/include/{ => uapi}/asm/kvm_para.h          |    0
  52  arch/um/include/{ => uapi}/asm/mmu.h               |    0
  53  arch/um/include/{ => uapi}/asm/mmu_context.h       |    0
  54  arch/um/include/{ => uapi}/asm/page.h              |    0
  55  arch/um/include/{ => uapi}/asm/pgalloc.h           |    0
  56  arch/um/include/{ => uapi}/asm/pgtable-2level.h    |    0
  57  arch/um/include/{ => uapi}/asm/pgtable-3level.h    |    0
  58  arch/um/include/{ => uapi}/asm/pgtable.h           |    0
  59  arch/um/include/{ => uapi}/asm/processor-generic.h |    0
  60  arch/um/include/{ => uapi}/asm/ptrace-generic.h    |    0
  61  arch/um/include/{ => uapi}/asm/setup.h             |    0
  62  arch/um/include/{ => uapi}/asm/smp.h               |    0
  63  arch/um/include/{ => uapi}/asm/sysrq.h             |    0
  64  arch/um/include/{ => uapi}/asm/thread_info.h       |    0
  65  arch/um/include/{ => uapi}/asm/timex.h             |    0
  66  arch/um/include/{ => uapi}/asm/tlb.h               |    0
  67  arch/um/include/{ => uapi}/asm/tlbflush.h          |    0
  68  arch/um/include/{ => uapi}/asm/uaccess.h           |    0
  69  28 files changed, 0 insertions(+), 0 deletions(-)
  70  rename arch/um/include/{ => uapi}/asm/Kbuild (100%)
  71  rename arch/um/include/{ => uapi}/asm/a.out-core.h (100%)
  72  rename arch/um/include/{ => uapi}/asm/bugs.h (100%)
  73  rename arch/um/include/{ => uapi}/asm/cache.h (100%)
  74  rename arch/um/include/{ => uapi}/asm/common.lds.S (100%)
  75  rename arch/um/include/{ => uapi}/asm/dma.h (100%)
  76  rename arch/um/include/{ => uapi}/asm/fixmap.h (100%)
  77  rename arch/um/include/{ => uapi}/asm/irq.h (100%)
  78  rename arch/um/include/{ => uapi}/asm/irqflags.h (100%)
  79  rename arch/um/include/{ => uapi}/asm/kmap_types.h (100%)
  80  rename arch/um/include/{ => uapi}/asm/kvm_para.h (100%)
  81  rename arch/um/include/{ => uapi}/asm/mmu.h (100%)
  82  rename arch/um/include/{ => uapi}/asm/mmu_context.h (100%)
  83  rename arch/um/include/{ => uapi}/asm/page.h (100%)
  84  rename arch/um/include/{ => uapi}/asm/pgalloc.h (100%)
  85  rename arch/um/include/{ => uapi}/asm/pgtable-2level.h (100%)
  86  rename arch/um/include/{ => uapi}/asm/pgtable-3level.h (100%)
  87  rename arch/um/include/{ => uapi}/asm/pgtable.h (100%)
  88  rename arch/um/include/{ => uapi}/asm/processor-generic.h (100%)
  89  rename arch/um/include/{ => uapi}/asm/ptrace-generic.h (100%)
  90  rename arch/um/include/{ => uapi}/asm/setup.h (100%)
  91  rename arch/um/include/{ => uapi}/asm/smp.h (100%)
  92  rename arch/um/include/{ => uapi}/asm/sysrq.h (100%)
  93  rename arch/um/include/{ => uapi}/asm/thread_info.h (100%)
  94  rename arch/um/include/{ => uapi}/asm/timex.h (100%)
  95  rename arch/um/include/{ => uapi}/asm/tlb.h (100%)
  96  rename arch/um/include/{ => uapi}/asm/tlbflush.h (100%)
  97  rename arch/um/include/{ => uapi}/asm/uaccess.h (100%)
  98
  99 --- a/arch/um/include/asm/Kbuild
 100 +++ /dev/null
 101 @@ -1,8 +0,0 @@
 102 -generic-y += bug.h cputime.h device.h emergency-restart.h futex.h hardirq.h
 103 -generic-y += hw_irq.h irq_regs.h kdebug.h percpu.h sections.h topology.h xor.h
 104 -generic-y += ftrace.h pci.h io.h param.h delay.h mutex.h current.h exec.h
 105 -generic-y += switch_to.h clkdev.h
 106 -generic-y += trace_clock.h
 107 -generic-y += preempt.h
 108 -generic-y += hash.h
 109 -generic-y += barrier.h
 110 --- a/arch/um/include/asm/a.out-core.h
 111 +++ /dev/null
 112 @@ -1,27 +0,0 @@
 113 -/* a.out coredump register dumper
 114 - *
 115 - * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 116 - * Written by David Howells (dhowells@redhat.com)
 117 - *
 118 - * This program is free software; you can redistribute it and/or
 119 - * modify it under the terms of the GNU General Public Licence
 120 - * as published by the Free Software Foundation; either version
 121 - * 2 of the Licence, or (at your option) any later version.
 122 - */
 123 -
 124 -#ifndef __UM_A_OUT_CORE_H
 125 -#define __UM_A_OUT_CORE_H
 126 -
 127 -#ifdef __KERNEL__
 128 -
 129 -#include <linux/user.h>
 130 -
 131 -/*
 132 - * fill in the user structure for an a.out core dump
 133 - */
 134 -static inline void aout_dump_thread(struct pt_regs *regs, struct user *u)
 135 -{
 136 -}
 137 -
 138 -#endif /* __KERNEL__ */
 139 -#endif /* __UM_A_OUT_CORE_H */
 140 --- a/arch/um/include/asm/bugs.h
 141 +++ /dev/null
 142 @@ -1,6 +0,0 @@
 143 -#ifndef __UM_BUGS_H
 144 -#define __UM_BUGS_H
 145 -
 146 -void check_bugs(void);
 147 -
 148 -#endif
 149 --- a/arch/um/include/asm/cache.h
 150 +++ /dev/null
 151 @@ -1,17 +0,0 @@
 152 -#ifndef __UM_CACHE_H
 153 -#define __UM_CACHE_H
 154 -
 155 -
 156 -#if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
 157 -# define L1_CACHE_SHIFT                (CONFIG_X86_L1_CACHE_SHIFT)
 158 -#elif defined(CONFIG_UML_X86) /* 64-bit */
 159 -# define L1_CACHE_SHIFT                6 /* Should be 7 on Intel */
 160 -#else
 161 -/* XXX: this was taken from x86, now it's completely random. Luckily only
 162 - * affects SMP padding. */
 163 -# define L1_CACHE_SHIFT                5
 164 -#endif
 165 -
 166 -#define L1_CACHE_BYTES         (1 << L1_CACHE_SHIFT)
 167 -
 168 -#endif
 169 --- a/arch/um/include/asm/common.lds.S
 170 +++ /dev/null
 171 @@ -1,107 +0,0 @@
 172 -#include <asm-generic/vmlinux.lds.h>
 173 -
 174 -  .fini      : { *(.fini)    } =0x9090
 175 -  _etext = .;
 176 -  PROVIDE (etext = .);
 177 -
 178 -  . = ALIGN(4096);
 179 -  _sdata = .;
 180 -  PROVIDE (sdata = .);
 181 -
 182 -  RODATA
 183 -
 184 -  .unprotected : { *(.unprotected) }
 185 -  . = ALIGN(4096);
 186 -  PROVIDE (_unprotected_end = .);
 187 -
 188 -  . = ALIGN(4096);
 189 -  .note : { *(.note.*) }
 190 -  EXCEPTION_TABLE(0)
 191 -
 192 -  BUG_TABLE
 193 -
 194 -  .uml.setup.init : {
 195 -       __uml_setup_start = .;
 196 -       *(.uml.setup.init)
 197 -       __uml_setup_end = .;
 198 -  }
 199 -
 200 -  .uml.help.init : {
 201 -       __uml_help_start = .;
 202 -       *(.uml.help.init)
 203 -       __uml_help_end = .;
 204 -  }
 205 -
 206 -  .uml.postsetup.init : {
 207 -       __uml_postsetup_start = .;
 208 -       *(.uml.postsetup.init)
 209 -       __uml_postsetup_end = .;
 210 -  }
 211 -
 212 -  .init.setup : {
 213 -       INIT_SETUP(0)
 214 -  }
 215 -
 216 -  PERCPU_SECTION(32)
 217 -
 218 -  .initcall.init : {
 219 -       INIT_CALLS
 220 -  }
 221 -
 222 -  .con_initcall.init : {
 223 -       CON_INITCALL
 224 -  }
 225 -
 226 -  .uml.initcall.init : {
 227 -       __uml_initcall_start = .;
 228 -       *(.uml.initcall.init)
 229 -       __uml_initcall_end = .;
 230 -  }
 231 -
 232 -  SECURITY_INIT
 233 -
 234 -  .exitcall : {
 235 -       __exitcall_begin = .;
 236 -       *(.exitcall.exit)
 237 -       __exitcall_end = .;
 238 -  }
 239 -
 240 -  .uml.exitcall : {
 241 -       __uml_exitcall_begin = .;
 242 -       *(.uml.exitcall.exit)
 243 -       __uml_exitcall_end = .;
 244 -  }
 245 -
 246 -  . = ALIGN(4);
 247 -  .altinstructions : {
 248 -       __alt_instructions = .;
 249 -       *(.altinstructions)
 250 -       __alt_instructions_end = .;
 251 -  }
 252 -  .altinstr_replacement : { *(.altinstr_replacement) }
 253 -  /* .exit.text is discard at runtime, not link time, to deal with references
 254 -     from .altinstructions and .eh_frame */
 255 -  .exit.text : { *(.exit.text) }
 256 -  .exit.data : { *(.exit.data) }
 257 -
 258 -  .preinit_array : {
 259 -       __preinit_array_start = .;
 260 -       *(.preinit_array)
 261 -       __preinit_array_end = .;
 262 -  }
 263 -  .init_array : {
 264 -       __init_array_start = .;
 265 -       *(.init_array)
 266 -       __init_array_end = .;
 267 -  }
 268 -  .fini_array : {
 269 -       __fini_array_start = .;
 270 -       *(.fini_array)
 271 -       __fini_array_end = .;
 272 -  }
 273 -
 274 -   . = ALIGN(4096);
 275 -  .init.ramfs : {
 276 -       INIT_RAM_FS
 277 -  }
 278 -
 279 --- a/arch/um/include/asm/dma.h
 280 +++ /dev/null
 281 @@ -1,10 +0,0 @@
 282 -#ifndef __UM_DMA_H
 283 -#define __UM_DMA_H
 284 -
 285 -#include <asm/io.h>
 286 -
 287 -extern unsigned long uml_physmem;
 288 -
 289 -#define MAX_DMA_ADDRESS (uml_physmem)
 290 -
 291 -#endif
 292 --- a/arch/um/include/asm/fixmap.h
 293 +++ /dev/null
 294 @@ -1,60 +0,0 @@
 295 -#ifndef __UM_FIXMAP_H
 296 -#define __UM_FIXMAP_H
 297 -
 298 -#include <asm/processor.h>
 299 -#include <asm/kmap_types.h>
 300 -#include <asm/archparam.h>
 301 -#include <asm/page.h>
 302 -#include <linux/threads.h>
 303 -
 304 -/*
 305 - * Here we define all the compile-time 'special' virtual
 306 - * addresses. The point is to have a constant address at
 307 - * compile time, but to set the physical address only
 308 - * in the boot process. We allocate these special  addresses
 309 - * from the end of virtual memory (0xfffff000) backwards.
 310 - * Also this lets us do fail-safe vmalloc(), we
 311 - * can guarantee that these special addresses and
 312 - * vmalloc()-ed addresses never overlap.
 313 - *
 314 - * these 'compile-time allocated' memory buffers are
 315 - * fixed-size 4k pages. (or larger if used with an increment
 316 - * highger than 1) use fixmap_set(idx,phys) to associate
 317 - * physical memory with fixmap indices.
 318 - *
 319 - * TLB entries of such buffers will not be flushed across
 320 - * task switches.
 321 - */
 322 -
 323 -/*
 324 - * on UP currently we will have no trace of the fixmap mechanizm,
 325 - * no page table allocations, etc. This might change in the
 326 - * future, say framebuffers for the console driver(s) could be
 327 - * fix-mapped?
 328 - */
 329 -enum fixed_addresses {
 330 -#ifdef CONFIG_HIGHMEM
 331 -       FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */
 332 -       FIX_KMAP_END = FIX_KMAP_BEGIN+(KM_TYPE_NR*NR_CPUS)-1,
 333 -#endif
 334 -       __end_of_fixed_addresses
 335 -};
 336 -
 337 -extern void __set_fixmap (enum fixed_addresses idx,
 338 -                         unsigned long phys, pgprot_t flags);
 339 -
 340 -/*
 341 - * used by vmalloc.c.
 342 - *
 343 - * Leave one empty page between vmalloc'ed areas and
 344 - * the start of the fixmap, and leave one page empty
 345 - * at the top of mem..
 346 - */
 347 -
 348 -#define FIXADDR_TOP    (TASK_SIZE - 2 * PAGE_SIZE)
 349 -#define FIXADDR_SIZE   (__end_of_fixed_addresses << PAGE_SHIFT)
 350 -#define FIXADDR_START  (FIXADDR_TOP - FIXADDR_SIZE)
 351 -
 352 -#include <asm-generic/fixmap.h>
 353 -
 354 -#endif
 355 --- a/arch/um/include/asm/irq.h
 356 +++ /dev/null
 357 @@ -1,23 +0,0 @@
 358 -#ifndef __UM_IRQ_H
 359 -#define __UM_IRQ_H
 360 -
 361 -#define TIMER_IRQ              0
 362 -#define UMN_IRQ                        1
 363 -#define CONSOLE_IRQ            2
 364 -#define CONSOLE_WRITE_IRQ      3
 365 -#define UBD_IRQ                        4
 366 -#define UM_ETH_IRQ             5
 367 -#define SSL_IRQ                        6
 368 -#define SSL_WRITE_IRQ          7
 369 -#define ACCEPT_IRQ             8
 370 -#define MCONSOLE_IRQ           9
 371 -#define WINCH_IRQ              10
 372 -#define SIGIO_WRITE_IRQ        11
 373 -#define TELNETD_IRQ            12
 374 -#define XTERM_IRQ              13
 375 -#define RANDOM_IRQ             14
 376 -
 377 -#define LAST_IRQ RANDOM_IRQ
 378 -#define NR_IRQS (LAST_IRQ + 1)
 379 -
 380 -#endif
 381 --- a/arch/um/include/asm/irqflags.h
 382 +++ /dev/null
 383 @@ -1,42 +0,0 @@
 384 -#ifndef __UM_IRQFLAGS_H
 385 -#define __UM_IRQFLAGS_H
 386 -
 387 -extern int get_signals(void);
 388 -extern int set_signals(int enable);
 389 -extern void block_signals(void);
 390 -extern void unblock_signals(void);
 391 -
 392 -static inline unsigned long arch_local_save_flags(void)
 393 -{
 394 -       return get_signals();
 395 -}
 396 -
 397 -static inline void arch_local_irq_restore(unsigned long flags)
 398 -{
 399 -       set_signals(flags);
 400 -}
 401 -
 402 -static inline void arch_local_irq_enable(void)
 403 -{
 404 -       unblock_signals();
 405 -}
 406 -
 407 -static inline void arch_local_irq_disable(void)
 408 -{
 409 -       block_signals();
 410 -}
 411 -
 412 -static inline unsigned long arch_local_irq_save(void)
 413 -{
 414 -       unsigned long flags;
 415 -       flags = arch_local_save_flags();
 416 -       arch_local_irq_disable();
 417 -       return flags;
 418 -}
 419 -
 420 -static inline bool arch_irqs_disabled(void)
 421 -{
 422 -       return arch_local_save_flags() == 0;
 423 -}
 424 -
 425 -#endif
 426 --- a/arch/um/include/asm/kmap_types.h
 427 +++ /dev/null
 428 @@ -1,13 +0,0 @@
 429 -/*
 430 - * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
 431 - * Licensed under the GPL
 432 - */
 433 -
 434 -#ifndef __UM_KMAP_TYPES_H
 435 -#define __UM_KMAP_TYPES_H
 436 -
 437 -/* No more #include "asm/arch/kmap_types.h" ! */
 438 -
 439 -#define KM_TYPE_NR 14
 440 -
 441 -#endif
 442 --- a/arch/um/include/asm/kvm_para.h
 443 +++ /dev/null
 444 @@ -1 +0,0 @@
 445 -#include <asm-generic/kvm_para.h>
 446 --- a/arch/um/include/asm/mmu.h
 447 +++ /dev/null
 448 @@ -1,24 +0,0 @@
 449 -/*
 450 - * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 451 - * Licensed under the GPL
 452 - */
 453 -
 454 -#ifndef __ARCH_UM_MMU_H
 455 -#define __ARCH_UM_MMU_H
 456 -
 457 -#include <mm_id.h>
 458 -#include <asm/mm_context.h>
 459 -
 460 -typedef struct mm_context {
 461 -       struct mm_id id;
 462 -       struct uml_arch_mm_context arch;
 463 -       struct page *stub_pages[2];
 464 -} mm_context_t;
 465 -
 466 -extern void __switch_mm(struct mm_id * mm_idp);
 467 -
 468 -/* Avoid tangled inclusion with asm/ldt.h */
 469 -extern long init_new_ldt(struct mm_context *to_mm, struct mm_context *from_mm);
 470 -extern void free_ldt(struct mm_context *mm);
 471 -
 472 -#endif
 473 --- a/arch/um/include/asm/mmu_context.h
 474 +++ /dev/null
 475 @@ -1,58 +0,0 @@
 476 -/*
 477 - * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 478 - * Licensed under the GPL
 479 - */
 480 -
 481 -#ifndef __UM_MMU_CONTEXT_H
 482 -#define __UM_MMU_CONTEXT_H
 483 -
 484 -#include <linux/sched.h>
 485 -#include <asm/mmu.h>
 486 -
 487 -extern void uml_setup_stubs(struct mm_struct *mm);
 488 -extern void arch_exit_mmap(struct mm_struct *mm);
 489 -
 490 -#define deactivate_mm(tsk,mm)  do { } while (0)
 491 -
 492 -extern void force_flush_all(void);
 493 -
 494 -static inline void activate_mm(struct mm_struct *old, struct mm_struct *new)
 495 -{
 496 -       /*
 497 -        * This is called by fs/exec.c and sys_unshare()
 498 -        * when the new ->mm is used for the first time.
 499 -        */
 500 -       __switch_mm(&new->context.id);
 501 -       down_write(&new->mmap_sem);
 502 -       uml_setup_stubs(new);
 503 -       up_write(&new->mmap_sem);
 504 -}
 505 -
 506 -static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
 507 -                            struct task_struct *tsk)
 508 -{
 509 -       unsigned cpu = smp_processor_id();
 510 -
 511 -       if(prev != next){
 512 -               cpumask_clear_cpu(cpu, mm_cpumask(prev));
 513 -               cpumask_set_cpu(cpu, mm_cpumask(next));
 514 -               if(next != &init_mm)
 515 -                       __switch_mm(&next->context.id);
 516 -       }
 517 -}
 518 -
 519 -static inline void arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
 520 -{
 521 -       uml_setup_stubs(mm);
 522 -}
 523 -
 524 -static inline void enter_lazy_tlb(struct mm_struct *mm,
 525 -                                 struct task_struct *tsk)
 526 -{
 527 -}
 528 -
 529 -extern int init_new_context(struct task_struct *task, struct mm_struct *mm);
 530 -
 531 -extern void destroy_context(struct mm_struct *mm);
 532 -
 533 -#endif
 534 --- a/arch/um/include/asm/page.h
 535 +++ /dev/null
 536 @@ -1,122 +0,0 @@
 537 -/*
 538 - * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
 539 - * Copyright 2003 PathScale, Inc.
 540 - * Licensed under the GPL
 541 - */
 542 -
 543 -#ifndef __UM_PAGE_H
 544 -#define __UM_PAGE_H
 545 -
 546 -#include <linux/const.h>
 547 -
 548 -/* PAGE_SHIFT determines the page size */
 549 -#define PAGE_SHIFT     12
 550 -#define PAGE_SIZE      (_AC(1, UL) << PAGE_SHIFT)
 551 -#define PAGE_MASK      (~(PAGE_SIZE-1))
 552 -
 553 -#ifndef __ASSEMBLY__
 554 -
 555 -struct page;
 556 -
 557 -#include <linux/types.h>
 558 -#include <asm/vm-flags.h>
 559 -
 560 -/*
 561 - * These are used to make use of C type-checking..
 562 - */
 563 -
 564 -#define clear_page(page)       memset((void *)(page), 0, PAGE_SIZE)
 565 -#define copy_page(to,from)     memcpy((void *)(to), (void *)(from), PAGE_SIZE)
 566 -
 567 -#define clear_user_page(page, vaddr, pg)       clear_page(page)
 568 -#define copy_user_page(to, from, vaddr, pg)    copy_page(to, from)
 569 -
 570 -#if defined(CONFIG_3_LEVEL_PGTABLES) && !defined(CONFIG_64BIT)
 571 -
 572 -typedef struct { unsigned long pte_low, pte_high; } pte_t;
 573 -typedef struct { unsigned long pmd; } pmd_t;
 574 -typedef struct { unsigned long pgd; } pgd_t;
 575 -#define pte_val(x) ((x).pte_low | ((unsigned long long) (x).pte_high << 32))
 576 -
 577 -#define pte_get_bits(pte, bits) ((pte).pte_low & (bits))
 578 -#define pte_set_bits(pte, bits) ((pte).pte_low |= (bits))
 579 -#define pte_clear_bits(pte, bits) ((pte).pte_low &= ~(bits))
 580 -#define pte_copy(to, from) ({ (to).pte_high = (from).pte_high; \
 581 -                             smp_wmb(); \
 582 -                             (to).pte_low = (from).pte_low; })
 583 -#define pte_is_zero(pte) (!((pte).pte_low & ~_PAGE_NEWPAGE) && !(pte).pte_high)
 584 -#define pte_set_val(pte, phys, prot) \
 585 -       ({ (pte).pte_high = (phys) >> 32; \
 586 -          (pte).pte_low = (phys) | pgprot_val(prot); })
 587 -
 588 -#define pmd_val(x)     ((x).pmd)
 589 -#define __pmd(x) ((pmd_t) { (x) } )
 590 -
 591 -typedef unsigned long long pfn_t;
 592 -typedef unsigned long long phys_t;
 593 -
 594 -#else
 595 -
 596 -typedef struct { unsigned long pte; } pte_t;
 597 -typedef struct { unsigned long pgd; } pgd_t;
 598 -
 599 -#ifdef CONFIG_3_LEVEL_PGTABLES
 600 -typedef struct { unsigned long pmd; } pmd_t;
 601 -#define pmd_val(x)     ((x).pmd)
 602 -#define __pmd(x) ((pmd_t) { (x) } )
 603 -#endif
 604 -
 605 -#define pte_val(x)     ((x).pte)
 606 -
 607 -
 608 -#define pte_get_bits(p, bits) ((p).pte & (bits))
 609 -#define pte_set_bits(p, bits) ((p).pte |= (bits))
 610 -#define pte_clear_bits(p, bits) ((p).pte &= ~(bits))
 611 -#define pte_copy(to, from) ((to).pte = (from).pte)
 612 -#define pte_is_zero(p) (!((p).pte & ~_PAGE_NEWPAGE))
 613 -#define pte_set_val(p, phys, prot) (p).pte = (phys | pgprot_val(prot))
 614 -
 615 -typedef unsigned long pfn_t;
 616 -typedef unsigned long phys_t;
 617 -
 618 -#endif
 619 -
 620 -typedef struct { unsigned long pgprot; } pgprot_t;
 621 -
 622 -typedef struct page *pgtable_t;
 623 -
 624 -#define pgd_val(x)     ((x).pgd)
 625 -#define pgprot_val(x)  ((x).pgprot)
 626 -
 627 -#define __pte(x) ((pte_t) { (x) } )
 628 -#define __pgd(x) ((pgd_t) { (x) } )
 629 -#define __pgprot(x)    ((pgprot_t) { (x) } )
 630 -
 631 -extern unsigned long uml_physmem;
 632 -
 633 -#define PAGE_OFFSET (uml_physmem)
 634 -#define KERNELBASE PAGE_OFFSET
 635 -
 636 -#define __va_space (8*1024*1024)
 637 -
 638 -#include <mem.h>
 639 -
 640 -/* Cast to unsigned long before casting to void * to avoid a warning from
 641 - * mmap_kmem about cutting a long long down to a void *.  Not sure that
 642 - * casting is the right thing, but 32-bit UML can't have 64-bit virtual
 643 - * addresses
 644 - */
 645 -#define __pa(virt) to_phys((void *) (unsigned long) (virt))
 646 -#define __va(phys) to_virt((unsigned long) (phys))
 647 -
 648 -#define phys_to_pfn(p) ((pfn_t) ((p) >> PAGE_SHIFT))
 649 -#define pfn_to_phys(pfn) ((phys_t) ((pfn) << PAGE_SHIFT))
 650 -
 651 -#define pfn_valid(pfn) ((pfn) < max_mapnr)
 652 -#define virt_addr_valid(v) pfn_valid(phys_to_pfn(__pa(v)))
 653 -
 654 -#include <asm-generic/memory_model.h>
 655 -#include <asm-generic/getorder.h>
 656 -
 657 -#endif /* __ASSEMBLY__ */
 658 -#endif /* __UM_PAGE_H */
 659 --- a/arch/um/include/asm/pgalloc.h
 660 +++ /dev/null
 661 @@ -1,61 +0,0 @@
 662 -/*
 663 - * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
 664 - * Copyright 2003 PathScale, Inc.
 665 - * Derived from include/asm-i386/pgalloc.h and include/asm-i386/pgtable.h
 666 - * Licensed under the GPL
 667 - */
 668 -
 669 -#ifndef __UM_PGALLOC_H
 670 -#define __UM_PGALLOC_H
 671 -
 672 -#include <linux/mm.h>
 673 -
 674 -#define pmd_populate_kernel(mm, pmd, pte) \
 675 -       set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) __pa(pte)))
 676 -
 677 -#define pmd_populate(mm, pmd, pte)                             \
 678 -       set_pmd(pmd, __pmd(_PAGE_TABLE +                        \
 679 -               ((unsigned long long)page_to_pfn(pte) <<        \
 680 -                       (unsigned long long) PAGE_SHIFT)))
 681 -#define pmd_pgtable(pmd) pmd_page(pmd)
 682 -
 683 -/*
 684 - * Allocate and free page tables.
 685 - */
 686 -extern pgd_t *pgd_alloc(struct mm_struct *);
 687 -extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
 688 -
 689 -extern pte_t *pte_alloc_one_kernel(struct mm_struct *, unsigned long);
 690 -extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
 691 -
 692 -static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
 693 -{
 694 -       free_page((unsigned long) pte);
 695 -}
 696 -
 697 -static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
 698 -{
 699 -       pgtable_page_dtor(pte);
 700 -       __free_page(pte);
 701 -}
 702 -
 703 -#define __pte_free_tlb(tlb,pte, address)               \
 704 -do {                                                   \
 705 -       pgtable_page_dtor(pte);                         \
 706 -       tlb_remove_page((tlb),(pte));                   \
 707 -} while (0)
 708 -
 709 -#ifdef CONFIG_3_LEVEL_PGTABLES
 710 -
 711 -static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
 712 -{
 713 -       free_page((unsigned long)pmd);
 714 -}
 715 -
 716 -#define __pmd_free_tlb(tlb,x, address)   tlb_remove_page((tlb),virt_to_page(x))
 717 -#endif
 718 -
 719 -#define check_pgt_cache()      do { } while (0)
 720 -
 721 -#endif
 722 -
 723 --- a/arch/um/include/asm/pgtable-2level.h
 724 +++ /dev/null
 725 @@ -1,53 +0,0 @@
 726 -/*
 727 - * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
 728 - * Copyright 2003 PathScale, Inc.
 729 - * Derived from include/asm-i386/pgtable.h
 730 - * Licensed under the GPL
 731 - */
 732 -
 733 -#ifndef __UM_PGTABLE_2LEVEL_H
 734 -#define __UM_PGTABLE_2LEVEL_H
 735 -
 736 -#include <asm-generic/pgtable-nopmd.h>
 737 -
 738 -/* PGDIR_SHIFT determines what a third-level page table entry can map */
 739 -
 740 -#define PGDIR_SHIFT    22
 741 -#define PGDIR_SIZE     (1UL << PGDIR_SHIFT)
 742 -#define PGDIR_MASK     (~(PGDIR_SIZE-1))
 743 -
 744 -/*
 745 - * entries per page directory level: the i386 is two-level, so
 746 - * we don't really have any PMD directory physically.
 747 - */
 748 -#define PTRS_PER_PTE   1024
 749 -#define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
 750 -#define PTRS_PER_PGD   1024
 751 -#define FIRST_USER_ADDRESS     0
 752 -
 753 -#define pte_ERROR(e) \
 754 -        printk("%s:%d: bad pte %p(%08lx).\n", __FILE__, __LINE__, &(e), \
 755 -              pte_val(e))
 756 -#define pgd_ERROR(e) \
 757 -        printk("%s:%d: bad pgd %p(%08lx).\n", __FILE__, __LINE__, &(e), \
 758 -              pgd_val(e))
 759 -
 760 -static inline int pgd_newpage(pgd_t pgd)       { return 0; }
 761 -static inline void pgd_mkuptodate(pgd_t pgd)   { }
 762 -
 763 -#define set_pmd(pmdptr, pmdval) (*(pmdptr) = (pmdval))
 764 -
 765 -#define pte_pfn(x) phys_to_pfn(pte_val(x))
 766 -#define pfn_pte(pfn, prot) __pte(pfn_to_phys(pfn) | pgprot_val(prot))
 767 -#define pfn_pmd(pfn, prot) __pmd(pfn_to_phys(pfn) | pgprot_val(prot))
 768 -
 769 -/*
 770 - * Bits 0 through 4 are taken
 771 - */
 772 -#define PTE_FILE_MAX_BITS      27
 773 -
 774 -#define pte_to_pgoff(pte) (pte_val(pte) >> 5)
 775 -
 776 -#define pgoff_to_pte(off) ((pte_t) { ((off) << 5) + _PAGE_FILE })
 777 -
 778 -#endif
 779 --- a/arch/um/include/asm/pgtable-3level.h
 780 +++ /dev/null
 781 @@ -1,136 +0,0 @@
 782 -/*
 783 - * Copyright 2003 PathScale Inc
 784 - * Derived from include/asm-i386/pgtable.h
 785 - * Licensed under the GPL
 786 - */
 787 -
 788 -#ifndef __UM_PGTABLE_3LEVEL_H
 789 -#define __UM_PGTABLE_3LEVEL_H
 790 -
 791 -#include <asm-generic/pgtable-nopud.h>
 792 -
 793 -/* PGDIR_SHIFT determines what a third-level page table entry can map */
 794 -
 795 -#ifdef CONFIG_64BIT
 796 -#define PGDIR_SHIFT    30
 797 -#else
 798 -#define PGDIR_SHIFT    31
 799 -#endif
 800 -#define PGDIR_SIZE     (1UL << PGDIR_SHIFT)
 801 -#define PGDIR_MASK     (~(PGDIR_SIZE-1))
 802 -
 803 -/* PMD_SHIFT determines the size of the area a second-level page table can
 804 - * map
 805 - */
 806 -
 807 -#define PMD_SHIFT      21
 808 -#define PMD_SIZE       (1UL << PMD_SHIFT)
 809 -#define PMD_MASK       (~(PMD_SIZE-1))
 810 -
 811 -/*
 812 - * entries per page directory level
 813 - */
 814 -
 815 -#define PTRS_PER_PTE 512
 816 -#ifdef CONFIG_64BIT
 817 -#define PTRS_PER_PMD 512
 818 -#define PTRS_PER_PGD 512
 819 -#else
 820 -#define PTRS_PER_PMD 1024
 821 -#define PTRS_PER_PGD 1024
 822 -#endif
 823 -
 824 -#define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
 825 -#define FIRST_USER_ADDRESS     0
 826 -
 827 -#define pte_ERROR(e) \
 828 -        printk("%s:%d: bad pte %p(%016lx).\n", __FILE__, __LINE__, &(e), \
 829 -              pte_val(e))
 830 -#define pmd_ERROR(e) \
 831 -        printk("%s:%d: bad pmd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
 832 -              pmd_val(e))
 833 -#define pgd_ERROR(e) \
 834 -        printk("%s:%d: bad pgd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
 835 -              pgd_val(e))
 836 -
 837 -#define pud_none(x)    (!(pud_val(x) & ~_PAGE_NEWPAGE))
 838 -#define        pud_bad(x)      ((pud_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
 839 -#define pud_present(x) (pud_val(x) & _PAGE_PRESENT)
 840 -#define pud_populate(mm, pud, pmd) \
 841 -       set_pud(pud, __pud(_PAGE_TABLE + __pa(pmd)))
 842 -
 843 -#ifdef CONFIG_64BIT
 844 -#define set_pud(pudptr, pudval) set_64bit((u64 *) (pudptr), pud_val(pudval))
 845 -#else
 846 -#define set_pud(pudptr, pudval) (*(pudptr) = (pudval))
 847 -#endif
 848 -
 849 -static inline int pgd_newpage(pgd_t pgd)
 850 -{
 851 -       return(pgd_val(pgd) & _PAGE_NEWPAGE);
 852 -}
 853 -
 854 -static inline void pgd_mkuptodate(pgd_t pgd) { pgd_val(pgd) &= ~_PAGE_NEWPAGE; }
 855 -
 856 -#ifdef CONFIG_64BIT
 857 -#define set_pmd(pmdptr, pmdval) set_64bit((u64 *) (pmdptr), pmd_val(pmdval))
 858 -#else
 859 -#define set_pmd(pmdptr, pmdval) (*(pmdptr) = (pmdval))
 860 -#endif
 861 -
 862 -struct mm_struct;
 863 -extern pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address);
 864 -
 865 -static inline void pud_clear (pud_t *pud)
 866 -{
 867 -       set_pud(pud, __pud(_PAGE_NEWPAGE));
 868 -}
 869 -
 870 -#define pud_page(pud) phys_to_page(pud_val(pud) & PAGE_MASK)
 871 -#define pud_page_vaddr(pud) ((unsigned long) __va(pud_val(pud) & PAGE_MASK))
 872 -
 873 -/* Find an entry in the second-level page table.. */
 874 -#define pmd_offset(pud, address) ((pmd_t *) pud_page_vaddr(*(pud)) + \
 875 -                       pmd_index(address))
 876 -
 877 -static inline unsigned long pte_pfn(pte_t pte)
 878 -{
 879 -       return phys_to_pfn(pte_val(pte));
 880 -}
 881 -
 882 -static inline pte_t pfn_pte(pfn_t page_nr, pgprot_t pgprot)
 883 -{
 884 -       pte_t pte;
 885 -       phys_t phys = pfn_to_phys(page_nr);
 886 -
 887 -       pte_set_val(pte, phys, pgprot);
 888 -       return pte;
 889 -}
 890 -
 891 -static inline pmd_t pfn_pmd(pfn_t page_nr, pgprot_t pgprot)
 892 -{
 893 -       return __pmd((page_nr << PAGE_SHIFT) | pgprot_val(pgprot));
 894 -}
 895 -
 896 -/*
 897 - * Bits 0 through 3 are taken in the low part of the pte,
 898 - * put the 32 bits of offset into the high part.
 899 - */
 900 -#define PTE_FILE_MAX_BITS      32
 901 -
 902 -#ifdef CONFIG_64BIT
 903 -
 904 -#define pte_to_pgoff(p) ((p).pte >> 32)
 905 -
 906 -#define pgoff_to_pte(off) ((pte_t) { ((off) << 32) | _PAGE_FILE })
 907 -
 908 -#else
 909 -
 910 -#define pte_to_pgoff(pte) ((pte).pte_high)
 911 -
 912 -#define pgoff_to_pte(off) ((pte_t) { _PAGE_FILE, (off) })
 913 -
 914 -#endif
 915 -
 916 -#endif
 917 -
 918 --- a/arch/um/include/asm/pgtable.h
 919 +++ /dev/null
 920 @@ -1,375 +0,0 @@
 921 -/*
 922 - * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 923 - * Copyright 2003 PathScale, Inc.
 924 - * Derived from include/asm-i386/pgtable.h
 925 - * Licensed under the GPL
 926 - */
 927 -
 928 -#ifndef __UM_PGTABLE_H
 929 -#define __UM_PGTABLE_H
 930 -
 931 -#include <asm/fixmap.h>
 932 -
 933 -#define _PAGE_PRESENT  0x001
 934 -#define _PAGE_NEWPAGE  0x002
 935 -#define _PAGE_NEWPROT  0x004
 936 -#define _PAGE_RW       0x020
 937 -#define _PAGE_USER     0x040
 938 -#define _PAGE_ACCESSED 0x080
 939 -#define _PAGE_DIRTY    0x100
 940 -/* If _PAGE_PRESENT is clear, we use these: */
 941 -#define _PAGE_FILE     0x008   /* nonlinear file mapping, saved PTE; unset:swap */
 942 -#define _PAGE_PROTNONE 0x010   /* if the user mapped it with PROT_NONE;
 943 -                                  pte_present gives true */
 944 -
 945 -#ifdef CONFIG_3_LEVEL_PGTABLES
 946 -#include <asm/pgtable-3level.h>
 947 -#else
 948 -#include <asm/pgtable-2level.h>
 949 -#endif
 950 -
 951 -extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
 952 -
 953 -/* zero page used for uninitialized stuff */
 954 -extern unsigned long *empty_zero_page;
 955 -
 956 -#define pgtable_cache_init() do ; while (0)
 957 -
 958 -/* Just any arbitrary offset to the start of the vmalloc VM area: the
 959 - * current 8MB value just means that there will be a 8MB "hole" after the
 960 - * physical memory until the kernel virtual memory starts.  That means that
 961 - * any out-of-bounds memory accesses will hopefully be caught.
 962 - * The vmalloc() routines leaves a hole of 4kB between each vmalloced
 963 - * area for the same reason. ;)
 964 - */
 965 -
 966 -extern unsigned long end_iomem;
 967 -
 968 -#define VMALLOC_OFFSET (__va_space)
 969 -#define VMALLOC_START ((end_iomem + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
 970 -#define PKMAP_BASE ((FIXADDR_START - LAST_PKMAP * PAGE_SIZE) & PMD_MASK)
 971 -#ifdef CONFIG_HIGHMEM
 972 -# define VMALLOC_END   (PKMAP_BASE-2*PAGE_SIZE)
 973 -#else
 974 -# define VMALLOC_END   (FIXADDR_START-2*PAGE_SIZE)
 975 -#endif
 976 -#define MODULES_VADDR  VMALLOC_START
 977 -#define MODULES_END    VMALLOC_END
 978 -#define MODULES_LEN    (MODULES_VADDR - MODULES_END)
 979 -
 980 -#define _PAGE_TABLE    (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
 981 -#define _KERNPG_TABLE  (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
 982 -#define _PAGE_CHG_MASK (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
 983 -#define __PAGE_KERNEL_EXEC                                              \
 984 -        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
 985 -#define PAGE_NONE      __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
 986 -#define PAGE_SHARED    __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
 987 -#define PAGE_COPY      __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
 988 -#define PAGE_READONLY  __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
 989 -#define PAGE_KERNEL    __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
 990 -#define PAGE_KERNEL_EXEC       __pgprot(__PAGE_KERNEL_EXEC)
 991 -
 992 -/*
 993 - * The i386 can't do page protection for execute, and considers that the same
 994 - * are read.
 995 - * Also, write permissions imply read permissions. This is the closest we can
 996 - * get..
 997 - */
 998 -#define __P000 PAGE_NONE
 999 -#define __P001 PAGE_READONLY
1000 -#define __P010 PAGE_COPY
1001 -#define __P011 PAGE_COPY
1002 -#define __P100 PAGE_READONLY
1003 -#define __P101 PAGE_READONLY
1004 -#define __P110 PAGE_COPY
1005 -#define __P111 PAGE_COPY
1006 -
1007 -#define __S000 PAGE_NONE
1008 -#define __S001 PAGE_READONLY
1009 -#define __S010 PAGE_SHARED
1010 -#define __S011 PAGE_SHARED
1011 -#define __S100 PAGE_READONLY
1012 -#define __S101 PAGE_READONLY
1013 -#define __S110 PAGE_SHARED
1014 -#define __S111 PAGE_SHARED
1015 -
1016 -/*
1017 - * ZERO_PAGE is a global shared page that is always zero: used
1018 - * for zero-mapped memory areas etc..
1019 - */
1020 -#define ZERO_PAGE(vaddr) virt_to_page(empty_zero_page)
1021 -
1022 -#define pte_clear(mm,addr,xp) pte_set_val(*(xp), (phys_t) 0, __pgprot(_PAGE_NEWPAGE))
1023 -
1024 -#define pmd_none(x)    (!((unsigned long)pmd_val(x) & ~_PAGE_NEWPAGE))
1025 -#define        pmd_bad(x)      ((pmd_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
1026 -
1027 -#define pmd_present(x) (pmd_val(x) & _PAGE_PRESENT)
1028 -#define pmd_clear(xp)  do { pmd_val(*(xp)) = _PAGE_NEWPAGE; } while (0)
1029 -
1030 -#define pmd_newpage(x)  (pmd_val(x) & _PAGE_NEWPAGE)
1031 -#define pmd_mkuptodate(x) (pmd_val(x) &= ~_PAGE_NEWPAGE)
1032 -
1033 -#define pud_newpage(x)  (pud_val(x) & _PAGE_NEWPAGE)
1034 -#define pud_mkuptodate(x) (pud_val(x) &= ~_PAGE_NEWPAGE)
1035 -
1036 -#define pmd_page(pmd) phys_to_page(pmd_val(pmd) & PAGE_MASK)
1037 -
1038 -#define pte_page(x) pfn_to_page(pte_pfn(x))
1039 -
1040 -#define pte_present(x) pte_get_bits(x, (_PAGE_PRESENT | _PAGE_PROTNONE))
1041 -
1042 -/*
1043 - * =================================
1044 - * Flags checking section.
1045 - * =================================
1046 - */
1047 -
1048 -static inline int pte_none(pte_t pte)
1049 -{
1050 -       return pte_is_zero(pte);
1051 -}
1052 -
1053 -/*
1054 - * The following only work if pte_present() is true.
1055 - * Undefined behaviour if not..
1056 - */
1057 -static inline int pte_read(pte_t pte)
1058 -{
1059 -       return((pte_get_bits(pte, _PAGE_USER)) &&
1060 -              !(pte_get_bits(pte, _PAGE_PROTNONE)));
1061 -}
1062 -
1063 -static inline int pte_exec(pte_t pte){
1064 -       return((pte_get_bits(pte, _PAGE_USER)) &&
1065 -              !(pte_get_bits(pte, _PAGE_PROTNONE)));
1066 -}
1067 -
1068 -static inline int pte_write(pte_t pte)
1069 -{
1070 -       return((pte_get_bits(pte, _PAGE_RW)) &&
1071 -              !(pte_get_bits(pte, _PAGE_PROTNONE)));
1072 -}
1073 -
1074 -/*
1075 - * The following only works if pte_present() is not true.
1076 - */
1077 -static inline int pte_file(pte_t pte)
1078 -{
1079 -       return pte_get_bits(pte, _PAGE_FILE);
1080 -}
1081 -
1082 -static inline int pte_dirty(pte_t pte)
1083 -{
1084 -       return pte_get_bits(pte, _PAGE_DIRTY);
1085 -}
1086 -
1087 -static inline int pte_young(pte_t pte)
1088 -{
1089 -       return pte_get_bits(pte, _PAGE_ACCESSED);
1090 -}
1091 -
1092 -static inline int pte_newpage(pte_t pte)
1093 -{
1094 -       return pte_get_bits(pte, _PAGE_NEWPAGE);
1095 -}
1096 -
1097 -static inline int pte_newprot(pte_t pte)
1098 -{
1099 -       return(pte_present(pte) && (pte_get_bits(pte, _PAGE_NEWPROT)));
1100 -}
1101 -
1102 -static inline int pte_special(pte_t pte)
1103 -{
1104 -       return 0;
1105 -}
1106 -
1107 -/*
1108 - * =================================
1109 - * Flags setting section.
1110 - * =================================
1111 - */
1112 -
1113 -static inline pte_t pte_mknewprot(pte_t pte)
1114 -{
1115 -       pte_set_bits(pte, _PAGE_NEWPROT);
1116 -       return(pte);
1117 -}
1118 -
1119 -static inline pte_t pte_mkclean(pte_t pte)
1120 -{
1121 -       pte_clear_bits(pte, _PAGE_DIRTY);
1122 -       return(pte);
1123 -}
1124 -
1125 -static inline pte_t pte_mkold(pte_t pte)
1126 -{
1127 -       pte_clear_bits(pte, _PAGE_ACCESSED);
1128 -       return(pte);
1129 -}
1130 -
1131 -static inline pte_t pte_wrprotect(pte_t pte)
1132 -{
1133 -       pte_clear_bits(pte, _PAGE_RW);
1134 -       return(pte_mknewprot(pte));
1135 -}
1136 -
1137 -static inline pte_t pte_mkread(pte_t pte)
1138 -{
1139 -       pte_set_bits(pte, _PAGE_USER);
1140 -       return(pte_mknewprot(pte));
1141 -}
1142 -
1143 -static inline pte_t pte_mkdirty(pte_t pte)
1144 -{
1145 -       pte_set_bits(pte, _PAGE_DIRTY);
1146 -       return(pte);
1147 -}
1148 -
1149 -static inline pte_t pte_mkyoung(pte_t pte)
1150 -{
1151 -       pte_set_bits(pte, _PAGE_ACCESSED);
1152 -       return(pte);
1153 -}
1154 -
1155 -static inline pte_t pte_mkwrite(pte_t pte)
1156 -{
1157 -       pte_set_bits(pte, _PAGE_RW);
1158 -       return(pte_mknewprot(pte));
1159 -}
1160 -
1161 -static inline pte_t pte_mkuptodate(pte_t pte)
1162 -{
1163 -       pte_clear_bits(pte, _PAGE_NEWPAGE);
1164 -       if(pte_present(pte))
1165 -               pte_clear_bits(pte, _PAGE_NEWPROT);
1166 -       return(pte);
1167 -}
1168 -
1169 -static inline pte_t pte_mknewpage(pte_t pte)
1170 -{
1171 -       pte_set_bits(pte, _PAGE_NEWPAGE);
1172 -       return(pte);
1173 -}
1174 -
1175 -static inline pte_t pte_mkspecial(pte_t pte)
1176 -{
1177 -       return(pte);
1178 -}
1179 -
1180 -static inline void set_pte(pte_t *pteptr, pte_t pteval)
1181 -{
1182 -       pte_copy(*pteptr, pteval);
1183 -
1184 -       /* If it's a swap entry, it needs to be marked _PAGE_NEWPAGE so
1185 -        * fix_range knows to unmap it.  _PAGE_NEWPROT is specific to
1186 -        * mapped pages.
1187 -        */
1188 -
1189 -       *pteptr = pte_mknewpage(*pteptr);
1190 -       if(pte_present(*pteptr)) *pteptr = pte_mknewprot(*pteptr);
1191 -}
1192 -#define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
1193 -
1194 -#define __HAVE_ARCH_PTE_SAME
1195 -static inline int pte_same(pte_t pte_a, pte_t pte_b)
1196 -{
1197 -       return !((pte_val(pte_a) ^ pte_val(pte_b)) & ~_PAGE_NEWPAGE);
1198 -}
1199 -
1200 -/*
1201 - * Conversion functions: convert a page and protection to a page entry,
1202 - * and a page entry and page directory to the page they refer to.
1203 - */
1204 -
1205 -#define phys_to_page(phys) pfn_to_page(phys_to_pfn(phys))
1206 -#define __virt_to_page(virt) phys_to_page(__pa(virt))
1207 -#define page_to_phys(page) pfn_to_phys((pfn_t) page_to_pfn(page))
1208 -#define virt_to_page(addr) __virt_to_page((const unsigned long) addr)
1209 -
1210 -#define mk_pte(page, pgprot) \
1211 -       ({ pte_t pte;                                   \
1212 -                                                       \
1213 -       pte_set_val(pte, page_to_phys(page), (pgprot)); \
1214 -       if (pte_present(pte))                           \
1215 -               pte_mknewprot(pte_mknewpage(pte));      \
1216 -       pte;})
1217 -
1218 -static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
1219 -{
1220 -       pte_set_val(pte, (pte_val(pte) & _PAGE_CHG_MASK), newprot);
1221 -       return pte;
1222 -}
1223 -
1224 -/*
1225 - * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
1226 - *
1227 - * this macro returns the index of the entry in the pgd page which would
1228 - * control the given virtual address
1229 - */
1230 -#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
1231 -
1232 -/*
1233 - * pgd_offset() returns a (pgd_t *)
1234 - * pgd_index() is used get the offset into the pgd page's array of pgd_t's;
1235 - */
1236 -#define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
1237 -
1238 -/*
1239 - * a shortcut which implies the use of the kernel's pgd, instead
1240 - * of a process's
1241 - */
1242 -#define pgd_offset_k(address) pgd_offset(&init_mm, address)
1243 -
1244 -/*
1245 - * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
1246 - *
1247 - * this macro returns the index of the entry in the pmd page which would
1248 - * control the given virtual address
1249 - */
1250 -#define pmd_page_vaddr(pmd) ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
1251 -#define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
1252 -
1253 -#define pmd_page_vaddr(pmd) \
1254 -       ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
1255 -
1256 -/*
1257 - * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
1258 - *
1259 - * this macro returns the index of the entry in the pte page which would
1260 - * control the given virtual address
1261 - */
1262 -#define pte_index(address) (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
1263 -#define pte_offset_kernel(dir, address) \
1264 -       ((pte_t *) pmd_page_vaddr(*(dir)) +  pte_index(address))
1265 -#define pte_offset_map(dir, address) \
1266 -       ((pte_t *)page_address(pmd_page(*(dir))) + pte_index(address))
1267 -#define pte_unmap(pte) do { } while (0)
1268 -
1269 -struct mm_struct;
1270 -extern pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr);
1271 -
1272 -#define update_mmu_cache(vma,address,ptep) do ; while (0)
1273 -
1274 -/* Encode and de-code a swap entry */
1275 -#define __swp_type(x)                  (((x).val >> 5) & 0x1f)
1276 -#define __swp_offset(x)                        ((x).val >> 11)
1277 -
1278 -#define __swp_entry(type, offset) \
1279 -       ((swp_entry_t) { ((type) << 5) | ((offset) << 11) })
1280 -#define __pte_to_swp_entry(pte) \
1281 -       ((swp_entry_t) { pte_val(pte_mkuptodate(pte)) })
1282 -#define __swp_entry_to_pte(x)          ((pte_t) { (x).val })
1283 -
1284 -#define kern_addr_valid(addr) (1)
1285 -
1286 -#include <asm-generic/pgtable.h>
1287 -
1288 -/* Clear a kernel PTE and flush it from the TLB */
1289 -#define kpte_clear_flush(ptep, vaddr)          \
1290 -do {                                           \
1291 -       pte_clear(&init_mm, (vaddr), (ptep));   \
1292 -       __flush_tlb_one((vaddr));               \
1293 -} while (0)
1294 -
1295 -#endif
1296 --- a/arch/um/include/asm/processor-generic.h
1297 +++ /dev/null
1298 @@ -1,115 +0,0 @@
1299 -/*
1300 - * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
1301 - * Licensed under the GPL
1302 - */
1303 -
1304 -#ifndef __UM_PROCESSOR_GENERIC_H
1305 -#define __UM_PROCESSOR_GENERIC_H
1306 -
1307 -struct pt_regs;
1308 -
1309 -struct task_struct;
1310 -
1311 -#include <asm/ptrace.h>
1312 -#include <registers.h>
1313 -#include <sysdep/archsetjmp.h>
1314 -
1315 -#include <linux/prefetch.h>
1316 -
1317 -struct mm_struct;
1318 -
1319 -struct thread_struct {
1320 -       struct pt_regs regs;
1321 -       struct pt_regs *segv_regs;
1322 -       int singlestep_syscall;
1323 -       void *fault_addr;
1324 -       jmp_buf *fault_catcher;
1325 -       struct task_struct *prev_sched;
1326 -       struct arch_thread arch;
1327 -       jmp_buf switch_buf;
1328 -       struct {
1329 -               int op;
1330 -               union {
1331 -                       struct {
1332 -                               int pid;
1333 -                       } fork, exec;
1334 -                       struct {
1335 -                               int (*proc)(void *);
1336 -                               void *arg;
1337 -                       } thread;
1338 -                       struct {
1339 -                               void (*proc)(void *);
1340 -                               void *arg;
1341 -                       } cb;
1342 -               } u;
1343 -       } request;
1344 -};
1345 -
1346 -#define INIT_THREAD \
1347 -{ \
1348 -       .regs                   = EMPTY_REGS,   \
1349 -       .fault_addr             = NULL, \
1350 -       .prev_sched             = NULL, \
1351 -       .arch                   = INIT_ARCH_THREAD, \
1352 -       .request                = { 0 } \
1353 -}
1354 -
1355 -static inline void release_thread(struct task_struct *task)
1356 -{
1357 -}
1358 -
1359 -extern unsigned long thread_saved_pc(struct task_struct *t);
1360 -
1361 -static inline void mm_copy_segments(struct mm_struct *from_mm,
1362 -                                   struct mm_struct *new_mm)
1363 -{
1364 -}
1365 -
1366 -#define init_stack     (init_thread_union.stack)
1367 -
1368 -/*
1369 - * User space process size: 3GB (default).
1370 - */
1371 -extern unsigned long task_size;
1372 -
1373 -#define TASK_SIZE (task_size)
1374 -
1375 -#undef STACK_TOP
1376 -#undef STACK_TOP_MAX
1377 -
1378 -extern unsigned long stacksizelim;
1379 -
1380 -#define STACK_ROOM     (stacksizelim)
1381 -#define STACK_TOP      (TASK_SIZE - 2 * PAGE_SIZE)
1382 -#define STACK_TOP_MAX  STACK_TOP
1383 -
1384 -/* This decides where the kernel will search for a free chunk of vm
1385 - * space during mmap's.
1386 - */
1387 -#define TASK_UNMAPPED_BASE     (0x40000000)
1388 -
1389 -extern void start_thread(struct pt_regs *regs, unsigned long entry,
1390 -                        unsigned long stack);
1391 -
1392 -struct cpuinfo_um {
1393 -       unsigned long loops_per_jiffy;
1394 -       int ipi_pipe[2];
1395 -};
1396 -
1397 -extern struct cpuinfo_um boot_cpu_data;
1398 -
1399 -#define my_cpu_data            cpu_data[smp_processor_id()]
1400 -
1401 -#ifdef CONFIG_SMP
1402 -extern struct cpuinfo_um cpu_data[];
1403 -#define current_cpu_data cpu_data[smp_processor_id()]
1404 -#else
1405 -#define cpu_data (&boot_cpu_data)
1406 -#define current_cpu_data boot_cpu_data
1407 -#endif
1408 -
1409 -
1410 -#define KSTK_REG(tsk, reg) get_thread_reg(reg, &tsk->thread.switch_buf)
1411 -extern unsigned long get_wchan(struct task_struct *p);
1412 -
1413 -#endif
1414 --- a/arch/um/include/asm/ptrace-generic.h
1415 +++ /dev/null
1416 @@ -1,45 +0,0 @@
1417 -/*
1418 - * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
1419 - * Licensed under the GPL
1420 - */
1421 -
1422 -#ifndef __UM_PTRACE_GENERIC_H
1423 -#define __UM_PTRACE_GENERIC_H
1424 -
1425 -#ifndef __ASSEMBLY__
1426 -
1427 -#include <asm/ptrace-abi.h>
1428 -#include <sysdep/ptrace.h>
1429 -
1430 -struct pt_regs {
1431 -       struct uml_pt_regs regs;
1432 -};
1433 -
1434 -#define arch_has_single_step() (1)
1435 -
1436 -#define EMPTY_REGS { .regs = EMPTY_UML_PT_REGS }
1437 -
1438 -#define PT_REGS_IP(r) UPT_IP(&(r)->regs)
1439 -#define PT_REGS_SP(r) UPT_SP(&(r)->regs)
1440 -
1441 -#define PT_REGS_RESTART_SYSCALL(r) UPT_RESTART_SYSCALL(&(r)->regs)
1442 -
1443 -#define PT_REGS_SYSCALL_NR(r) UPT_SYSCALL_NR(&(r)->regs)
1444 -
1445 -#define instruction_pointer(regs) PT_REGS_IP(regs)
1446 -
1447 -struct task_struct;
1448 -
1449 -extern long subarch_ptrace(struct task_struct *child, long request,
1450 -       unsigned long addr, unsigned long data);
1451 -extern unsigned long getreg(struct task_struct *child, int regno);
1452 -extern int putreg(struct task_struct *child, int regno, unsigned long value);
1453 -
1454 -extern int arch_copy_tls(struct task_struct *new);
1455 -extern void clear_flushed_tls(struct task_struct *task);
1456 -extern void syscall_trace_enter(struct pt_regs *regs);
1457 -extern void syscall_trace_leave(struct pt_regs *regs);
1458 -
1459 -#endif
1460 -
1461 -#endif
1462 --- a/arch/um/include/asm/setup.h
1463 +++ /dev/null
1464 @@ -1,10 +0,0 @@
1465 -#ifndef SETUP_H_INCLUDED
1466 -#define SETUP_H_INCLUDED
1467 -
1468 -/* POSIX mandated with _POSIX_ARG_MAX that we can rely on 4096 chars in the
1469 - * command line, so this choice is ok.
1470 - */
1471 -
1472 -#define COMMAND_LINE_SIZE 4096
1473 -
1474 -#endif         /* SETUP_H_INCLUDED */
1475 --- a/arch/um/include/asm/smp.h
1476 +++ /dev/null
1477 @@ -1,32 +0,0 @@
1478 -#ifndef __UM_SMP_H
1479 -#define __UM_SMP_H
1480 -
1481 -#ifdef CONFIG_SMP
1482 -
1483 -#include <linux/bitops.h>
1484 -#include <asm/current.h>
1485 -#include <linux/cpumask.h>
1486 -
1487 -#define raw_smp_processor_id() (current_thread->cpu)
1488 -
1489 -#define cpu_logical_map(n) (n)
1490 -#define cpu_number_map(n) (n)
1491 -extern int hard_smp_processor_id(void);
1492 -#define NO_PROC_ID -1
1493 -
1494 -extern int ncpus;
1495 -
1496 -
1497 -static inline void smp_cpus_done(unsigned int maxcpus)
1498 -{
1499 -}
1500 -
1501 -extern struct task_struct *idle_threads[NR_CPUS];
1502 -
1503 -#else
1504 -
1505 -#define hard_smp_processor_id()                0
1506 -
1507 -#endif
1508 -
1509 -#endif
1510 --- a/arch/um/include/asm/sysrq.h
1511 +++ /dev/null
1512 @@ -1,7 +0,0 @@
1513 -#ifndef __UM_SYSRQ_H
1514 -#define __UM_SYSRQ_H
1515 -
1516 -struct task_struct;
1517 -extern void show_trace(struct task_struct* task, unsigned long *stack);
1518 -
1519 -#endif
1520 --- a/arch/um/include/asm/thread_info.h
1521 +++ /dev/null
1522 @@ -1,78 +0,0 @@
1523 -/*
1524 - * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
1525 - * Licensed under the GPL
1526 - */
1527 -
1528 -#ifndef __UM_THREAD_INFO_H
1529 -#define __UM_THREAD_INFO_H
1530 -
1531 -#ifndef __ASSEMBLY__
1532 -
1533 -#include <asm/types.h>
1534 -#include <asm/page.h>
1535 -#include <asm/uaccess.h>
1536 -
1537 -struct thread_info {
1538 -       struct task_struct      *task;          /* main task structure */
1539 -       struct exec_domain      *exec_domain;   /* execution domain */
1540 -       unsigned long           flags;          /* low level flags */
1541 -       __u32                   cpu;            /* current CPU */
1542 -       int                     preempt_count;  /* 0 => preemptable,
1543 -                                                  <0 => BUG */
1544 -       mm_segment_t            addr_limit;     /* thread address space:
1545 -                                                  0-0xBFFFFFFF for user
1546 -                                                  0-0xFFFFFFFF for kernel */
1547 -       struct restart_block    restart_block;
1548 -       struct thread_info      *real_thread;    /* Points to non-IRQ stack */
1549 -};
1550 -
1551 -#define INIT_THREAD_INFO(tsk)                  \
1552 -{                                              \
1553 -       .task =         &tsk,                   \
1554 -       .exec_domain =  &default_exec_domain,   \
1555 -       .flags =                0,              \
1556 -       .cpu =          0,                      \
1557 -       .preempt_count = INIT_PREEMPT_COUNT,    \
1558 -       .addr_limit =   KERNEL_DS,              \
1559 -       .restart_block =  {                     \
1560 -               .fn =  do_no_restart_syscall,   \
1561 -       },                                      \
1562 -       .real_thread = NULL,                    \
1563 -}
1564 -
1565 -#define init_thread_info       (init_thread_union.thread_info)
1566 -#define init_stack             (init_thread_union.stack)
1567 -
1568 -#define THREAD_SIZE ((1 << CONFIG_KERNEL_STACK_ORDER) * PAGE_SIZE)
1569 -/* how to get the thread information struct from C */
1570 -static inline struct thread_info *current_thread_info(void)
1571 -{
1572 -       struct thread_info *ti;
1573 -       unsigned long mask = THREAD_SIZE - 1;
1574 -       void *p;
1575 -
1576 -       asm volatile ("" : "=r" (p) : "0" (&ti));
1577 -       ti = (struct thread_info *) (((unsigned long)p) & ~mask);
1578 -       return ti;
1579 -}
1580 -
1581 -#define THREAD_SIZE_ORDER CONFIG_KERNEL_STACK_ORDER
1582 -
1583 -#endif
1584 -
1585 -#define TIF_SYSCALL_TRACE      0       /* syscall trace active */
1586 -#define TIF_SIGPENDING         1       /* signal pending */
1587 -#define TIF_NEED_RESCHED       2       /* rescheduling necessary */
1588 -#define TIF_RESTART_BLOCK      4
1589 -#define TIF_MEMDIE             5       /* is terminating due to OOM killer */
1590 -#define TIF_SYSCALL_AUDIT      6
1591 -#define TIF_RESTORE_SIGMASK    7
1592 -#define TIF_NOTIFY_RESUME      8
1593 -
1594 -#define _TIF_SYSCALL_TRACE     (1 << TIF_SYSCALL_TRACE)
1595 -#define _TIF_SIGPENDING                (1 << TIF_SIGPENDING)
1596 -#define _TIF_NEED_RESCHED      (1 << TIF_NEED_RESCHED)
1597 -#define _TIF_MEMDIE            (1 << TIF_MEMDIE)
1598 -#define _TIF_SYSCALL_AUDIT     (1 << TIF_SYSCALL_AUDIT)
1599 -
1600 -#endif
1601 --- a/arch/um/include/asm/timex.h
1602 +++ /dev/null
1603 @@ -1,13 +0,0 @@
1604 -#ifndef __UM_TIMEX_H
1605 -#define __UM_TIMEX_H
1606 -
1607 -typedef unsigned long cycles_t;
1608 -
1609 -static inline cycles_t get_cycles (void)
1610 -{
1611 -       return 0;
1612 -}
1613 -
1614 -#define CLOCK_TICK_RATE (HZ)
1615 -
1616 -#endif
1617 --- a/arch/um/include/asm/tlb.h
1618 +++ /dev/null
1619 @@ -1,122 +0,0 @@
1620 -#ifndef __UM_TLB_H
1621 -#define __UM_TLB_H
1622 -
1623 -#include <linux/pagemap.h>
1624 -#include <linux/swap.h>
1625 -#include <asm/percpu.h>
1626 -#include <asm/pgalloc.h>
1627 -#include <asm/tlbflush.h>
1628 -
1629 -#define tlb_start_vma(tlb, vma) do { } while (0)
1630 -#define tlb_end_vma(tlb, vma) do { } while (0)
1631 -#define tlb_flush(tlb) flush_tlb_mm((tlb)->mm)
1632 -
1633 -/* struct mmu_gather is an opaque type used by the mm code for passing around
1634 - * any data needed by arch specific code for tlb_remove_page.
1635 - */
1636 -struct mmu_gather {
1637 -       struct mm_struct        *mm;
1638 -       unsigned int            need_flush; /* Really unmapped some ptes? */
1639 -       unsigned long           start;
1640 -       unsigned long           end;
1641 -       unsigned int            fullmm; /* non-zero means full mm flush */
1642 -};
1643 -
1644 -static inline void __tlb_remove_tlb_entry(struct mmu_gather *tlb, pte_t *ptep,
1645 -                                         unsigned long address)
1646 -{
1647 -       if (tlb->start > address)
1648 -               tlb->start = address;
1649 -       if (tlb->end < address + PAGE_SIZE)
1650 -               tlb->end = address + PAGE_SIZE;
1651 -}
1652 -
1653 -static inline void init_tlb_gather(struct mmu_gather *tlb)
1654 -{
1655 -       tlb->need_flush = 0;
1656 -
1657 -       tlb->start = TASK_SIZE;
1658 -       tlb->end = 0;
1659 -
1660 -       if (tlb->fullmm) {
1661 -               tlb->start = 0;
1662 -               tlb->end = TASK_SIZE;
1663 -       }
1664 -}
1665 -
1666 -static inline void
1667 -tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
1668 -{
1669 -       tlb->mm = mm;
1670 -       tlb->start = start;
1671 -       tlb->end = end;
1672 -       tlb->fullmm = !(start | (end+1));
1673 -
1674 -       init_tlb_gather(tlb);
1675 -}
1676 -
1677 -extern void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
1678 -                              unsigned long end);
1679 -
1680 -static inline void
1681 -tlb_flush_mmu(struct mmu_gather *tlb)
1682 -{
1683 -       if (!tlb->need_flush)
1684 -               return;
1685 -
1686 -       flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end);
1687 -       init_tlb_gather(tlb);
1688 -}
1689 -
1690 -/* tlb_finish_mmu
1691 - *     Called at the end of the shootdown operation to free up any resources
1692 - *     that were required.
1693 - */
1694 -static inline void
1695 -tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
1696 -{
1697 -       tlb_flush_mmu(tlb);
1698 -
1699 -       /* keep the page table cache within bounds */
1700 -       check_pgt_cache();
1701 -}
1702 -
1703 -/* tlb_remove_page
1704 - *     Must perform the equivalent to __free_pte(pte_get_and_clear(ptep)),
1705 - *     while handling the additional races in SMP caused by other CPUs
1706 - *     caching valid mappings in their TLBs.
1707 - */
1708 -static inline int __tlb_remove_page(struct mmu_gather *tlb, struct page *page)
1709 -{
1710 -       tlb->need_flush = 1;
1711 -       free_page_and_swap_cache(page);
1712 -       return 1; /* avoid calling tlb_flush_mmu */
1713 -}
1714 -
1715 -static inline void tlb_remove_page(struct mmu_gather *tlb, struct page *page)
1716 -{
1717 -       __tlb_remove_page(tlb, page);
1718 -}
1719 -
1720 -/**
1721 - * tlb_remove_tlb_entry - remember a pte unmapping for later tlb invalidation.
1722 - *
1723 - * Record the fact that pte's were really umapped in ->need_flush, so we can
1724 - * later optimise away the tlb invalidate.   This helps when userspace is
1725 - * unmapping already-unmapped pages, which happens quite a lot.
1726 - */
1727 -#define tlb_remove_tlb_entry(tlb, ptep, address)               \
1728 -       do {                                                    \
1729 -               tlb->need_flush = 1;                            \
1730 -               __tlb_remove_tlb_entry(tlb, ptep, address);     \
1731 -       } while (0)
1732 -
1733 -#define pte_free_tlb(tlb, ptep, addr) __pte_free_tlb(tlb, ptep, addr)
1734 -
1735 -#define pud_free_tlb(tlb, pudp, addr) __pud_free_tlb(tlb, pudp, addr)
1736 -
1737 -#define pmd_free_tlb(tlb, pmdp, addr) __pmd_free_tlb(tlb, pmdp, addr)
1738 -
1739 -#define tlb_migrate_finish(mm) do {} while (0)
1740 -
1741 -#endif
1742 --- a/arch/um/include/asm/tlbflush.h
1743 +++ /dev/null
1744 @@ -1,31 +0,0 @@
1745 -/*
1746 - * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
1747 - * Licensed under the GPL
1748 - */
1749 -
1750 -#ifndef __UM_TLBFLUSH_H
1751 -#define __UM_TLBFLUSH_H
1752 -
1753 -#include <linux/mm.h>
1754 -
1755 -/*
1756 - * TLB flushing:
1757 - *
1758 - *  - flush_tlb() flushes the current mm struct TLBs
1759 - *  - flush_tlb_all() flushes all processes TLBs
1760 - *  - flush_tlb_mm(mm) flushes the specified mm context TLB's
1761 - *  - flush_tlb_page(vma, vmaddr) flushes one page
1762 - *  - flush_tlb_kernel_vm() flushes the kernel vm area
1763 - *  - flush_tlb_range(vma, start, end) flushes a range of pages
1764 - */
1765 -
1766 -extern void flush_tlb_all(void);
1767 -extern void flush_tlb_mm(struct mm_struct *mm);
1768 -extern void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
1769 -                           unsigned long end);
1770 -extern void flush_tlb_page(struct vm_area_struct *vma, unsigned long address);
1771 -extern void flush_tlb_kernel_vm(void);
1772 -extern void flush_tlb_kernel_range(unsigned long start, unsigned long end);
1773 -extern void __flush_tlb_one(unsigned long addr);
1774 -
1775 -#endif
1776 --- a/arch/um/include/asm/uaccess.h
1777 +++ /dev/null
1778 @@ -1,178 +0,0 @@
1779 -/*
1780 - * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
1781 - * Licensed under the GPL
1782 - */
1783 -
1784 -#ifndef __UM_UACCESS_H
1785 -#define __UM_UACCESS_H
1786 -
1787 -/* thread_info has a mm_segment_t in it, so put the definition up here */
1788 -typedef struct {
1789 -       unsigned long seg;
1790 -} mm_segment_t;
1791 -
1792 -#include <linux/thread_info.h>
1793 -#include <linux/errno.h>
1794 -#include <asm/processor.h>
1795 -#include <asm/elf.h>
1796 -
1797 -#define VERIFY_READ 0
1798 -#define VERIFY_WRITE 1
1799 -
1800 -/*
1801 - * The fs value determines whether argument validity checking should be
1802 - * performed or not.  If get_fs() == USER_DS, checking is performed, with
1803 - * get_fs() == KERNEL_DS, checking is bypassed.
1804 - *
1805 - * For historical reasons, these macros are grossly misnamed.
1806 - */
1807 -
1808 -#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
1809 -
1810 -#define KERNEL_DS      MAKE_MM_SEG(0xFFFFFFFF)
1811 -#define USER_DS                MAKE_MM_SEG(TASK_SIZE)
1812 -
1813 -#define get_ds()       (KERNEL_DS)
1814 -#define get_fs()       (current_thread_info()->addr_limit)
1815 -#define set_fs(x)      (current_thread_info()->addr_limit = (x))
1816 -
1817 -#define segment_eq(a, b) ((a).seg == (b).seg)
1818 -
1819 -#define __under_task_size(addr, size) \
1820 -       (((unsigned long) (addr) < TASK_SIZE) && \
1821 -        (((unsigned long) (addr) + (size)) < TASK_SIZE))
1822 -
1823 -#define __access_ok_vsyscall(type, addr, size) \
1824 -        ((type == VERIFY_READ) && \
1825 -         ((unsigned long) (addr) >= FIXADDR_USER_START) && \
1826 -         ((unsigned long) (addr) + (size) <= FIXADDR_USER_END) && \
1827 -         ((unsigned long) (addr) + (size) >= (unsigned long)(addr)))
1828 -
1829 -#define __addr_range_nowrap(addr, size) \
1830 -       ((unsigned long) (addr) <= ((unsigned long) (addr) + (size)))
1831 -
1832 -#define access_ok(type, addr, size) \
1833 -       (__addr_range_nowrap(addr, size) && \
1834 -        (__under_task_size(addr, size) || \
1835 -         __access_ok_vsyscall(type, addr, size) || \
1836 -         segment_eq(get_fs(), KERNEL_DS)))
1837 -
1838 -extern int copy_from_user(void *to, const void __user *from, int n);
1839 -extern int copy_to_user(void __user *to, const void *from, int n);
1840 -
1841 -/*
1842 - * strncpy_from_user: - Copy a NUL terminated string from userspace.
1843 - * @dst:   Destination address, in kernel space.  This buffer must be at
1844 - *         least @count bytes long.
1845 - * @src:   Source address, in user space.
1846 - * @count: Maximum number of bytes to copy, including the trailing NUL.
1847 - *
1848 - * Copies a NUL-terminated string from userspace to kernel space.
1849 - *
1850 - * On success, returns the length of the string (not including the trailing
1851 - * NUL).
1852 - *
1853 - * If access to userspace fails, returns -EFAULT (some data may have been
1854 - * copied).
1855 - *
1856 - * If @count is smaller than the length of the string, copies @count bytes
1857 - * and returns @count.
1858 - */
1859 -
1860 -extern int strncpy_from_user(char *dst, const char __user *src, int count);
1861 -
1862 -/*
1863 - * __clear_user: - Zero a block of memory in user space, with less checking.
1864 - * @to:   Destination address, in user space.
1865 - * @n:    Number of bytes to zero.
1866 - *
1867 - * Zero a block of memory in user space.  Caller must check
1868 - * the specified block with access_ok() before calling this function.
1869 - *
1870 - * Returns number of bytes that could not be cleared.
1871 - * On success, this will be zero.
1872 - */
1873 -extern int __clear_user(void __user *mem, int len);
1874 -
1875 -/*
1876 - * clear_user: - Zero a block of memory in user space.
1877 - * @to:   Destination address, in user space.
1878 - * @n:    Number of bytes to zero.
1879 - *
1880 - * Zero a block of memory in user space.
1881 - *
1882 - * Returns number of bytes that could not be cleared.
1883 - * On success, this will be zero.
1884 - */
1885 -extern int clear_user(void __user *mem, int len);
1886 -
1887 -/*
1888 - * strlen_user: - Get the size of a string in user space.
1889 - * @str: The string to measure.
1890 - * @n:   The maximum valid length
1891 - *
1892 - * Get the size of a NUL-terminated string in user space.
1893 - *
1894 - * Returns the size of the string INCLUDING the terminating NUL.
1895 - * On exception, returns 0.
1896 - * If the string is too long, returns a value greater than @n.
1897 - */
1898 -extern int strnlen_user(const void __user *str, int len);
1899 -
1900 -#define __copy_from_user(to, from, n) copy_from_user(to, from, n)
1901 -
1902 -#define __copy_to_user(to, from, n) copy_to_user(to, from, n)
1903 -
1904 -#define __copy_to_user_inatomic __copy_to_user
1905 -#define __copy_from_user_inatomic __copy_from_user
1906 -
1907 -#define __get_user(x, ptr) \
1908 -({ \
1909 -       const __typeof__(*(ptr)) __user *__private_ptr = (ptr); \
1910 -       __typeof__(x) __private_val;                    \
1911 -       int __private_ret = -EFAULT;                    \
1912 -       (x) = (__typeof__(*(__private_ptr)))0;                          \
1913 -       if (__copy_from_user((__force void *)&__private_val, (__private_ptr),\
1914 -                            sizeof(*(__private_ptr))) == 0) {          \
1915 -               (x) = (__typeof__(*(__private_ptr))) __private_val;     \
1916 -               __private_ret = 0;                                      \
1917 -       }                                                               \
1918 -       __private_ret;                                                  \
1919 -})
1920 -
1921 -#define get_user(x, ptr) \
1922 -({ \
1923 -        const __typeof__((*(ptr))) __user *private_ptr = (ptr); \
1924 -        (access_ok(VERIFY_READ, private_ptr, sizeof(*private_ptr)) ? \
1925 -        __get_user(x, private_ptr) : ((x) = (__typeof__(*ptr))0, -EFAULT)); \
1926 -})
1927 -
1928 -#define __put_user(x, ptr) \
1929 -({ \
1930 -        __typeof__(*(ptr)) __user *__private_ptr = ptr; \
1931 -        __typeof__(*(__private_ptr)) __private_val; \
1932 -        int __private_ret = -EFAULT; \
1933 -        __private_val = (__typeof__(*(__private_ptr))) (x); \
1934 -        if (__copy_to_user((__private_ptr), &__private_val, \
1935 -                          sizeof(*(__private_ptr))) == 0) { \
1936 -               __private_ret = 0; \
1937 -       } \
1938 -        __private_ret; \
1939 -})
1940 -
1941 -#define put_user(x, ptr) \
1942 -({ \
1943 -        __typeof__(*(ptr)) __user *private_ptr = (ptr); \
1944 -        (access_ok(VERIFY_WRITE, private_ptr, sizeof(*private_ptr)) ? \
1945 -        __put_user(x, private_ptr) : -EFAULT); \
1946 -})
1947 -
1948 -#define strlen_user(str) strnlen_user(str, ~0U >> 1)
1949 -
1950 -struct exception_table_entry
1951 -{
1952 -        unsigned long insn;
1953 -       unsigned long fixup;
1954 -};
1955 -
1956 -#endif
1957 --- /dev/null
1958 +++ b/arch/um/include/uapi/asm/Kbuild
1959 @@ -0,0 +1,8 @@
1960 +generic-y += bug.h cputime.h device.h emergency-restart.h futex.h hardirq.h
1961 +generic-y += hw_irq.h irq_regs.h kdebug.h percpu.h sections.h topology.h xor.h
1962 +generic-y += ftrace.h pci.h io.h param.h delay.h mutex.h current.h exec.h
1963 +generic-y += switch_to.h clkdev.h
1964 +generic-y += trace_clock.h
1965 +generic-y += preempt.h
1966 +generic-y += hash.h
1967 +generic-y += barrier.h
1968 --- /dev/null
1969 +++ b/arch/um/include/uapi/asm/a.out-core.h
1970 @@ -0,0 +1,27 @@
1971 +/* a.out coredump register dumper
1972 + *
1973 + * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
1974 + * Written by David Howells (dhowells@redhat.com)
1975 + *
1976 + * This program is free software; you can redistribute it and/or
1977 + * modify it under the terms of the GNU General Public Licence
1978 + * as published by the Free Software Foundation; either version
1979 + * 2 of the Licence, or (at your option) any later version.
1980 + */
1981 +
1982 +#ifndef __UM_A_OUT_CORE_H
1983 +#define __UM_A_OUT_CORE_H
1984 +
1985 +#ifdef __KERNEL__
1986 +
1987 +#include <linux/user.h>
1988 +
1989 +/*
1990 + * fill in the user structure for an a.out core dump
1991 + */
1992 +static inline void aout_dump_thread(struct pt_regs *regs, struct user *u)
1993 +{
1994 +}
1995 +
1996 +#endif /* __KERNEL__ */
1997 +#endif /* __UM_A_OUT_CORE_H */
1998 --- /dev/null
1999 +++ b/arch/um/include/uapi/asm/bugs.h
2000 @@ -0,0 +1,6 @@
2001 +#ifndef __UM_BUGS_H
2002 +#define __UM_BUGS_H
2003 +
2004 +void check_bugs(void);
2005 +
2006 +#endif
2007 --- /dev/null
2008 +++ b/arch/um/include/uapi/asm/cache.h
2009 @@ -0,0 +1,17 @@
2010 +#ifndef __UM_CACHE_H
2011 +#define __UM_CACHE_H
2012 +
2013 +
2014 +#if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
2015 +# define L1_CACHE_SHIFT                (CONFIG_X86_L1_CACHE_SHIFT)
2016 +#elif defined(CONFIG_UML_X86) /* 64-bit */
2017 +# define L1_CACHE_SHIFT                6 /* Should be 7 on Intel */
2018 +#else
2019 +/* XXX: this was taken from x86, now it's completely random. Luckily only
2020 + * affects SMP padding. */
2021 +# define L1_CACHE_SHIFT                5
2022 +#endif
2023 +
2024 +#define L1_CACHE_BYTES         (1 << L1_CACHE_SHIFT)
2025 +
2026 +#endif
2027 --- /dev/null
2028 +++ b/arch/um/include/uapi/asm/common.lds.S
2029 @@ -0,0 +1,107 @@
2030 +#include <asm-generic/vmlinux.lds.h>
2031 +
2032 +  .fini      : { *(.fini)    } =0x9090
2033 +  _etext = .;
2034 +  PROVIDE (etext = .);
2035 +
2036 +  . = ALIGN(4096);
2037 +  _sdata = .;
2038 +  PROVIDE (sdata = .);
2039 +
2040 +  RODATA
2041 +
2042 +  .unprotected : { *(.unprotected) }
2043 +  . = ALIGN(4096);
2044 +  PROVIDE (_unprotected_end = .);
2045 +
2046 +  . = ALIGN(4096);
2047 +  .note : { *(.note.*) }
2048 +  EXCEPTION_TABLE(0)
2049 +
2050 +  BUG_TABLE
2051 +
2052 +  .uml.setup.init : {
2053 +       __uml_setup_start = .;
2054 +       *(.uml.setup.init)
2055 +       __uml_setup_end = .;
2056 +  }
2057 +
2058 +  .uml.help.init : {
2059 +       __uml_help_start = .;
2060 +       *(.uml.help.init)
2061 +       __uml_help_end = .;
2062 +  }
2063 +
2064 +  .uml.postsetup.init : {
2065 +       __uml_postsetup_start = .;
2066 +       *(.uml.postsetup.init)
2067 +       __uml_postsetup_end = .;
2068 +  }
2069 +
2070 +  .init.setup : {
2071 +       INIT_SETUP(0)
2072 +  }
2073 +
2074 +  PERCPU_SECTION(32)
2075 +
2076 +  .initcall.init : {
2077 +       INIT_CALLS
2078 +  }
2079 +
2080 +  .con_initcall.init : {
2081 +       CON_INITCALL
2082 +  }
2083 +
2084 +  .uml.initcall.init : {
2085 +       __uml_initcall_start = .;
2086 +       *(.uml.initcall.init)
2087 +       __uml_initcall_end = .;
2088 +  }
2089 +
2090 +  SECURITY_INIT
2091 +
2092 +  .exitcall : {
2093 +       __exitcall_begin = .;
2094 +       *(.exitcall.exit)
2095 +       __exitcall_end = .;
2096 +  }
2097 +
2098 +  .uml.exitcall : {
2099 +       __uml_exitcall_begin = .;
2100 +       *(.uml.exitcall.exit)
2101 +       __uml_exitcall_end = .;
2102 +  }
2103 +
2104 +  . = ALIGN(4);
2105 +  .altinstructions : {
2106 +       __alt_instructions = .;
2107 +       *(.altinstructions)
2108 +       __alt_instructions_end = .;
2109 +  }
2110 +  .altinstr_replacement : { *(.altinstr_replacement) }
2111 +  /* .exit.text is discard at runtime, not link time, to deal with references
2112 +     from .altinstructions and .eh_frame */
2113 +  .exit.text : { *(.exit.text) }
2114 +  .exit.data : { *(.exit.data) }
2115 +
2116 +  .preinit_array : {
2117 +       __preinit_array_start = .;
2118 +       *(.preinit_array)
2119 +       __preinit_array_end = .;
2120 +  }
2121 +  .init_array : {
2122 +       __init_array_start = .;
2123 +       *(.init_array)
2124 +       __init_array_end = .;
2125 +  }
2126 +  .fini_array : {
2127 +       __fini_array_start = .;
2128 +       *(.fini_array)
2129 +       __fini_array_end = .;
2130 +  }
2131 +
2132 +   . = ALIGN(4096);
2133 +  .init.ramfs : {
2134 +       INIT_RAM_FS
2135 +  }
2136 +
2137 --- /dev/null
2138 +++ b/arch/um/include/uapi/asm/dma.h
2139 @@ -0,0 +1,10 @@
2140 +#ifndef __UM_DMA_H
2141 +#define __UM_DMA_H
2142 +
2143 +#include <asm/io.h>
2144 +
2145 +extern unsigned long uml_physmem;
2146 +
2147 +#define MAX_DMA_ADDRESS (uml_physmem)
2148 +
2149 +#endif
2150 --- /dev/null
2151 +++ b/arch/um/include/uapi/asm/fixmap.h
2152 @@ -0,0 +1,60 @@
2153 +#ifndef __UM_FIXMAP_H
2154 +#define __UM_FIXMAP_H
2155 +
2156 +#include <asm/processor.h>
2157 +#include <asm/kmap_types.h>
2158 +#include <asm/archparam.h>
2159 +#include <asm/page.h>
2160 +#include <linux/threads.h>
2161 +
2162 +/*
2163 + * Here we define all the compile-time 'special' virtual
2164 + * addresses. The point is to have a constant address at
2165 + * compile time, but to set the physical address only
2166 + * in the boot process. We allocate these special  addresses
2167 + * from the end of virtual memory (0xfffff000) backwards.
2168 + * Also this lets us do fail-safe vmalloc(), we
2169 + * can guarantee that these special addresses and
2170 + * vmalloc()-ed addresses never overlap.
2171 + *
2172 + * these 'compile-time allocated' memory buffers are
2173 + * fixed-size 4k pages. (or larger if used with an increment
2174 + * highger than 1) use fixmap_set(idx,phys) to associate
2175 + * physical memory with fixmap indices.
2176 + *
2177 + * TLB entries of such buffers will not be flushed across
2178 + * task switches.
2179 + */
2180 +
2181 +/*
2182 + * on UP currently we will have no trace of the fixmap mechanizm,
2183 + * no page table allocations, etc. This might change in the
2184 + * future, say framebuffers for the console driver(s) could be
2185 + * fix-mapped?
2186 + */
2187 +enum fixed_addresses {
2188 +#ifdef CONFIG_HIGHMEM
2189 +       FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */
2190 +       FIX_KMAP_END = FIX_KMAP_BEGIN+(KM_TYPE_NR*NR_CPUS)-1,
2191 +#endif
2192 +       __end_of_fixed_addresses
2193 +};
2194 +
2195 +extern void __set_fixmap (enum fixed_addresses idx,
2196 +                         unsigned long phys, pgprot_t flags);
2197 +
2198 +/*
2199 + * used by vmalloc.c.
2200 + *
2201 + * Leave one empty page between vmalloc'ed areas and
2202 + * the start of the fixmap, and leave one page empty
2203 + * at the top of mem..
2204 + */
2205 +
2206 +#define FIXADDR_TOP    (TASK_SIZE - 2 * PAGE_SIZE)
2207 +#define FIXADDR_SIZE   (__end_of_fixed_addresses << PAGE_SHIFT)
2208 +#define FIXADDR_START  (FIXADDR_TOP - FIXADDR_SIZE)
2209 +
2210 +#include <asm-generic/fixmap.h>
2211 +
2212 +#endif
2213 --- /dev/null
2214 +++ b/arch/um/include/uapi/asm/irq.h
2215 @@ -0,0 +1,23 @@
2216 +#ifndef __UM_IRQ_H
2217 +#define __UM_IRQ_H
2218 +
2219 +#define TIMER_IRQ              0
2220 +#define UMN_IRQ                        1
2221 +#define CONSOLE_IRQ            2
2222 +#define CONSOLE_WRITE_IRQ      3
2223 +#define UBD_IRQ                        4
2224 +#define UM_ETH_IRQ             5
2225 +#define SSL_IRQ                        6
2226 +#define SSL_WRITE_IRQ          7
2227 +#define ACCEPT_IRQ             8
2228 +#define MCONSOLE_IRQ           9
2229 +#define WINCH_IRQ              10
2230 +#define SIGIO_WRITE_IRQ        11
2231 +#define TELNETD_IRQ            12
2232 +#define XTERM_IRQ              13
2233 +#define RANDOM_IRQ             14
2234 +
2235 +#define LAST_IRQ RANDOM_IRQ
2236 +#define NR_IRQS (LAST_IRQ + 1)
2237 +
2238 +#endif
2239 --- /dev/null
2240 +++ b/arch/um/include/uapi/asm/irqflags.h
2241 @@ -0,0 +1,42 @@
2242 +#ifndef __UM_IRQFLAGS_H
2243 +#define __UM_IRQFLAGS_H
2244 +
2245 +extern int get_signals(void);
2246 +extern int set_signals(int enable);
2247 +extern void block_signals(void);
2248 +extern void unblock_signals(void);
2249 +
2250 +static inline unsigned long arch_local_save_flags(void)
2251 +{
2252 +       return get_signals();
2253 +}
2254 +
2255 +static inline void arch_local_irq_restore(unsigned long flags)
2256 +{
2257 +       set_signals(flags);
2258 +}
2259 +
2260 +static inline void arch_local_irq_enable(void)
2261 +{
2262 +       unblock_signals();
2263 +}
2264 +
2265 +static inline void arch_local_irq_disable(void)
2266 +{
2267 +       block_signals();
2268 +}
2269 +
2270 +static inline unsigned long arch_local_irq_save(void)
2271 +{
2272 +       unsigned long flags;
2273 +       flags = arch_local_save_flags();
2274 +       arch_local_irq_disable();
2275 +       return flags;
2276 +}
2277 +
2278 +static inline bool arch_irqs_disabled(void)
2279 +{
2280 +       return arch_local_save_flags() == 0;
2281 +}
2282 +
2283 +#endif
2284 --- /dev/null
2285 +++ b/arch/um/include/uapi/asm/kmap_types.h
2286 @@ -0,0 +1,13 @@
2287 +/*
2288 + * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
2289 + * Licensed under the GPL
2290 + */
2291 +
2292 +#ifndef __UM_KMAP_TYPES_H
2293 +#define __UM_KMAP_TYPES_H
2294 +
2295 +/* No more #include "asm/arch/kmap_types.h" ! */
2296 +
2297 +#define KM_TYPE_NR 14
2298 +
2299 +#endif
2300 --- /dev/null
2301 +++ b/arch/um/include/uapi/asm/kvm_para.h
2302 @@ -0,0 +1 @@
2303 +#include <asm-generic/kvm_para.h>
2304 --- /dev/null
2305 +++ b/arch/um/include/uapi/asm/mmu.h
2306 @@ -0,0 +1,24 @@
2307 +/*
2308 + * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
2309 + * Licensed under the GPL
2310 + */
2311 +
2312 +#ifndef __ARCH_UM_MMU_H
2313 +#define __ARCH_UM_MMU_H
2314 +
2315 +#include <mm_id.h>
2316 +#include <asm/mm_context.h>
2317 +
2318 +typedef struct mm_context {
2319 +       struct mm_id id;
2320 +       struct uml_arch_mm_context arch;
2321 +       struct page *stub_pages[2];
2322 +} mm_context_t;
2323 +
2324 +extern void __switch_mm(struct mm_id * mm_idp);
2325 +
2326 +/* Avoid tangled inclusion with asm/ldt.h */
2327 +extern long init_new_ldt(struct mm_context *to_mm, struct mm_context *from_mm);
2328 +extern void free_ldt(struct mm_context *mm);
2329 +
2330 +#endif
2331 --- /dev/null
2332 +++ b/arch/um/include/uapi/asm/mmu_context.h
2333 @@ -0,0 +1,58 @@
2334 +/*
2335 + * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
2336 + * Licensed under the GPL
2337 + */
2338 +
2339 +#ifndef __UM_MMU_CONTEXT_H
2340 +#define __UM_MMU_CONTEXT_H
2341 +
2342 +#include <linux/sched.h>
2343 +#include <asm/mmu.h>
2344 +
2345 +extern void uml_setup_stubs(struct mm_struct *mm);
2346 +extern void arch_exit_mmap(struct mm_struct *mm);
2347 +
2348 +#define deactivate_mm(tsk,mm)  do { } while (0)
2349 +
2350 +extern void force_flush_all(void);
2351 +
2352 +static inline void activate_mm(struct mm_struct *old, struct mm_struct *new)
2353 +{
2354 +       /*
2355 +        * This is called by fs/exec.c and sys_unshare()
2356 +        * when the new ->mm is used for the first time.
2357 +        */
2358 +       __switch_mm(&new->context.id);
2359 +       down_write(&new->mmap_sem);
2360 +       uml_setup_stubs(new);
2361 +       up_write(&new->mmap_sem);
2362 +}
2363 +
2364 +static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
2365 +                            struct task_struct *tsk)
2366 +{
2367 +       unsigned cpu = smp_processor_id();
2368 +
2369 +       if(prev != next){
2370 +               cpumask_clear_cpu(cpu, mm_cpumask(prev));
2371 +               cpumask_set_cpu(cpu, mm_cpumask(next));
2372 +               if(next != &init_mm)
2373 +                       __switch_mm(&next->context.id);
2374 +       }
2375 +}
2376 +
2377 +static inline void arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
2378 +{
2379 +       uml_setup_stubs(mm);
2380 +}
2381 +
2382 +static inline void enter_lazy_tlb(struct mm_struct *mm,
2383 +                                 struct task_struct *tsk)
2384 +{
2385 +}
2386 +
2387 +extern int init_new_context(struct task_struct *task, struct mm_struct *mm);
2388 +
2389 +extern void destroy_context(struct mm_struct *mm);
2390 +
2391 +#endif
2392 --- /dev/null
2393 +++ b/arch/um/include/uapi/asm/page.h
2394 @@ -0,0 +1,122 @@
2395 +/*
2396 + * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
2397 + * Copyright 2003 PathScale, Inc.
2398 + * Licensed under the GPL
2399 + */
2400 +
2401 +#ifndef __UM_PAGE_H
2402 +#define __UM_PAGE_H
2403 +
2404 +#include <linux/const.h>
2405 +
2406 +/* PAGE_SHIFT determines the page size */
2407 +#define PAGE_SHIFT     12
2408 +#define PAGE_SIZE      (_AC(1, UL) << PAGE_SHIFT)
2409 +#define PAGE_MASK      (~(PAGE_SIZE-1))
2410 +
2411 +#ifndef __ASSEMBLY__
2412 +
2413 +struct page;
2414 +
2415 +#include <linux/types.h>
2416 +#include <asm/vm-flags.h>
2417 +
2418 +/*
2419 + * These are used to make use of C type-checking..
2420 + */
2421 +
2422 +#define clear_page(page)       memset((void *)(page), 0, PAGE_SIZE)
2423 +#define copy_page(to,from)     memcpy((void *)(to), (void *)(from), PAGE_SIZE)
2424 +
2425 +#define clear_user_page(page, vaddr, pg)       clear_page(page)
2426 +#define copy_user_page(to, from, vaddr, pg)    copy_page(to, from)
2427 +
2428 +#if defined(CONFIG_3_LEVEL_PGTABLES) && !defined(CONFIG_64BIT)
2429 +
2430 +typedef struct { unsigned long pte_low, pte_high; } pte_t;
2431 +typedef struct { unsigned long pmd; } pmd_t;
2432 +typedef struct { unsigned long pgd; } pgd_t;
2433 +#define pte_val(x) ((x).pte_low | ((unsigned long long) (x).pte_high << 32))
2434 +
2435 +#define pte_get_bits(pte, bits) ((pte).pte_low & (bits))
2436 +#define pte_set_bits(pte, bits) ((pte).pte_low |= (bits))
2437 +#define pte_clear_bits(pte, bits) ((pte).pte_low &= ~(bits))
2438 +#define pte_copy(to, from) ({ (to).pte_high = (from).pte_high; \
2439 +                             smp_wmb(); \
2440 +                             (to).pte_low = (from).pte_low; })
2441 +#define pte_is_zero(pte) (!((pte).pte_low & ~_PAGE_NEWPAGE) && !(pte).pte_high)
2442 +#define pte_set_val(pte, phys, prot) \
2443 +       ({ (pte).pte_high = (phys) >> 32; \
2444 +          (pte).pte_low = (phys) | pgprot_val(prot); })
2445 +
2446 +#define pmd_val(x)     ((x).pmd)
2447 +#define __pmd(x) ((pmd_t) { (x) } )
2448 +
2449 +typedef unsigned long long pfn_t;
2450 +typedef unsigned long long phys_t;
2451 +
2452 +#else
2453 +
2454 +typedef struct { unsigned long pte; } pte_t;
2455 +typedef struct { unsigned long pgd; } pgd_t;
2456 +
2457 +#ifdef CONFIG_3_LEVEL_PGTABLES
2458 +typedef struct { unsigned long pmd; } pmd_t;
2459 +#define pmd_val(x)     ((x).pmd)
2460 +#define __pmd(x) ((pmd_t) { (x) } )
2461 +#endif
2462 +
2463 +#define pte_val(x)     ((x).pte)
2464 +
2465 +
2466 +#define pte_get_bits(p, bits) ((p).pte & (bits))
2467 +#define pte_set_bits(p, bits) ((p).pte |= (bits))
2468 +#define pte_clear_bits(p, bits) ((p).pte &= ~(bits))
2469 +#define pte_copy(to, from) ((to).pte = (from).pte)
2470 +#define pte_is_zero(p) (!((p).pte & ~_PAGE_NEWPAGE))
2471 +#define pte_set_val(p, phys, prot) (p).pte = (phys | pgprot_val(prot))
2472 +
2473 +typedef unsigned long pfn_t;
2474 +typedef unsigned long phys_t;
2475 +
2476 +#endif
2477 +
2478 +typedef struct { unsigned long pgprot; } pgprot_t;
2479 +
2480 +typedef struct page *pgtable_t;
2481 +
2482 +#define pgd_val(x)     ((x).pgd)
2483 +#define pgprot_val(x)  ((x).pgprot)
2484 +
2485 +#define __pte(x) ((pte_t) { (x) } )
2486 +#define __pgd(x) ((pgd_t) { (x) } )
2487 +#define __pgprot(x)    ((pgprot_t) { (x) } )
2488 +
2489 +extern unsigned long uml_physmem;
2490 +
2491 +#define PAGE_OFFSET (uml_physmem)
2492 +#define KERNELBASE PAGE_OFFSET
2493 +
2494 +#define __va_space (8*1024*1024)
2495 +
2496 +#include <mem.h>
2497 +
2498 +/* Cast to unsigned long before casting to void * to avoid a warning from
2499 + * mmap_kmem about cutting a long long down to a void *.  Not sure that
2500 + * casting is the right thing, but 32-bit UML can't have 64-bit virtual
2501 + * addresses
2502 + */
2503 +#define __pa(virt) to_phys((void *) (unsigned long) (virt))
2504 +#define __va(phys) to_virt((unsigned long) (phys))
2505 +
2506 +#define phys_to_pfn(p) ((pfn_t) ((p) >> PAGE_SHIFT))
2507 +#define pfn_to_phys(pfn) ((phys_t) ((pfn) << PAGE_SHIFT))
2508 +
2509 +#define pfn_valid(pfn) ((pfn) < max_mapnr)
2510 +#define virt_addr_valid(v) pfn_valid(phys_to_pfn(__pa(v)))
2511 +
2512 +#include <asm-generic/memory_model.h>
2513 +#include <asm-generic/getorder.h>
2514 +
2515 +#endif /* __ASSEMBLY__ */
2516 +#endif /* __UM_PAGE_H */
2517 --- /dev/null
2518 +++ b/arch/um/include/uapi/asm/pgalloc.h
2519 @@ -0,0 +1,61 @@
2520 +/*
2521 + * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
2522 + * Copyright 2003 PathScale, Inc.
2523 + * Derived from include/asm-i386/pgalloc.h and include/asm-i386/pgtable.h
2524 + * Licensed under the GPL
2525 + */
2526 +
2527 +#ifndef __UM_PGALLOC_H
2528 +#define __UM_PGALLOC_H
2529 +
2530 +#include <linux/mm.h>
2531 +
2532 +#define pmd_populate_kernel(mm, pmd, pte) \
2533 +       set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) __pa(pte)))
2534 +
2535 +#define pmd_populate(mm, pmd, pte)                             \
2536 +       set_pmd(pmd, __pmd(_PAGE_TABLE +                        \
2537 +               ((unsigned long long)page_to_pfn(pte) <<        \
2538 +                       (unsigned long long) PAGE_SHIFT)))
2539 +#define pmd_pgtable(pmd) pmd_page(pmd)
2540 +
2541 +/*
2542 + * Allocate and free page tables.
2543 + */
2544 +extern pgd_t *pgd_alloc(struct mm_struct *);
2545 +extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
2546 +
2547 +extern pte_t *pte_alloc_one_kernel(struct mm_struct *, unsigned long);
2548 +extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
2549 +
2550 +static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
2551 +{
2552 +       free_page((unsigned long) pte);
2553 +}
2554 +
2555 +static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
2556 +{
2557 +       pgtable_page_dtor(pte);
2558 +       __free_page(pte);
2559 +}
2560 +
2561 +#define __pte_free_tlb(tlb,pte, address)               \
2562 +do {                                                   \
2563 +       pgtable_page_dtor(pte);                         \
2564 +       tlb_remove_page((tlb),(pte));                   \
2565 +} while (0)
2566 +
2567 +#ifdef CONFIG_3_LEVEL_PGTABLES
2568 +
2569 +static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
2570 +{
2571 +       free_page((unsigned long)pmd);
2572 +}
2573 +
2574 +#define __pmd_free_tlb(tlb,x, address)   tlb_remove_page((tlb),virt_to_page(x))
2575 +#endif
2576 +
2577 +#define check_pgt_cache()      do { } while (0)
2578 +
2579 +#endif
2580 +
2581 --- /dev/null
2582 +++ b/arch/um/include/uapi/asm/pgtable-2level.h
2583 @@ -0,0 +1,53 @@
2584 +/*
2585 + * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
2586 + * Copyright 2003 PathScale, Inc.
2587 + * Derived from include/asm-i386/pgtable.h
2588 + * Licensed under the GPL
2589 + */
2590 +
2591 +#ifndef __UM_PGTABLE_2LEVEL_H
2592 +#define __UM_PGTABLE_2LEVEL_H
2593 +
2594 +#include <asm-generic/pgtable-nopmd.h>
2595 +
2596 +/* PGDIR_SHIFT determines what a third-level page table entry can map */
2597 +
2598 +#define PGDIR_SHIFT    22
2599 +#define PGDIR_SIZE     (1UL << PGDIR_SHIFT)
2600 +#define PGDIR_MASK     (~(PGDIR_SIZE-1))
2601 +
2602 +/*
2603 + * entries per page directory level: the i386 is two-level, so
2604 + * we don't really have any PMD directory physically.
2605 + */
2606 +#define PTRS_PER_PTE   1024
2607 +#define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
2608 +#define PTRS_PER_PGD   1024
2609 +#define FIRST_USER_ADDRESS     0
2610 +
2611 +#define pte_ERROR(e) \
2612 +        printk("%s:%d: bad pte %p(%08lx).\n", __FILE__, __LINE__, &(e), \
2613 +              pte_val(e))
2614 +#define pgd_ERROR(e) \
2615 +        printk("%s:%d: bad pgd %p(%08lx).\n", __FILE__, __LINE__, &(e), \
2616 +              pgd_val(e))
2617 +
2618 +static inline int pgd_newpage(pgd_t pgd)       { return 0; }
2619 +static inline void pgd_mkuptodate(pgd_t pgd)   { }
2620 +
2621 +#define set_pmd(pmdptr, pmdval) (*(pmdptr) = (pmdval))
2622 +
2623 +#define pte_pfn(x) phys_to_pfn(pte_val(x))
2624 +#define pfn_pte(pfn, prot) __pte(pfn_to_phys(pfn) | pgprot_val(prot))
2625 +#define pfn_pmd(pfn, prot) __pmd(pfn_to_phys(pfn) | pgprot_val(prot))
2626 +
2627 +/*
2628 + * Bits 0 through 4 are taken
2629 + */
2630 +#define PTE_FILE_MAX_BITS      27
2631 +
2632 +#define pte_to_pgoff(pte) (pte_val(pte) >> 5)
2633 +
2634 +#define pgoff_to_pte(off) ((pte_t) { ((off) << 5) + _PAGE_FILE })
2635 +
2636 +#endif
2637 --- /dev/null
2638 +++ b/arch/um/include/uapi/asm/pgtable-3level.h
2639 @@ -0,0 +1,136 @@
2640 +/*
2641 + * Copyright 2003 PathScale Inc
2642 + * Derived from include/asm-i386/pgtable.h
2643 + * Licensed under the GPL
2644 + */
2645 +
2646 +#ifndef __UM_PGTABLE_3LEVEL_H
2647 +#define __UM_PGTABLE_3LEVEL_H
2648 +
2649 +#include <asm-generic/pgtable-nopud.h>
2650 +
2651 +/* PGDIR_SHIFT determines what a third-level page table entry can map */
2652 +
2653 +#ifdef CONFIG_64BIT
2654 +#define PGDIR_SHIFT    30
2655 +#else
2656 +#define PGDIR_SHIFT    31
2657 +#endif
2658 +#define PGDIR_SIZE     (1UL << PGDIR_SHIFT)
2659 +#define PGDIR_MASK     (~(PGDIR_SIZE-1))
2660 +
2661 +/* PMD_SHIFT determines the size of the area a second-level page table can
2662 + * map
2663 + */
2664 +
2665 +#define PMD_SHIFT      21
2666 +#define PMD_SIZE       (1UL << PMD_SHIFT)
2667 +#define PMD_MASK       (~(PMD_SIZE-1))
2668 +
2669 +/*
2670 + * entries per page directory level
2671 + */
2672 +
2673 +#define PTRS_PER_PTE 512
2674 +#ifdef CONFIG_64BIT
2675 +#define PTRS_PER_PMD 512
2676 +#define PTRS_PER_PGD 512
2677 +#else
2678 +#define PTRS_PER_PMD 1024
2679 +#define PTRS_PER_PGD 1024
2680 +#endif
2681 +
2682 +#define USER_PTRS_PER_PGD ((TASK_SIZE + (PGDIR_SIZE - 1)) / PGDIR_SIZE)
2683 +#define FIRST_USER_ADDRESS     0
2684 +
2685 +#define pte_ERROR(e) \
2686 +        printk("%s:%d: bad pte %p(%016lx).\n", __FILE__, __LINE__, &(e), \
2687 +              pte_val(e))
2688 +#define pmd_ERROR(e) \
2689 +        printk("%s:%d: bad pmd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
2690 +              pmd_val(e))
2691 +#define pgd_ERROR(e) \
2692 +        printk("%s:%d: bad pgd %p(%016lx).\n", __FILE__, __LINE__, &(e), \
2693 +              pgd_val(e))
2694 +
2695 +#define pud_none(x)    (!(pud_val(x) & ~_PAGE_NEWPAGE))
2696 +#define        pud_bad(x)      ((pud_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
2697 +#define pud_present(x) (pud_val(x) & _PAGE_PRESENT)
2698 +#define pud_populate(mm, pud, pmd) \
2699 +       set_pud(pud, __pud(_PAGE_TABLE + __pa(pmd)))
2700 +
2701 +#ifdef CONFIG_64BIT
2702 +#define set_pud(pudptr, pudval) set_64bit((u64 *) (pudptr), pud_val(pudval))
2703 +#else
2704 +#define set_pud(pudptr, pudval) (*(pudptr) = (pudval))
2705 +#endif
2706 +
2707 +static inline int pgd_newpage(pgd_t pgd)
2708 +{
2709 +       return(pgd_val(pgd) & _PAGE_NEWPAGE);
2710 +}
2711 +
2712 +static inline void pgd_mkuptodate(pgd_t pgd) { pgd_val(pgd) &= ~_PAGE_NEWPAGE; }
2713 +
2714 +#ifdef CONFIG_64BIT
2715 +#define set_pmd(pmdptr, pmdval) set_64bit((u64 *) (pmdptr), pmd_val(pmdval))
2716 +#else
2717 +#define set_pmd(pmdptr, pmdval) (*(pmdptr) = (pmdval))
2718 +#endif
2719 +
2720 +struct mm_struct;
2721 +extern pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address);
2722 +
2723 +static inline void pud_clear (pud_t *pud)
2724 +{
2725 +       set_pud(pud, __pud(_PAGE_NEWPAGE));
2726 +}
2727 +
2728 +#define pud_page(pud) phys_to_page(pud_val(pud) & PAGE_MASK)
2729 +#define pud_page_vaddr(pud) ((unsigned long) __va(pud_val(pud) & PAGE_MASK))
2730 +
2731 +/* Find an entry in the second-level page table.. */
2732 +#define pmd_offset(pud, address) ((pmd_t *) pud_page_vaddr(*(pud)) + \
2733 +                       pmd_index(address))
2734 +
2735 +static inline unsigned long pte_pfn(pte_t pte)
2736 +{
2737 +       return phys_to_pfn(pte_val(pte));
2738 +}
2739 +
2740 +static inline pte_t pfn_pte(pfn_t page_nr, pgprot_t pgprot)
2741 +{
2742 +       pte_t pte;
2743 +       phys_t phys = pfn_to_phys(page_nr);
2744 +
2745 +       pte_set_val(pte, phys, pgprot);
2746 +       return pte;
2747 +}
2748 +
2749 +static inline pmd_t pfn_pmd(pfn_t page_nr, pgprot_t pgprot)
2750 +{
2751 +       return __pmd((page_nr << PAGE_SHIFT) | pgprot_val(pgprot));
2752 +}
2753 +
2754 +/*
2755 + * Bits 0 through 3 are taken in the low part of the pte,
2756 + * put the 32 bits of offset into the high part.
2757 + */
2758 +#define PTE_FILE_MAX_BITS      32
2759 +
2760 +#ifdef CONFIG_64BIT
2761 +
2762 +#define pte_to_pgoff(p) ((p).pte >> 32)
2763 +
2764 +#define pgoff_to_pte(off) ((pte_t) { ((off) << 32) | _PAGE_FILE })
2765 +
2766 +#else
2767 +
2768 +#define pte_to_pgoff(pte) ((pte).pte_high)
2769 +
2770 +#define pgoff_to_pte(off) ((pte_t) { _PAGE_FILE, (off) })
2771 +
2772 +#endif
2773 +
2774 +#endif
2775 +
2776 --- /dev/null
2777 +++ b/arch/um/include/uapi/asm/pgtable.h
2778 @@ -0,0 +1,375 @@
2779 +/*
2780 + * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
2781 + * Copyright 2003 PathScale, Inc.
2782 + * Derived from include/asm-i386/pgtable.h
2783 + * Licensed under the GPL
2784 + */
2785 +
2786 +#ifndef __UM_PGTABLE_H
2787 +#define __UM_PGTABLE_H
2788 +
2789 +#include <asm/fixmap.h>
2790 +
2791 +#define _PAGE_PRESENT  0x001
2792 +#define _PAGE_NEWPAGE  0x002
2793 +#define _PAGE_NEWPROT  0x004
2794 +#define _PAGE_RW       0x020
2795 +#define _PAGE_USER     0x040
2796 +#define _PAGE_ACCESSED 0x080
2797 +#define _PAGE_DIRTY    0x100
2798 +/* If _PAGE_PRESENT is clear, we use these: */
2799 +#define _PAGE_FILE     0x008   /* nonlinear file mapping, saved PTE; unset:swap */
2800 +#define _PAGE_PROTNONE 0x010   /* if the user mapped it with PROT_NONE;
2801 +                                  pte_present gives true */
2802 +
2803 +#ifdef CONFIG_3_LEVEL_PGTABLES
2804 +#include <asm/pgtable-3level.h>
2805 +#else
2806 +#include <asm/pgtable-2level.h>
2807 +#endif
2808 +
2809 +extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
2810 +
2811 +/* zero page used for uninitialized stuff */
2812 +extern unsigned long *empty_zero_page;
2813 +
2814 +#define pgtable_cache_init() do ; while (0)
2815 +
2816 +/* Just any arbitrary offset to the start of the vmalloc VM area: the
2817 + * current 8MB value just means that there will be a 8MB "hole" after the
2818 + * physical memory until the kernel virtual memory starts.  That means that
2819 + * any out-of-bounds memory accesses will hopefully be caught.
2820 + * The vmalloc() routines leaves a hole of 4kB between each vmalloced
2821 + * area for the same reason. ;)
2822 + */
2823 +
2824 +extern unsigned long end_iomem;
2825 +
2826 +#define VMALLOC_OFFSET (__va_space)
2827 +#define VMALLOC_START ((end_iomem + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
2828 +#define PKMAP_BASE ((FIXADDR_START - LAST_PKMAP * PAGE_SIZE) & PMD_MASK)
2829 +#ifdef CONFIG_HIGHMEM
2830 +# define VMALLOC_END   (PKMAP_BASE-2*PAGE_SIZE)
2831 +#else
2832 +# define VMALLOC_END   (FIXADDR_START-2*PAGE_SIZE)
2833 +#endif
2834 +#define MODULES_VADDR  VMALLOC_START
2835 +#define MODULES_END    VMALLOC_END
2836 +#define MODULES_LEN    (MODULES_VADDR - MODULES_END)
2837 +
2838 +#define _PAGE_TABLE    (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
2839 +#define _KERNPG_TABLE  (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
2840 +#define _PAGE_CHG_MASK (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
2841 +#define __PAGE_KERNEL_EXEC                                              \
2842 +        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
2843 +#define PAGE_NONE      __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
2844 +#define PAGE_SHARED    __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
2845 +#define PAGE_COPY      __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
2846 +#define PAGE_READONLY  __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
2847 +#define PAGE_KERNEL    __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
2848 +#define PAGE_KERNEL_EXEC       __pgprot(__PAGE_KERNEL_EXEC)
2849 +
2850 +/*
2851 + * The i386 can't do page protection for execute, and considers that the same
2852 + * are read.
2853 + * Also, write permissions imply read permissions. This is the closest we can
2854 + * get..
2855 + */
2856 +#define __P000 PAGE_NONE
2857 +#define __P001 PAGE_READONLY
2858 +#define __P010 PAGE_COPY
2859 +#define __P011 PAGE_COPY
2860 +#define __P100 PAGE_READONLY
2861 +#define __P101 PAGE_READONLY
2862 +#define __P110 PAGE_COPY
2863 +#define __P111 PAGE_COPY
2864 +
2865 +#define __S000 PAGE_NONE
2866 +#define __S001 PAGE_READONLY
2867 +#define __S010 PAGE_SHARED
2868 +#define __S011 PAGE_SHARED
2869 +#define __S100 PAGE_READONLY
2870 +#define __S101 PAGE_READONLY
2871 +#define __S110 PAGE_SHARED
2872 +#define __S111 PAGE_SHARED
2873 +
2874 +/*
2875 + * ZERO_PAGE is a global shared page that is always zero: used
2876 + * for zero-mapped memory areas etc..
2877 + */
2878 +#define ZERO_PAGE(vaddr) virt_to_page(empty_zero_page)
2879 +
2880 +#define pte_clear(mm,addr,xp) pte_set_val(*(xp), (phys_t) 0, __pgprot(_PAGE_NEWPAGE))
2881 +
2882 +#define pmd_none(x)    (!((unsigned long)pmd_val(x) & ~_PAGE_NEWPAGE))
2883 +#define        pmd_bad(x)      ((pmd_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
2884 +
2885 +#define pmd_present(x) (pmd_val(x) & _PAGE_PRESENT)
2886 +#define pmd_clear(xp)  do { pmd_val(*(xp)) = _PAGE_NEWPAGE; } while (0)
2887 +
2888 +#define pmd_newpage(x)  (pmd_val(x) & _PAGE_NEWPAGE)
2889 +#define pmd_mkuptodate(x) (pmd_val(x) &= ~_PAGE_NEWPAGE)
2890 +
2891 +#define pud_newpage(x)  (pud_val(x) & _PAGE_NEWPAGE)
2892 +#define pud_mkuptodate(x) (pud_val(x) &= ~_PAGE_NEWPAGE)
2893 +
2894 +#define pmd_page(pmd) phys_to_page(pmd_val(pmd) & PAGE_MASK)
2895 +
2896 +#define pte_page(x) pfn_to_page(pte_pfn(x))
2897 +
2898 +#define pte_present(x) pte_get_bits(x, (_PAGE_PRESENT | _PAGE_PROTNONE))
2899 +
2900 +/*
2901 + * =================================
2902 + * Flags checking section.
2903 + * =================================
2904 + */
2905 +
2906 +static inline int pte_none(pte_t pte)
2907 +{
2908 +       return pte_is_zero(pte);
2909 +}
2910 +
2911 +/*
2912 + * The following only work if pte_present() is true.
2913 + * Undefined behaviour if not..
2914 + */
2915 +static inline int pte_read(pte_t pte)
2916 +{
2917 +       return((pte_get_bits(pte, _PAGE_USER)) &&
2918 +              !(pte_get_bits(pte, _PAGE_PROTNONE)));
2919 +}
2920 +
2921 +static inline int pte_exec(pte_t pte){
2922 +       return((pte_get_bits(pte, _PAGE_USER)) &&
2923 +              !(pte_get_bits(pte, _PAGE_PROTNONE)));
2924 +}
2925 +
2926 +static inline int pte_write(pte_t pte)
2927 +{
2928 +       return((pte_get_bits(pte, _PAGE_RW)) &&
2929 +              !(pte_get_bits(pte, _PAGE_PROTNONE)));
2930 +}
2931 +
2932 +/*
2933 + * The following only works if pte_present() is not true.
2934 + */
2935 +static inline int pte_file(pte_t pte)
2936 +{
2937 +       return pte_get_bits(pte, _PAGE_FILE);
2938 +}
2939 +
2940 +static inline int pte_dirty(pte_t pte)
2941 +{
2942 +       return pte_get_bits(pte, _PAGE_DIRTY);
2943 +}
2944 +
2945 +static inline int pte_young(pte_t pte)
2946 +{
2947 +       return pte_get_bits(pte, _PAGE_ACCESSED);
2948 +}
2949 +
2950 +static inline int pte_newpage(pte_t pte)
2951 +{
2952 +       return pte_get_bits(pte, _PAGE_NEWPAGE);
2953 +}
2954 +
2955 +static inline int pte_newprot(pte_t pte)
2956 +{
2957 +       return(pte_present(pte) && (pte_get_bits(pte, _PAGE_NEWPROT)));
2958 +}
2959 +
2960 +static inline int pte_special(pte_t pte)
2961 +{
2962 +       return 0;
2963 +}
2964 +
2965 +/*
2966 + * =================================
2967 + * Flags setting section.
2968 + * =================================
2969 + */
2970 +
2971 +static inline pte_t pte_mknewprot(pte_t pte)
2972 +{
2973 +       pte_set_bits(pte, _PAGE_NEWPROT);
2974 +       return(pte);
2975 +}
2976 +
2977 +static inline pte_t pte_mkclean(pte_t pte)
2978 +{
2979 +       pte_clear_bits(pte, _PAGE_DIRTY);
2980 +       return(pte);
2981 +}
2982 +
2983 +static inline pte_t pte_mkold(pte_t pte)
2984 +{
2985 +       pte_clear_bits(pte, _PAGE_ACCESSED);
2986 +       return(pte);
2987 +}
2988 +
2989 +static inline pte_t pte_wrprotect(pte_t pte)
2990 +{
2991 +       pte_clear_bits(pte, _PAGE_RW);
2992 +       return(pte_mknewprot(pte));
2993 +}
2994 +
2995 +static inline pte_t pte_mkread(pte_t pte)
2996 +{
2997 +       pte_set_bits(pte, _PAGE_USER);
2998 +       return(pte_mknewprot(pte));
2999 +}
3000 +
3001 +static inline pte_t pte_mkdirty(pte_t pte)
3002 +{
3003 +       pte_set_bits(pte, _PAGE_DIRTY);
3004 +       return(pte);
3005 +}
3006 +
3007 +static inline pte_t pte_mkyoung(pte_t pte)
3008 +{
3009 +       pte_set_bits(pte, _PAGE_ACCESSED);
3010 +       return(pte);
3011 +}
3012 +
3013 +static inline pte_t pte_mkwrite(pte_t pte)
3014 +{
3015 +       pte_set_bits(pte, _PAGE_RW);
3016 +       return(pte_mknewprot(pte));
3017 +}
3018 +
3019 +static inline pte_t pte_mkuptodate(pte_t pte)
3020 +{
3021 +       pte_clear_bits(pte, _PAGE_NEWPAGE);
3022 +       if(pte_present(pte))
3023 +               pte_clear_bits(pte, _PAGE_NEWPROT);
3024 +       return(pte);
3025 +}
3026 +
3027 +static inline pte_t pte_mknewpage(pte_t pte)
3028 +{
3029 +       pte_set_bits(pte, _PAGE_NEWPAGE);
3030 +       return(pte);
3031 +}
3032 +
3033 +static inline pte_t pte_mkspecial(pte_t pte)
3034 +{
3035 +       return(pte);
3036 +}
3037 +
3038 +static inline void set_pte(pte_t *pteptr, pte_t pteval)
3039 +{
3040 +       pte_copy(*pteptr, pteval);
3041 +
3042 +       /* If it's a swap entry, it needs to be marked _PAGE_NEWPAGE so
3043 +        * fix_range knows to unmap it.  _PAGE_NEWPROT is specific to
3044 +        * mapped pages.
3045 +        */
3046 +
3047 +       *pteptr = pte_mknewpage(*pteptr);
3048 +       if(pte_present(*pteptr)) *pteptr = pte_mknewprot(*pteptr);
3049 +}
3050 +#define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
3051 +
3052 +#define __HAVE_ARCH_PTE_SAME
3053 +static inline int pte_same(pte_t pte_a, pte_t pte_b)
3054 +{
3055 +       return !((pte_val(pte_a) ^ pte_val(pte_b)) & ~_PAGE_NEWPAGE);
3056 +}
3057 +
3058 +/*
3059 + * Conversion functions: convert a page and protection to a page entry,
3060 + * and a page entry and page directory to the page they refer to.
3061 + */
3062 +
3063 +#define phys_to_page(phys) pfn_to_page(phys_to_pfn(phys))
3064 +#define __virt_to_page(virt) phys_to_page(__pa(virt))
3065 +#define page_to_phys(page) pfn_to_phys((pfn_t) page_to_pfn(page))
3066 +#define virt_to_page(addr) __virt_to_page((const unsigned long) addr)
3067 +
3068 +#define mk_pte(page, pgprot) \
3069 +       ({ pte_t pte;                                   \
3070 +                                                       \
3071 +       pte_set_val(pte, page_to_phys(page), (pgprot)); \
3072 +       if (pte_present(pte))                           \
3073 +               pte_mknewprot(pte_mknewpage(pte));      \
3074 +       pte;})
3075 +
3076 +static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
3077 +{
3078 +       pte_set_val(pte, (pte_val(pte) & _PAGE_CHG_MASK), newprot);
3079 +       return pte;
3080 +}
3081 +
3082 +/*
3083 + * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
3084 + *
3085 + * this macro returns the index of the entry in the pgd page which would
3086 + * control the given virtual address
3087 + */
3088 +#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
3089 +
3090 +/*
3091 + * pgd_offset() returns a (pgd_t *)
3092 + * pgd_index() is used get the offset into the pgd page's array of pgd_t's;
3093 + */
3094 +#define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
3095 +
3096 +/*
3097 + * a shortcut which implies the use of the kernel's pgd, instead
3098 + * of a process's
3099 + */
3100 +#define pgd_offset_k(address) pgd_offset(&init_mm, address)
3101 +
3102 +/*
3103 + * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
3104 + *
3105 + * this macro returns the index of the entry in the pmd page which would
3106 + * control the given virtual address
3107 + */
3108 +#define pmd_page_vaddr(pmd) ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
3109 +#define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
3110 +
3111 +#define pmd_page_vaddr(pmd) \
3112 +       ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
3113 +
3114 +/*
3115 + * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
3116 + *
3117 + * this macro returns the index of the entry in the pte page which would
3118 + * control the given virtual address
3119 + */
3120 +#define pte_index(address) (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
3121 +#define pte_offset_kernel(dir, address) \
3122 +       ((pte_t *) pmd_page_vaddr(*(dir)) +  pte_index(address))
3123 +#define pte_offset_map(dir, address) \
3124 +       ((pte_t *)page_address(pmd_page(*(dir))) + pte_index(address))
3125 +#define pte_unmap(pte) do { } while (0)
3126 +
3127 +struct mm_struct;
3128 +extern pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr);
3129 +
3130 +#define update_mmu_cache(vma,address,ptep) do ; while (0)
3131 +
3132 +/* Encode and de-code a swap entry */
3133 +#define __swp_type(x)                  (((x).val >> 5) & 0x1f)
3134 +#define __swp_offset(x)                        ((x).val >> 11)
3135 +
3136 +#define __swp_entry(type, offset) \
3137 +       ((swp_entry_t) { ((type) << 5) | ((offset) << 11) })
3138 +#define __pte_to_swp_entry(pte) \
3139 +       ((swp_entry_t) { pte_val(pte_mkuptodate(pte)) })
3140 +#define __swp_entry_to_pte(x)          ((pte_t) { (x).val })
3141 +
3142 +#define kern_addr_valid(addr) (1)
3143 +
3144 +#include <asm-generic/pgtable.h>
3145 +
3146 +/* Clear a kernel PTE and flush it from the TLB */
3147 +#define kpte_clear_flush(ptep, vaddr)          \
3148 +do {                                           \
3149 +       pte_clear(&init_mm, (vaddr), (ptep));   \
3150 +       __flush_tlb_one((vaddr));               \
3151 +} while (0)
3152 +
3153 +#endif
3154 --- /dev/null
3155 +++ b/arch/um/include/uapi/asm/processor-generic.h
3156 @@ -0,0 +1,115 @@
3157 +/*
3158 + * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3159 + * Licensed under the GPL
3160 + */
3161 +
3162 +#ifndef __UM_PROCESSOR_GENERIC_H
3163 +#define __UM_PROCESSOR_GENERIC_H
3164 +
3165 +struct pt_regs;
3166 +
3167 +struct task_struct;
3168 +
3169 +#include <asm/ptrace.h>
3170 +#include <registers.h>
3171 +#include <sysdep/archsetjmp.h>
3172 +
3173 +#include <linux/prefetch.h>
3174 +
3175 +struct mm_struct;
3176 +
3177 +struct thread_struct {
3178 +       struct pt_regs regs;
3179 +       struct pt_regs *segv_regs;
3180 +       int singlestep_syscall;
3181 +       void *fault_addr;
3182 +       jmp_buf *fault_catcher;
3183 +       struct task_struct *prev_sched;
3184 +       struct arch_thread arch;
3185 +       jmp_buf switch_buf;
3186 +       struct {
3187 +               int op;
3188 +               union {
3189 +                       struct {
3190 +                               int pid;
3191 +                       } fork, exec;
3192 +                       struct {
3193 +                               int (*proc)(void *);
3194 +                               void *arg;
3195 +                       } thread;
3196 +                       struct {
3197 +                               void (*proc)(void *);
3198 +                               void *arg;
3199 +                       } cb;
3200 +               } u;
3201 +       } request;
3202 +};
3203 +
3204 +#define INIT_THREAD \
3205 +{ \
3206 +       .regs                   = EMPTY_REGS,   \
3207 +       .fault_addr             = NULL, \
3208 +       .prev_sched             = NULL, \
3209 +       .arch                   = INIT_ARCH_THREAD, \
3210 +       .request                = { 0 } \
3211 +}
3212 +
3213 +static inline void release_thread(struct task_struct *task)
3214 +{
3215 +}
3216 +
3217 +extern unsigned long thread_saved_pc(struct task_struct *t);
3218 +
3219 +static inline void mm_copy_segments(struct mm_struct *from_mm,
3220 +                                   struct mm_struct *new_mm)
3221 +{
3222 +}
3223 +
3224 +#define init_stack     (init_thread_union.stack)
3225 +
3226 +/*
3227 + * User space process size: 3GB (default).
3228 + */
3229 +extern unsigned long task_size;
3230 +
3231 +#define TASK_SIZE (task_size)
3232 +
3233 +#undef STACK_TOP
3234 +#undef STACK_TOP_MAX
3235 +
3236 +extern unsigned long stacksizelim;
3237 +
3238 +#define STACK_ROOM     (stacksizelim)
3239 +#define STACK_TOP      (TASK_SIZE - 2 * PAGE_SIZE)
3240 +#define STACK_TOP_MAX  STACK_TOP
3241 +
3242 +/* This decides where the kernel will search for a free chunk of vm
3243 + * space during mmap's.
3244 + */
3245 +#define TASK_UNMAPPED_BASE     (0x40000000)
3246 +
3247 +extern void start_thread(struct pt_regs *regs, unsigned long entry,
3248 +                        unsigned long stack);
3249 +
3250 +struct cpuinfo_um {
3251 +       unsigned long loops_per_jiffy;
3252 +       int ipi_pipe[2];
3253 +};
3254 +
3255 +extern struct cpuinfo_um boot_cpu_data;
3256 +
3257 +#define my_cpu_data            cpu_data[smp_processor_id()]
3258 +
3259 +#ifdef CONFIG_SMP
3260 +extern struct cpuinfo_um cpu_data[];
3261 +#define current_cpu_data cpu_data[smp_processor_id()]
3262 +#else
3263 +#define cpu_data (&boot_cpu_data)
3264 +#define current_cpu_data boot_cpu_data
3265 +#endif
3266 +
3267 +
3268 +#define KSTK_REG(tsk, reg) get_thread_reg(reg, &tsk->thread.switch_buf)
3269 +extern unsigned long get_wchan(struct task_struct *p);
3270 +
3271 +#endif
3272 --- /dev/null
3273 +++ b/arch/um/include/uapi/asm/ptrace-generic.h
3274 @@ -0,0 +1,45 @@
3275 +/*
3276 + * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3277 + * Licensed under the GPL
3278 + */
3279 +
3280 +#ifndef __UM_PTRACE_GENERIC_H
3281 +#define __UM_PTRACE_GENERIC_H
3282 +
3283 +#ifndef __ASSEMBLY__
3284 +
3285 +#include <asm/ptrace-abi.h>
3286 +#include <sysdep/ptrace.h>
3287 +
3288 +struct pt_regs {
3289 +       struct uml_pt_regs regs;
3290 +};
3291 +
3292 +#define arch_has_single_step() (1)
3293 +
3294 +#define EMPTY_REGS { .regs = EMPTY_UML_PT_REGS }
3295 +
3296 +#define PT_REGS_IP(r) UPT_IP(&(r)->regs)
3297 +#define PT_REGS_SP(r) UPT_SP(&(r)->regs)
3298 +
3299 +#define PT_REGS_RESTART_SYSCALL(r) UPT_RESTART_SYSCALL(&(r)->regs)
3300 +
3301 +#define PT_REGS_SYSCALL_NR(r) UPT_SYSCALL_NR(&(r)->regs)
3302 +
3303 +#define instruction_pointer(regs) PT_REGS_IP(regs)
3304 +
3305 +struct task_struct;
3306 +
3307 +extern long subarch_ptrace(struct task_struct *child, long request,
3308 +       unsigned long addr, unsigned long data);
3309 +extern unsigned long getreg(struct task_struct *child, int regno);
3310 +extern int putreg(struct task_struct *child, int regno, unsigned long value);
3311 +
3312 +extern int arch_copy_tls(struct task_struct *new);
3313 +extern void clear_flushed_tls(struct task_struct *task);
3314 +extern void syscall_trace_enter(struct pt_regs *regs);
3315 +extern void syscall_trace_leave(struct pt_regs *regs);
3316 +
3317 +#endif
3318 +
3319 +#endif
3320 --- /dev/null
3321 +++ b/arch/um/include/uapi/asm/setup.h
3322 @@ -0,0 +1,10 @@
3323 +#ifndef SETUP_H_INCLUDED
3324 +#define SETUP_H_INCLUDED
3325 +
3326 +/* POSIX mandated with _POSIX_ARG_MAX that we can rely on 4096 chars in the
3327 + * command line, so this choice is ok.
3328 + */
3329 +
3330 +#define COMMAND_LINE_SIZE 4096
3331 +
3332 +#endif         /* SETUP_H_INCLUDED */
3333 --- /dev/null
3334 +++ b/arch/um/include/uapi/asm/smp.h
3335 @@ -0,0 +1,32 @@
3336 +#ifndef __UM_SMP_H
3337 +#define __UM_SMP_H
3338 +
3339 +#ifdef CONFIG_SMP
3340 +
3341 +#include <linux/bitops.h>
3342 +#include <asm/current.h>
3343 +#include <linux/cpumask.h>
3344 +
3345 +#define raw_smp_processor_id() (current_thread->cpu)
3346 +
3347 +#define cpu_logical_map(n) (n)
3348 +#define cpu_number_map(n) (n)
3349 +extern int hard_smp_processor_id(void);
3350 +#define NO_PROC_ID -1
3351 +
3352 +extern int ncpus;
3353 +
3354 +
3355 +static inline void smp_cpus_done(unsigned int maxcpus)
3356 +{
3357 +}
3358 +
3359 +extern struct task_struct *idle_threads[NR_CPUS];
3360 +
3361 +#else
3362 +
3363 +#define hard_smp_processor_id()                0
3364 +
3365 +#endif
3366 +
3367 +#endif
3368 --- /dev/null
3369 +++ b/arch/um/include/uapi/asm/sysrq.h
3370 @@ -0,0 +1,7 @@
3371 +#ifndef __UM_SYSRQ_H
3372 +#define __UM_SYSRQ_H
3373 +
3374 +struct task_struct;
3375 +extern void show_trace(struct task_struct* task, unsigned long *stack);
3376 +
3377 +#endif
3378 --- /dev/null
3379 +++ b/arch/um/include/uapi/asm/thread_info.h
3380 @@ -0,0 +1,78 @@
3381 +/*
3382 + * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3383 + * Licensed under the GPL
3384 + */
3385 +
3386 +#ifndef __UM_THREAD_INFO_H
3387 +#define __UM_THREAD_INFO_H
3388 +
3389 +#ifndef __ASSEMBLY__
3390 +
3391 +#include <asm/types.h>
3392 +#include <asm/page.h>
3393 +#include <asm/uaccess.h>
3394 +
3395 +struct thread_info {
3396 +       struct task_struct      *task;          /* main task structure */
3397 +       struct exec_domain      *exec_domain;   /* execution domain */
3398 +       unsigned long           flags;          /* low level flags */
3399 +       __u32                   cpu;            /* current CPU */
3400 +       int                     preempt_count;  /* 0 => preemptable,
3401 +                                                  <0 => BUG */
3402 +       mm_segment_t            addr_limit;     /* thread address space:
3403 +                                                  0-0xBFFFFFFF for user
3404 +                                                  0-0xFFFFFFFF for kernel */
3405 +       struct restart_block    restart_block;
3406 +       struct thread_info      *real_thread;    /* Points to non-IRQ stack */
3407 +};
3408 +
3409 +#define INIT_THREAD_INFO(tsk)                  \
3410 +{                                              \
3411 +       .task =         &tsk,                   \
3412 +       .exec_domain =  &default_exec_domain,   \
3413 +       .flags =                0,              \
3414 +       .cpu =          0,                      \
3415 +       .preempt_count = INIT_PREEMPT_COUNT,    \
3416 +       .addr_limit =   KERNEL_DS,              \
3417 +       .restart_block =  {                     \
3418 +               .fn =  do_no_restart_syscall,   \
3419 +       },                                      \
3420 +       .real_thread = NULL,                    \
3421 +}
3422 +
3423 +#define init_thread_info       (init_thread_union.thread_info)
3424 +#define init_stack             (init_thread_union.stack)
3425 +
3426 +#define THREAD_SIZE ((1 << CONFIG_KERNEL_STACK_ORDER) * PAGE_SIZE)
3427 +/* how to get the thread information struct from C */
3428 +static inline struct thread_info *current_thread_info(void)
3429 +{
3430 +       struct thread_info *ti;
3431 +       unsigned long mask = THREAD_SIZE - 1;
3432 +       void *p;
3433 +
3434 +       asm volatile ("" : "=r" (p) : "0" (&ti));
3435 +       ti = (struct thread_info *) (((unsigned long)p) & ~mask);
3436 +       return ti;
3437 +}
3438 +
3439 +#define THREAD_SIZE_ORDER CONFIG_KERNEL_STACK_ORDER
3440 +
3441 +#endif
3442 +
3443 +#define TIF_SYSCALL_TRACE      0       /* syscall trace active */
3444 +#define TIF_SIGPENDING         1       /* signal pending */
3445 +#define TIF_NEED_RESCHED       2       /* rescheduling necessary */
3446 +#define TIF_RESTART_BLOCK      4
3447 +#define TIF_MEMDIE             5       /* is terminating due to OOM killer */
3448 +#define TIF_SYSCALL_AUDIT      6
3449 +#define TIF_RESTORE_SIGMASK    7
3450 +#define TIF_NOTIFY_RESUME      8
3451 +
3452 +#define _TIF_SYSCALL_TRACE     (1 << TIF_SYSCALL_TRACE)
3453 +#define _TIF_SIGPENDING                (1 << TIF_SIGPENDING)
3454 +#define _TIF_NEED_RESCHED      (1 << TIF_NEED_RESCHED)
3455 +#define _TIF_MEMDIE            (1 << TIF_MEMDIE)
3456 +#define _TIF_SYSCALL_AUDIT     (1 << TIF_SYSCALL_AUDIT)
3457 +
3458 +#endif
3459 --- /dev/null
3460 +++ b/arch/um/include/uapi/asm/timex.h
3461 @@ -0,0 +1,13 @@
3462 +#ifndef __UM_TIMEX_H
3463 +#define __UM_TIMEX_H
3464 +
3465 +typedef unsigned long cycles_t;
3466 +
3467 +static inline cycles_t get_cycles (void)
3468 +{
3469 +       return 0;
3470 +}
3471 +
3472 +#define CLOCK_TICK_RATE (HZ)
3473 +
3474 +#endif
3475 --- /dev/null
3476 +++ b/arch/um/include/uapi/asm/tlb.h
3477 @@ -0,0 +1,122 @@
3478 +#ifndef __UM_TLB_H
3479 +#define __UM_TLB_H
3480 +
3481 +#include <linux/pagemap.h>
3482 +#include <linux/swap.h>
3483 +#include <asm/percpu.h>
3484 +#include <asm/pgalloc.h>
3485 +#include <asm/tlbflush.h>
3486 +
3487 +#define tlb_start_vma(tlb, vma) do { } while (0)
3488 +#define tlb_end_vma(tlb, vma) do { } while (0)
3489 +#define tlb_flush(tlb) flush_tlb_mm((tlb)->mm)
3490 +
3491 +/* struct mmu_gather is an opaque type used by the mm code for passing around
3492 + * any data needed by arch specific code for tlb_remove_page.
3493 + */
3494 +struct mmu_gather {
3495 +       struct mm_struct        *mm;
3496 +       unsigned int            need_flush; /* Really unmapped some ptes? */
3497 +       unsigned long           start;
3498 +       unsigned long           end;
3499 +       unsigned int            fullmm; /* non-zero means full mm flush */
3500 +};
3501 +
3502 +static inline void __tlb_remove_tlb_entry(struct mmu_gather *tlb, pte_t *ptep,
3503 +                                         unsigned long address)
3504 +{
3505 +       if (tlb->start > address)
3506 +               tlb->start = address;
3507 +       if (tlb->end < address + PAGE_SIZE)
3508 +               tlb->end = address + PAGE_SIZE;
3509 +}
3510 +
3511 +static inline void init_tlb_gather(struct mmu_gather *tlb)
3512 +{
3513 +       tlb->need_flush = 0;
3514 +
3515 +       tlb->start = TASK_SIZE;
3516 +       tlb->end = 0;
3517 +
3518 +       if (tlb->fullmm) {
3519 +               tlb->start = 0;
3520 +               tlb->end = TASK_SIZE;
3521 +       }
3522 +}
3523 +
3524 +static inline void
3525 +tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
3526 +{
3527 +       tlb->mm = mm;
3528 +       tlb->start = start;
3529 +       tlb->end = end;
3530 +       tlb->fullmm = !(start | (end+1));
3531 +
3532 +       init_tlb_gather(tlb);
3533 +}
3534 +
3535 +extern void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
3536 +                              unsigned long end);
3537 +
3538 +static inline void
3539 +tlb_flush_mmu(struct mmu_gather *tlb)
3540 +{
3541 +       if (!tlb->need_flush)
3542 +               return;
3543 +
3544 +       flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end);
3545 +       init_tlb_gather(tlb);
3546 +}
3547 +
3548 +/* tlb_finish_mmu
3549 + *     Called at the end of the shootdown operation to free up any resources
3550 + *     that were required.
3551 + */
3552 +static inline void
3553 +tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
3554 +{
3555 +       tlb_flush_mmu(tlb);
3556 +
3557 +       /* keep the page table cache within bounds */
3558 +       check_pgt_cache();
3559 +}
3560 +
3561 +/* tlb_remove_page
3562 + *     Must perform the equivalent to __free_pte(pte_get_and_clear(ptep)),
3563 + *     while handling the additional races in SMP caused by other CPUs
3564 + *     caching valid mappings in their TLBs.
3565 + */
3566 +static inline int __tlb_remove_page(struct mmu_gather *tlb, struct page *page)
3567 +{
3568 +       tlb->need_flush = 1;
3569 +       free_page_and_swap_cache(page);
3570 +       return 1; /* avoid calling tlb_flush_mmu */
3571 +}
3572 +
3573 +static inline void tlb_remove_page(struct mmu_gather *tlb, struct page *page)
3574 +{
3575 +       __tlb_remove_page(tlb, page);
3576 +}
3577 +
3578 +/**
3579 + * tlb_remove_tlb_entry - remember a pte unmapping for later tlb invalidation.
3580 + *
3581 + * Record the fact that pte's were really umapped in ->need_flush, so we can
3582 + * later optimise away the tlb invalidate.   This helps when userspace is
3583 + * unmapping already-unmapped pages, which happens quite a lot.
3584 + */
3585 +#define tlb_remove_tlb_entry(tlb, ptep, address)               \
3586 +       do {                                                    \
3587 +               tlb->need_flush = 1;                            \
3588 +               __tlb_remove_tlb_entry(tlb, ptep, address);     \
3589 +       } while (0)
3590 +
3591 +#define pte_free_tlb(tlb, ptep, addr) __pte_free_tlb(tlb, ptep, addr)
3592 +
3593 +#define pud_free_tlb(tlb, pudp, addr) __pud_free_tlb(tlb, pudp, addr)
3594 +
3595 +#define pmd_free_tlb(tlb, pmdp, addr) __pmd_free_tlb(tlb, pmdp, addr)
3596 +
3597 +#define tlb_migrate_finish(mm) do {} while (0)
3598 +
3599 +#endif
3600 --- /dev/null
3601 +++ b/arch/um/include/uapi/asm/tlbflush.h
3602 @@ -0,0 +1,31 @@
3603 +/*
3604 + * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3605 + * Licensed under the GPL
3606 + */
3607 +
3608 +#ifndef __UM_TLBFLUSH_H
3609 +#define __UM_TLBFLUSH_H
3610 +
3611 +#include <linux/mm.h>
3612 +
3613 +/*
3614 + * TLB flushing:
3615 + *
3616 + *  - flush_tlb() flushes the current mm struct TLBs
3617 + *  - flush_tlb_all() flushes all processes TLBs
3618 + *  - flush_tlb_mm(mm) flushes the specified mm context TLB's
3619 + *  - flush_tlb_page(vma, vmaddr) flushes one page
3620 + *  - flush_tlb_kernel_vm() flushes the kernel vm area
3621 + *  - flush_tlb_range(vma, start, end) flushes a range of pages
3622 + */
3623 +
3624 +extern void flush_tlb_all(void);
3625 +extern void flush_tlb_mm(struct mm_struct *mm);
3626 +extern void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
3627 +                           unsigned long end);
3628 +extern void flush_tlb_page(struct vm_area_struct *vma, unsigned long address);
3629 +extern void flush_tlb_kernel_vm(void);
3630 +extern void flush_tlb_kernel_range(unsigned long start, unsigned long end);
3631 +extern void __flush_tlb_one(unsigned long addr);
3632 +
3633 +#endif
3634 --- /dev/null
3635 +++ b/arch/um/include/uapi/asm/uaccess.h
3636 @@ -0,0 +1,178 @@
3637 +/*
3638 + * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
3639 + * Licensed under the GPL
3640 + */
3641 +
3642 +#ifndef __UM_UACCESS_H
3643 +#define __UM_UACCESS_H
3644 +
3645 +/* thread_info has a mm_segment_t in it, so put the definition up here */
3646 +typedef struct {
3647 +       unsigned long seg;
3648 +} mm_segment_t;
3649 +
3650 +#include <linux/thread_info.h>
3651 +#include <linux/errno.h>
3652 +#include <asm/processor.h>
3653 +#include <asm/elf.h>
3654 +
3655 +#define VERIFY_READ 0
3656 +#define VERIFY_WRITE 1
3657 +
3658 +/*
3659 + * The fs value determines whether argument validity checking should be
3660 + * performed or not.  If get_fs() == USER_DS, checking is performed, with
3661 + * get_fs() == KERNEL_DS, checking is bypassed.
3662 + *
3663 + * For historical reasons, these macros are grossly misnamed.
3664 + */
3665 +
3666 +#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
3667 +
3668 +#define KERNEL_DS      MAKE_MM_SEG(0xFFFFFFFF)
3669 +#define USER_DS                MAKE_MM_SEG(TASK_SIZE)
3670 +
3671 +#define get_ds()       (KERNEL_DS)
3672 +#define get_fs()       (current_thread_info()->addr_limit)
3673 +#define set_fs(x)      (current_thread_info()->addr_limit = (x))
3674 +
3675 +#define segment_eq(a, b) ((a).seg == (b).seg)
3676 +
3677 +#define __under_task_size(addr, size) \
3678 +       (((unsigned long) (addr) < TASK_SIZE) && \
3679 +        (((unsigned long) (addr) + (size)) < TASK_SIZE))
3680 +
3681 +#define __access_ok_vsyscall(type, addr, size) \
3682 +        ((type == VERIFY_READ) && \
3683 +         ((unsigned long) (addr) >= FIXADDR_USER_START) && \
3684 +         ((unsigned long) (addr) + (size) <= FIXADDR_USER_END) && \
3685 +         ((unsigned long) (addr) + (size) >= (unsigned long)(addr)))
3686 +
3687 +#define __addr_range_nowrap(addr, size) \
3688 +       ((unsigned long) (addr) <= ((unsigned long) (addr) + (size)))
3689 +
3690 +#define access_ok(type, addr, size) \
3691 +       (__addr_range_nowrap(addr, size) && \
3692 +        (__under_task_size(addr, size) || \
3693 +         __access_ok_vsyscall(type, addr, size) || \
3694 +         segment_eq(get_fs(), KERNEL_DS)))
3695 +
3696 +extern int copy_from_user(void *to, const void __user *from, int n);
3697 +extern int copy_to_user(void __user *to, const void *from, int n);
3698 +
3699 +/*
3700 + * strncpy_from_user: - Copy a NUL terminated string from userspace.
3701 + * @dst:   Destination address, in kernel space.  This buffer must be at
3702 + *         least @count bytes long.
3703 + * @src:   Source address, in user space.
3704 + * @count: Maximum number of bytes to copy, including the trailing NUL.
3705 + *
3706 + * Copies a NUL-terminated string from userspace to kernel space.
3707 + *
3708 + * On success, returns the length of the string (not including the trailing
3709 + * NUL).
3710 + *
3711 + * If access to userspace fails, returns -EFAULT (some data may have been
3712 + * copied).
3713 + *
3714 + * If @count is smaller than the length of the string, copies @count bytes
3715 + * and returns @count.
3716 + */
3717 +
3718 +extern int strncpy_from_user(char *dst, const char __user *src, int count);
3719 +
3720 +/*
3721 + * __clear_user: - Zero a block of memory in user space, with less checking.
3722 + * @to:   Destination address, in user space.
3723 + * @n:    Number of bytes to zero.
3724 + *
3725 + * Zero a block of memory in user space.  Caller must check
3726 + * the specified block with access_ok() before calling this function.
3727 + *
3728 + * Returns number of bytes that could not be cleared.
3729 + * On success, this will be zero.
3730 + */
3731 +extern int __clear_user(void __user *mem, int len);
3732 +
3733 +/*
3734 + * clear_user: - Zero a block of memory in user space.
3735 + * @to:   Destination address, in user space.
3736 + * @n:    Number of bytes to zero.
3737 + *
3738 + * Zero a block of memory in user space.
3739 + *
3740 + * Returns number of bytes that could not be cleared.
3741 + * On success, this will be zero.
3742 + */
3743 +extern int clear_user(void __user *mem, int len);
3744 +
3745 +/*
3746 + * strlen_user: - Get the size of a string in user space.
3747 + * @str: The string to measure.
3748 + * @n:   The maximum valid length
3749 + *
3750 + * Get the size of a NUL-terminated string in user space.
3751 + *
3752 + * Returns the size of the string INCLUDING the terminating NUL.
3753 + * On exception, returns 0.
3754 + * If the string is too long, returns a value greater than @n.
3755 + */
3756 +extern int strnlen_user(const void __user *str, int len);
3757 +
3758 +#define __copy_from_user(to, from, n) copy_from_user(to, from, n)
3759 +
3760 +#define __copy_to_user(to, from, n) copy_to_user(to, from, n)
3761 +
3762 +#define __copy_to_user_inatomic __copy_to_user
3763 +#define __copy_from_user_inatomic __copy_from_user
3764 +
3765 +#define __get_user(x, ptr) \
3766 +({ \
3767 +       const __typeof__(*(ptr)) __user *__private_ptr = (ptr); \
3768 +       __typeof__(x) __private_val;                    \
3769 +       int __private_ret = -EFAULT;                    \
3770 +       (x) = (__typeof__(*(__private_ptr)))0;                          \
3771 +       if (__copy_from_user((__force void *)&__private_val, (__private_ptr),\
3772 +                            sizeof(*(__private_ptr))) == 0) {          \
3773 +               (x) = (__typeof__(*(__private_ptr))) __private_val;     \
3774 +               __private_ret = 0;                                      \
3775 +       }                                                               \
3776 +       __private_ret;                                                  \
3777 +})
3778 +
3779 +#define get_user(x, ptr) \
3780 +({ \
3781 +        const __typeof__((*(ptr))) __user *private_ptr = (ptr); \
3782 +        (access_ok(VERIFY_READ, private_ptr, sizeof(*private_ptr)) ? \
3783 +        __get_user(x, private_ptr) : ((x) = (__typeof__(*ptr))0, -EFAULT)); \
3784 +})
3785 +
3786 +#define __put_user(x, ptr) \
3787 +({ \
3788 +        __typeof__(*(ptr)) __user *__private_ptr = ptr; \
3789 +        __typeof__(*(__private_ptr)) __private_val; \
3790 +        int __private_ret = -EFAULT; \
3791 +        __private_val = (__typeof__(*(__private_ptr))) (x); \
3792 +        if (__copy_to_user((__private_ptr), &__private_val, \
3793 +                          sizeof(*(__private_ptr))) == 0) { \
3794 +               __private_ret = 0; \
3795 +       } \
3796 +        __private_ret; \
3797 +})
3798 +
3799 +#define put_user(x, ptr) \
3800 +({ \
3801 +        __typeof__(*(ptr)) __user *private_ptr = (ptr); \
3802 +        (access_ok(VERIFY_WRITE, private_ptr, sizeof(*private_ptr)) ? \
3803 +        __put_user(x, private_ptr) : -EFAULT); \
3804 +})
3805 +
3806 +#define strlen_user(str) strnlen_user(str, ~0U >> 1)
3807 +
3808 +struct exception_table_entry
3809 +{
3810 +        unsigned long insn;
3811 +       unsigned long fixup;
3812 +};
3813 +
3814 +#endif