1 /* $NetBSD: uvm_amap.h,v 1.20 2002/11/30 18:28:05 bouyer Exp $ */ 2 3 /* 4 * 5 * Copyright (c) 1997 Charles D. Cranor and Washington University. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by Charles D. Cranor and 19 * Washington University. 20 * 4. The name of the author may not be used to endorse or promote products 21 * derived from this software without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #ifndef _UVM_UVM_AMAP_H_ 36 #define _UVM_UVM_AMAP_H_ 37 38 /* 39 * uvm_amap.h: general amap interface and amap implementation-specific info 40 */ 41 42 /* 43 * an amap structure contains pointers to a set of anons that are 44 * mapped together in virtual memory (an anon is a single page of 45 * anonymous virtual memory -- see uvm_anon.h). in uvm we hide the 46 * details of the implementation of amaps behind a general amap 47 * interface. this allows us to change the amap implementation 48 * without having to touch the rest of the code. this file is divided 49 * into two parts: the definition of the uvm amap interface and the 50 * amap implementation-specific definitions. 51 */ 52 53 #ifdef _KERNEL 54 55 /* 56 * part 1: amap interface 57 */ 58 59 /* 60 * forward definition of vm_amap structure. only amap 61 * implementation-specific code should directly access the fields of 62 * this structure. 63 */ 64 65 struct vm_amap; 66 67 /* 68 * handle inline options... we allow amap ops to be inline, but we also 69 * provide a hook to turn this off. macros can also be used. 70 */ 71 72 #ifdef UVM_AMAP_INLINE /* defined/undef'd in uvm_amap.c */ 73 #define AMAP_INLINE static __inline /* inline enabled */ 74 #else 75 #define AMAP_INLINE /* inline disabled */ 76 #endif /* UVM_AMAP_INLINE */ 77 78 79 /* 80 * prototypes for the amap interface 81 */ 82 83 AMAP_INLINE 84 void amap_add /* add an anon to an amap */ 85 __P((struct vm_aref *, vaddr_t, 86 struct vm_anon *, boolean_t)); 87 struct vm_amap *amap_alloc /* allocate a new amap */ 88 __P((vaddr_t, vaddr_t, int)); 89 void amap_copy /* clear amap needs-copy flag */ 90 __P((struct vm_map *, struct vm_map_entry *, int, 91 boolean_t, vaddr_t, vaddr_t)); 92 void amap_cow_now /* resolve all COW faults now */ 93 __P((struct vm_map *, struct vm_map_entry *)); 94 int amap_extend /* make amap larger */ 95 __P((struct vm_map_entry *, vsize_t, int)); 96 int amap_flags /* get amap's flags */ 97 __P((struct vm_amap *)); 98 void amap_free /* free amap */ 99 __P((struct vm_amap *)); 100 void amap_init /* init amap module (at boot time) */ 101 __P((void)); 102 void amap_lock /* lock amap */ 103 __P((struct vm_amap *)); 104 AMAP_INLINE 105 struct vm_anon *amap_lookup /* lookup an anon @ offset in amap */ 106 __P((struct vm_aref *, vaddr_t)); 107 AMAP_INLINE 108 void amap_lookups /* lookup multiple anons */ 109 __P((struct vm_aref *, vaddr_t, 110 struct vm_anon **, int)); 111 AMAP_INLINE 112 void amap_ref /* add a reference to an amap */ 113 __P((struct vm_amap *, vaddr_t, vsize_t, int)); 114 int amap_refs /* get number of references of amap */ 115 __P((struct vm_amap *)); 116 void amap_share_protect /* protect pages in a shared amap */ 117 __P((struct vm_map_entry *, vm_prot_t)); 118 void amap_splitref /* split reference to amap into two */ 119 __P((struct vm_aref *, struct vm_aref *, 120 vaddr_t)); 121 AMAP_INLINE 122 void amap_unadd /* remove an anon from an amap */ 123 __P((struct vm_aref *, vaddr_t)); 124 void amap_unlock /* unlock amap */ 125 __P((struct vm_amap *)); 126 AMAP_INLINE 127 void amap_unref /* drop reference to an amap */ 128 __P((struct vm_amap *, vaddr_t, vsize_t, int)); 129 void amap_wipeout /* remove all anons from amap */ 130 __P((struct vm_amap *)); 131 132 /* 133 * amap flag values 134 */ 135 136 #define AMAP_SHARED 0x1 /* amap is shared */ 137 #define AMAP_REFALL 0x2 /* amap_ref: reference entire amap */ 138 139 /* 140 * amap_extend flags 141 */ 142 #define AMAP_EXTEND_BACKWARDS 0x00 /* add "size" to start of map */ 143 #define AMAP_EXTEND_FORWARDS 0x01 /* add "size" to end of map */ 144 #define AMAP_EXTEND_NOWAIT 0x02 /* not allowed to sleep */ 145 146 #endif /* _KERNEL */ 147 148 /**********************************************************************/ 149 150 /* 151 * part 2: amap implementation-specific info 152 */ 153 154 /* 155 * we currently provide an array-based amap implementation. in this 156 * implementation we provide the option of tracking split references 157 * so that we don't lose track of references during partial unmaps 158 * ... this is enabled with the "UVM_AMAP_PPREF" define. 159 */ 160 161 #define UVM_AMAP_PPREF /* track partial references */ 162 163 /* 164 * here is the definition of the vm_amap structure for this implementation. 165 */ 166 167 struct vm_amap { 168 struct simplelock am_l; /* simple lock [locks all vm_amap fields] */ 169 int am_ref; /* reference count */ 170 int am_flags; /* flags */ 171 int am_maxslot; /* max # of slots allocated */ 172 int am_nslot; /* # of slots currently in map ( <= maxslot) */ 173 int am_nused; /* # of slots currently in use */ 174 int *am_slots; /* contig array of active slots */ 175 int *am_bckptr; /* back pointer array to am_slots */ 176 struct vm_anon **am_anon; /* array of anonymous pages */ 177 #ifdef UVM_AMAP_PPREF 178 int *am_ppref; /* per page reference count (if !NULL) */ 179 #endif 180 }; 181 182 /* 183 * note that am_slots, am_bckptr, and am_anon are arrays. this allows 184 * fast lookup of pages based on their virual address at the expense of 185 * some extra memory. in the future we should be smarter about memory 186 * usage and fall back to a non-array based implementation on systems 187 * that are short of memory (XXXCDC). 188 * 189 * the entries in the array are called slots... for example an amap that 190 * covers four pages of virtual memory is said to have four slots. here 191 * is an example of the array usage for a four slot amap. note that only 192 * slots one and three have anons assigned to them. "D/C" means that we 193 * "don't care" about the value. 194 * 195 * 0 1 2 3 196 * am_anon: NULL, anon0, NULL, anon1 (actual pointers to anons) 197 * am_bckptr: D/C, 1, D/C, 0 (points to am_slots entry) 198 * 199 * am_slots: 3, 1, D/C, D/C (says slots 3 and 1 are in use) 200 * 201 * note that am_bckptr is D/C if the slot in am_anon is set to NULL. 202 * to find the entry in am_slots for an anon, look at am_bckptr[slot], 203 * thus the entry for slot 3 in am_slots[] is at am_slots[am_bckptr[3]]. 204 * in general, if am_anon[X] is non-NULL, then the following must be 205 * true: am_slots[am_bckptr[X]] == X 206 * 207 * note that am_slots is always contig-packed. 208 */ 209 210 /* 211 * defines for handling of large sparce amaps: 212 * 213 * one of the problems of array-based amaps is that if you allocate a 214 * large sparcely-used area of virtual memory you end up allocating 215 * large arrays that, for the most part, don't get used. this is a 216 * problem for BSD in that the kernel likes to make these types of 217 * allocations to "reserve" memory for possible future use. 218 * 219 * for example, the kernel allocates (reserves) a large chunk of user 220 * VM for possible stack growth. most of the time only a page or two 221 * of this VM is actually used. since the stack is anonymous memory 222 * it makes sense for it to live in an amap, but if we allocated an 223 * amap for the entire stack range we could end up wasting a large 224 * amount of malloc'd KVM. 225 * 226 * for example, on the i386 at boot time we allocate two amaps for the stack 227 * of /sbin/init: 228 * 1. a 7680 slot amap at protection 0 (reserve space for stack) 229 * 2. a 512 slot amap at protection 7 (top of stack) 230 * 231 * most of the array allocated for the amaps for this is never used. 232 * the amap interface provides a way for us to avoid this problem by 233 * allowing amap_copy() to break larger amaps up into smaller sized 234 * chunks (controlled by the "canchunk" option). we use this feature 235 * to reduce our memory usage with the BSD stack management. if we 236 * are asked to create an amap with more than UVM_AMAP_LARGE slots in it, 237 * we attempt to break it up into a UVM_AMAP_CHUNK sized amap if the 238 * "canchunk" flag is set. 239 * 240 * so, in the i386 example, the 7680 slot area is never referenced so 241 * nothing gets allocated (amap_copy is never called because the protection 242 * is zero). the 512 slot area for the top of the stack is referenced. 243 * the chunking code breaks it up into 16 slot chunks (hopefully a single 244 * 16 slot chunk is enough to handle the whole stack). 245 */ 246 247 #define UVM_AMAP_LARGE 256 /* # of slots in "large" amap */ 248 #define UVM_AMAP_CHUNK 16 /* # of slots to chunk large amaps in */ 249 250 #ifdef _KERNEL 251 252 /* 253 * macros 254 */ 255 256 /* AMAP_B2SLOT: convert byte offset to slot */ 257 #define AMAP_B2SLOT(S,B) { \ 258 KASSERT(((B) & (PAGE_SIZE - 1)) == 0); \ 259 (S) = (B) >> PAGE_SHIFT; \ 260 } 261 262 /* 263 * lock/unlock/refs/flags macros 264 */ 265 266 #define amap_flags(AMAP) ((AMAP)->am_flags) 267 #define amap_lock(AMAP) simple_lock(&(AMAP)->am_l) 268 #define amap_refs(AMAP) ((AMAP)->am_ref) 269 #define amap_unlock(AMAP) simple_unlock(&(AMAP)->am_l) 270 271 /* 272 * if we enable PPREF, then we have a couple of extra functions that 273 * we need to prototype here... 274 */ 275 276 #ifdef UVM_AMAP_PPREF 277 278 #define PPREF_NONE ((int *) -1) /* not using ppref */ 279 280 void amap_pp_adjref /* adjust references */ 281 __P((struct vm_amap *, int, vsize_t, int)); 282 void amap_pp_establish /* establish ppref */ 283 __P((struct vm_amap *)); 284 void amap_wiperange /* wipe part of an amap */ 285 __P((struct vm_amap *, int, int)); 286 #endif /* UVM_AMAP_PPREF */ 287 288 #endif /* _KERNEL */ 289 290 #endif /* _UVM_UVM_AMAP_H_ */ 291