开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
pgtable.h
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：17k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

pgtable.h：源码内容
  1. /* CRIS pgtable.h - macros and functions to manipulate page tables
  2.  *
  3.  * HISTORY:
  4.  *
  5.  * $Log: pgtable.h,v $
  6.  * Revision 1.15  2002/04/23 15:37:52  bjornw
  7.  * Removed page_address and added flush_icache_user_range
  8.  *
  9.  * Revision 1.14  2001/12/10 03:08:50  bjornw
  10.  * Added pgtable_cache_init dummy
  11.  *
  12.  * Revision 1.13  2001/11/12 18:05:38  pkj
  13.  * Added declaration of paging_init().
  14.  *
  15.  * Revision 1.12  2001/08/11 00:28:00  bjornw
  16.  * PAGE_CHG_MASK and PAGE_NONE had somewhat untraditional values
  17.  *
  18.  * Revision 1.11  2001/04/04 14:38:36  bjornw
  19.  * Removed bad_pagetable handling and the _kernel functions
  20.  *
  21.  * Revision 1.10  2001/03/23 07:46:42  starvik
  22.  * Corrected according to review remarks
  23.  *
  24.  * Revision 1.9  2000/11/22 14:57:53  bjornw
  25.  * * extern inline -> static inline
  26.  * * include asm-generic/pgtable.h
  27.  *
  28.  * Revision 1.8  2000/11/21 13:56:16  bjornw
  29.  * Use CONFIG_CRIS_LOW_MAP for the low VM map instead of explicit CPU type
  30.  *
  31.  * Revision 1.7  2000/10/06 15:05:32  bjornw
  32.  * VMALLOC area changed in memory mapping change
  33.  *
  34.  * Revision 1.6  2000/10/04 16:59:14  bjornw
  35.  * Changed comments
  36.  *
  37.  * Revision 1.5  2000/09/13 14:39:53  bjornw
  38.  * New macros
  39.  *
  40.  * Revision 1.4  2000/08/17 15:38:48  bjornw
  41.  * 2.4.0-test6 modifications:
  42.  *   * flush_dcache_page added
  43.  *   * MAP_NR removed
  44.  *   * virt_to_page added
  45.  *
  46.  * Plus some comments and type-clarifications.
  47.  *
  48.  * Revision 1.3  2000/08/15 16:33:35  bjornw
  49.  * pmd_bad should recognize both kernel and user page-tables
  50.  *
  51.  * Revision 1.2  2000/07/10 17:06:01  bjornw
  52.  * Fixed warnings
  53.  *
  54.  * Revision 1.1.1.1  2000/07/10 16:32:31  bjornw
  55.  * CRIS architecture, working draft
  56.  *
  57.  *
  58.  * Revision 1.11  2000/05/29 14:55:56  bjornw
  59.  * Small tweaks of pte_mk routines
  60.  *
  61.  * Revision 1.10  2000/01/27 01:49:06  bjornw
  62.  * * Ooops. The physical frame number in a PTE entry needs to point to the
  63.  *   DRAM directly, not to what the kernel thinks is DRAM (due to KSEG mapping).
  64.  *   Hence we need to strip bit 31 so 0xcXXXXXXX -> 0x4XXXXXXX.
  65.  *
  66.  * Revision 1.9  2000/01/26 16:25:50  bjornw
  67.  * Fixed PAGE_KERNEL bits
  68.  *
  69.  * Revision 1.8  2000/01/23 22:53:22  bjornw
  70.  * Correct flush_tlb_* macros and externs
  71.  *
  72.  * Revision 1.7  2000/01/18 16:22:55  bjornw
  73.  * Use PAGE_MASK instead of PFN_MASK.
  74.  *
  75.  * Revision 1.6  2000/01/17 02:42:53  bjornw
  76.  * Added the pmd_set macro.
  77.  *
  78.  * Revision 1.5  2000/01/16 19:53:42  bjornw
  79.  * Removed VMALLOC_OFFSET. Changed definitions of swapper_pg_dir and zero_page.
  80.  *
  81.  * Revision 1.4  2000/01/14 16:38:20  bjornw
  82.  * PAGE_DIRTY -> PAGE_SILENT_WRITE, removed PAGE_COW from PAGE_COPY.
  83.  *
  84.  * Revision 1.3  1999/12/04 20:12:21  bjornw
  85.  * * PTE bits have moved to asm/mmu.h
  86.  * * Fixed definitions of the higher level page protection bits
  87.  * * Added the pte_* functions, including dirty/accessed SW simulation
  88.  *   (these are exactly the same as for the MIPS port)
  89.  *
  90.  * Revision 1.2  1999/12/04 00:41:54  bjornw
  91.  * * Fixed page table offsets, sizes and shifts
  92.  * * Removed reference to i386 SMP stuff
  93.  * * Added stray comments about Linux/CRIS mm design
  94.  * * Include asm/mmu.h which will contain MMU details
  95.  *
  96.  * Revision 1.1  1999/12/03 15:04:02  bjornw
  97.  * Copied from include/asm-etrax100. For the new CRIS architecture.
  98.  */
  100. #ifndef _CRIS_PGTABLE_H
  101. #define _CRIS_PGTABLE_H
  103. #include <linux/config.h>
  104. #include <asm/mmu.h>
  106. /*
  107.  * The Linux memory management assumes a three-level page table setup. On
  108.  * CRIS, we use that, but "fold" the mid level into the top-level page
  109.  * table. Since the MMU TLB is software loaded through an interrupt, it
  110.  * supports any page table structure, so we could have used a three-level
  111.  * setup, but for the amounts of memory we normally use, a two-level is
  112.  * probably more efficient.
  113.  *
  114.  * This file contains the functions and defines necessary to modify and use
  115.  * the CRIS page table tree.
  116.  */
  118. extern void paging_init(void);
  120. /* The cache doesn't need to be flushed when TLB entries change because 
  121.  * the cache is mapped to physical memory, not virtual memory
  122.  */
  123. #define flush_cache_all() do { } while (0)
  124. #define flush_cache_mm(mm) do { } while (0)
  125. #define flush_cache_range(mm, start, end) do { } while (0)
  126. #define flush_cache_page(vma, vmaddr) do { } while (0)
  127. #define flush_page_to_ram(page) do { } while (0)
  128. #define flush_dcache_page(page)                 do { } while (0)
  129. #define flush_icache_range(start, end)          do { } while (0)
  130. #define flush_icache_page(vma,pg)               do { } while (0)
  131. #define flush_icache_user_range(vma,pg,adr,len) do { } while (0)
  133. /*
  134.  * TLB flushing (implemented in arch/cris/mm/tlb.c):
  135.  *
  136.  *  - flush_tlb() flushes the current mm struct TLBs
  137.  *  - flush_tlb_all() flushes all processes TLBs
  138.  *  - flush_tlb_mm(mm) flushes the specified mm context TLB's
  139.  *  - flush_tlb_page(vma, vmaddr) flushes one page
  140.  *  - flush_tlb_range(mm, start, end) flushes a range of pages
  141.  *
  142.  */
  144. extern void flush_tlb_all(void);
  145. extern void flush_tlb_mm(struct mm_struct *mm);
  146. extern void flush_tlb_page(struct vm_area_struct *vma, 
  147.    unsigned long addr);
  148. extern void flush_tlb_range(struct mm_struct *mm,
  149.     unsigned long start,
  150.     unsigned long end);
  152. static inline void flush_tlb_pgtables(struct mm_struct *mm,
  153.                                       unsigned long start, unsigned long end)
  154. {
  155.         /* CRIS does not keep any page table caches in TLB */
  156. }
  159. static inline void flush_tlb(void) 
  160. {
  161. flush_tlb_mm(current->mm);
  162. }
  164. /* Certain architectures need to do special things when pte's
  165.  * within a page table are directly modified.  Thus, the following
  166.  * hook is made available.
  167.  */
  168. #define set_pte(pteptr, pteval) ((*(pteptr)) = (pteval))
  169. /*
  170.  * (pmds are folded into pgds so this doesn't get actually called,
  171.  * but the define is needed for a generic inline function.)
  172.  */
  173. #define set_pmd(pmdptr, pmdval) (*(pmdptr) = pmdval)
  174. #define set_pgd(pgdptr, pgdval) (*(pgdptr) = pgdval)
  176. /* PMD_SHIFT determines the size of the area a second-level page table can
  177.  * map. It is equal to the page size times the number of PTE's that fit in
  178.  * a PMD page. A PTE is 4-bytes in CRIS. Hence the following number.
  179.  */
  181. #define PMD_SHIFT (PAGE_SHIFT + (PAGE_SHIFT-2))
  182. #define PMD_SIZE (1UL << PMD_SHIFT)
  183. #define PMD_MASK (~(PMD_SIZE-1))
  185. /* PGDIR_SHIFT determines what a third-level page table entry can map.
  186.  * Since we fold into a two-level structure, this is the same as PMD_SHIFT.
  187.  */
  189. #define PGDIR_SHIFT PMD_SHIFT
  190. #define PGDIR_SIZE (1UL << PGDIR_SHIFT)
  191. #define PGDIR_MASK (~(PGDIR_SIZE-1))
  193. /*
  194.  * entries per page directory level: we use a two-level, so
  195.  * we don't really have any PMD directory physically.
  196.  * pointers are 4 bytes so we can use the page size and 
  197.  * divide it by 4 (shift by 2).
  198.  */
  199. #define PTRS_PER_PTE (1UL << (PAGE_SHIFT-2))
  200. #define PTRS_PER_PMD 1
  201. #define PTRS_PER_PGD (1UL << (PAGE_SHIFT-2))
  203. /* calculate how many PGD entries a user-level program can use
  204.  * the first mappable virtual address is 0
  205.  * (TASK_SIZE is the maximum virtual address space)
  206.  */
  208. #define USER_PTRS_PER_PGD       (TASK_SIZE/PGDIR_SIZE)
  209. #define FIRST_USER_PGD_NR       0
  211. /*
  212.  * Kernels own virtual memory area. 
  213.  */
  215. #ifdef CONFIG_CRIS_LOW_MAP
  216. #define VMALLOC_START     KSEG_7
  217. #define VMALLOC_VMADDR(x) ((unsigned long)(x))
  218. #define VMALLOC_END       KSEG_8
  219. #else
  220. #define VMALLOC_START     KSEG_D
  221. #define VMALLOC_VMADDR(x) ((unsigned long)(x))
  222. #define VMALLOC_END       KSEG_E
  223. #endif
  225. /* Define some higher level generic page attributes. The PTE bits are
  226.  * defined in asm-cris/mmu.h, and these are just combinations of those.
  227.  */
  229. #define __READABLE      (_PAGE_READ | _PAGE_SILENT_READ | _PAGE_ACCESSED)
  230. #define __WRITEABLE     (_PAGE_WRITE | _PAGE_SILENT_WRITE | _PAGE_MODIFIED)
  232. #define _PAGE_TABLE     (_PAGE_PRESENT | __READABLE | __WRITEABLE)
  233. #define _PAGE_CHG_MASK  (PAGE_MASK | _PAGE_ACCESSED | _PAGE_MODIFIED)
  235. #define PAGE_NONE       __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED)
  236. #define PAGE_SHARED     __pgprot(_PAGE_PRESENT | __READABLE | _PAGE_WRITE | 
  237.  _PAGE_ACCESSED)
  238. #define PAGE_COPY       __pgprot(_PAGE_PRESENT | __READABLE)  // | _PAGE_COW
  239. #define PAGE_READONLY   __pgprot(_PAGE_PRESENT | __READABLE)
  240. #define PAGE_KERNEL     __pgprot(_PAGE_GLOBAL | _PAGE_KERNEL | 
  241.  _PAGE_PRESENT | __READABLE | __WRITEABLE)
  242. #define _KERNPG_TABLE   (_PAGE_TABLE | _PAGE_KERNEL)
  244. /*
  245.  * CRIS can't do page protection for execute, and considers read the same.
  246.  * Also, write permissions imply read permissions. This is the closest we can
  247.  * get..
  248.  */
  250. #define __P000 PAGE_NONE
  251. #define __P001 PAGE_READONLY
  252. #define __P010 PAGE_COPY
  253. #define __P011 PAGE_COPY
  254. #define __P100 PAGE_READONLY
  255. #define __P101 PAGE_READONLY
  256. #define __P110 PAGE_COPY
  257. #define __P111 PAGE_COPY
  259. #define __S000 PAGE_NONE
  260. #define __S001 PAGE_READONLY
  261. #define __S010 PAGE_SHARED
  262. #define __S011 PAGE_SHARED
  263. #define __S100 PAGE_READONLY
  264. #define __S101 PAGE_READONLY
  265. #define __S110 PAGE_SHARED
  266. #define __S111 PAGE_SHARED
  268. /* zero page used for uninitialized stuff */
  269. extern unsigned long empty_zero_page;
  270. #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
  272. /* number of bits that fit into a memory pointer */
  273. #define BITS_PER_PTR (8*sizeof(unsigned long))
  275. /* to align the pointer to a pointer address */
  276. #define PTR_MASK (~(sizeof(void*)-1))
  278. /* sizeof(void*)==1<<SIZEOF_PTR_LOG2 */
  279. /* 64-bit machines, beware!  SRB. */
  280. #define SIZEOF_PTR_LOG2 2
  282. /* to find an entry in a page-table */
  283. #define PAGE_PTR(address) 
  284. ((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
  286. /* to set the page-dir */
  287. #define SET_PAGE_DIR(tsk,pgdir)
  289. #define pte_none(x) (!pte_val(x))
  290. #define pte_present(x) (pte_val(x) & _PAGE_PRESENT)
  291. #define pte_clear(xp) do { pte_val(*(xp)) = 0; } while (0)
  293. #define pmd_none(x) (!pmd_val(x))
  294. /* by removing the _PAGE_KERNEL bit from the comparision, the same pmd_bad
  295.  * works for both _PAGE_TABLE and _KERNPG_TABLE pmd entries.
  296.  */
  297. #define pmd_bad(x) ((pmd_val(x) & (~PAGE_MASK & ~_PAGE_KERNEL)) != _PAGE_TABLE)
  298. #define pmd_present(x) (pmd_val(x) & _PAGE_PRESENT)
  299. #define pmd_clear(xp) do { pmd_val(*(xp)) = 0; } while (0)
  301. /*
  302.  * The "pgd_xxx()" functions here are trivial for a folded two-level
  303.  * setup: the pgd is never bad, and a pmd always exists (as it's folded
  304.  * into the pgd entry)
  305.  */
  306. static inline int pgd_none(pgd_t pgd) { return 0; }
  307. static inline int pgd_bad(pgd_t pgd) { return 0; }
  308. static inline int pgd_present(pgd_t pgd) { return 1; }
  309. static inline void pgd_clear(pgd_t * pgdp) { }
  311. /*
  312.  * The following only work if pte_present() is true.
  313.  * Undefined behaviour if not..
  314.  */
  316. static inline int pte_read(pte_t pte)           { return pte_val(pte) & _PAGE_READ; }
  317. static inline int pte_write(pte_t pte)          { return pte_val(pte) & _PAGE_WRITE; }
  318. static inline int pte_exec(pte_t pte)           { return pte_val(pte) & _PAGE_READ; }
  319. static inline int pte_dirty(pte_t pte)          { return pte_val(pte) & _PAGE_MODIFIED; }
  320. static inline int pte_young(pte_t pte)          { return pte_val(pte) & _PAGE_ACCESSED; }
  322. static inline pte_t pte_wrprotect(pte_t pte)
  323. {
  324.         pte_val(pte) &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
  325.         return pte;
  326. }
  328. static inline pte_t pte_rdprotect(pte_t pte)
  329. {
  330.         pte_val(pte) &= ~(_PAGE_READ | _PAGE_SILENT_READ);
  331. return pte;
  332. }
  334. static inline pte_t pte_exprotect(pte_t pte)
  335. {
  336.         pte_val(pte) &= ~(_PAGE_READ | _PAGE_SILENT_READ);
  337. return pte;
  338. }
  340. static inline pte_t pte_mkclean(pte_t pte)
  341. {
  342. pte_val(pte) &= ~(_PAGE_MODIFIED | _PAGE_SILENT_WRITE); 
  343. return pte; 
  344. }
  346. static inline pte_t pte_mkold(pte_t pte)
  347. {
  348. pte_val(pte) &= ~(_PAGE_ACCESSED | _PAGE_SILENT_READ);
  349. return pte;
  350. }
  352. static inline pte_t pte_mkwrite(pte_t pte)
  353. {
  354.         pte_val(pte) |= _PAGE_WRITE;
  355.         if (pte_val(pte) & _PAGE_MODIFIED)
  356.                 pte_val(pte) |= _PAGE_SILENT_WRITE;
  357.         return pte;
  358. }
  360. static inline pte_t pte_mkread(pte_t pte)
  361. {
  362.         pte_val(pte) |= _PAGE_READ;
  363.         if (pte_val(pte) & _PAGE_ACCESSED)
  364.                 pte_val(pte) |= _PAGE_SILENT_READ;
  365.         return pte;
  366. }
  368. static inline pte_t pte_mkexec(pte_t pte)
  369. {
  370.         pte_val(pte) |= _PAGE_READ;
  371.         if (pte_val(pte) & _PAGE_ACCESSED)
  372.                 pte_val(pte) |= _PAGE_SILENT_READ;
  373.         return pte;
  374. }
  376. static inline pte_t pte_mkdirty(pte_t pte)
  377. {
  378.         pte_val(pte) |= _PAGE_MODIFIED;
  379.         if (pte_val(pte) & _PAGE_WRITE)
  380.                 pte_val(pte) |= _PAGE_SILENT_WRITE;
  381.         return pte;
  382. }
  384. static inline pte_t pte_mkyoung(pte_t pte)
  385. {
  386.         pte_val(pte) |= _PAGE_ACCESSED;
  387.         if (pte_val(pte) & _PAGE_READ)
  388.         {
  389.                 pte_val(pte) |= _PAGE_SILENT_READ;
  390.                 if ((pte_val(pte) & (_PAGE_WRITE | _PAGE_MODIFIED)) ==
  391.     (_PAGE_WRITE | _PAGE_MODIFIED))
  392.                         pte_val(pte) |= _PAGE_SILENT_WRITE;
  393.         }
  394.         return pte;
  395. }
  397. /*
  398.  * Conversion functions: convert a page and protection to a page entry,
  399.  * and a page entry and page directory to the page they refer to.
  400.  */
  402. /* What actually goes as arguments to the various functions is less than
  403.  * obvious, but a rule of thumb is that struct page's goes as struct page *,
  404.  * really physical DRAM addresses are unsigned long's, and DRAM "virtual"
  405.  * addresses (the 0xc0xxxxxx's) goes as void *'s.
  406.  */
  408. static inline pte_t __mk_pte(void * page, pgprot_t pgprot)
  409. {
  410. pte_t pte;
  411. /* the PTE needs a physical address */
  412. pte_val(pte) = __pa(page) | pgprot_val(pgprot);
  413. return pte;
  414. }
  416. #define mk_pte(page, pgprot) __mk_pte(page_address(page), (pgprot))
  418. #define mk_pte_phys(physpage, pgprot) 
  419. ({                                                                      
  420.         pte_t __pte;                                                    
  421.                                                                         
  422.         pte_val(__pte) = (physpage) + pgprot_val(pgprot);               
  423.         __pte;                                                          
  424. })
  426. static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  427. { pte_val(pte) = (pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot); return pte; }
  430. /* pte_val refers to a page in the 0x4xxxxxxx physical DRAM interval
  431.  * __pte_page(pte_val) refers to the "virtual" DRAM interval
  432.  * pte_pagenr refers to the page-number counted starting from the virtual DRAM start
  433.  */
  435. static inline unsigned long __pte_page(pte_t pte)
  436. {
  437. /* the PTE contains a physical address */
  438. return (unsigned long)__va(pte_val(pte) & PAGE_MASK);
  439. }
  441. #define pte_pagenr(pte)         ((__pte_page(pte) - PAGE_OFFSET) >> PAGE_SHIFT)
  443. /* permanent address of a page */
  445. #define __page_address(page)    (PAGE_OFFSET + (((page) - mem_map) << PAGE_SHIFT))
  446. #define pte_page(pte)           (mem_map+pte_pagenr(pte))
  448. /* only the pte's themselves need to point to physical DRAM (see above)
  449.  * the pagetable links are purely handled within the kernel SW and thus
  450.  * don't need the __pa and __va transformations.
  451.  */
  453. static inline unsigned long pmd_page(pmd_t pmd)
  454. { return pmd_val(pmd) & PAGE_MASK; }
  456. static inline void pmd_set(pmd_t * pmdp, pte_t * ptep)
  457. { pmd_val(*pmdp) = _PAGE_TABLE | (unsigned long) ptep; }
  459. /* to find an entry in a page-table-directory. */
  460. #define pgd_index(address) ((address >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
  462. /* to find an entry in a page-table-directory */
  463. static inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
  464. {
  465. return mm->pgd + pgd_index(address);
  466. }
  468. /* to find an entry in a kernel page-table-directory */
  469. #define pgd_offset_k(address) pgd_offset(&init_mm, address)
  471. /* Find an entry in the second-level page table.. */
  472. static inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
  473. {
  474. return (pmd_t *) dir;
  475. }
  477. /* Find an entry in the third-level page table.. */ 
  478. static inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
  479. {
  480. return (pte_t *) pmd_page(*dir) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
  481. }
  483. #define pte_ERROR(e) 
  484.         printk("%s:%d: bad pte %p(%08lx).n", __FILE__, __LINE__, &(e), pte_val(e))
  485. #define pmd_ERROR(e) 
  486.         printk("%s:%d: bad pmd %p(%08lx).n", __FILE__, __LINE__, &(e), pmd_val(e))
  487. #define pgd_ERROR(e) 
  488.         printk("%s:%d: bad pgd %p(%08lx).n", __FILE__, __LINE__, &(e), pgd_val(e))
  490. extern pgd_t swapper_pg_dir[PTRS_PER_PGD]; /* defined in head.S */
  492. /*
  493.  * CRIS doesn't have any external MMU info: the kernel page
  494.  * tables contain all the necessary information.
  495.  * 
  496.  * Actually I am not sure on what this could be used for.
  497.  */
  498. static inline void update_mmu_cache(struct vm_area_struct * vma,
  499. unsigned long address, pte_t pte)
  500. {
  501. }
  503. /* Encode and de-code a swap entry (must be !pte_none(e) && !pte_present(e)) */
  504. /* Since the PAGE_PRESENT bit is bit 4, we can use the bits above */
  506. #define SWP_TYPE(x)                     (((x).val >> 5) & 0x7f)
  507. #define SWP_OFFSET(x)                   ((x).val >> 12)
  508. #define SWP_ENTRY(type, offset)         ((swp_entry_t) { ((type) << 5) | ((offset) << 12) })
  509. #define pte_to_swp_entry(pte)           ((swp_entry_t) { pte_val(pte) })
  510. #define swp_entry_to_pte(x)             ((pte_t) { (x).val })
  512. /* Needs to be defined here and not in linux/mm.h, as it is arch dependent */
  513. #define PageSkip(page)          (0)
  514. #define kern_addr_valid(addr)   (1)
  516. #include <asm-generic/pgtable.h>
  518. /*
  519.  * No page table caches to initialise
  520.  */
  521. #define pgtable_cache_init()   do { } while (0)
  523. #endif /* _CRIS_PGTABLE_H */