osfmk/ppc/mappings.h

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