1 /* $NetBSD: pmap.h,v 1.20 2002/01/19 16:55:22 chs Exp $ */ 2 3 /* 4 * Copyright (c) 1994,1995 Mark Brinicombe. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Mark Brinicombe 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #ifndef _ARM32_PMAP_H_ 34 #define _ARM32_PMAP_H_ 35 36 #ifdef _KERNEL 37 38 #include <arm/cpufunc.h> 39 #include <arm/arm32/pte.h> 40 #include <uvm/uvm_object.h> 41 42 /* 43 * a pmap describes a processes' 4GB virtual address space. this 44 * virtual address space can be broken up into 4096 1MB regions which 45 * are described by PDEs in the PDP. the PDEs are defined as follows: 46 * 47 * (ranges are inclusive -> exclusive, just like vm_map_entry start/end) 48 * (the following assumes that KERNBASE is 0xf0000000) 49 * 50 * PDE#s VA range usage 51 * 0->3835 0x0 -> 0xefc00000 user address space 52 * 3836->3839 0xefc00000-> recursive mapping of PDP (used for 53 * 0xf0000000 linear mapping of PTPs) 54 * 3840->3851 0xf0000000-> kernel text address space (constant 55 * 0xf0c00000 across all pmap's/processes) 56 * 3852->3855 0xf0c00000-> "alternate" recursive PDP mapping 57 * 0xf1000000 (for other pmaps) 58 * 3856->4095 0xf1000000-> KVM and device mappings, constant 59 * 0x00000000 across all pmaps 60 * 61 * The maths works out that to then map each 1MB block into 4k pages requires 62 * 256 entries, of 4 bytes each, totaling 1k per 1MB. However as we use 4k 63 * pages we allocate 4 PDE's at a time, allocating the same access permissions 64 * to them all. This means we only need 1024 entries in the page table page 65 * table, IE we use 1 4k page to linearly map all the other page tables used. 66 */ 67 68 /* 69 * Data structures used by pmap 70 */ 71 72 /* 73 * Structure that describes a Level 1 page table and the flags 74 * associated with it. 75 */ 76 struct l1pt { 77 SIMPLEQ_ENTRY(l1pt) pt_queue; /* Queue pointers */ 78 struct pglist pt_plist; /* Allocated page list */ 79 vaddr_t pt_va; /* Allocated virtual address */ 80 int pt_flags; /* Flags */ 81 }; 82 #define PTFLAG_STATIC 1 /* Statically allocated */ 83 #define PTFLAG_KPT 2 /* Kernel pt's are mapped */ 84 #define PTFLAG_CLEAN 4 /* L1 is clean */ 85 86 /* 87 * The pmap structure itself. 88 */ 89 struct pmap { 90 struct uvm_object pm_obj; /* uvm_object */ 91 #define pm_lock pm_obj.vmobjlock 92 pd_entry_t *pm_pdir; /* KVA of page directory */ 93 struct l1pt *pm_l1pt; /* L1 descriptor */ 94 paddr_t pm_pptpt; /* PA of pt's page table */ 95 vaddr_t pm_vptpt; /* VA of pt's page table */ 96 struct pmap_statistics pm_stats; /* pmap statistics */ 97 }; 98 99 typedef struct pmap *pmap_t; 100 101 /* 102 * for each managed physical page we maintain a list of <PMAP,VA>'s 103 * which it is mapped at. the list is headed by a pv_head structure. 104 * there is one pv_head per managed phys page (allocated at boot time). 105 * the pv_head structure points to a list of pv_entry structures (each 106 * describes one mapping). 107 * 108 * pv_entry's are only visible within pmap.c, so only provide a placeholder 109 * here 110 */ 111 112 struct pv_entry; 113 114 struct pv_head { 115 struct simplelock pvh_lock; /* locks every pv on this list */ 116 struct pv_entry *pvh_list; /* head of list (locked by pvh_lock) */ 117 }; 118 119 /* 120 * Page hooks. I'll eliminate these sometime soon :-) 121 * 122 * For speed we store the both the virtual address and the page table 123 * entry address for each page hook. 124 */ 125 typedef struct { 126 vaddr_t va; 127 pt_entry_t *pte; 128 } pagehook_t; 129 130 /* 131 * Physical / virtual address structure. In a number of places (particularly 132 * during bootstrapping) we need to keep track of the physical and virtual 133 * addresses of various pages 134 */ 135 typedef struct { 136 paddr_t pv_pa; 137 vaddr_t pv_va; 138 } pv_addr_t; 139 140 /* 141 * _KERNEL specific macros, functions and prototypes 142 */ 143 144 #ifdef _KERNEL 145 146 /* 147 * Commonly referenced structures 148 */ 149 extern struct pv_entry *pv_table; /* Phys to virt mappings, per page. */ 150 extern struct pmap kernel_pmap_store; 151 extern int pmap_debug_level; /* Only exists if PMAP_DEBUG */ 152 153 /* 154 * Macros that we need to export 155 */ 156 #define pmap_kernel() (&kernel_pmap_store) 157 #define pmap_resident_count(pmap) ((pmap)->pm_stats.resident_count) 158 #define pmap_wired_count(pmap) ((pmap)->pm_stats.wired_count) 159 160 #define pmap_phys_address(ppn) (arm_page_to_byte((ppn))) 161 162 /* 163 * Functions that we need to export 164 */ 165 extern vaddr_t pmap_map __P((vaddr_t, vaddr_t, vaddr_t, int)); 166 extern void pmap_procwr __P((struct proc *, vaddr_t, int)); 167 #define PMAP_NEED_PROCWR 168 169 /* 170 * Functions we use internally 171 */ 172 void pmap_bootstrap __P((pd_entry_t *, pv_addr_t)); 173 void pmap_debug __P((int)); 174 int pmap_handled_emulation __P((struct pmap *, vaddr_t)); 175 int pmap_modified_emulation __P((struct pmap *, vaddr_t)); 176 void pmap_postinit __P((void)); 177 pt_entry_t *pmap_pte __P((struct pmap *, vaddr_t)); 178 179 /* 180 * Special page zero routine for use by the idle loop (no cache cleans). 181 */ 182 boolean_t pmap_pageidlezero __P((paddr_t)); 183 #define PMAP_PAGEIDLEZERO(pa) pmap_pageidlezero((pa)) 184 185 #endif /* _KERNEL */ 186 187 /* 188 * Useful macros and constants 189 */ 190 191 /* Virtual address to page table entry */ 192 #define vtopte(va) \ 193 ((pt_entry_t *)(PROCESS_PAGE_TBLS_BASE + \ 194 (arm_byte_to_page((unsigned int)(va)) << 2))) 195 196 /* Virtual address to physical address */ 197 #define vtophys(va) \ 198 ((*vtopte(va) & PG_FRAME) | ((unsigned int)(va) & ~PG_FRAME)) 199 200 /* L1 and L2 page table macros */ 201 #define pmap_pde(m, v) (&((m)->pm_pdir[((vaddr_t)(v) >> PDSHIFT)&4095])) 202 #define pmap_pte_pa(pte) (*(pte) & PG_FRAME) 203 #define pmap_pde_v(pde) (*(pde) != 0) 204 #define pmap_pde_section(pde) ((*(pde) & L1_MASK) == L1_SECTION) 205 #define pmap_pde_page(pde) ((*(pde) & L1_MASK) == L1_PAGE) 206 #define pmap_pde_fpage(pde) ((*(pde) & L1_MASK) == L1_FPAGE) 207 208 #define pmap_pte_v(pte) (*(pte) != 0) 209 210 /* Size of the kernel part of the L1 page table */ 211 #define KERNEL_PD_SIZE \ 212 (PD_SIZE - (KERNEL_SPACE_START >> PDSHIFT) * sizeof(pd_entry_t)) 213 214 /* 215 * tell MI code that the cache is virtually-indexed *and* virtually-tagged. 216 */ 217 218 #define PMAP_CACHE_VIVT 219 220 #endif /* _KERNEL */ 221 222 #endif /* _ARM32_PMAP_H_ */ 223