Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/osfmk/ppc/mappings.h
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* 2 * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * The contents of this file constitute Original Code as defined in and 7 * are subject to the Apple Public Source License Version 1.1 (the 8 * "License"). You may not use this file except in compliance with the 9 * License. Please obtain a copy of the License at 10 * http://www.apple.com/publicsource and read it before using this file. 11 * 12 * This Original Code and all software distributed under the License are 13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER 14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the 17 * License for the specific language governing rights and limitations 18 * under the License. 19 * 20 * @APPLE_LICENSE_HEADER_END@ 21 */ 22 /* 23 * Header files for the hardware virtual memory mapping stuff 24 */ 25 #ifdef XNU_KERNEL_PRIVATE 26 27 #ifndef _PPC_MAPPINGS_H_ 28 #define _PPC_MAPPINGS_H_ 29 30 #include <mach/mach_types.h> 31 #include <mach/vm_types.h> 32 #include <mach/machine/vm_types.h> 33 #include <mach/vm_prot.h> 34 #include <mach/vm_statistics.h> 35 #include <kern/assert.h> 36 #include <kern/cpu_number.h> 37 #include <kern/lock.h> 38 #include <kern/queue.h> 39 #include <ppc/proc_reg.h> 40 41 /* 42 * Don't change these structures unless you change the assembly code 43 */ 44 45 /* 46 * This control block serves as anchor for all virtual mappings of the same physical 47 * page, i.e., aliases. There is a table for each bank (mem_region). All tables 48 * must reside in V=R storage and within the first 2GB of memory. Also, the 49 * mappings to which it points must be on at least a 64-byte boundary. These 50 * requirements allow a total of 2 bits for status and flags, and allow all address 51 * calculations to be 32-bit. 52 */ 53 54 #pragma pack(4) /* Make sure the structure stays as we defined it */ 55 typedef struct phys_entry { 56 addr64_t ppLink; /* Physical pointer to aliased mappings and flags */ 57 #define ppLock 0x8000000000000000LL /* Lock for alias chain */ 58 #define ppFlags 0x700000000000000FLL /* Status and flags */ 59 #define ppI 0x2000000000000000LL /* Cache inhibited */ 60 #define ppIb 2 /* Cache inhibited */ 61 #define ppG 0x1000000000000000LL /* Guarded */ 62 #define ppGb 3 /* Guarded */ 63 #define ppR 0x0000000000000008LL /* Referenced */ 64 #define ppRb 60 /* Referenced */ 65 #define ppC 0x0000000000000004LL /* Changed */ 66 #define ppCb 61 /* Changed */ 67 68 /* The lock, attribute, and flag bits are arranged so that their positions may be 69 * described by a contiguous mask of one bits wrapping from bit postion 63 to 0. 70 * In assembly language, we can then rapidly produce this mask with: 71 * li r0,ppLFAmask ; r0 <- 0x00000000000000FF 72 * rotrdi r0,r0,ppLFArrot ; r0 <- 0xF00000000000000F 73 */ 74 #define ppLFAmask 0x00FF /* One bit for each lock, attr, or flag bit */ 75 #define ppLFArrot 4 /* Right-rotate count to obtain 64-bit mask */ 76 } phys_entry_t; 77 #pragma pack() 78 #define physEntrySize sizeof(phys_entry_t) 79 80 /* Memory may be non-contiguous. This data structure contains info 81 * for mapping this non-contiguous space into the contiguous 82 * physical->virtual mapping tables. An array of this type is 83 * provided to the pmap system at bootstrap by ppc_vm_init. 84 * 85 */ 86 87 #pragma pack(4) /* Make sure the structure stays as we defined it */ 88 typedef struct mem_region { 89 phys_entry_t *mrPhysTab; /* Base of region table */ 90 ppnum_t mrStart; /* Start of region */ 91 ppnum_t mrEnd; /* Last page in region */ 92 ppnum_t mrAStart; /* Next page in region to allocate */ 93 ppnum_t mrAEnd; /* Last page in region to allocate */ 94 } mem_region_t; 95 #pragma pack() 96 97 #define mrSize sizeof(mem_region_t) 98 #define PMAP_MEM_REGION_MAX 11 99 100 extern mem_region_t pmap_mem_regions[PMAP_MEM_REGION_MAX + 1]; 101 extern int pmap_mem_regions_count; 102 103 /* Prototypes */ 104 105 106 #pragma pack(4) /* Make sure the structure stays as we defined it */ 107 typedef struct PCA { /* PTEG Control Area */ 108 union flgs { 109 unsigned int PCAallo; /* Allocation controls */ 110 struct PCAalflgs { /* Keep these in order!!! */ 111 unsigned char PCAfree; /* Indicates the slot is free */ 112 unsigned char PCAsteal; /* Steal scan start position */ 113 unsigned char PCAauto; /* Indicates that the PTE was autogenned */ 114 unsigned char PCAmisc; /* Misc. flags */ 115 #define PCAlock 1 /* This locks up the associated PTEG */ 116 #define PCAlockb 31 117 } PCAalflgs; 118 } flgs; 119 } PCA_t; 120 #pragma pack() 121 122 /* The hash table is composed of mappings organized into G groups of S slots 123 * each. In the macros below, by GV_GROUPS_LG2, GV_SLOT_SZ_LG2, and GV_SLOTS_LG2, the number 124 * of groups, the size (in bytes) of a slot, and the number of slots in a group are given. 125 * Since these values are given as log2, they're restricted to powers of two. Fast operation 126 * and all that. 127 * 128 * This patch of macros define all of the hash table's metrics and handy masks. It's a 129 * build-time thing because it's faster that way. Only the first group of values may 130 * be adjusted. 131 */ 132 #define GV_GROUPS_LG2 10 /* 1024 groups per hash table (log2(max) is 14, viz. 16K groups) */ 133 #define GV_SLOTS_LG2 3 /* 8 slots per group (log2(max) is 8, viz. 256 slots) */ 134 135 #define GV_SLOT_SZ_LG2 5 /* 32 bytes per slot (mapping size) */ 136 #define GV_PGIDX_SZ_LG2 3 /* 64-bit Hash-table-page physical-addrress index entry size */ 137 #define GV_PAGE_SZ_LG2 12 /* 4k-byte hash-table-page size */ 138 139 #define GV_GROUPS (1 << GV_GROUPS_LG2) 140 #define GV_SLOT_SZ (1 << GV_SLOT_SZ_LG2) 141 #define GV_SLOTS (1 << GV_SLOTS_LG2) 142 #define GV_PAGE_SZ (1 << GV_PAGE_SZ_LG2) 143 #define GV_GRP_MASK (GV_GROUPS - 1) 144 #define GV_SLOT_MASK (GV_SLOTS - 1) 145 #define GV_PAGE_MASK (GV_PAGE_SZ - 1) 146 #define GV_HPAGES (1 << (GV_GROUPS_LG2 + GV_SLOT_SZ_LG2 + GV_SLOTS_LG2 - GV_PAGE_SZ_LG2)) 147 #define GV_GRPS_PPG_LG2 (GV_PAGE_SZ_LG2 - (GV_SLOT_SZ_LG2 + GV_SLOTS_LG2)) 148 #define GV_GRPS_PPG (1 << GV_GRPS_PPG_LG2) 149 #define GV_SLTS_PPG_LG2 (GV_PAGE_SZ_LG2 - GV_SLOT_SZ_LG2) 150 #define GV_SLTS_PPG (1 << GV_SLTS_PPG_LG2) 151 152 #define GV_HPAGE_SHIFT (GV_PGIDX_SZ_LG2 - GV_GRPS_PPG_LG2) 153 #define GV_HPAGE_MASK ((GV_HPAGES - 1) << GV_PGIDX_SZ_LG2) 154 #define GV_HGRP_SHIFT (GV_SLOT_SZ_LG2 + GV_SLOTS_LG2) 155 #define GV_HGRP_MASK ((GV_GRPS_PPG - 1) << GV_HGRP_SHIFT) 156 157 #define GV_MAPWD_BITS_LG2 5 /* 32-bit active map word size */ 158 #define GV_MAPWD_SZ_LG2 (GV_MAPWD_BITS_LG2 - 3) 159 #define GV_BAND_SHIFT (GV_MAPWD_BITS_LG2 + GV_SLOT_SZ_LG2) 160 #define GV_BAND_SZ_LG2 (GV_PAGE_SZ_LG2 - GV_SLOT_SZ_LG2 - GV_MAPWD_BITS_LG2) 161 #define GV_BAND_MASK (((1 << GV_BAND_SZ_LG2) - 1) << GV_BAND_SHIFT) 162 #define GV_MAP_WORDS (1 << (GV_GROUPS_LG2 + GV_SLOTS_LG2 - GV_MAPWD_BITS_LG2)) 163 #define GV_MAP_MASK ((GV_MAP_WORDS - 1) << GV_MAPWD_SZ_LG2) 164 #define GV_MAP_SHIFT (GV_PGIDX_SZ_LG2 - GV_BAND_SZ_LG2) 165 166 167 /* Mappings currently come in two sizes: 64 and 128 bytes. The only difference is the 168 * number of skiplists (ie, mpLists): 64-byte mappings have 1-4 lists and 128-byte mappings 169 * have from 5-12. Only 1 in 256 mappings is large, so an average mapping is 64.25 bytes. 170 * All mappings are 64-byte aligned. 171 * 172 * Special note on mpFIP and mpRIP: 173 * These flags are manipulated under various locks. RIP is always set under an 174 * exclusive lock while FIP is shared. The only worry is that there is a possibility that 175 * FIP could be attempted by more than 1 processor at a time. Obviously, one will win. 176 * The other(s) bail all the way to user state and may refault (or not). There are only 177 * a few things in mpFlags that are not static, mpFIP, mpRIP, and mpBusy. 178 * 179 * We organize these so that mpFIP is in a byte with static data and mpRIP is in another. 180 * That means that we can use a store byte to update the guys without worrying about load 181 * and reserve. Note that mpFIP must be set atomically because it is under a share lock; 182 * but, it may be cleared with a simple store byte. Because mpRip is set once and then never 183 * cleared, we can get away with setting it by means of a simple store byte. 184 * 185 */ 186 #pragma pack(4) /* Make sure the structure stays as we defined it */ 187 typedef struct mapping { 188 unsigned int mpFlags; /* 0x000 - Various flags, lock bit. These are static except for lock */ 189 #define mpBusy 0xFF000000 /* Busy count */ 190 #define mpPrevious 0x00800000 /* A previous mapping exists in a composite */ 191 #define mpNext 0x00400000 /* A next mapping exist in a composite */ 192 #define mpPIndex 0x003F0000 /* Index into physical table (in words) */ 193 #define mpType 0x0000F000 /* Mapping type: */ 194 #define mpNormal 0x00000000 /* Normal logical page - backed by RAM, RC maintained, logical page size == physical page size */ 195 /* DO NOT CHANGE THIS CODE */ 196 #define mpBlock 0x00001000 /* Block mapping - used for I/O memory or non-RC maintained RAM, logical page size is independent from physical */ 197 #define mpMinSpecial 0x00002000 /* Any mapping with this type or above has extra special handling */ 198 #define mpNest 0x00002000 /* Forces transtion to an alternate address space after applying relocation */ 199 #define mpLinkage 0x00003000 /* Transition to current user address space with relocation - used for copyin/out/pv */ 200 #define mpACID 0x00004000 /* Address Chunk ID - provides the address space ID for VSID calculation. Normally mapped at chunk size - 2KB */ 201 #define mpGuest 0x00005000 /* Guest->physical shadow mapping */ 202 /* 0x00006000 - 0x0000F000 Reserved */ 203 #define mpFIP 0x00000800 /* Fault in progress */ 204 #define mpFIPb 20 /* Fault in progress */ 205 #define mpPcfg 0x00000700 /* Physical Page configuration */ 206 #define mpPcfgb 23 /* Physical Page configuration index bit */ 207 #define mpRIP 0x00000080 /* Remove in progress - DO NOT MOVE */ 208 #define mpRIPb 24 /* Remove in progress */ 209 #define mpPerm 0x00000040 /* Mapping is permanent - DO NOT MOVE */ 210 #define mpPermb 25 /* Mapping is permanent */ 211 #define mpBSu 0x00000020 /* Basic Size unit - 0 = 4KB, 1 = 32MB */ 212 #define mpBSub 26 /* Basic Size unit - 0 = 4KB, 1 = 32MB */ 213 #define mpLists 0x0000001F /* Number of skip lists mapping is on, max of 27 */ 214 #define mpListsb 27 /* Number of skip lists mapping is on, max of 27 */ 215 #define mpgFlags 0x0000001F /* Shadow cache mappings re-use mpLists for flags: */ 216 #define mpgGlobal 0x00000004 /* Mapping is global (1) or local (0) */ 217 #define mpgFree 0x00000002 /* Mapping is free */ 218 #define mpgDormant 0x00000001 /* Mapping is dormant */ 219 220 unsigned short mpSpace; /* 0x004 - Address space hash */ 221 union { 222 unsigned short mpBSize; /* 0x006 - Block size - 1 in pages - max block size 256MB */ 223 unsigned char mpgCursor; /* 0x006 - Shadow-cache group allocation cursor (first mapping in the group) */ 224 } u; 225 226 unsigned int mpPte; /* 0x008 - Offset to PTEG in hash table. Offset to exact PTE if mpHValid set - NOTE: this MUST be 0 for block mappings */ 227 #define mpHValid 0x00000001 /* PTE is entered in hash table */ 228 #define mpHValidb 31 /* PTE is entered in hash table */ 229 ppnum_t mpPAddr; /* 0x00C - Physical page number */ 230 addr64_t mpVAddr; /* 0x010 - Starting virtual address */ 231 #define mpHWFlags 0x0000000000000FFFULL /* Reference/Change, WIMG, AC, N, protection flags from PTE */ 232 #define mpHWFlagsb 52 233 #define mpN 0x0000000000000004ULL /* Page-level no-execute (PowerAS machines) */ 234 #define mpNb 61 235 #define mpPP 0x0000000000000003ULL /* Protection flags */ 236 #define mpPPb 62 237 #define mpPPe 63 238 #define mpKKN 0x0000000000000007ULL /* Segment key and no execute flag (nested pmap) */ 239 #define mpKKNb 61 240 #define mpWIMG 0x0000000000000078ULL /* Attribute bits */ 241 #define mpWIMGb 57 242 #define mpW 0x0000000000000040ULL 243 #define mpWb 57 244 #define mpI 0x0000000000000020ULL 245 #define mpIb 58 246 #define mpM 0x0000000000000010ULL 247 #define mpMb 59 248 #define mpG 0x0000000000000008ULL 249 #define mpGb 60 250 #define mpWIMGe 60 251 #define mpC 0x0000000000000080ULL /* Change bit */ 252 #define mpCb 56 253 #define mpR 0x0000000000000100ULL /* Reference bit */ 254 #define mpRb 55 255 addr64_t mpAlias; /* 0x018 - Pointer to alias mappings of physical page */ 256 #define mpNestReloc mpAlias /* 0x018 - Redefines mpAlias relocation value of vaddr to nested pmap value */ 257 #define mpBlkRemCur mpAlias /* 0x018 - Next offset in block map to remove (this is 4 bytes) */ 258 addr64_t mpList0; /* 0x020 - Forward chain of mappings. This one is always used */ 259 addr64_t mpList[3]; /* 0x028 - Forward chain of mappings. Next higher order */ 260 /* 0x040 - End of basic mapping */ 261 #define mpBasicSize 64 262 #define mpBasicLists 4 263 /* note the dependence on kSkipListMaxLists, which must be <= #lists in a 256-byte mapping (ie, <=28) */ 264 /* addr64_t mpList4[8]; 0x040 - First extended list entries */ 265 /* 0x080 - End of first extended mapping */ 266 /* addr64_t mpList12[8]; 0x080 - Second extended list entries */ 267 /* 0x0C0 - End of second extended mapping */ 268 /* addr64_t mpList20[8]; 0x0C0 - Third extended list entries */ 269 /* 0x100 - End of third extended mapping */ 270 271 } mapping_t; 272 #pragma pack() 273 274 #define MAPPING_NULL ((struct mapping *) 0) 275 276 #define mapDirect 0x08 277 #define mapRWNA 0x00000000 278 #define mapRWRO 0x00000001 279 #define mapRWRW 0x00000002 280 #define mapRORO 0x00000003 281 282 /* All counts are in units of basic 64-byte mappings. A 128-byte mapping is 283 * just two adjacent 64-byte entries. 284 */ 285 #pragma pack(4) /* Make sure the structure stays as we defined it */ 286 287 typedef struct mappingflush { 288 addr64_t addr; /* Start address to search mapping */ 289 unsigned int spacenum; /* Last space num to search pmap */ 290 unsigned int mapfgas[1]; /* Pad to 64 bytes */ 291 } mappingflush_t; 292 293 typedef struct mappingctl { 294 unsigned int mapclock; /* Mapping allocation lock */ 295 unsigned int mapcrecurse; /* Mapping allocation recursion control */ 296 struct mappingblok *mapcnext; /* First mapping block with free entries */ 297 struct mappingblok *mapclast; /* Last mapping block with free entries */ 298 struct mappingblok *mapcrel; /* List of deferred block releases */ 299 unsigned int mapcfree; /* Total free entries on list */ 300 unsigned int mapcinuse; /* Total entries in use */ 301 unsigned int mapcreln; /* Total blocks on pending release list */ 302 int mapcholdoff; /* Hold off clearing release list */ 303 unsigned int mapcfreec; /* Total calls to mapping free */ 304 unsigned int mapcallocc; /* Total calls to mapping alloc */ 305 unsigned int mapcbig; /* Count times a big mapping was requested of mapping_alloc */ 306 unsigned int mapcbigfails; /* Times caller asked for a big one but we gave 'em a small one */ 307 unsigned int mapcmin; /* Minimum free mappings to keep */ 308 unsigned int mapcmaxalloc; /* Maximum number of mappings allocated at one time */ 309 unsigned int mapcgas[1]; /* Pad to 64 bytes */ 310 struct mappingflush mapcflush; 311 } mappingctl_t; 312 #pragma pack() 313 314 /* MAPPERBLOK is the number of basic 64-byte mappings per block (ie, per page.) */ 315 #define MAPPERBLOK 63 316 #define MAPALTHRSH (4*MAPPERBLOK) 317 #define MAPFRTHRSH (2 * ((MAPALTHRSH + MAPPERBLOK - 1) / MAPPERBLOK)) 318 typedef struct mappingblok { 319 unsigned int mapblokfree[2]; /* Bit map of free mapping entrys */ 320 addr64_t mapblokvrswap; /* Virtual address XORed with physical address */ 321 unsigned int mapblokflags; /* Various flags */ 322 #define mbPerm 0x80000000 /* Block is permanent */ 323 struct mappingblok *nextblok; /* Pointer to the next mapping block */ 324 } mappingblok_t; 325 326 #define mapRemChunk 128 327 328 #define mapRetCode 0xF 329 #define mapRtOK 0 330 #define mapRtBadLk 1 331 #define mapRtPerm 2 332 #define mapRtNotFnd 3 333 #define mapRtBlock 4 334 #define mapRtNest 5 335 #define mapRtRemove 6 336 #define mapRtMapDup 7 337 #define mapRtGuest 8 338 #define mapRtEmpty 9 339 #define mapRtSmash 10 /* Mapping already exists and doesn't match new mapping */ 340 #define mapRtBadSz 11 /* Requested size too big or more than 256MB and not mult of 32MB */ 341 342 /* 343 * This struct describes available physical page configurations 344 * Note: 345 * Index 0 is required and is the primary page configuration (4K, non-large) 346 * Index 1 is the primary large page config if supported by hw (16M, large page) 347 */ 348 349 typedef struct pcfg { 350 uint8_t pcfFlags; /* Flags */ 351 #define pcfValid 0x80 /* Configuration is valid */ 352 #define pcfLarge 0x40 /* Large page */ 353 #define pcfDedSeg 0x20 /* Requires dedicated segment */ 354 uint8_t pcfEncode; /* Implementation specific PTE encoding */ 355 uint8_t pcfPSize; /* Page size in powers of 2 */ 356 uint8_t pcfShift; /* Shift for PTE construction */ 357 } pcfg; 358 359 #define pcfDefPcfg 0 /* Primary page configuration */ 360 #define pcfLargePcfg 1 /* Primary large page configuration */ 361 362 extern pcfg pPcfg[8]; /* Supported page configurations */ 363 364 extern mappingctl_t mapCtl; /* Mapping allocation control */ 365 366 extern unsigned char ppc_prot[]; /* Mach -> PPC protection translation table */ 367 368 #define getProtPPC(__key) (ppc_prot[(__key) & 0xF]) 369 /* Safe Mach -> PPC protection key conversion */ 370 371 extern addr64_t mapping_remove(pmap_t pmap, addr64_t va); /* Remove a single mapping for this VADDR */ 372 extern mapping_t *mapping_find(pmap_t pmap, addr64_t va, addr64_t *nextva, int full); /* Finds a mapping */ 373 extern void mapping_free_init(vm_offset_t mbl, int perm, boolean_t locked); /* Sets start and end of a block of mappings */ 374 extern void mapping_prealloc(unsigned int); /* Preallocate mappings for large use */ 375 extern void mapping_relpre(void); /* Releases preallocate request */ 376 extern void mapping_init(void); /* Do initial stuff */ 377 extern mapping_t *mapping_alloc(int lists); /* Obtain a mapping */ 378 extern void mapping_free(struct mapping *mp); /* Release a mapping */ 379 extern boolean_t mapping_tst_ref(ppnum_t pa); /* Tests the reference bit of a physical page */ 380 extern boolean_t mapping_tst_mod(ppnum_t pa); /* Tests the change bit of a physical page */ 381 extern void mapping_set_ref(ppnum_t pa); /* Sets the reference bit of a physical page */ 382 extern void mapping_clr_ref(ppnum_t pa); /* Clears the reference bit of a physical page */ 383 extern void mapping_set_mod(ppnum_t pa); /* Sets the change bit of a physical page */ 384 extern void mapping_clr_mod(ppnum_t pa); /* Clears the change bit of a physical page */ 385 extern unsigned int mapping_tst_refmod(ppnum_t pa); /* Tests the reference and change bits of a physical page */ 386 extern void mapping_clr_refmod(ppnum_t pa, unsigned int mask); /* Clears the reference and change bits of a physical page */ 387 extern void mapping_protect_phys(ppnum_t pa, vm_prot_t prot); /* Change protection of all mappings to page */ 388 extern void mapping_protect(pmap_t pmap, addr64_t va, vm_prot_t prot, addr64_t *nextva); /* Change protection of a single mapping to page */ 389 extern addr64_t mapping_make(pmap_t pmap, addr64_t va, ppnum_t pa, unsigned int flags, unsigned int size, vm_prot_t prot); /* Make a mapping */ 390 /* Flags for mapping_make */ 391 #define mmFlgBlock 0x80000000 /* This is a block map, use size for number of pages covered */ 392 #define mmFlgUseAttr 0x40000000 /* Use specified attributes */ 393 #define mmFlgPerm 0x20000000 /* Mapping is permanant */ 394 #define mmFlgPcfg 0x07000000 /* Physical page configuration index */ 395 #define mmFlgCInhib 0x00000002 /* Cahching inhibited - use if mapFlgUseAttr set or block */ 396 #define mmFlgGuarded 0x00000001 /* Access guarded - use if mapFlgUseAttr set or block */ 397 extern void mapping_purge(ppnum_t pa); /* Remove all mappings for this physent */ 398 extern addr64_t mapping_p2v(pmap_t pmap, ppnum_t pa); /* Finds first virtual mapping of a physical page in a space */ 399 extern void mapping_drop_busy(struct mapping *mapping); /* Drops busy count on mapping */ 400 extern phys_entry_t *mapping_phys_lookup(ppnum_t pp, unsigned int *pindex); /* Finds the physical entry for the page */ 401 extern int mapalc1(struct mappingblok *mb); /* Finds and allcates a 1-bit mapping entry */ 402 extern int mapalc2(struct mappingblok *mb); /* Finds and allcates a 2-bit mapping entry */ 403 extern void ignore_zero_fault(boolean_t type); /* Sets up to ignore or honor any fault on page 0 access for the current thread */ 404 extern void mapping_hibernate_flush(void); 405 406 extern void mapping_fake_zone_info( /* return mapping usage stats as a fake zone info */ 407 int *count, 408 vm_size_t *cur_size, 409 vm_size_t *max_size, 410 vm_size_t *elem_size, 411 vm_size_t *alloc_size, 412 int *collectable, 413 int *exhaustable); 414 415 extern mapping_t *hw_rem_map(pmap_t pmap, addr64_t va, addr64_t *next); /* Remove a mapping from the system */ 416 extern mapping_t *hw_purge_map(pmap_t pmap, addr64_t va, addr64_t *next); /* Remove a regular mapping from the system */ 417 extern mapping_t *hw_purge_space(struct phys_entry *pp, pmap_t pmap); /* Remove the first mapping for a specific pmap from physentry */ 418 extern mapping_t *hw_purge_phys(struct phys_entry *pp); /* Remove the first mapping for a physentry */ 419 extern mapping_t *hw_scrub_guest(struct phys_entry *pp, pmap_t pmap); /* Scrub first guest mapping belonging to this host */ 420 extern mapping_t *hw_find_map(pmap_t pmap, addr64_t va, addr64_t *nextva); /* Finds a mapping */ 421 extern mapping_t *hw_find_space(struct phys_entry *pp, unsigned int space); /* Given a phys_entry, find its first mapping in the specified space */ 422 extern addr64_t hw_add_map(pmap_t pmap, struct mapping *mp); /* Add a mapping to a pmap */ 423 extern unsigned int hw_protect(pmap_t pmap, addr64_t va, vm_prot_t prot, addr64_t *nextva); /* Change the protection of a virtual page */ 424 extern unsigned int hw_test_rc(pmap_t pmap, addr64_t va, boolean_t reset); /* Test and optionally reset the RC bit of specific mapping */ 425 426 extern unsigned int hw_clear_maps(void); 427 428 extern unsigned int hw_walk_phys(struct phys_entry *pp, unsigned int preop, unsigned int op, /* Perform function on all mappings on a physical page */ 429 unsigned int postop, unsigned int parm, unsigned int opmod); 430 /* Opcodes for hw_walk_phys */ 431 #define hwpNoop 0 /* No operation */ 432 #define hwpSPrtPhy 1 /* Sets protection in physent (obsolete) */ 433 #define hwpSPrtMap 2 /* Sets protection in mapping */ 434 #define hwpSAtrPhy 3 /* Sets attributes in physent */ 435 #define hwpSAtrMap 4 /* Sets attributes in mapping */ 436 #define hwpCRefPhy 5 /* Clears reference in physent */ 437 #define hwpCRefMap 6 /* Clears reference in mapping */ 438 #define hwpCCngPhy 7 /* Clears change in physent */ 439 #define hwpCCngMap 8 /* Clears change in mapping */ 440 #define hwpSRefPhy 9 /* Sets reference in physent */ 441 #define hwpSRefMap 10 /* Sets reference in mapping */ 442 #define hwpSCngPhy 11 /* Sets change in physent */ 443 #define hwpSCngMap 12 /* Sets change in mapping */ 444 #define hwpTRefPhy 13 /* Tests reference in physent */ 445 #define hwpTRefMap 14 /* Tests reference in mapping */ 446 #define hwpTCngPhy 15 /* Tests change in physent */ 447 #define hwpTCngMap 16 /* Tests change in mapping */ 448 #define hwpTRefCngPhy 17 /* Tests reference and change in physent */ 449 #define hwpTRefCngMap 18 /* Tests reference and change in mapping */ 450 #define hwpCRefCngPhy 19 /* Clears reference and change in physent */ 451 #define hwpCRefCngMap 20 /* Clears reference and change in mapping */ 452 /* Operation modifiers for connected PTE visits for hw_walk_phys */ 453 #define hwpPurgePTE 0 /* Invalidate/purge PTE and merge RC bits for each connected mapping */ 454 #define hwpMergePTE 1 /* Merge RC bits for each connected mapping */ 455 #define hwpNoopPTE 2 /* Take no additional action for each connected mapping */ 456 457 extern void hw_set_user_space(pmap_t pmap); /* Indicate we need a space switch */ 458 extern void hw_set_user_space_dis(pmap_t pmap); /* Indicate we need a space switch (already disabled) */ 459 extern void hw_setup_trans(void); /* Setup hardware for translation */ 460 extern void hw_start_trans(void); /* Start translation for the first time */ 461 extern void hw_map_seg(pmap_t pmap, addr64_t seg, addr64_t va); /* Validate a segment */ 462 extern void hw_blow_seg(addr64_t seg); /* Invalidate a segment */ 463 extern void invalidateSegs(pmap_t pmap); /* Invalidate the segment cache */ 464 extern struct phys_entry *pmap_find_physentry(ppnum_t pa); 465 extern void mapLog(unsigned int laddr, unsigned int type, addr64_t va); 466 extern unsigned int mapSkipListVerifyC(pmap_t pmap, unsigned long long *dumpa); 467 extern void fillPage(ppnum_t pa, unsigned int fill); 468 extern kern_return_t hw_copypv_32(addr64_t source, addr64_t sink, unsigned int size, int which); 469 470 extern void hw_rem_all_gv(pmap_t pmap); /* Remove all of a guest's mappings */ 471 extern void hw_rem_local_gv(pmap_t gpmap); /* Remove guest local mappings */ 472 extern unsigned int hw_res_map_gv(pmap_t hpmap, pmap_t gpmap, addr64_t hva, addr64_t gva, vm_prot_t prot); 473 /* Resume a guest mapping */ 474 extern void hw_add_map_gv(pmap_t hpmap, pmap_t gpmap, addr64_t gva, unsigned int mflags, ppnum_t pa); 475 /* Add a guest mapping */ 476 extern void hw_susp_map_gv(pmap_t hpmap, pmap_t gpmap, addr64_t gva); 477 /* Suspend a guest mapping */ 478 extern unsigned int hw_test_rc_gv(pmap_t hpmap, pmap_t gpmap, addr64_t gva, unsigned int reset); 479 /* Test/reset mapping ref and chg */ 480 extern unsigned int hw_protect_gv(pmap_t gpmap, addr64_t va, vm_prot_t prot); 481 /* Change the protection of a guest page */ 482 extern addr64_t hw_gva_to_hva(pmap_t gpmap, addr64_t gva); /* Convert guest to host virtual address */ 483 extern unsigned int hw_find_map_gv(pmap_t gpmap, addr64_t gva, void *mpbuf); 484 /* Find and copy guest mapping into buffer */ 485 486 extern unsigned int mappingdeb0; /* (TEST/DEBUG) */ 487 extern unsigned int incrVSID; /* VSID increment value */ 488 489 extern int mapSetLists(pmap_t); 490 extern void consider_mapping_adjust(void); 491 492 #endif /* _PPC_MAPPINGS_H_ */ 493 494 #endif /* XNU_KERNEL_PRIVATE */
Cache object: 1f165aa1009295bc4f99f276ab011800
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]