osfmk/vm/pmap.h

   1 /*
   2  * Copyright (c) 2000 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  * @OSF_COPYRIGHT@
  24  */
  25 /*
  26  * Mach Operating System
  27  * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
  28  * All Rights Reserved.
  29  *
  30  * Permission to use, copy, modify and distribute this software and its
  31  * documentation is hereby granted, provided that both the copyright
  32  * notice and this permission notice appear in all copies of the
  33  * software, derivative works or modified versions, and any portions
  34  * thereof, and that both notices appear in supporting documentation.
  35  *
  36  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  37  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  38  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  39  *
  40  * Carnegie Mellon requests users of this software to return to
  41  *
  42  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  43  *  School of Computer Science
  44  *  Carnegie Mellon University
  45  *  Pittsburgh PA 15213-3890
  46  *
  47  * any improvements or extensions that they make and grant Carnegie Mellon
  48  * the rights to redistribute these changes.
  49  */
  50 /*
  51  */
  52 /*
  53  *      File:   vm/pmap.h
  54  *      Author: Avadis Tevanian, Jr.
  55  *      Date:   1985
  56  *
  57  *      Machine address mapping definitions -- machine-independent
  58  *      section.  [For machine-dependent section, see "machine/pmap.h".]
  59  */
  60
  61 #ifndef _VM_PMAP_H_
  62 #define _VM_PMAP_H_
  63
  64 #include <mach/kern_return.h>
  65 #include <mach/vm_param.h>
  66 #include <mach/vm_types.h>
  67 #include <mach/vm_attributes.h>
  68 #include <mach/boolean.h>
  69 #include <mach/vm_prot.h>
  70
  71 /*
  72  *      The following is a description of the interface to the
  73  *      machine-dependent "physical map" data structure.  The module
  74  *      must provide a "pmap_t" data type that represents the
  75  *      set of valid virtual-to-physical addresses for one user
  76  *      address space.  [The kernel address space is represented
  77  *      by a distinguished "pmap_t".]  The routines described manage
  78  *      this type, install and update virtual-to-physical mappings,
  79  *      and perform operations on physical addresses common to
  80  *      many address spaces.
  81  */
  82
  83 #ifndef MACH_KERNEL_PRIVATE
  84
  85 typedef void *pmap_t;
  86
  87 #else /* MACH_KERNEL_PRIVATE */
  88
  89 typedef struct pmap *pmap_t;
  90
  91 #include <machine/pmap.h>
  92
  93 /*
  94  *      Routines used for initialization.
  95  *      There is traditionally also a pmap_bootstrap,
  96  *      used very early by machine-dependent code,
  97  *      but it is not part of the interface.
  98  */
  99
 100 extern vm_offset_t      pmap_steal_memory(vm_size_t size);
 101                                                 /* During VM initialization,
 102                                                  * steal a chunk of memory.
 103                                                  */
 104 extern unsigned int     pmap_free_pages(void);  /* During VM initialization,
 105                                                  * report remaining unused
 106                                                  * physical pages.
 107                                                  */
 108 extern void             pmap_startup(
 109                                 vm_offset_t *startp,
 110                                 vm_offset_t *endp);
 111                                                 /* During VM initialization,
 112                                                  * use remaining physical pages
 113                                                  * to allocate page frames.
 114                                                  */
 115 extern void             pmap_init(void);        /* Initialization,
 116                                                  * after kernel runs
 117                                                  * in virtual memory.
 118                                                  */
 119
 120 #ifndef MACHINE_PAGES
 121 /*
 122  *      If machine/pmap.h defines MACHINE_PAGES, it must implement
 123  *      the above functions.  The pmap module has complete control.
 124  *      Otherwise, it must implement
 125  *              pmap_free_pages
 126  *              pmap_virtual_space
 127  *              pmap_next_page
 128  *              pmap_init
 129  *      and vm/vm_resident.c implements pmap_steal_memory and pmap_startup
 130  *      using pmap_free_pages, pmap_next_page, pmap_virtual_space,
 131  *      and pmap_enter.  pmap_free_pages may over-estimate the number
 132  *      of unused physical pages, and pmap_next_page may return FALSE
 133  *      to indicate that there are no more unused pages to return.
 134  *      However, for best performance pmap_free_pages should be accurate.
 135  */
 136
 137 extern boolean_t        pmap_next_page(vm_offset_t *paddr);
 138                                                 /* During VM initialization,
 139                                                  * return the next unused
 140                                                  * physical page.
 141                                                  */
 142 extern void             pmap_virtual_space(
 143                                         vm_offset_t     *virtual_start,
 144                                         vm_offset_t     *virtual_end);
 145                                                 /* During VM initialization,
 146                                                  * report virtual space
 147                                                  * available for the kernel.
 148                                                  */
 149 #endif  /* MACHINE_PAGES */
 150
 151 /*
 152  *      Routines to manage the physical map data structure.
 153  */
 154 extern pmap_t           pmap_create(vm_size_t size);    /* Create a pmap_t. */
 155 extern pmap_t           (pmap_kernel)(void);    /* Return the kernel's pmap */
 156 extern void             pmap_reference(pmap_t pmap);    /* Gain a reference. */
 157 extern void             pmap_destroy(pmap_t pmap); /* Release a reference. */
 158 extern void             pmap_switch(pmap_t);
 159
 160
 161 extern void             pmap_enter(     /* Enter a mapping */
 162                                 pmap_t          pmap,
 163                                 vm_offset_t     v,
 164                                 vm_offset_t     pa,
 165                                 vm_prot_t       prot,
 166                                 boolean_t       wired);
 167
 168 extern void             pmap_remove_some_phys(
 169                                 pmap_t          pmap,
 170                                 vm_offset_t     pa);
 171
 172
 173 /*
 174  *      Routines that operate on physical addresses.
 175  */
 176
 177 extern void             pmap_page_protect(      /* Restrict access to page. */
 178                                 vm_offset_t     phys,
 179                                 vm_prot_t       prot);
 180
 181 extern void             (pmap_zero_page)(
 182                                 vm_offset_t     phys);
 183
 184 extern void             (pmap_zero_part_page)(
 185                                 vm_offset_t     p,
 186                                 vm_offset_t     offset,
 187                                 vm_size_t       len);
 188
 189 extern void             (pmap_copy_page)(
 190                                 vm_offset_t     src,
 191                                 vm_offset_t     dest);
 192
 193 extern void             (pmap_copy_part_page)(
 194                                 vm_offset_t     src,
 195                                 vm_offset_t     src_offset,
 196                                 vm_offset_t     dst,
 197                                 vm_offset_t     dst_offset,
 198                                 vm_size_t       len);
 199
 200 extern void             (pmap_copy_part_lpage)(
 201                                 vm_offset_t     src,
 202                                 vm_offset_t     dst,
 203                                 vm_offset_t     dst_offset,
 204                                 vm_size_t       len);
 205
 206 extern void             (pmap_copy_part_rpage)(
 207                                 vm_offset_t     src,
 208                                 vm_offset_t     src_offset,
 209                                 vm_offset_t     dst,
 210                                 vm_size_t       len);
 211
 212 /*
 213  * debug/assertions. pmap_verify_free returns true iff
 214  * the given physical page is mapped into no pmap.
 215  */
 216 extern boolean_t        pmap_verify_free(vm_offset_t paddr);
 217
 218 /*
 219  *      Statistics routines
 220  */
 221 extern int              (pmap_resident_count)(pmap_t pmap);
 222
 223 /*
 224  *      Sundry required (internal) routines
 225  */
 226 extern void             pmap_collect(pmap_t pmap);/* Perform garbage
 227                                                  * collection, if any */
 228
 229
 230 extern vm_offset_t      (pmap_phys_address)(    /* Transform address returned
 231                                                  * by device driver mapping
 232                                                  * function to physical address
 233                                                  * known to this module.  */
 234                                 int             frame);
 235
 236 extern int              (pmap_phys_to_frame)(   /* Inverse of pmap_phys_addess,
 237                                                  * for use by device driver
 238                                                  * mapping function in
 239                                                  * machine-independent
 240                                                  * pseudo-devices.  */
 241                                 vm_offset_t     phys);
 242
 243 /*
 244  *      Optional routines
 245  */
 246 extern void             (pmap_copy)(            /* Copy range of mappings,
 247                                                  * if desired. */
 248                                 pmap_t          dest,
 249                                 pmap_t          source,
 250                                 vm_offset_t     dest_va,
 251                                 vm_size_t       size,
 252                                 vm_offset_t     source_va);
 253
 254 extern kern_return_t    (pmap_attribute)(       /* Get/Set special memory
 255                                                  * attributes */
 256                                 pmap_t          pmap,
 257                                 vm_offset_t     va,
 258                                 vm_size_t       size,
 259                                 vm_machine_attribute_t  attribute,
 260                                 vm_machine_attribute_val_t* value);
 261
 262 /*
 263  * Routines defined as macros.
 264  */
 265 #ifndef PMAP_ACTIVATE_USER
 266 #define PMAP_ACTIVATE_USER(act, cpu) {                          \
 267         pmap_t  pmap;                                           \
 268                                                                 \
 269         pmap = (act)->map->pmap;                                \
 270         if (pmap != pmap_kernel())                              \
 271                 PMAP_ACTIVATE(pmap, (act), (cpu));              \
 272 }
 273 #endif  /* PMAP_ACTIVATE_USER */
 274
 275 #ifndef PMAP_DEACTIVATE_USER
 276 #define PMAP_DEACTIVATE_USER(act, cpu) {                        \
 277         pmap_t  pmap;                                           \
 278                                                                 \
 279         pmap = (act)->map->pmap;                                \
 280         if ((pmap) != pmap_kernel())                            \
 281                 PMAP_DEACTIVATE(pmap, (act), (cpu));            \
 282 }
 283 #endif  /* PMAP_DEACTIVATE_USER */
 284
 285 #ifndef PMAP_ACTIVATE_KERNEL
 286 #define PMAP_ACTIVATE_KERNEL(cpu)                       \
 287                 PMAP_ACTIVATE(pmap_kernel(), THR_ACT_NULL, cpu)
 288 #endif  /* PMAP_ACTIVATE_KERNEL */
 289
 290 #ifndef PMAP_DEACTIVATE_KERNEL
 291 #define PMAP_DEACTIVATE_KERNEL(cpu)                     \
 292                 PMAP_DEACTIVATE(pmap_kernel(), THR_ACT_NULL, cpu)
 293 #endif  /* PMAP_DEACTIVATE_KERNEL */
 294
 295 #ifndef PMAP_ENTER
 296 /*
 297  *      Macro to be used in place of pmap_enter()
 298  */
 299 #define PMAP_ENTER(pmap, virtual_address, page, protection, wired) \
 300                 MACRO_BEGIN                                     \
 301                 pmap_enter(                                     \
 302                         (pmap),                                 \
 303                         (virtual_address),                      \
 304                         (page)->phys_addr,                      \
 305                         (protection) & ~(page)->page_lock,      \
 306                         (wired)                                 \
 307                  );                                             \
 308                 MACRO_END
 309 #endif  /* !PMAP_ENTER */
 310
 311 #endif /* MACH_KERNEL_PRIVATE */
 312
 313 /*
 314  * JMM - This portion is exported to other kernel components right now,
 315  * but will be pulled back in the future when the needed functionality
 316  * is provided in a cleaner manner.
 317  */
 318
 319 #define PMAP_NULL  ((pmap_t) 0)
 320
 321 extern pmap_t   kernel_pmap;                    /* The kernel's map */
 322 #define         pmap_kernel()   (kernel_pmap)
 323
 324 /*
 325  *      Routines to manage reference/modify bits based on
 326  *      physical addresses, simulating them if not provided
 327  *      by the hardware.
 328  */
 329                                 /* Clear reference bit */
 330 extern void             pmap_clear_reference(vm_offset_t paddr);
 331                                 /* Return reference bit */
 332 extern boolean_t        (pmap_is_referenced)(vm_offset_t paddr);
 333                                 /* Set modify bit */
 334 extern void             pmap_set_modify(vm_offset_t paddr);
 335                                 /* Clear modify bit */
 336 extern void             pmap_clear_modify(vm_offset_t paddr);
 337                                 /* Return modify bit */
 338 extern boolean_t        pmap_is_modified(vm_offset_t paddr);
 339
 340 /*
 341  *      Routines that operate on ranges of virtual addresses.
 342  */
 343 extern void             pmap_remove(    /* Remove mappings. */
 344                                 pmap_t          map,
 345                                 vm_offset_t     s,
 346                                 vm_offset_t     e);
 347
 348 extern void             pmap_protect(   /* Change protections. */
 349                                 pmap_t          map,
 350                                 vm_offset_t     s,
 351                                 vm_offset_t     e,
 352                                 vm_prot_t       prot);
 353
 354 extern void             (pmap_pageable)(
 355                                 pmap_t          pmap,
 356                                 vm_offset_t     start,
 357                                 vm_offset_t     end,
 358                                 boolean_t       pageable);
 359
 360 extern void             pmap_modify_pages(      /* Set modify bit for pages */
 361                                 pmap_t          map,
 362                                 vm_offset_t     s,
 363                                 vm_offset_t     e);
 364
 365 extern vm_offset_t      pmap_extract(pmap_t pmap,
 366                                 vm_offset_t va);
 367
 368 extern void             pmap_change_wiring(     /* Specify pageability */
 369                                 pmap_t          pmap,
 370                                 vm_offset_t     va,
 371                                 boolean_t       wired);
 372 #endif  /* _VM_PMAP_H_ */