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