osfmk/vm/pmap.h

   1 /*
   2  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_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
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30 /*
  31  * @OSF_COPYRIGHT@
  32  */
  33 /*
  34  * Mach Operating System
  35  * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
  36  * All Rights Reserved.
  37  *
  38  * Permission to use, copy, modify and distribute this software and its
  39  * documentation is hereby granted, provided that both the copyright
  40  * notice and this permission notice appear in all copies of the
  41  * software, derivative works or modified versions, and any portions
  42  * thereof, and that both notices appear in supporting documentation.
  43  *
  44  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  45  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  46  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  47  *
  48  * Carnegie Mellon requests users of this software to return to
  49  *
  50  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  51  *  School of Computer Science
  52  *  Carnegie Mellon University
  53  *  Pittsburgh PA 15213-3890
  54  *
  55  * any improvements or extensions that they make and grant Carnegie Mellon
  56  * the rights to redistribute these changes.
  57  */
  58 /*
  59  */
  60 /*
  61  *      File:   vm/pmap.h
  62  *      Author: Avadis Tevanian, Jr.
  63  *      Date:   1985
  64  *
  65  *      Machine address mapping definitions -- machine-independent
  66  *      section.  [For machine-dependent section, see "machine/pmap.h".]
  67  */
  68
  69 #ifndef _VM_PMAP_H_
  70 #define _VM_PMAP_H_
  71
  72 #include <mach/kern_return.h>
  73 #include <mach/vm_param.h>
  74 #include <mach/vm_types.h>
  75 #include <mach/vm_attributes.h>
  76 #include <mach/boolean.h>
  77 #include <mach/vm_prot.h>
  78
  79 #ifdef  KERNEL_PRIVATE
  80
  81 /*
  82  *      The following is a description of the interface to the
  83  *      machine-dependent "physical map" data structure.  The module
  84  *      must provide a "pmap_t" data type that represents the
  85  *      set of valid virtual-to-physical addresses for one user
  86  *      address space.  [The kernel address space is represented
  87  *      by a distinguished "pmap_t".]  The routines described manage
  88  *      this type, install and update virtual-to-physical mappings,
  89  *      and perform operations on physical addresses common to
  90  *      many address spaces.
  91  */
  92
  93 /* Copy between a physical page and a virtual address */
  94 /* LP64todo - switch to vm_map_offset_t when it grows */
  95 extern kern_return_t    copypv(
  96                                 addr64_t source,
  97                                 addr64_t sink,
  98                                 unsigned int size,
  99                                 int which);
 100 #define cppvPsnk        1
 101 #define cppvPsnkb      31
 102 #define cppvPsrc        2
 103 #define cppvPsrcb      30
 104 #define cppvFsnk        4
 105 #define cppvFsnkb      29
 106 #define cppvFsrc        8
 107 #define cppvFsrcb      28
 108 #define cppvNoModSnk   16
 109 #define cppvNoModSnkb  27
 110 #define cppvNoRefSrc   32
 111 #define cppvNoRefSrcb  26
 112 #define cppvKmap       64       /* Use the kernel's vm_map */
 113 #define cppvKmapb      25
 114
 115 #ifdef  MACH_KERNEL_PRIVATE
 116
 117 #include <machine/pmap.h>
 118
 119 /*
 120  *      Routines used for initialization.
 121  *      There is traditionally also a pmap_bootstrap,
 122  *      used very early by machine-dependent code,
 123  *      but it is not part of the interface.
 124  *
 125  *      LP64todo -
 126  *      These interfaces are tied to the size of the
 127  *      kernel pmap - and therefore use the "local"
 128  *      vm_offset_t, etc... types.
 129  */
 130
 131 extern void             *pmap_steal_memory(vm_size_t size);
 132                                                 /* During VM initialization,
 133                                                  * steal a chunk of memory.
 134                                                  */
 135 extern unsigned int     pmap_free_pages(void);  /* During VM initialization,
 136                                                  * report remaining unused
 137                                                  * physical pages.
 138                                                  */
 139 extern void             pmap_startup(
 140                                 vm_offset_t *startp,
 141                                 vm_offset_t *endp);
 142                                                 /* During VM initialization,
 143                                                  * use remaining physical pages
 144                                                  * to allocate page frames.
 145                                                  */
 146 extern void             pmap_init(void);        /* Initialization,
 147                                                  * after kernel runs
 148                                                  * in virtual memory.
 149                                                  */
 150
 151 extern void             mapping_adjust(void);   /* Adjust free mapping count */
 152
 153 extern void             mapping_free_prime(void); /* Primes the mapping block release list */
 154
 155 #ifndef MACHINE_PAGES
 156 /*
 157  *      If machine/pmap.h defines MACHINE_PAGES, it must implement
 158  *      the above functions.  The pmap module has complete control.
 159  *      Otherwise, it must implement
 160  *              pmap_free_pages
 161  *              pmap_virtual_space
 162  *              pmap_next_page
 163  *              pmap_init
 164  *      and vm/vm_resident.c implements pmap_steal_memory and pmap_startup
 165  *      using pmap_free_pages, pmap_next_page, pmap_virtual_space,
 166  *      and pmap_enter.  pmap_free_pages may over-estimate the number
 167  *      of unused physical pages, and pmap_next_page may return FALSE
 168  *      to indicate that there are no more unused pages to return.
 169  *      However, for best performance pmap_free_pages should be accurate.
 170  */
 171
 172 extern boolean_t        pmap_next_page(ppnum_t *pnum);
 173                                                 /* During VM initialization,
 174                                                  * return the next unused
 175                                                  * physical page.
 176                                                  */
 177 extern void             pmap_virtual_space(
 178                                         vm_offset_t     *virtual_start,
 179                                         vm_offset_t     *virtual_end);
 180                                                 /* During VM initialization,
 181                                                  * report virtual space
 182                                                  * available for the kernel.
 183                                                  */
 184 #endif  /* MACHINE_PAGES */
 185
 186 /*
 187  *      Routines to manage the physical map data structure.
 188  */
 189 extern pmap_t           pmap_create(    /* Create a pmap_t. */
 190                                 vm_map_size_t   size,
 191                                 boolean_t       is_64bit);
 192 extern pmap_t           (pmap_kernel)(void);    /* Return the kernel's pmap */
 193 extern void             pmap_reference(pmap_t pmap);    /* Gain a reference. */
 194 extern void             pmap_destroy(pmap_t pmap); /* Release a reference. */
 195 extern void             pmap_switch(pmap_t);
 196
 197
 198 extern void             pmap_enter(     /* Enter a mapping */
 199                                 pmap_t          pmap,
 200                                 vm_map_offset_t v,
 201                                 ppnum_t         pn,
 202                                 vm_prot_t       prot,
 203                                 unsigned int    flags,
 204                                 boolean_t       wired);
 205
 206 extern void             pmap_remove_some_phys(
 207                                 pmap_t          pmap,
 208                                 ppnum_t         pn);
 209
 210
 211 /*
 212  *      Routines that operate on physical addresses.
 213  */
 214
 215 extern void             pmap_page_protect(      /* Restrict access to page. */
 216                                 ppnum_t phys,
 217                                 vm_prot_t       prot);
 218
 219 extern void             (pmap_zero_page)(
 220                                 ppnum_t         pn);
 221
 222 extern void             (pmap_zero_part_page)(
 223                                 ppnum_t         pn,
 224                                 vm_offset_t     offset,
 225                                 vm_size_t       len);
 226
 227 extern void             (pmap_copy_page)(
 228                                 ppnum_t         src,
 229                                 ppnum_t         dest);
 230
 231 extern void             (pmap_copy_part_page)(
 232                                 ppnum_t         src,
 233                                 vm_offset_t     src_offset,
 234                                 ppnum_t         dst,
 235                                 vm_offset_t     dst_offset,
 236                                 vm_size_t       len);
 237
 238 extern void             (pmap_copy_part_lpage)(
 239                                 vm_offset_t     src,
 240                                 ppnum_t         dst,
 241                                 vm_offset_t     dst_offset,
 242                                 vm_size_t       len);
 243
 244 extern void             (pmap_copy_part_rpage)(
 245                                 ppnum_t         src,
 246                                 vm_offset_t     src_offset,
 247                                 vm_offset_t     dst,
 248                                 vm_size_t       len);
 249
 250 extern unsigned int (pmap_disconnect)(  /* disconnect mappings and return reference and change */
 251                                 ppnum_t         phys);
 252
 253 extern kern_return_t    (pmap_attribute_cache_sync)(  /* Flush appropriate
 254                                                        * cache based on
 255                                                        * page number sent */
 256                                 ppnum_t         pn,
 257                                 vm_size_t       size,
 258                                 vm_machine_attribute_t attribute,
 259                                 vm_machine_attribute_val_t* value);
 260
 261 extern unsigned int     (pmap_cache_attributes)(
 262                                 ppnum_t         pn);
 263
 264 /*
 265  * debug/assertions. pmap_verify_free returns true iff
 266  * the given physical page is mapped into no pmap.
 267  */
 268 extern boolean_t        pmap_verify_free(ppnum_t pn);
 269
 270 /*
 271  *      Statistics routines
 272  */
 273 extern int              (pmap_resident_count)(pmap_t pmap);
 274
 275 /*
 276  *      Sundry required (internal) routines
 277  */
 278 extern void             pmap_collect(pmap_t pmap);/* Perform garbage
 279                                                  * collection, if any */
 280
 281 /*
 282  *      Optional routines
 283  */
 284 extern void             (pmap_copy)(            /* Copy range of mappings,
 285                                                  * if desired. */
 286                                 pmap_t          dest,
 287                                 pmap_t          source,
 288                                 vm_map_offset_t dest_va,
 289                                 vm_map_size_t   size,
 290                                 vm_map_offset_t source_va);
 291
 292 extern kern_return_t    (pmap_attribute)(       /* Get/Set special memory
 293                                                  * attributes */
 294                                 pmap_t          pmap,
 295                                 vm_map_offset_t va,
 296                                 vm_map_size_t   size,
 297                                 vm_machine_attribute_t  attribute,
 298                                 vm_machine_attribute_val_t* value);
 299
 300 /*
 301  * Routines defined as macros.
 302  */
 303 #ifndef PMAP_ACTIVATE_USER
 304 #ifndef PMAP_ACTIVATE
 305 #define PMAP_ACTIVATE_USER(thr, cpu)
 306 #else   /* PMAP_ACTIVATE */
 307 #define PMAP_ACTIVATE_USER(thr, cpu) {                  \
 308         pmap_t  pmap;                                           \
 309                                                                 \
 310         pmap = (thr)->map->pmap;                                \
 311         if (pmap != pmap_kernel())                              \
 312                 PMAP_ACTIVATE(pmap, (thr), (cpu));              \
 313 }
 314 #endif  /* PMAP_ACTIVATE */
 315 #endif  /* PMAP_ACTIVATE_USER */
 316
 317 #ifndef PMAP_DEACTIVATE_USER
 318 #ifndef PMAP_DEACTIVATE
 319 #define PMAP_DEACTIVATE_USER(thr, cpu)
 320 #else   /* PMAP_DEACTIVATE */
 321 #define PMAP_DEACTIVATE_USER(thr, cpu) {                        \
 322         pmap_t  pmap;                                           \
 323                                                                 \
 324         pmap = (thr)->map->pmap;                                \
 325         if ((pmap) != pmap_kernel())                    \
 326                 PMAP_DEACTIVATE(pmap, (thr), (cpu));    \
 327 }
 328 #endif  /* PMAP_DEACTIVATE */
 329 #endif  /* PMAP_DEACTIVATE_USER */
 330
 331 #ifndef PMAP_ACTIVATE_KERNEL
 332 #ifndef PMAP_ACTIVATE
 333 #define PMAP_ACTIVATE_KERNEL(cpu)
 334 #else   /* PMAP_ACTIVATE */
 335 #define PMAP_ACTIVATE_KERNEL(cpu)                       \
 336                 PMAP_ACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
 337 #endif  /* PMAP_ACTIVATE */
 338 #endif  /* PMAP_ACTIVATE_KERNEL */
 339
 340 #ifndef PMAP_DEACTIVATE_KERNEL
 341 #ifndef PMAP_DEACTIVATE
 342 #define PMAP_DEACTIVATE_KERNEL(cpu)
 343 #else   /* PMAP_DEACTIVATE */
 344 #define PMAP_DEACTIVATE_KERNEL(cpu)                     \
 345                 PMAP_DEACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
 346 #endif  /* PMAP_DEACTIVATE */
 347 #endif  /* PMAP_DEACTIVATE_KERNEL */
 348
 349 #ifndef PMAP_ENTER
 350 /*
 351  *      Macro to be used in place of pmap_enter()
 352  */
 353 #define PMAP_ENTER(pmap, virtual_address, page, protection, flags, wired) \
 354         MACRO_BEGIN                                                     \
 355         pmap_t          __pmap = (pmap);                                \
 356         vm_page_t       __page = (page);                                \
 357                                                                         \
 358         if (__pmap != kernel_pmap) {                                    \
 359                 ASSERT_PAGE_DECRYPTED(__page);                          \
 360         }                                                               \
 361         pmap_enter(__pmap,                                              \
 362                    (virtual_address),                                   \
 363                    __page->phys_page,                                   \
 364                    (protection) & ~__page->page_lock,                   \
 365                    (flags),                                             \
 366                    (wired));                                            \
 367         MACRO_END
 368 #endif  /* !PMAP_ENTER */
 369
 370 /*
 371  *      Routines to manage reference/modify bits based on
 372  *      physical addresses, simulating them if not provided
 373  *      by the hardware.
 374  */
 375                                 /* Clear reference bit */
 376 extern void             pmap_clear_reference(ppnum_t     pn);
 377                                 /* Return reference bit */
 378 extern boolean_t        (pmap_is_referenced)(ppnum_t     pn);
 379                                 /* Set modify bit */
 380 extern void             pmap_set_modify(ppnum_t  pn);
 381                                 /* Clear modify bit */
 382 extern void             pmap_clear_modify(ppnum_t pn);
 383                                 /* Return modify bit */
 384 extern boolean_t        pmap_is_modified(ppnum_t pn);
 385                                 /* Return modified and referenced bits */
 386 extern unsigned int pmap_get_refmod(ppnum_t pn);
 387                                 /* Clear modified and referenced bits */
 388 extern void                     pmap_clear_refmod(ppnum_t pn, unsigned int mask);
 389 #define VM_MEM_MODIFIED         0x01    /* Modified bit */
 390 #define VM_MEM_REFERENCED       0x02    /* Referenced bit */
 391
 392 /*
 393  *      Routines that operate on ranges of virtual addresses.
 394  */
 395 extern void             pmap_protect(   /* Change protections. */
 396                                 pmap_t          map,
 397                                 vm_map_offset_t s,
 398                                 vm_map_offset_t e,
 399                                 vm_prot_t       prot);
 400
 401 extern void             (pmap_pageable)(
 402                                 pmap_t          pmap,
 403                                 vm_map_offset_t start,
 404                                 vm_map_offset_t end,
 405                                 boolean_t       pageable);
 406
 407 #endif  /* MACH_KERNEL_PRIVATE */
 408
 409 /*
 410  * JMM - This portion is exported to other kernel components right now,
 411  * but will be pulled back in the future when the needed functionality
 412  * is provided in a cleaner manner.
 413  */
 414
 415 extern pmap_t   kernel_pmap;                    /* The kernel's map */
 416 #define         pmap_kernel()   (kernel_pmap)
 417
 418 /* machine independent WIMG bits */
 419
 420 #define VM_MEM_GUARDED          0x1             /* (G) Guarded Storage */
 421 #define VM_MEM_COHERENT         0x2             /* (M) Memory Coherency */
 422 #define VM_MEM_NOT_CACHEABLE    0x4             /* (I) Cache Inhibit */
 423 #define VM_MEM_WRITE_THROUGH    0x8             /* (W) Write-Through */
 424
 425 #define VM_WIMG_MASK            0xFF
 426 #define VM_WIMG_USE_DEFAULT     0x80000000
 427
 428 extern void             pmap_modify_pages(      /* Set modify bit for pages */
 429                                 pmap_t          map,
 430                                 vm_map_offset_t s,
 431                                 vm_map_offset_t e);
 432
 433 extern vm_offset_t      pmap_extract(pmap_t pmap,
 434                                 vm_map_offset_t va);
 435
 436 extern void             pmap_change_wiring(     /* Specify pageability */
 437                                 pmap_t          pmap,
 438                                 vm_map_offset_t va,
 439                                 boolean_t       wired);
 440
 441 /* LP64todo - switch to vm_map_offset_t when it grows */
 442 extern void             pmap_remove(    /* Remove mappings. */
 443                                 pmap_t          map,
 444                                 addr64_t        s,
 445                                 addr64_t        e);
 446
 447
 448 #endif  /* KERNEL_PRIVATE */
 449
 450 #endif  /* _VM_PMAP_H_ */