sys/arm64/arm64/pmap.c

   1 /*-
   2  * Copyright (c) 1991 Regents of the University of California.
   3  * All rights reserved.
   4  * Copyright (c) 1994 John S. Dyson
   5  * All rights reserved.
   6  * Copyright (c) 1994 David Greenman
   7  * All rights reserved.
   8  * Copyright (c) 2003 Peter Wemm
   9  * All rights reserved.
  10  * Copyright (c) 2005-2010 Alan L. Cox <alc@cs.rice.edu>
  11  * All rights reserved.
  12  * Copyright (c) 2014 Andrew Turner
  13  * All rights reserved.
  14  * Copyright (c) 2014-2016 The FreeBSD Foundation
  15  * All rights reserved.
  16  *
  17  * This code is derived from software contributed to Berkeley by
  18  * the Systems Programming Group of the University of Utah Computer
  19  * Science Department and William Jolitz of UUNET Technologies Inc.
  20  *
  21  * This software was developed by Andrew Turner under sponsorship from
  22  * the FreeBSD Foundation.
  23  *
  24  * Redistribution and use in source and binary forms, with or without
  25  * modification, are permitted provided that the following conditions
  26  * are met:
  27  * 1. Redistributions of source code must retain the above copyright
  28  *    notice, this list of conditions and the following disclaimer.
  29  * 2. Redistributions in binary form must reproduce the above copyright
  30  *    notice, this list of conditions and the following disclaimer in the
  31  *    documentation and/or other materials provided with the distribution.
  32  * 3. All advertising materials mentioning features or use of this software
  33  *    must display the following acknowledgement:
  34  *      This product includes software developed by the University of
  35  *      California, Berkeley and its contributors.
  36  * 4. Neither the name of the University nor the names of its contributors
  37  *    may be used to endorse or promote products derived from this software
  38  *    without specific prior written permission.
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  *      from:   @(#)pmap.c      7.7 (Berkeley)  5/12/91
  53  */
  54 /*-
  55  * Copyright (c) 2003 Networks Associates Technology, Inc.
  56  * All rights reserved.
  57  *
  58  * This software was developed for the FreeBSD Project by Jake Burkholder,
  59  * Safeport Network Services, and Network Associates Laboratories, the
  60  * Security Research Division of Network Associates, Inc. under
  61  * DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA
  62  * CHATS research program.
  63  *
  64  * Redistribution and use in source and binary forms, with or without
  65  * modification, are permitted provided that the following conditions
  66  * are met:
  67  * 1. Redistributions of source code must retain the above copyright
  68  *    notice, this list of conditions and the following disclaimer.
  69  * 2. Redistributions in binary form must reproduce the above copyright
  70  *    notice, this list of conditions and the following disclaimer in the
  71  *    documentation and/or other materials provided with the distribution.
  72  *
  73  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  74  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  75  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  76  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  77  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  78  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  79  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  80  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  81  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  82  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  83  * SUCH DAMAGE.
  84  */
  85
  86 #include <sys/cdefs.h>
  87 __FBSDID("$FreeBSD$");
  88
  89 /*
  90  *      Manages physical address maps.
  91  *
  92  *      Since the information managed by this module is
  93  *      also stored by the logical address mapping module,
  94  *      this module may throw away valid virtual-to-physical
  95  *      mappings at almost any time.  However, invalidations
  96  *      of virtual-to-physical mappings must be done as
  97  *      requested.
  98  *
  99  *      In order to cope with hardware architectures which
 100  *      make virtual-to-physical map invalidates expensive,
 101  *      this module may delay invalidate or reduced protection
 102  *      operations until such time as they are actually
 103  *      necessary.  This module is given full information as
 104  *      to which processors are currently using which maps,
 105  *      and to when physical maps must be made correct.
 106  */
 107
 108 #include "opt_vm.h"
 109
 110 #include <sys/param.h>
 111 #include <sys/bitstring.h>
 112 #include <sys/bus.h>
 113 #include <sys/systm.h>
 114 #include <sys/kernel.h>
 115 #include <sys/ktr.h>
 116 #include <sys/limits.h>
 117 #include <sys/lock.h>
 118 #include <sys/malloc.h>
 119 #include <sys/mman.h>
 120 #include <sys/msgbuf.h>
 121 #include <sys/mutex.h>
 122 #include <sys/proc.h>
 123 #include <sys/rwlock.h>
 124 #include <sys/sbuf.h>
 125 #include <sys/sx.h>
 126 #include <sys/vmem.h>
 127 #include <sys/vmmeter.h>
 128 #include <sys/sched.h>
 129 #include <sys/sysctl.h>
 130 #include <sys/_unrhdr.h>
 131 #include <sys/smp.h>
 132
 133 #include <vm/vm.h>
 134 #include <vm/vm_param.h>
 135 #include <vm/vm_kern.h>
 136 #include <vm/vm_page.h>
 137 #include <vm/vm_map.h>
 138 #include <vm/vm_object.h>
 139 #include <vm/vm_extern.h>
 140 #include <vm/vm_pageout.h>
 141 #include <vm/vm_pager.h>
 142 #include <vm/vm_phys.h>
 143 #include <vm/vm_radix.h>
 144 #include <vm/vm_reserv.h>
 145 #include <vm/uma.h>
 146
 147 #include <machine/machdep.h>
 148 #include <machine/md_var.h>
 149 #include <machine/pcb.h>
 150
 151 #include <arm/include/physmem.h>
 152
 153 #define PMAP_ASSERT_STAGE1(pmap)        MPASS((pmap)->pm_stage == PM_STAGE1)
 154
 155 #define NL0PG           (PAGE_SIZE/(sizeof (pd_entry_t)))
 156 #define NL1PG           (PAGE_SIZE/(sizeof (pd_entry_t)))
 157 #define NL2PG           (PAGE_SIZE/(sizeof (pd_entry_t)))
 158 #define NL3PG           (PAGE_SIZE/(sizeof (pt_entry_t)))
 159
 160 #define NUL0E           L0_ENTRIES
 161 #define NUL1E           (NUL0E * NL1PG)
 162 #define NUL2E           (NUL1E * NL2PG)
 163
 164 #if !defined(DIAGNOSTIC)
 165 #ifdef __GNUC_GNU_INLINE__
 166 #define PMAP_INLINE     __attribute__((__gnu_inline__)) inline
 167 #else
 168 #define PMAP_INLINE     extern inline
 169 #endif
 170 #else
 171 #define PMAP_INLINE
 172 #endif
 173
 174 #ifdef PV_STATS
 175 #define PV_STAT(x)      do { x ; } while (0)
 176 #else
 177 #define PV_STAT(x)      do { } while (0)
 178 #endif
 179
 180 #define pmap_l2_pindex(v)       ((v) >> L2_SHIFT)
 181 #define pa_to_pvh(pa)           (&pv_table[pmap_l2_pindex(pa)])
 182
 183 #define NPV_LIST_LOCKS  MAXCPU
 184
 185 #define PHYS_TO_PV_LIST_LOCK(pa)        \
 186                         (&pv_list_locks[pa_index(pa) % NPV_LIST_LOCKS])
 187
 188 #define CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa)  do {    \
 189         struct rwlock **_lockp = (lockp);               \
 190         struct rwlock *_new_lock;                       \
 191                                                         \
 192         _new_lock = PHYS_TO_PV_LIST_LOCK(pa);           \
 193         if (_new_lock != *_lockp) {                     \
 194                 if (*_lockp != NULL)                    \
 195                         rw_wunlock(*_lockp);            \
 196                 *_lockp = _new_lock;                    \
 197                 rw_wlock(*_lockp);                      \
 198         }                                               \
 199 } while (0)
 200
 201 #define CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m)        \
 202                         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, VM_PAGE_TO_PHYS(m))
 203
 204 #define RELEASE_PV_LIST_LOCK(lockp)             do {    \
 205         struct rwlock **_lockp = (lockp);               \
 206                                                         \
 207         if (*_lockp != NULL) {                          \
 208                 rw_wunlock(*_lockp);                    \
 209                 *_lockp = NULL;                         \
 210         }                                               \
 211 } while (0)
 212
 213 #define VM_PAGE_TO_PV_LIST_LOCK(m)      \
 214                         PHYS_TO_PV_LIST_LOCK(VM_PAGE_TO_PHYS(m))
 215
 216 /*
 217  * The presence of this flag indicates that the mapping is writeable.
 218  * If the ATTR_S1_AP_RO bit is also set, then the mapping is clean, otherwise
 219  * it is dirty.  This flag may only be set on managed mappings.
 220  *
 221  * The DBM bit is reserved on ARMv8.0 but it seems we can safely treat it
 222  * as a software managed bit.
 223  */
 224 #define ATTR_SW_DBM     ATTR_DBM
 225
 226 struct pmap kernel_pmap_store;
 227
 228 /* Used for mapping ACPI memory before VM is initialized */
 229 #define PMAP_PREINIT_MAPPING_COUNT      32
 230 #define PMAP_PREINIT_MAPPING_SIZE       (PMAP_PREINIT_MAPPING_COUNT * L2_SIZE)
 231 static vm_offset_t preinit_map_va;      /* Start VA of pre-init mapping space */
 232 static int vm_initialized = 0;          /* No need to use pre-init maps when set */
 233
 234 /*
 235  * Reserve a few L2 blocks starting from 'preinit_map_va' pointer.
 236  * Always map entire L2 block for simplicity.
 237  * VA of L2 block = preinit_map_va + i * L2_SIZE
 238  */
 239 static struct pmap_preinit_mapping {
 240         vm_paddr_t      pa;
 241         vm_offset_t     va;
 242         vm_size_t       size;
 243 } pmap_preinit_mapping[PMAP_PREINIT_MAPPING_COUNT];
 244
 245 vm_offset_t virtual_avail;      /* VA of first avail page (after kernel bss) */
 246 vm_offset_t virtual_end;        /* VA of last avail page (end of kernel AS) */
 247 vm_offset_t kernel_vm_end = 0;
 248
 249 /*
 250  * Data for the pv entry allocation mechanism.
 251  */
 252 static TAILQ_HEAD(pch, pv_chunk) pv_chunks = TAILQ_HEAD_INITIALIZER(pv_chunks);
 253 static struct mtx pv_chunks_mutex;
 254 static struct rwlock pv_list_locks[NPV_LIST_LOCKS];
 255 static struct md_page *pv_table;
 256 static struct md_page pv_dummy;
 257
 258 vm_paddr_t dmap_phys_base;      /* The start of the dmap region */
 259 vm_paddr_t dmap_phys_max;       /* The limit of the dmap region */
 260 vm_offset_t dmap_max_addr;      /* The virtual address limit of the dmap */
 261
 262 /* This code assumes all L1 DMAP entries will be used */
 263 CTASSERT((DMAP_MIN_ADDRESS  & ~L0_OFFSET) == DMAP_MIN_ADDRESS);
 264 CTASSERT((DMAP_MAX_ADDRESS  & ~L0_OFFSET) == DMAP_MAX_ADDRESS);
 265
 266 #define DMAP_TABLES     ((DMAP_MAX_ADDRESS - DMAP_MIN_ADDRESS) >> L0_SHIFT)
 267 extern pt_entry_t pagetable_dmap[];
 268
 269 #define PHYSMAP_SIZE    (2 * (VM_PHYSSEG_MAX - 1))
 270 static vm_paddr_t physmap[PHYSMAP_SIZE];
 271 static u_int physmap_idx;
 272
 273 static SYSCTL_NODE(_vm, OID_AUTO, pmap, CTLFLAG_RD, 0, "VM/pmap parameters");
 274
 275 /*
 276  * This ASID allocator uses a bit vector ("asid_set") to remember which ASIDs
 277  * that it has currently allocated to a pmap, a cursor ("asid_next") to
 278  * optimize its search for a free ASID in the bit vector, and an epoch number
 279  * ("asid_epoch") to indicate when it has reclaimed all previously allocated
 280  * ASIDs that are not currently active on a processor.
 281  *
 282  * The current epoch number is always in the range [0, INT_MAX).  Negative
 283  * numbers and INT_MAX are reserved for special cases that are described
 284  * below.
 285  */
 286 static SYSCTL_NODE(_vm_pmap, OID_AUTO, asid, CTLFLAG_RD, 0, "ASID allocator");
 287 static int asid_bits;
 288 SYSCTL_INT(_vm_pmap_asid, OID_AUTO, bits, CTLFLAG_RD, &asid_bits, 0,
 289     "The number of bits in an ASID");
 290 static bitstr_t *asid_set;
 291 static int asid_set_size;
 292 static int asid_next;
 293 SYSCTL_INT(_vm_pmap_asid, OID_AUTO, next, CTLFLAG_RD, &asid_next, 0,
 294     "The last allocated ASID plus one");
 295 static int asid_epoch;
 296 SYSCTL_INT(_vm_pmap_asid, OID_AUTO, epoch, CTLFLAG_RD, &asid_epoch, 0,
 297     "The current epoch number");
 298 static struct mtx asid_set_mutex;
 299
 300 /*
 301  * A pmap's cookie encodes an ASID and epoch number.  Cookies for reserved
 302  * ASIDs have a negative epoch number, specifically, INT_MIN.  Cookies for
 303  * dynamically allocated ASIDs have a non-negative epoch number.
 304  *
 305  * An invalid ASID is represented by -1.
 306  *
 307  * There are two special-case cookie values: (1) COOKIE_FROM(-1, INT_MIN),
 308  * which indicates that an ASID should never be allocated to the pmap, and
 309  * (2) COOKIE_FROM(-1, INT_MAX), which indicates that an ASID should be
 310  * allocated when the pmap is next activated.
 311  */
 312 #define COOKIE_FROM(asid, epoch)        ((long)((u_int)(asid) | \
 313                                             ((u_long)(epoch) << 32)))
 314 #define COOKIE_TO_ASID(cookie)          ((int)(cookie))
 315 #define COOKIE_TO_EPOCH(cookie)         ((int)((u_long)(cookie) >> 32))
 316
 317 static int superpages_enabled = 1;
 318 SYSCTL_INT(_vm_pmap, OID_AUTO, superpages_enabled,
 319     CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &superpages_enabled, 0,
 320     "Are large page mappings enabled?");
 321
 322 /*
 323  * Internal flags for pmap_enter()'s helper functions.
 324  */
 325 #define PMAP_ENTER_NORECLAIM    0x1000000       /* Don't reclaim PV entries. */
 326 #define PMAP_ENTER_NOREPLACE    0x2000000       /* Don't replace mappings. */
 327
 328 static void     free_pv_chunk(struct pv_chunk *pc);
 329 static void     free_pv_entry(pmap_t pmap, pv_entry_t pv);
 330 static pv_entry_t get_pv_entry(pmap_t pmap, struct rwlock **lockp);
 331 static vm_page_t reclaim_pv_chunk(pmap_t locked_pmap, struct rwlock **lockp);
 332 static void     pmap_pvh_free(struct md_page *pvh, pmap_t pmap, vm_offset_t va);
 333 static pv_entry_t pmap_pvh_remove(struct md_page *pvh, pmap_t pmap,
 334                     vm_offset_t va);
 335
 336 static void pmap_abort_ptp(pmap_t pmap, vm_offset_t va, vm_page_t mpte);
 337 static bool pmap_activate_int(pmap_t pmap);
 338 static void pmap_alloc_asid(pmap_t pmap);
 339 static int pmap_change_attr_locked(vm_offset_t va, vm_size_t size, int mode);
 340 static pt_entry_t *pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va);
 341 static pt_entry_t *pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2,
 342     vm_offset_t va, struct rwlock **lockp);
 343 static pt_entry_t *pmap_demote_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t va);
 344 static vm_page_t pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va,
 345     vm_page_t m, vm_prot_t prot, vm_page_t mpte, struct rwlock **lockp);
 346 static int pmap_enter_l2(pmap_t pmap, vm_offset_t va, pd_entry_t new_l2,
 347     u_int flags, vm_page_t m, struct rwlock **lockp);
 348 static int pmap_remove_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t sva,
 349     pd_entry_t l1e, struct spglist *free, struct rwlock **lockp);
 350 static int pmap_remove_l3(pmap_t pmap, pt_entry_t *l3, vm_offset_t sva,
 351     pd_entry_t l2e, struct spglist *free, struct rwlock **lockp);
 352 static void pmap_reset_asid_set(void);
 353 static boolean_t pmap_try_insert_pv_entry(pmap_t pmap, vm_offset_t va,
 354     vm_page_t m, struct rwlock **lockp);
 355
 356 static vm_page_t _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex,
 357                 struct rwlock **lockp);
 358
 359 static void _pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m,
 360     struct spglist *free);
 361 static int pmap_unuse_pt(pmap_t, vm_offset_t, pd_entry_t, struct spglist *);
 362 static __inline vm_page_t pmap_remove_pt_page(pmap_t pmap, vm_offset_t va);
 363
 364 /*
 365  * These load the old table data and store the new value.
 366  * They need to be atomic as the System MMU may write to the table at
 367  * the same time as the CPU.
 368  */
 369 #define pmap_clear(table)               atomic_store_64(table, 0)
 370 #define pmap_clear_bits(table, bits)    atomic_clear_64(table, bits)
 371 #define pmap_load(table)                (*table)
 372 #define pmap_load_clear(table)          atomic_swap_64(table, 0)
 373 #define pmap_load_store(table, entry)   atomic_swap_64(table, entry)
 374 #define pmap_set_bits(table, bits)      atomic_set_64(table, bits)
 375 #define pmap_store(table, entry)        atomic_store_64(table, entry)
 376
 377 /********************/
 378 /* Inline functions */
 379 /********************/
 380
 381 static __inline void
 382 pagecopy(void *s, void *d)
 383 {
 384
 385         memcpy(d, s, PAGE_SIZE);
 386 }
 387
 388 static __inline pd_entry_t *
 389 pmap_l0(pmap_t pmap, vm_offset_t va)
 390 {
 391
 392         return (&pmap->pm_l0[pmap_l0_index(va)]);
 393 }
 394
 395 static __inline pd_entry_t *
 396 pmap_l0_to_l1(pd_entry_t *l0, vm_offset_t va)
 397 {
 398         pd_entry_t *l1;
 399
 400         l1 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l0) & ~ATTR_MASK);
 401         return (&l1[pmap_l1_index(va)]);
 402 }
 403
 404 static __inline pd_entry_t *
 405 pmap_l1(pmap_t pmap, vm_offset_t va)
 406 {
 407         pd_entry_t *l0;
 408
 409         l0 = pmap_l0(pmap, va);
 410         if ((pmap_load(l0) & ATTR_DESCR_MASK) != L0_TABLE)
 411                 return (NULL);
 412
 413         return (pmap_l0_to_l1(l0, va));
 414 }
 415
 416 static __inline pd_entry_t *
 417 pmap_l1_to_l2(pd_entry_t *l1, vm_offset_t va)
 418 {
 419         pd_entry_t *l2;
 420
 421         l2 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l1) & ~ATTR_MASK);
 422         return (&l2[pmap_l2_index(va)]);
 423 }
 424
 425 static __inline pd_entry_t *
 426 pmap_l2(pmap_t pmap, vm_offset_t va)
 427 {
 428         pd_entry_t *l1;
 429
 430         l1 = pmap_l1(pmap, va);
 431         if ((pmap_load(l1) & ATTR_DESCR_MASK) != L1_TABLE)
 432                 return (NULL);
 433
 434         return (pmap_l1_to_l2(l1, va));
 435 }
 436
 437 static __inline pt_entry_t *
 438 pmap_l2_to_l3(pd_entry_t *l2, vm_offset_t va)
 439 {
 440         pt_entry_t *l3;
 441
 442         l3 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l2) & ~ATTR_MASK);
 443         return (&l3[pmap_l3_index(va)]);
 444 }
 445
 446 /*
 447  * Returns the lowest valid pde for a given virtual address.
 448  * The next level may or may not point to a valid page or block.
 449  */
 450 static __inline pd_entry_t *
 451 pmap_pde(pmap_t pmap, vm_offset_t va, int *level)
 452 {
 453         pd_entry_t *l0, *l1, *l2, desc;
 454
 455         l0 = pmap_l0(pmap, va);
 456         desc = pmap_load(l0) & ATTR_DESCR_MASK;
 457         if (desc != L0_TABLE) {
 458                 *level = -1;
 459                 return (NULL);
 460         }
 461
 462         l1 = pmap_l0_to_l1(l0, va);
 463         desc = pmap_load(l1) & ATTR_DESCR_MASK;
 464         if (desc != L1_TABLE) {
 465                 *level = 0;
 466                 return (l0);
 467         }
 468
 469         l2 = pmap_l1_to_l2(l1, va);
 470         desc = pmap_load(l2) & ATTR_DESCR_MASK;
 471         if (desc != L2_TABLE) {
 472                 *level = 1;
 473                 return (l1);
 474         }
 475
 476         *level = 2;
 477         return (l2);
 478 }
 479
 480 /*
 481  * Returns the lowest valid pte block or table entry for a given virtual
 482  * address. If there are no valid entries return NULL and set the level to
 483  * the first invalid level.
 484  */
 485 static __inline pt_entry_t *
 486 pmap_pte(pmap_t pmap, vm_offset_t va, int *level)
 487 {
 488         pd_entry_t *l1, *l2, desc;
 489         pt_entry_t *l3;
 490
 491         l1 = pmap_l1(pmap, va);
 492         if (l1 == NULL) {
 493                 *level = 0;
 494                 return (NULL);
 495         }
 496         desc = pmap_load(l1) & ATTR_DESCR_MASK;
 497         if (desc == L1_BLOCK) {
 498                 *level = 1;
 499                 return (l1);
 500         }
 501
 502         if (desc != L1_TABLE) {
 503                 *level = 1;
 504                 return (NULL);
 505         }
 506
 507         l2 = pmap_l1_to_l2(l1, va);
 508         desc = pmap_load(l2) & ATTR_DESCR_MASK;
 509         if (desc == L2_BLOCK) {
 510                 *level = 2;
 511                 return (l2);
 512         }
 513
 514         if (desc != L2_TABLE) {
 515                 *level = 2;
 516                 return (NULL);
 517         }
 518
 519         *level = 3;
 520         l3 = pmap_l2_to_l3(l2, va);
 521         if ((pmap_load(l3) & ATTR_DESCR_MASK) != L3_PAGE)
 522                 return (NULL);
 523
 524         return (l3);
 525 }
 526
 527 bool
 528 pmap_ps_enabled(pmap_t pmap __unused)
 529 {
 530
 531         return (superpages_enabled != 0);
 532 }
 533
 534 bool
 535 pmap_get_tables(pmap_t pmap, vm_offset_t va, pd_entry_t **l0, pd_entry_t **l1,
 536     pd_entry_t **l2, pt_entry_t **l3)
 537 {
 538         pd_entry_t *l0p, *l1p, *l2p;
 539
 540         if (pmap->pm_l0 == NULL)
 541                 return (false);
 542
 543         l0p = pmap_l0(pmap, va);
 544         *l0 = l0p;
 545
 546         if ((pmap_load(l0p) & ATTR_DESCR_MASK) != L0_TABLE)
 547                 return (false);
 548
 549         l1p = pmap_l0_to_l1(l0p, va);
 550         *l1 = l1p;
 551
 552         if ((pmap_load(l1p) & ATTR_DESCR_MASK) == L1_BLOCK) {
 553                 *l2 = NULL;
 554                 *l3 = NULL;
 555                 return (true);
 556         }
 557
 558         if ((pmap_load(l1p) & ATTR_DESCR_MASK) != L1_TABLE)
 559                 return (false);
 560
 561         l2p = pmap_l1_to_l2(l1p, va);
 562         *l2 = l2p;
 563
 564         if ((pmap_load(l2p) & ATTR_DESCR_MASK) == L2_BLOCK) {
 565                 *l3 = NULL;
 566                 return (true);
 567         }
 568
 569         if ((pmap_load(l2p) & ATTR_DESCR_MASK) != L2_TABLE)
 570                 return (false);
 571
 572         *l3 = pmap_l2_to_l3(l2p, va);
 573
 574         return (true);
 575 }
 576
 577 static __inline int
 578 pmap_l3_valid(pt_entry_t l3)
 579 {
 580
 581         return ((l3 & ATTR_DESCR_MASK) == L3_PAGE);
 582 }
 583
 584
 585 CTASSERT(L1_BLOCK == L2_BLOCK);
 586
 587 /*
 588  * Checks if the PTE is dirty.
 589  */
 590 static inline int
 591 pmap_pte_dirty(pmap_t pmap, pt_entry_t pte)
 592 {
 593
 594         PMAP_ASSERT_STAGE1(pmap);
 595         KASSERT((pte & ATTR_SW_MANAGED) != 0, ("pte %#lx is unmanaged", pte));
 596         KASSERT((pte & (ATTR_S1_AP_RW_BIT | ATTR_SW_DBM)) != 0,
 597             ("pte %#lx is writeable and missing ATTR_SW_DBM", pte));
 598
 599         return ((pte & (ATTR_S1_AP_RW_BIT | ATTR_SW_DBM)) ==
 600             (ATTR_S1_AP(ATTR_S1_AP_RW) | ATTR_SW_DBM));
 601 }
 602
 603 static __inline void
 604 pmap_resident_count_inc(pmap_t pmap, int count)
 605 {
 606
 607         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
 608         pmap->pm_stats.resident_count += count;
 609 }
 610
 611 static __inline void
 612 pmap_resident_count_dec(pmap_t pmap, int count)
 613 {
 614
 615         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
 616         KASSERT(pmap->pm_stats.resident_count >= count,
 617             ("pmap %p resident count underflow %ld %d", pmap,
 618             pmap->pm_stats.resident_count, count));
 619         pmap->pm_stats.resident_count -= count;
 620 }
 621
 622 static pt_entry_t *
 623 pmap_early_page_idx(vm_offset_t l1pt, vm_offset_t va, u_int *l1_slot,
 624     u_int *l2_slot)
 625 {
 626         pt_entry_t *l2;
 627         pd_entry_t *l1;
 628
 629         l1 = (pd_entry_t *)l1pt;
 630         *l1_slot = (va >> L1_SHIFT) & Ln_ADDR_MASK;
 631
 632         /* Check locore has used a table L1 map */
 633         KASSERT((l1[*l1_slot] & ATTR_DESCR_MASK) == L1_TABLE,
 634            ("Invalid bootstrap L1 table"));
 635         /* Find the address of the L2 table */
 636         l2 = (pt_entry_t *)init_pt_va;
 637         *l2_slot = pmap_l2_index(va);
 638
 639         return (l2);
 640 }
 641
 642 static vm_paddr_t
 643 pmap_early_vtophys(vm_offset_t l1pt, vm_offset_t va)
 644 {
 645         u_int l1_slot, l2_slot;
 646         pt_entry_t *l2;
 647
 648         l2 = pmap_early_page_idx(l1pt, va, &l1_slot, &l2_slot);
 649
 650         return ((l2[l2_slot] & ~ATTR_MASK) + (va & L2_OFFSET));
 651 }
 652
 653 static vm_offset_t
 654 pmap_bootstrap_dmap(vm_offset_t kern_l1, vm_paddr_t min_pa,
 655     vm_offset_t freemempos)
 656 {
 657         pt_entry_t *l2;
 658         vm_offset_t va;
 659         vm_paddr_t l2_pa, pa;
 660         u_int l1_slot, l2_slot, prev_l1_slot;
 661         int i;
 662
 663         dmap_phys_base = min_pa & ~L1_OFFSET;
 664         dmap_phys_max = 0;
 665         dmap_max_addr = 0;
 666         l2 = NULL;
 667         prev_l1_slot = -1;
 668
 669 #define DMAP_TABLES     ((DMAP_MAX_ADDRESS - DMAP_MIN_ADDRESS) >> L0_SHIFT)
 670         memset(pagetable_dmap, 0, PAGE_SIZE * DMAP_TABLES);
 671
 672         for (i = 0; i < (physmap_idx * 2); i += 2) {
 673                 pa = physmap[i] & ~L2_OFFSET;
 674                 va = pa - dmap_phys_base + DMAP_MIN_ADDRESS;
 675
 676                 /* Create L2 mappings at the start of the region */
 677                 if ((pa & L1_OFFSET) != 0) {
 678                         l1_slot = ((va - DMAP_MIN_ADDRESS) >> L1_SHIFT);
 679                         if (l1_slot != prev_l1_slot) {
 680                                 prev_l1_slot = l1_slot;
 681                                 l2 = (pt_entry_t *)freemempos;
 682                                 l2_pa = pmap_early_vtophys(kern_l1,
 683                                     (vm_offset_t)l2);
 684                                 freemempos += PAGE_SIZE;
 685
 686                                 pmap_store(&pagetable_dmap[l1_slot],
 687                                     (l2_pa & ~Ln_TABLE_MASK) | L1_TABLE);
 688
 689                                 memset(l2, 0, PAGE_SIZE);
 690                         }
 691                         KASSERT(l2 != NULL,
 692                             ("pmap_bootstrap_dmap: NULL l2 map"));
 693                         for (; va < DMAP_MAX_ADDRESS && pa < physmap[i + 1];
 694                             pa += L2_SIZE, va += L2_SIZE) {
 695                                 /*
 696                                  * We are on a boundary, stop to
 697                                  * create a level 1 block
 698                                  */
 699                                 if ((pa & L1_OFFSET) == 0)
 700                                         break;
 701
 702                                 l2_slot = pmap_l2_index(va);
 703                                 KASSERT(l2_slot != 0, ("..."));
 704                                 pmap_store(&l2[l2_slot],
 705                                     (pa & ~L2_OFFSET) | ATTR_DEFAULT |
 706                                     ATTR_S1_XN |
 707                                     ATTR_S1_IDX(VM_MEMATTR_WRITE_BACK) |
 708                                     L2_BLOCK);
 709                         }
 710                         KASSERT(va == (pa - dmap_phys_base + DMAP_MIN_ADDRESS),
 711                             ("..."));
 712                 }
 713
 714                 for (; va < DMAP_MAX_ADDRESS && pa < physmap[i + 1] &&
 715                     (physmap[i + 1] - pa) >= L1_SIZE;
 716                     pa += L1_SIZE, va += L1_SIZE) {
 717                         l1_slot = ((va - DMAP_MIN_ADDRESS) >> L1_SHIFT);
 718                         pmap_store(&pagetable_dmap[l1_slot],
 719                             (pa & ~L1_OFFSET) | ATTR_DEFAULT | ATTR_S1_XN |
 720                             ATTR_S1_IDX(VM_MEMATTR_WRITE_BACK) | L1_BLOCK);
 721                 }
 722
 723                 /* Create L2 mappings at the end of the region */
 724                 if (pa < physmap[i + 1]) {
 725                         l1_slot = ((va - DMAP_MIN_ADDRESS) >> L1_SHIFT);
 726                         if (l1_slot != prev_l1_slot) {
 727                                 prev_l1_slot = l1_slot;
 728                                 l2 = (pt_entry_t *)freemempos;
 729                                 l2_pa = pmap_early_vtophys(kern_l1,
 730                                     (vm_offset_t)l2);
 731                                 freemempos += PAGE_SIZE;
 732
 733                                 pmap_store(&pagetable_dmap[l1_slot],
 734                                     (l2_pa & ~Ln_TABLE_MASK) | L1_TABLE);
 735
 736                                 memset(l2, 0, PAGE_SIZE);
 737                         }
 738                         KASSERT(l2 != NULL,
 739                             ("pmap_bootstrap_dmap: NULL l2 map"));
 740                         for (; va < DMAP_MAX_ADDRESS && pa < physmap[i + 1];
 741                             pa += L2_SIZE, va += L2_SIZE) {
 742                                 l2_slot = pmap_l2_index(va);
 743                                 pmap_store(&l2[l2_slot],
 744                                     (pa & ~L2_OFFSET) | ATTR_DEFAULT |
 745                                     ATTR_S1_XN |
 746                                     ATTR_S1_IDX(VM_MEMATTR_WRITE_BACK) |
 747                                     L2_BLOCK);
 748                         }
 749                 }
 750
 751                 if (pa > dmap_phys_max) {
 752                         dmap_phys_max = pa;
 753                         dmap_max_addr = va;
 754                 }
 755         }
 756
 757         cpu_tlb_flushID();
 758
 759         return (freemempos);
 760 }
 761
 762 static vm_offset_t
 763 pmap_bootstrap_l2(vm_offset_t l1pt, vm_offset_t va, vm_offset_t l2_start)
 764 {
 765         vm_offset_t l2pt;
 766         vm_paddr_t pa;
 767         pd_entry_t *l1;
 768         u_int l1_slot;
 769
 770         KASSERT((va & L1_OFFSET) == 0, ("Invalid virtual address"));
 771
 772         l1 = (pd_entry_t *)l1pt;
 773         l1_slot = pmap_l1_index(va);
 774         l2pt = l2_start;
 775
 776         for (; va < VM_MAX_KERNEL_ADDRESS; l1_slot++, va += L1_SIZE) {
 777                 KASSERT(l1_slot < Ln_ENTRIES, ("Invalid L1 index"));
 778
 779                 pa = pmap_early_vtophys(l1pt, l2pt);
 780                 pmap_store(&l1[l1_slot],
 781                     (pa & ~Ln_TABLE_MASK) | L1_TABLE);
 782                 l2pt += PAGE_SIZE;
 783         }
 784
 785         /* Clean the L2 page table */
 786         memset((void *)l2_start, 0, l2pt - l2_start);
 787
 788         return l2pt;
 789 }
 790
 791 static vm_offset_t
 792 pmap_bootstrap_l3(vm_offset_t l1pt, vm_offset_t va, vm_offset_t l3_start)
 793 {
 794         vm_offset_t l3pt;
 795         vm_paddr_t pa;
 796         pd_entry_t *l2;
 797         u_int l2_slot;
 798
 799         KASSERT((va & L2_OFFSET) == 0, ("Invalid virtual address"));
 800
 801         l2 = pmap_l2(kernel_pmap, va);
 802         l2 = (pd_entry_t *)rounddown2((uintptr_t)l2, PAGE_SIZE);
 803         l2_slot = pmap_l2_index(va);
 804         l3pt = l3_start;
 805
 806         for (; va < VM_MAX_KERNEL_ADDRESS; l2_slot++, va += L2_SIZE) {
 807                 KASSERT(l2_slot < Ln_ENTRIES, ("Invalid L2 index"));
 808
 809                 pa = pmap_early_vtophys(l1pt, l3pt);
 810                 pmap_store(&l2[l2_slot],
 811                     (pa & ~Ln_TABLE_MASK) | ATTR_S1_UXN | L2_TABLE);
 812                 l3pt += PAGE_SIZE;
 813         }
 814
 815         /* Clean the L2 page table */
 816         memset((void *)l3_start, 0, l3pt - l3_start);
 817
 818         return l3pt;
 819 }
 820
 821 /*
 822  *      Bootstrap the system enough to run with virtual memory.
 823  */
 824 void
 825 pmap_bootstrap(vm_offset_t l0pt, vm_offset_t l1pt, vm_paddr_t kernstart,
 826     vm_size_t kernlen)
 827 {
 828         u_int l1_slot, l2_slot;
 829         pt_entry_t *l2;
 830         vm_offset_t va, freemempos;
 831         vm_offset_t dpcpu, msgbufpv;
 832         vm_paddr_t start_pa, pa, min_pa;
 833         uint64_t kern_delta;
 834         int i;
 835
 836         /* Verify that the ASID is set through TTBR0. */
 837         KASSERT((READ_SPECIALREG(tcr_el1) & TCR_A1) == 0,
 838             ("pmap_bootstrap: TCR_EL1.A1 != 0"));
 839
 840         kern_delta = KERNBASE - kernstart;
 841
 842         printf("pmap_bootstrap %lx %lx %lx\n", l1pt, kernstart, kernlen);
 843         printf("%lx\n", l1pt);
 844         printf("%lx\n", (KERNBASE >> L1_SHIFT) & Ln_ADDR_MASK);
 845
 846         /* Set this early so we can use the pagetable walking functions */
 847         kernel_pmap_store.pm_l0 = (pd_entry_t *)l0pt;
 848         PMAP_LOCK_INIT(kernel_pmap);
 849         kernel_pmap->pm_l0_paddr = l0pt - kern_delta;
 850         kernel_pmap->pm_cookie = COOKIE_FROM(-1, INT_MIN);
 851         kernel_pmap->pm_stage = PM_STAGE1;
 852
 853         /* Assume the address we were loaded to is a valid physical address */
 854         min_pa = KERNBASE - kern_delta;
 855
 856         physmap_idx = arm_physmem_avail(physmap, nitems(physmap));
 857         physmap_idx /= 2;
 858
 859         /*
 860          * Find the minimum physical address. physmap is sorted,
 861          * but may contain empty ranges.
 862          */
 863         for (i = 0; i < (physmap_idx * 2); i += 2) {
 864                 if (physmap[i] == physmap[i + 1])
 865                         continue;
 866                 if (physmap[i] <= min_pa)
 867                         min_pa = physmap[i];
 868         }
 869
 870         freemempos = KERNBASE + kernlen;
 871         freemempos = roundup2(freemempos, PAGE_SIZE);
 872
 873         /* Create a direct map region early so we can use it for pa -> va */
 874         freemempos = pmap_bootstrap_dmap(l1pt, min_pa, freemempos);
 875
 876         va = KERNBASE;
 877         start_pa = pa = KERNBASE - kern_delta;
 878
 879         /*
 880          * Read the page table to find out what is already mapped.
 881          * This assumes we have mapped a block of memory from KERNBASE
 882          * using a single L1 entry.
 883          */
 884         l2 = pmap_early_page_idx(l1pt, KERNBASE, &l1_slot, &l2_slot);
 885
 886         /* Sanity check the index, KERNBASE should be the first VA */
 887         KASSERT(l2_slot == 0, ("The L2 index is non-zero"));
 888
 889         /* Find how many pages we have mapped */
 890         for (; l2_slot < Ln_ENTRIES; l2_slot++) {
 891                 if ((l2[l2_slot] & ATTR_DESCR_MASK) == 0)
 892                         break;
 893
 894                 /* Check locore used L2 blocks */
 895                 KASSERT((l2[l2_slot] & ATTR_DESCR_MASK) == L2_BLOCK,
 896                     ("Invalid bootstrap L2 table"));
 897                 KASSERT((l2[l2_slot] & ~ATTR_MASK) == pa,
 898                     ("Incorrect PA in L2 table"));
 899
 900                 va += L2_SIZE;
 901                 pa += L2_SIZE;
 902         }
 903
 904         va = roundup2(va, L1_SIZE);
 905
 906         /* Create the l2 tables up to VM_MAX_KERNEL_ADDRESS */
 907         freemempos = pmap_bootstrap_l2(l1pt, va, freemempos);
 908         /* And the l3 tables for the early devmap */
 909         freemempos = pmap_bootstrap_l3(l1pt,
 910             VM_MAX_KERNEL_ADDRESS - (PMAP_MAPDEV_EARLY_SIZE), freemempos);
 911
 912         cpu_tlb_flushID();
 913
 914 #define alloc_pages(var, np)                                            \
 915         (var) = freemempos;                                             \
 916         freemempos += (np * PAGE_SIZE);                                 \
 917         memset((char *)(var), 0, ((np) * PAGE_SIZE));
 918
 919         /* Allocate dynamic per-cpu area. */
 920         alloc_pages(dpcpu, DPCPU_SIZE / PAGE_SIZE);
 921         dpcpu_init((void *)dpcpu, 0);
 922
 923         /* Allocate memory for the msgbuf, e.g. for /sbin/dmesg */
 924         alloc_pages(msgbufpv, round_page(msgbufsize) / PAGE_SIZE);
 925         msgbufp = (void *)msgbufpv;
 926
 927         /* Reserve some VA space for early BIOS/ACPI mapping */
 928         preinit_map_va = roundup2(freemempos, L2_SIZE);
 929
 930         virtual_avail = preinit_map_va + PMAP_PREINIT_MAPPING_SIZE;
 931         virtual_avail = roundup2(virtual_avail, L1_SIZE);
 932         virtual_end = VM_MAX_KERNEL_ADDRESS - (PMAP_MAPDEV_EARLY_SIZE);
 933         kernel_vm_end = virtual_avail;
 934
 935         pa = pmap_early_vtophys(l1pt, freemempos);
 936
 937         arm_physmem_exclude_region(start_pa, pa - start_pa, EXFLAG_NOALLOC);
 938
 939         cpu_tlb_flushID();
 940 }
 941
 942 /*
 943  *      Initialize a vm_page's machine-dependent fields.
 944  */
 945 void
 946 pmap_page_init(vm_page_t m)
 947 {
 948
 949         TAILQ_INIT(&m->md.pv_list);
 950         m->md.pv_memattr = VM_MEMATTR_WRITE_BACK;
 951 }
 952
 953 /*
 954  *      Initialize the pmap module.
 955  *      Called by vm_init, to initialize any structures that the pmap
 956  *      system needs to map virtual memory.
 957  */
 958 void
 959 pmap_init(void)
 960 {
 961         vm_size_t s;
 962         int i, pv_npg;
 963
 964         /*
 965          * Determine whether an ASID is 8 or 16 bits in size.
 966          */
 967         asid_bits = (READ_SPECIALREG(tcr_el1) & TCR_ASID_16) != 0 ? 16 : 8;
 968
 969         /*
 970          * Are large page mappings enabled?
 971          */
 972         TUNABLE_INT_FETCH("vm.pmap.superpages_enabled", &superpages_enabled);
 973         if (superpages_enabled) {
 974                 KASSERT(MAXPAGESIZES > 1 && pagesizes[1] == 0,
 975                     ("pmap_init: can't assign to pagesizes[1]"));
 976                 pagesizes[1] = L2_SIZE;
 977         }
 978
 979         /*
 980          * Initialize the ASID allocator.  At this point, we are still too
 981          * early in the overall initialization process to use bit_alloc().
 982          */
 983         asid_set_size = 1 << asid_bits;
 984         asid_set = (bitstr_t *)kmem_malloc(bitstr_size(asid_set_size),
 985             M_WAITOK | M_ZERO);
 986         for (i = 0; i < ASID_FIRST_AVAILABLE; i++)
 987                 bit_set(asid_set, i);
 988         asid_next = ASID_FIRST_AVAILABLE;
 989         mtx_init(&asid_set_mutex, "asid set", NULL, MTX_SPIN);
 990
 991         /*
 992          * Initialize the pv chunk list mutex.
 993          */
 994         mtx_init(&pv_chunks_mutex, "pmap pv chunk list", NULL, MTX_DEF);
 995
 996         /*
 997          * Initialize the pool of pv list locks.
 998          */
 999         for (i = 0; i < NPV_LIST_LOCKS; i++)
1000                 rw_init(&pv_list_locks[i], "pmap pv list");
1001
1002         /*
1003          * Calculate the size of the pv head table for superpages.
1004          */
1005         pv_npg = howmany(vm_phys_segs[vm_phys_nsegs - 1].end, L2_SIZE);
1006
1007         /*
1008          * Allocate memory for the pv head table for superpages.
1009          */
1010         s = (vm_size_t)(pv_npg * sizeof(struct md_page));
1011         s = round_page(s);
1012         pv_table = (struct md_page *)kmem_malloc(s, M_WAITOK | M_ZERO);
1013         for (i = 0; i < pv_npg; i++)
1014                 TAILQ_INIT(&pv_table[i].pv_list);
1015         TAILQ_INIT(&pv_dummy.pv_list);
1016
1017         vm_initialized = 1;
1018 }
1019
1020 static SYSCTL_NODE(_vm_pmap, OID_AUTO, l2, CTLFLAG_RD, 0,
1021     "2MB page mapping counters");
1022
1023 static u_long pmap_l2_demotions;
1024 SYSCTL_ULONG(_vm_pmap_l2, OID_AUTO, demotions, CTLFLAG_RD,
1025     &pmap_l2_demotions, 0, "2MB page demotions");
1026
1027 static u_long pmap_l2_mappings;
1028 SYSCTL_ULONG(_vm_pmap_l2, OID_AUTO, mappings, CTLFLAG_RD,
1029     &pmap_l2_mappings, 0, "2MB page mappings");
1030
1031 static u_long pmap_l2_p_failures;
1032 SYSCTL_ULONG(_vm_pmap_l2, OID_AUTO, p_failures, CTLFLAG_RD,
1033     &pmap_l2_p_failures, 0, "2MB page promotion failures");
1034
1035 static u_long pmap_l2_promotions;
1036 SYSCTL_ULONG(_vm_pmap_l2, OID_AUTO, promotions, CTLFLAG_RD,
1037     &pmap_l2_promotions, 0, "2MB page promotions");
1038
1039 /*
1040  * Invalidate a single TLB entry.
1041  */
1042 static __inline void
1043 pmap_invalidate_page(pmap_t pmap, vm_offset_t va)
1044 {
1045         uint64_t r;
1046
1047         PMAP_ASSERT_STAGE1(pmap);
1048
1049         dsb(ishst);
1050         if (pmap == kernel_pmap) {
1051                 r = atop(va);
1052                 __asm __volatile("tlbi vaae1is, %0" : : "r" (r));
1053         } else {
1054                 r = ASID_TO_OPERAND(COOKIE_TO_ASID(pmap->pm_cookie)) | atop(va);
1055                 __asm __volatile("tlbi vae1is, %0" : : "r" (r));
1056         }
1057         dsb(ish);
1058         isb();
1059 }
1060
1061 static __inline void
1062 pmap_invalidate_range(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
1063 {
1064         uint64_t end, r, start;
1065
1066         PMAP_ASSERT_STAGE1(pmap);
1067
1068         dsb(ishst);
1069         if (pmap == kernel_pmap) {
1070                 start = atop(sva);
1071                 end = atop(eva);
1072                 for (r = start; r < end; r++)
1073                         __asm __volatile("tlbi vaae1is, %0" : : "r" (r));
1074         } else {
1075                 start = end = ASID_TO_OPERAND(COOKIE_TO_ASID(pmap->pm_cookie));
1076                 start |= atop(sva);
1077                 end |= atop(eva);
1078                 for (r = start; r < end; r++)
1079                         __asm __volatile("tlbi vae1is, %0" : : "r" (r));
1080         }
1081         dsb(ish);
1082         isb();
1083 }
1084
1085 static __inline void
1086 pmap_invalidate_all(pmap_t pmap)
1087 {
1088         uint64_t r;
1089
1090         PMAP_ASSERT_STAGE1(pmap);
1091
1092         dsb(ishst);
1093         if (pmap == kernel_pmap) {
1094                 __asm __volatile("tlbi vmalle1is");
1095         } else {
1096                 r = ASID_TO_OPERAND(COOKIE_TO_ASID(pmap->pm_cookie));
1097                 __asm __volatile("tlbi aside1is, %0" : : "r" (r));
1098         }
1099         dsb(ish);
1100         isb();
1101 }
1102
1103 /*
1104  *      Routine:        pmap_extract
1105  *      Function:
1106  *              Extract the physical page address associated
1107  *              with the given map/virtual_address pair.
1108  */
1109 vm_paddr_t
1110 pmap_extract(pmap_t pmap, vm_offset_t va)
1111 {
1112         pt_entry_t *pte, tpte;
1113         vm_paddr_t pa;
1114         int lvl;
1115
1116         pa = 0;
1117         PMAP_LOCK(pmap);
1118         /*
1119          * Find the block or page map for this virtual address. pmap_pte
1120          * will return either a valid block/page entry, or NULL.
1121          */
1122         pte = pmap_pte(pmap, va, &lvl);
1123         if (pte != NULL) {
1124                 tpte = pmap_load(pte);
1125                 pa = tpte & ~ATTR_MASK;
1126                 switch(lvl) {
1127                 case 1:
1128                         KASSERT((tpte & ATTR_DESCR_MASK) == L1_BLOCK,
1129                             ("pmap_extract: Invalid L1 pte found: %lx",
1130                             tpte & ATTR_DESCR_MASK));
1131                         pa |= (va & L1_OFFSET);
1132                         break;
1133                 case 2:
1134                         KASSERT((tpte & ATTR_DESCR_MASK) == L2_BLOCK,
1135                             ("pmap_extract: Invalid L2 pte found: %lx",
1136                             tpte & ATTR_DESCR_MASK));
1137                         pa |= (va & L2_OFFSET);
1138                         break;
1139                 case 3:
1140                         KASSERT((tpte & ATTR_DESCR_MASK) == L3_PAGE,
1141                             ("pmap_extract: Invalid L3 pte found: %lx",
1142                             tpte & ATTR_DESCR_MASK));
1143                         pa |= (va & L3_OFFSET);
1144                         break;
1145                 }
1146         }
1147         PMAP_UNLOCK(pmap);
1148         return (pa);
1149 }
1150
1151 /*
1152  *      Routine:        pmap_extract_and_hold
1153  *      Function:
1154  *              Atomically extract and hold the physical page
1155  *              with the given pmap and virtual address pair
1156  *              if that mapping permits the given protection.
1157  */
1158 vm_page_t
1159 pmap_extract_and_hold(pmap_t pmap, vm_offset_t va, vm_prot_t prot)
1160 {
1161         pt_entry_t *pte, tpte;
1162         vm_offset_t off;
1163         vm_page_t m;
1164         int lvl;
1165
1166         PMAP_ASSERT_STAGE1(pmap);
1167
1168         m = NULL;
1169         PMAP_LOCK(pmap);
1170         pte = pmap_pte(pmap, va, &lvl);
1171         if (pte != NULL) {
1172                 tpte = pmap_load(pte);
1173
1174                 KASSERT(lvl > 0 && lvl <= 3,
1175                     ("pmap_extract_and_hold: Invalid level %d", lvl));
1176                 CTASSERT(L1_BLOCK == L2_BLOCK);
1177                 KASSERT((lvl == 3 && (tpte & ATTR_DESCR_MASK) == L3_PAGE) ||
1178                     (lvl < 3 && (tpte & ATTR_DESCR_MASK) == L1_BLOCK),
1179                     ("pmap_extract_and_hold: Invalid pte at L%d: %lx", lvl,
1180                      tpte & ATTR_DESCR_MASK));
1181                 if (((tpte & ATTR_S1_AP_RW_BIT) == ATTR_S1_AP(ATTR_S1_AP_RW)) ||
1182                     ((prot & VM_PROT_WRITE) == 0)) {
1183                         switch(lvl) {
1184                         case 1:
1185                                 off = va & L1_OFFSET;
1186                                 break;
1187                         case 2:
1188                                 off = va & L2_OFFSET;
1189                                 break;
1190                         case 3:
1191                         default:
1192                                 off = 0;
1193                         }
1194                         m = PHYS_TO_VM_PAGE((tpte & ~ATTR_MASK) | off);
1195                         if (!vm_page_wire_mapped(m))
1196                                 m = NULL;
1197                 }
1198         }
1199         PMAP_UNLOCK(pmap);
1200         return (m);
1201 }
1202
1203 vm_paddr_t
1204 pmap_kextract(vm_offset_t va)
1205 {
1206         pt_entry_t *pte, tpte;
1207
1208         if (va >= DMAP_MIN_ADDRESS && va < DMAP_MAX_ADDRESS)
1209                 return (DMAP_TO_PHYS(va));
1210         pte = pmap_l1(kernel_pmap, va);
1211         if (pte == NULL)
1212                 return (0);
1213
1214         /*
1215          * A concurrent pmap_update_entry() will clear the entry's valid bit
1216          * but leave the rest of the entry unchanged.  Therefore, we treat a
1217          * non-zero entry as being valid, and we ignore the valid bit when
1218          * determining whether the entry maps a block, page, or table.
1219          */
1220         tpte = pmap_load(pte);
1221         if (tpte == 0)
1222                 return (0);
1223         if ((tpte & ATTR_DESCR_TYPE_MASK) == ATTR_DESCR_TYPE_BLOCK)
1224                 return ((tpte & ~ATTR_MASK) | (va & L1_OFFSET));
1225         pte = pmap_l1_to_l2(&tpte, va);
1226         tpte = pmap_load(pte);
1227         if (tpte == 0)
1228                 return (0);
1229         if ((tpte & ATTR_DESCR_TYPE_MASK) == ATTR_DESCR_TYPE_BLOCK)
1230                 return ((tpte & ~ATTR_MASK) | (va & L2_OFFSET));
1231         pte = pmap_l2_to_l3(&tpte, va);
1232         tpte = pmap_load(pte);
1233         if (tpte == 0)
1234                 return (0);
1235         return ((tpte & ~ATTR_MASK) | (va & L3_OFFSET));
1236 }
1237
1238 /***************************************************
1239  * Low level mapping routines.....
1240  ***************************************************/
1241
1242 void
1243 pmap_kenter(vm_offset_t sva, vm_size_t size, vm_paddr_t pa, int mode)
1244 {
1245         pd_entry_t *pde;
1246         pt_entry_t *pte, attr;
1247         vm_offset_t va;
1248         int lvl;
1249
1250         KASSERT((pa & L3_OFFSET) == 0,
1251            ("pmap_kenter: Invalid physical address"));
1252         KASSERT((sva & L3_OFFSET) == 0,
1253            ("pmap_kenter: Invalid virtual address"));
1254         KASSERT((size & PAGE_MASK) == 0,
1255             ("pmap_kenter: Mapping is not page-sized"));
1256
1257         attr = ATTR_DEFAULT | ATTR_S1_AP(ATTR_S1_AP_RW) | ATTR_S1_XN |
1258             ATTR_S1_IDX(mode) | L3_PAGE;
1259         va = sva;
1260         while (size != 0) {
1261                 pde = pmap_pde(kernel_pmap, va, &lvl);
1262                 KASSERT(pde != NULL,
1263                     ("pmap_kenter: Invalid page entry, va: 0x%lx", va));
1264                 KASSERT(lvl == 2, ("pmap_kenter: Invalid level %d", lvl));
1265
1266                 pte = pmap_l2_to_l3(pde, va);
1267                 pmap_load_store(pte, (pa & ~L3_OFFSET) | attr);
1268
1269                 va += PAGE_SIZE;
1270                 pa += PAGE_SIZE;
1271                 size -= PAGE_SIZE;
1272         }
1273         pmap_invalidate_range(kernel_pmap, sva, va);
1274 }
1275
1276 void
1277 pmap_kenter_device(vm_offset_t sva, vm_size_t size, vm_paddr_t pa)
1278 {
1279
1280         pmap_kenter(sva, size, pa, VM_MEMATTR_DEVICE);
1281 }
1282
1283 /*
1284  * Remove a page from the kernel pagetables.
1285  */
1286 PMAP_INLINE void
1287 pmap_kremove(vm_offset_t va)
1288 {
1289         pt_entry_t *pte;
1290         int lvl;
1291
1292         pte = pmap_pte(kernel_pmap, va, &lvl);
1293         KASSERT(pte != NULL, ("pmap_kremove: Invalid address"));
1294         KASSERT(lvl == 3, ("pmap_kremove: Invalid pte level %d", lvl));
1295
1296         pmap_clear(pte);
1297         pmap_invalidate_page(kernel_pmap, va);
1298 }
1299
1300 void
1301 pmap_kremove_device(vm_offset_t sva, vm_size_t size)
1302 {
1303         pt_entry_t *pte;
1304         vm_offset_t va;
1305         int lvl;
1306
1307         KASSERT((sva & L3_OFFSET) == 0,
1308            ("pmap_kremove_device: Invalid virtual address"));
1309         KASSERT((size & PAGE_MASK) == 0,
1310             ("pmap_kremove_device: Mapping is not page-sized"));
1311
1312         va = sva;
1313         while (size != 0) {
1314                 pte = pmap_pte(kernel_pmap, va, &lvl);
1315                 KASSERT(pte != NULL, ("Invalid page table, va: 0x%lx", va));
1316                 KASSERT(lvl == 3,
1317                     ("Invalid device pagetable level: %d != 3", lvl));
1318                 pmap_clear(pte);
1319
1320                 va += PAGE_SIZE;
1321                 size -= PAGE_SIZE;
1322         }
1323         pmap_invalidate_range(kernel_pmap, sva, va);
1324 }
1325
1326 /*
1327  *      Used to map a range of physical addresses into kernel
1328  *      virtual address space.
1329  *
1330  *      The value passed in '*virt' is a suggested virtual address for
1331  *      the mapping. Architectures which can support a direct-mapped
1332  *      physical to virtual region can return the appropriate address
1333  *      within that region, leaving '*virt' unchanged. Other
1334  *      architectures should map the pages starting at '*virt' and
1335  *      update '*virt' with the first usable address after the mapped
1336  *      region.
1337  */
1338 vm_offset_t
1339 pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
1340 {
1341         return PHYS_TO_DMAP(start);
1342 }
1343
1344
1345 /*
1346  * Add a list of wired pages to the kva
1347  * this routine is only used for temporary
1348  * kernel mappings that do not need to have
1349  * page modification or references recorded.
1350  * Note that old mappings are simply written
1351  * over.  The page *must* be wired.
1352  * Note: SMP coherent.  Uses a ranged shootdown IPI.
1353  */
1354 void
1355 pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
1356 {
1357         pd_entry_t *pde;
1358         pt_entry_t *pte, pa;
1359         vm_offset_t va;
1360         vm_page_t m;
1361         int i, lvl;
1362
1363         va = sva;
1364         for (i = 0; i < count; i++) {
1365                 pde = pmap_pde(kernel_pmap, va, &lvl);
1366                 KASSERT(pde != NULL,
1367                     ("pmap_qenter: Invalid page entry, va: 0x%lx", va));
1368                 KASSERT(lvl == 2,
1369                     ("pmap_qenter: Invalid level %d", lvl));
1370
1371                 m = ma[i];
1372                 pa = VM_PAGE_TO_PHYS(m) | ATTR_DEFAULT |
1373                     ATTR_S1_AP(ATTR_S1_AP_RW) | ATTR_S1_XN |
1374                     ATTR_S1_IDX(m->md.pv_memattr) | L3_PAGE;
1375                 pte = pmap_l2_to_l3(pde, va);
1376                 pmap_load_store(pte, pa);
1377
1378                 va += L3_SIZE;
1379         }
1380         pmap_invalidate_range(kernel_pmap, sva, va);
1381 }
1382
1383 /*
1384  * This routine tears out page mappings from the
1385  * kernel -- it is meant only for temporary mappings.
1386  */
1387 void
1388 pmap_qremove(vm_offset_t sva, int count)
1389 {
1390         pt_entry_t *pte;
1391         vm_offset_t va;
1392         int lvl;
1393
1394         KASSERT(sva >= VM_MIN_KERNEL_ADDRESS, ("usermode va %lx", sva));
1395
1396         va = sva;
1397         while (count-- > 0) {
1398                 pte = pmap_pte(kernel_pmap, va, &lvl);
1399                 KASSERT(lvl == 3,
1400                     ("Invalid device pagetable level: %d != 3", lvl));
1401                 if (pte != NULL) {
1402                         pmap_clear(pte);
1403                 }
1404
1405                 va += PAGE_SIZE;
1406         }
1407         pmap_invalidate_range(kernel_pmap, sva, va);
1408 }
1409
1410 /***************************************************
1411  * Page table page management routines.....
1412  ***************************************************/
1413 /*
1414  * Schedule the specified unused page table page to be freed.  Specifically,
1415  * add the page to the specified list of pages that will be released to the
1416  * physical memory manager after the TLB has been updated.
1417  */
1418 static __inline void
1419 pmap_add_delayed_free_list(vm_page_t m, struct spglist *free,
1420     boolean_t set_PG_ZERO)
1421 {
1422
1423         if (set_PG_ZERO)
1424                 m->flags |= PG_ZERO;
1425         else
1426                 m->flags &= ~PG_ZERO;
1427         SLIST_INSERT_HEAD(free, m, plinks.s.ss);
1428 }
1429
1430 /*
1431  * Decrements a page table page's reference count, which is used to record the
1432  * number of valid page table entries within the page.  If the reference count
1433  * drops to zero, then the page table page is unmapped.  Returns TRUE if the
1434  * page table page was unmapped and FALSE otherwise.
1435  */
1436 static inline boolean_t
1437 pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m, struct spglist *free)
1438 {
1439
1440         --m->ref_count;
1441         if (m->ref_count == 0) {
1442                 _pmap_unwire_l3(pmap, va, m, free);
1443                 return (TRUE);
1444         } else
1445                 return (FALSE);
1446 }
1447
1448 static void
1449 _pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m, struct spglist *free)
1450 {
1451
1452         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1453         /*
1454          * unmap the page table page
1455          */
1456         if (m->pindex >= (NUL2E + NUL1E)) {
1457                 /* l1 page */
1458                 pd_entry_t *l0;
1459
1460                 l0 = pmap_l0(pmap, va);
1461                 pmap_clear(l0);
1462         } else if (m->pindex >= NUL2E) {
1463                 /* l2 page */
1464                 pd_entry_t *l1;
1465
1466                 l1 = pmap_l1(pmap, va);
1467                 pmap_clear(l1);
1468         } else {
1469                 /* l3 page */
1470                 pd_entry_t *l2;
1471
1472                 l2 = pmap_l2(pmap, va);
1473                 pmap_clear(l2);
1474         }
1475         pmap_resident_count_dec(pmap, 1);
1476         if (m->pindex < NUL2E) {
1477                 /* We just released an l3, unhold the matching l2 */
1478                 pd_entry_t *l1, tl1;
1479                 vm_page_t l2pg;
1480
1481                 l1 = pmap_l1(pmap, va);
1482                 tl1 = pmap_load(l1);
1483                 l2pg = PHYS_TO_VM_PAGE(tl1 & ~ATTR_MASK);
1484                 pmap_unwire_l3(pmap, va, l2pg, free);
1485         } else if (m->pindex < (NUL2E + NUL1E)) {
1486                 /* We just released an l2, unhold the matching l1 */
1487                 pd_entry_t *l0, tl0;
1488                 vm_page_t l1pg;
1489
1490                 l0 = pmap_l0(pmap, va);
1491                 tl0 = pmap_load(l0);
1492                 l1pg = PHYS_TO_VM_PAGE(tl0 & ~ATTR_MASK);
1493                 pmap_unwire_l3(pmap, va, l1pg, free);
1494         }
1495         pmap_invalidate_page(pmap, va);
1496
1497         /*
1498          * Put page on a list so that it is released after
1499          * *ALL* TLB shootdown is done
1500          */
1501         pmap_add_delayed_free_list(m, free, TRUE);
1502 }
1503
1504 /*
1505  * After removing a page table entry, this routine is used to
1506  * conditionally free the page, and manage the reference count.
1507  */
1508 static int
1509 pmap_unuse_pt(pmap_t pmap, vm_offset_t va, pd_entry_t ptepde,
1510     struct spglist *free)
1511 {
1512         vm_page_t mpte;
1513
1514         if (va >= VM_MAXUSER_ADDRESS)
1515                 return (0);
1516         KASSERT(ptepde != 0, ("pmap_unuse_pt: ptepde != 0"));
1517         mpte = PHYS_TO_VM_PAGE(ptepde & ~ATTR_MASK);
1518         return (pmap_unwire_l3(pmap, va, mpte, free));
1519 }
1520
1521 /*
1522  * Release a page table page reference after a failed attempt to create a
1523  * mapping.
1524  */
1525 static void
1526 pmap_abort_ptp(pmap_t pmap, vm_offset_t va, vm_page_t mpte)
1527 {
1528         struct spglist free;
1529
1530         SLIST_INIT(&free);
1531         if (pmap_unwire_l3(pmap, va, mpte, &free)) {
1532                 /*
1533                  * Although "va" was never mapped, the TLB could nonetheless
1534                  * have intermediate entries that refer to the freed page
1535                  * table pages.  Invalidate those entries.
1536                  *
1537                  * XXX redundant invalidation (See _pmap_unwire_l3().)
1538                  */
1539                 pmap_invalidate_page(pmap, va);
1540                 vm_page_free_pages_toq(&free, true);
1541         }
1542 }
1543
1544 void
1545 pmap_pinit0(pmap_t pmap)
1546 {
1547
1548         PMAP_LOCK_INIT(pmap);
1549         bzero(&pmap->pm_stats, sizeof(pmap->pm_stats));
1550         pmap->pm_l0_paddr = READ_SPECIALREG(ttbr0_el1);
1551         pmap->pm_l0 = (pd_entry_t *)PHYS_TO_DMAP(pmap->pm_l0_paddr);
1552         pmap->pm_root.rt_root = 0;
1553         pmap->pm_cookie = COOKIE_FROM(ASID_RESERVED_FOR_PID_0, INT_MIN);
1554         pmap->pm_stage = PM_STAGE1;
1555
1556         PCPU_SET(curpmap, pmap);
1557 }
1558
1559 int
1560 pmap_pinit(pmap_t pmap)
1561 {
1562         vm_page_t l0pt;
1563
1564         /*
1565          * allocate the l0 page
1566          */
1567         while ((l0pt = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
1568             VM_ALLOC_NOOBJ | VM_ALLOC_WIRED | VM_ALLOC_ZERO)) == NULL)
1569                 vm_wait(NULL);
1570
1571         pmap->pm_l0_paddr = VM_PAGE_TO_PHYS(l0pt);
1572         pmap->pm_l0 = (pd_entry_t *)PHYS_TO_DMAP(pmap->pm_l0_paddr);
1573
1574         if ((l0pt->flags & PG_ZERO) == 0)
1575                 pagezero(pmap->pm_l0);
1576
1577         pmap->pm_root.rt_root = 0;
1578         bzero(&pmap->pm_stats, sizeof(pmap->pm_stats));
1579         pmap->pm_cookie = COOKIE_FROM(-1, INT_MAX);
1580         pmap->pm_stage = PM_STAGE1;
1581         /* XXX Temporarily disable deferred ASID allocation. */
1582         pmap_alloc_asid(pmap);
1583
1584         return (1);
1585 }
1586
1587 /*
1588  * This routine is called if the desired page table page does not exist.
1589  *
1590  * If page table page allocation fails, this routine may sleep before
1591  * returning NULL.  It sleeps only if a lock pointer was given.
1592  *
1593  * Note: If a page allocation fails at page table level two or three,
1594  * one or two pages may be held during the wait, only to be released
1595  * afterwards.  This conservative approach is easily argued to avoid
1596  * race conditions.
1597  */
1598 static vm_page_t
1599 _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
1600 {
1601         vm_page_t m, l1pg, l2pg;
1602
1603         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1604
1605         /*
1606          * Allocate a page table page.
1607          */
1608         if ((m = vm_page_alloc(NULL, ptepindex, VM_ALLOC_NOOBJ |
1609             VM_ALLOC_WIRED | VM_ALLOC_ZERO)) == NULL) {
1610                 if (lockp != NULL) {
1611                         RELEASE_PV_LIST_LOCK(lockp);
1612                         PMAP_UNLOCK(pmap);
1613                         vm_wait(NULL);
1614                         PMAP_LOCK(pmap);
1615                 }
1616
1617                 /*
1618                  * Indicate the need to retry.  While waiting, the page table
1619                  * page may have been allocated.
1620                  */
1621                 return (NULL);
1622         }
1623         if ((m->flags & PG_ZERO) == 0)
1624                 pmap_zero_page(m);
1625
1626         /*
1627          * Because of AArch64's weak memory consistency model, we must have a
1628          * barrier here to ensure that the stores for zeroing "m", whether by
1629          * pmap_zero_page() or an earlier function, are visible before adding
1630          * "m" to the page table.  Otherwise, a page table walk by another
1631          * processor's MMU could see the mapping to "m" and a stale, non-zero
1632          * PTE within "m".
1633          */
1634         dmb(ishst);
1635
1636         /*
1637          * Map the pagetable page into the process address space, if
1638          * it isn't already there.
1639          */
1640
1641         if (ptepindex >= (NUL2E + NUL1E)) {
1642                 pd_entry_t *l0;
1643                 vm_pindex_t l0index;
1644
1645                 l0index = ptepindex - (NUL2E + NUL1E);
1646                 l0 = &pmap->pm_l0[l0index];
1647                 pmap_store(l0, VM_PAGE_TO_PHYS(m) | L0_TABLE);
1648         } else if (ptepindex >= NUL2E) {
1649                 vm_pindex_t l0index, l1index;
1650                 pd_entry_t *l0, *l1;
1651                 pd_entry_t tl0;
1652
1653                 l1index = ptepindex - NUL2E;
1654                 l0index = l1index >> L0_ENTRIES_SHIFT;
1655
1656                 l0 = &pmap->pm_l0[l0index];
1657                 tl0 = pmap_load(l0);
1658                 if (tl0 == 0) {
1659                         /* recurse for allocating page dir */
1660                         if (_pmap_alloc_l3(pmap, NUL2E + NUL1E + l0index,
1661                             lockp) == NULL) {
1662                                 vm_page_unwire_noq(m);
1663                                 vm_page_free_zero(m);
1664                                 return (NULL);
1665                         }
1666                 } else {
1667                         l1pg = PHYS_TO_VM_PAGE(tl0 & ~ATTR_MASK);
1668                         l1pg->ref_count++;
1669                 }
1670
1671                 l1 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l0) & ~ATTR_MASK);
1672                 l1 = &l1[ptepindex & Ln_ADDR_MASK];
1673                 pmap_store(l1, VM_PAGE_TO_PHYS(m) | L1_TABLE);
1674         } else {
1675                 vm_pindex_t l0index, l1index;
1676                 pd_entry_t *l0, *l1, *l2;
1677                 pd_entry_t tl0, tl1;
1678
1679                 l1index = ptepindex >> Ln_ENTRIES_SHIFT;
1680                 l0index = l1index >> L0_ENTRIES_SHIFT;
1681
1682                 l0 = &pmap->pm_l0[l0index];
1683                 tl0 = pmap_load(l0);
1684                 if (tl0 == 0) {
1685                         /* recurse for allocating page dir */
1686                         if (_pmap_alloc_l3(pmap, NUL2E + l1index,
1687                             lockp) == NULL) {
1688                                 vm_page_unwire_noq(m);
1689                                 vm_page_free_zero(m);
1690                                 return (NULL);
1691                         }
1692                         tl0 = pmap_load(l0);
1693                         l1 = (pd_entry_t *)PHYS_TO_DMAP(tl0 & ~ATTR_MASK);
1694                         l1 = &l1[l1index & Ln_ADDR_MASK];
1695                 } else {
1696                         l1 = (pd_entry_t *)PHYS_TO_DMAP(tl0 & ~ATTR_MASK);
1697                         l1 = &l1[l1index & Ln_ADDR_MASK];
1698                         tl1 = pmap_load(l1);
1699                         if (tl1 == 0) {
1700                                 /* recurse for allocating page dir */
1701                                 if (_pmap_alloc_l3(pmap, NUL2E + l1index,
1702                                     lockp) == NULL) {
1703                                         vm_page_unwire_noq(m);
1704                                         vm_page_free_zero(m);
1705                                         return (NULL);
1706                                 }
1707                         } else {
1708                                 l2pg = PHYS_TO_VM_PAGE(tl1 & ~ATTR_MASK);
1709                                 l2pg->ref_count++;
1710                         }
1711                 }
1712
1713                 l2 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l1) & ~ATTR_MASK);
1714                 l2 = &l2[ptepindex & Ln_ADDR_MASK];
1715                 pmap_store(l2, VM_PAGE_TO_PHYS(m) | L2_TABLE);
1716         }
1717
1718         pmap_resident_count_inc(pmap, 1);
1719
1720         return (m);
1721 }
1722
1723 static pd_entry_t *
1724 pmap_alloc_l2(pmap_t pmap, vm_offset_t va, vm_page_t *l2pgp,
1725     struct rwlock **lockp)
1726 {
1727         pd_entry_t *l1, *l2;
1728         vm_page_t l2pg;
1729         vm_pindex_t l2pindex;
1730
1731 retry:
1732         l1 = pmap_l1(pmap, va);
1733         if (l1 != NULL && (pmap_load(l1) & ATTR_DESCR_MASK) == L1_TABLE) {
1734                 l2 = pmap_l1_to_l2(l1, va);
1735                 if (va < VM_MAXUSER_ADDRESS) {
1736                         /* Add a reference to the L2 page. */
1737                         l2pg = PHYS_TO_VM_PAGE(pmap_load(l1) & ~ATTR_MASK);
1738                         l2pg->ref_count++;
1739                 } else
1740                         l2pg = NULL;
1741         } else if (va < VM_MAXUSER_ADDRESS) {
1742                 /* Allocate a L2 page. */
1743                 l2pindex = pmap_l2_pindex(va) >> Ln_ENTRIES_SHIFT;
1744                 l2pg = _pmap_alloc_l3(pmap, NUL2E + l2pindex, lockp);
1745                 if (l2pg == NULL) {
1746                         if (lockp != NULL)
1747                                 goto retry;
1748                         else
1749                                 return (NULL);
1750                 }
1751                 l2 = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(l2pg));
1752                 l2 = &l2[pmap_l2_index(va)];
1753         } else
1754                 panic("pmap_alloc_l2: missing page table page for va %#lx",
1755                     va);
1756         *l2pgp = l2pg;
1757         return (l2);
1758 }
1759
1760 static vm_page_t
1761 pmap_alloc_l3(pmap_t pmap, vm_offset_t va, struct rwlock **lockp)
1762 {
1763         vm_pindex_t ptepindex;
1764         pd_entry_t *pde, tpde;
1765 #ifdef INVARIANTS
1766         pt_entry_t *pte;
1767 #endif
1768         vm_page_t m;
1769         int lvl;
1770
1771         /*
1772          * Calculate pagetable page index
1773          */
1774         ptepindex = pmap_l2_pindex(va);
1775 retry:
1776         /*
1777          * Get the page directory entry
1778          */
1779         pde = pmap_pde(pmap, va, &lvl);
1780
1781         /*
1782          * If the page table page is mapped, we just increment the hold count,
1783          * and activate it. If we get a level 2 pde it will point to a level 3
1784          * table.
1785          */
1786         switch (lvl) {
1787         case -1:
1788                 break;
1789         case 0:
1790 #ifdef INVARIANTS
1791                 pte = pmap_l0_to_l1(pde, va);
1792                 KASSERT(pmap_load(pte) == 0,
1793                     ("pmap_alloc_l3: TODO: l0 superpages"));
1794 #endif
1795                 break;
1796         case 1:
1797 #ifdef INVARIANTS
1798                 pte = pmap_l1_to_l2(pde, va);
1799                 KASSERT(pmap_load(pte) == 0,
1800                     ("pmap_alloc_l3: TODO: l1 superpages"));
1801 #endif
1802                 break;
1803         case 2:
1804                 tpde = pmap_load(pde);
1805                 if (tpde != 0) {
1806                         m = PHYS_TO_VM_PAGE(tpde & ~ATTR_MASK);
1807                         m->ref_count++;
1808                         return (m);
1809                 }
1810                 break;
1811         default:
1812                 panic("pmap_alloc_l3: Invalid level %d", lvl);
1813         }
1814
1815         /*
1816          * Here if the pte page isn't mapped, or if it has been deallocated.
1817          */
1818         m = _pmap_alloc_l3(pmap, ptepindex, lockp);
1819         if (m == NULL && lockp != NULL)
1820                 goto retry;
1821
1822         return (m);
1823 }
1824
1825 /***************************************************
1826  * Pmap allocation/deallocation routines.
1827  ***************************************************/
1828
1829 /*
1830  * Release any resources held by the given physical map.
1831  * Called when a pmap initialized by pmap_pinit is being released.
1832  * Should only be called if the map contains no valid mappings.
1833  */
1834 void
1835 pmap_release(pmap_t pmap)
1836 {
1837         vm_page_t m;
1838         int asid;
1839
1840         KASSERT(pmap->pm_stats.resident_count == 0,
1841             ("pmap_release: pmap resident count %ld != 0",
1842             pmap->pm_stats.resident_count));
1843         KASSERT(vm_radix_is_empty(&pmap->pm_root),
1844             ("pmap_release: pmap has reserved page table page(s)"));
1845         PMAP_ASSERT_STAGE1(pmap);
1846
1847         mtx_lock_spin(&asid_set_mutex);
1848         if (COOKIE_TO_EPOCH(pmap->pm_cookie) == asid_epoch) {
1849                 asid = COOKIE_TO_ASID(pmap->pm_cookie);
1850                 KASSERT(asid >= ASID_FIRST_AVAILABLE && asid < asid_set_size,
1851                     ("pmap_release: pmap cookie has out-of-range asid"));
1852                 bit_clear(asid_set, asid);
1853         }
1854         mtx_unlock_spin(&asid_set_mutex);
1855
1856         m = PHYS_TO_VM_PAGE(pmap->pm_l0_paddr);
1857         vm_page_unwire_noq(m);
1858         vm_page_free_zero(m);
1859 }
1860
1861 static int
1862 kvm_size(SYSCTL_HANDLER_ARGS)
1863 {
1864         unsigned long ksize = VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS;
1865
1866         return sysctl_handle_long(oidp, &ksize, 0, req);
1867 }
1868 SYSCTL_PROC(_vm, OID_AUTO, kvm_size, CTLTYPE_LONG | CTLFLAG_RD | CTLFLAG_MPSAFE,
1869     0, 0, kvm_size, "LU",
1870     "Size of KVM");
1871
1872 static int
1873 kvm_free(SYSCTL_HANDLER_ARGS)
1874 {
1875         unsigned long kfree = VM_MAX_KERNEL_ADDRESS - kernel_vm_end;
1876
1877         return sysctl_handle_long(oidp, &kfree, 0, req);
1878 }
1879 SYSCTL_PROC(_vm, OID_AUTO, kvm_free, CTLTYPE_LONG | CTLFLAG_RD | CTLFLAG_MPSAFE,
1880     0, 0, kvm_free, "LU",
1881     "Amount of KVM free");
1882
1883 /*
1884  * grow the number of kernel page table entries, if needed
1885  */
1886 void
1887 pmap_growkernel(vm_offset_t addr)
1888 {
1889         vm_paddr_t paddr;
1890         vm_page_t nkpg;
1891         pd_entry_t *l0, *l1, *l2;
1892
1893         mtx_assert(&kernel_map->system_mtx, MA_OWNED);
1894
1895         addr = roundup2(addr, L2_SIZE);
1896         if (addr - 1 >= vm_map_max(kernel_map))
1897                 addr = vm_map_max(kernel_map);
1898         while (kernel_vm_end < addr) {
1899                 l0 = pmap_l0(kernel_pmap, kernel_vm_end);
1900                 KASSERT(pmap_load(l0) != 0,
1901                     ("pmap_growkernel: No level 0 kernel entry"));
1902
1903                 l1 = pmap_l0_to_l1(l0, kernel_vm_end);
1904                 if (pmap_load(l1) == 0) {
1905                         /* We need a new PDP entry */
1906                         nkpg = vm_page_alloc(NULL, kernel_vm_end >> L1_SHIFT,
1907                             VM_ALLOC_INTERRUPT | VM_ALLOC_NOOBJ |
1908                             VM_ALLOC_WIRED | VM_ALLOC_ZERO);
1909                         if (nkpg == NULL)
1910                                 panic("pmap_growkernel: no memory to grow kernel");
1911                         if ((nkpg->flags & PG_ZERO) == 0)
1912                                 pmap_zero_page(nkpg);
1913                         /* See the dmb() in _pmap_alloc_l3(). */
1914                         dmb(ishst);
1915                         paddr = VM_PAGE_TO_PHYS(nkpg);
1916                         pmap_store(l1, paddr | L1_TABLE);
1917                         continue; /* try again */
1918                 }
1919                 l2 = pmap_l1_to_l2(l1, kernel_vm_end);
1920                 if (pmap_load(l2) != 0) {
1921                         kernel_vm_end = (kernel_vm_end + L2_SIZE) & ~L2_OFFSET;
1922                         if (kernel_vm_end - 1 >= vm_map_max(kernel_map)) {
1923                                 kernel_vm_end = vm_map_max(kernel_map);
1924                                 break;
1925                         }
1926                         continue;
1927                 }
1928
1929                 nkpg = vm_page_alloc(NULL, kernel_vm_end >> L2_SHIFT,
1930                     VM_ALLOC_INTERRUPT | VM_ALLOC_NOOBJ | VM_ALLOC_WIRED |
1931                     VM_ALLOC_ZERO);
1932                 if (nkpg == NULL)
1933                         panic("pmap_growkernel: no memory to grow kernel");
1934                 if ((nkpg->flags & PG_ZERO) == 0)
1935                         pmap_zero_page(nkpg);
1936                 /* See the dmb() in _pmap_alloc_l3(). */
1937                 dmb(ishst);
1938                 paddr = VM_PAGE_TO_PHYS(nkpg);
1939                 pmap_store(l2, paddr | L2_TABLE);
1940
1941                 kernel_vm_end = (kernel_vm_end + L2_SIZE) & ~L2_OFFSET;
1942                 if (kernel_vm_end - 1 >= vm_map_max(kernel_map)) {
1943                         kernel_vm_end = vm_map_max(kernel_map);
1944                         break;
1945                 }
1946         }
1947 }
1948
1949
1950 /***************************************************
1951  * page management routines.
1952  ***************************************************/
1953
1954 CTASSERT(sizeof(struct pv_chunk) == PAGE_SIZE);
1955 CTASSERT(_NPCM == 3);
1956 CTASSERT(_NPCPV == 168);
1957
1958 static __inline struct pv_chunk *
1959 pv_to_chunk(pv_entry_t pv)
1960 {
1961
1962         return ((struct pv_chunk *)((uintptr_t)pv & ~(uintptr_t)PAGE_MASK));
1963 }
1964
1965 #define PV_PMAP(pv) (pv_to_chunk(pv)->pc_pmap)
1966
1967 #define PC_FREE0        0xfffffffffffffffful
1968 #define PC_FREE1        0xfffffffffffffffful
1969 #define PC_FREE2        0x000000fffffffffful
1970
1971 static const uint64_t pc_freemask[_NPCM] = { PC_FREE0, PC_FREE1, PC_FREE2 };
1972
1973 #if 0
1974 #ifdef PV_STATS
1975 static int pc_chunk_count, pc_chunk_allocs, pc_chunk_frees, pc_chunk_tryfail;
1976
1977 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_count, CTLFLAG_RD, &pc_chunk_count, 0,
1978         "Current number of pv entry chunks");
1979 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_allocs, CTLFLAG_RD, &pc_chunk_allocs, 0,
1980         "Current number of pv entry chunks allocated");
1981 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_frees, CTLFLAG_RD, &pc_chunk_frees, 0,
1982         "Current number of pv entry chunks frees");
1983 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_tryfail, CTLFLAG_RD, &pc_chunk_tryfail, 0,
1984         "Number of times tried to get a chunk page but failed.");
1985
1986 static long pv_entry_frees, pv_entry_allocs, pv_entry_count;
1987 static int pv_entry_spare;
1988
1989 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_frees, CTLFLAG_RD, &pv_entry_frees, 0,
1990         "Current number of pv entry frees");
1991 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_allocs, CTLFLAG_RD, &pv_entry_allocs, 0,
1992         "Current number of pv entry allocs");
1993 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_count, CTLFLAG_RD, &pv_entry_count, 0,
1994         "Current number of pv entries");
1995 SYSCTL_INT(_vm_pmap, OID_AUTO, pv_entry_spare, CTLFLAG_RD, &pv_entry_spare, 0,
1996         "Current number of spare pv entries");
1997 #endif
1998 #endif /* 0 */
1999
2000 /*
2001  * We are in a serious low memory condition.  Resort to
2002  * drastic measures to free some pages so we can allocate
2003  * another pv entry chunk.
2004  *
2005  * Returns NULL if PV entries were reclaimed from the specified pmap.
2006  *
2007  * We do not, however, unmap 2mpages because subsequent accesses will
2008  * allocate per-page pv entries until repromotion occurs, thereby
2009  * exacerbating the shortage of free pv entries.
2010  */
2011 static vm_page_t
2012 reclaim_pv_chunk(pmap_t locked_pmap, struct rwlock **lockp)
2013 {
2014         struct pv_chunk *pc, *pc_marker, *pc_marker_end;
2015         struct pv_chunk_header pc_marker_b, pc_marker_end_b;
2016         struct md_page *pvh;
2017         pd_entry_t *pde;
2018         pmap_t next_pmap, pmap;
2019         pt_entry_t *pte, tpte;
2020         pv_entry_t pv;
2021         vm_offset_t va;
2022         vm_page_t m, m_pc;
2023         struct spglist free;
2024         uint64_t inuse;
2025         int bit, field, freed, lvl;
2026         static int active_reclaims = 0;
2027
2028         PMAP_LOCK_ASSERT(locked_pmap, MA_OWNED);
2029         KASSERT(lockp != NULL, ("reclaim_pv_chunk: lockp is NULL"));
2030
2031         pmap = NULL;
2032         m_pc = NULL;
2033         SLIST_INIT(&free);
2034         bzero(&pc_marker_b, sizeof(pc_marker_b));
2035         bzero(&pc_marker_end_b, sizeof(pc_marker_end_b));
2036         pc_marker = (struct pv_chunk *)&pc_marker_b;
2037         pc_marker_end = (struct pv_chunk *)&pc_marker_end_b;
2038
2039         mtx_lock(&pv_chunks_mutex);
2040         active_reclaims++;
2041         TAILQ_INSERT_HEAD(&pv_chunks, pc_marker, pc_lru);
2042         TAILQ_INSERT_TAIL(&pv_chunks, pc_marker_end, pc_lru);
2043         while ((pc = TAILQ_NEXT(pc_marker, pc_lru)) != pc_marker_end &&
2044             SLIST_EMPTY(&free)) {
2045                 next_pmap = pc->pc_pmap;
2046                 if (next_pmap == NULL) {
2047                         /*
2048                          * The next chunk is a marker.  However, it is
2049                          * not our marker, so active_reclaims must be
2050                          * > 1.  Consequently, the next_chunk code
2051                          * will not rotate the pv_chunks list.
2052                          */
2053                         goto next_chunk;
2054                 }
2055                 mtx_unlock(&pv_chunks_mutex);
2056
2057                 /*
2058                  * A pv_chunk can only be removed from the pc_lru list
2059                  * when both pv_chunks_mutex is owned and the
2060                  * corresponding pmap is locked.
2061                  */
2062                 if (pmap != next_pmap) {
2063                         if (pmap != NULL && pmap != locked_pmap)
2064                                 PMAP_UNLOCK(pmap);
2065                         pmap = next_pmap;
2066                         /* Avoid deadlock and lock recursion. */
2067                         if (pmap > locked_pmap) {
2068                                 RELEASE_PV_LIST_LOCK(lockp);
2069                                 PMAP_LOCK(pmap);
2070                                 mtx_lock(&pv_chunks_mutex);
2071                                 continue;
2072                         } else if (pmap != locked_pmap) {
2073                                 if (PMAP_TRYLOCK(pmap)) {
2074                                         mtx_lock(&pv_chunks_mutex);
2075                                         continue;
2076                                 } else {
2077                                         pmap = NULL; /* pmap is not locked */
2078                                         mtx_lock(&pv_chunks_mutex);
2079                                         pc = TAILQ_NEXT(pc_marker, pc_lru);
2080                                         if (pc == NULL ||
2081                                             pc->pc_pmap != next_pmap)
2082                                                 continue;
2083                                         goto next_chunk;
2084                                 }
2085                         }
2086                 }
2087
2088                 /*
2089                  * Destroy every non-wired, 4 KB page mapping in the chunk.
2090                  */
2091                 freed = 0;
2092                 for (field = 0; field < _NPCM; field++) {
2093                         for (inuse = ~pc->pc_map[field] & pc_freemask[field];
2094                             inuse != 0; inuse &= ~(1UL << bit)) {
2095                                 bit = ffsl(inuse) - 1;
2096                                 pv = &pc->pc_pventry[field * 64 + bit];
2097                                 va = pv->pv_va;
2098                                 pde = pmap_pde(pmap, va, &lvl);
2099                                 if (lvl != 2)
2100                                         continue;
2101                                 pte = pmap_l2_to_l3(pde, va);
2102                                 tpte = pmap_load(pte);
2103                                 if ((tpte & ATTR_SW_WIRED) != 0)
2104                                         continue;
2105                                 tpte = pmap_load_clear(pte);
2106                                 m = PHYS_TO_VM_PAGE(tpte & ~ATTR_MASK);
2107                                 if (pmap_pte_dirty(pmap, tpte))
2108                                         vm_page_dirty(m);
2109                                 if ((tpte & ATTR_AF) != 0) {
2110                                         pmap_invalidate_page(pmap, va);
2111                                         vm_page_aflag_set(m, PGA_REFERENCED);
2112                                 }
2113                                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m);
2114                                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
2115                                 m->md.pv_gen++;
2116                                 if (TAILQ_EMPTY(&m->md.pv_list) &&
2117                                     (m->flags & PG_FICTITIOUS) == 0) {
2118                                         pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
2119                                         if (TAILQ_EMPTY(&pvh->pv_list)) {
2120                                                 vm_page_aflag_clear(m,
2121                                                     PGA_WRITEABLE);
2122                                         }
2123                                 }
2124                                 pc->pc_map[field] |= 1UL << bit;
2125                                 pmap_unuse_pt(pmap, va, pmap_load(pde), &free);
2126                                 freed++;
2127                         }
2128                 }
2129                 if (freed == 0) {
2130                         mtx_lock(&pv_chunks_mutex);
2131                         goto next_chunk;
2132                 }
2133                 /* Every freed mapping is for a 4 KB page. */
2134                 pmap_resident_count_dec(pmap, freed);
2135                 PV_STAT(atomic_add_long(&pv_entry_frees, freed));
2136                 PV_STAT(atomic_add_int(&pv_entry_spare, freed));
2137                 PV_STAT(atomic_subtract_long(&pv_entry_count, freed));
2138                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2139                 if (pc->pc_map[0] == PC_FREE0 && pc->pc_map[1] == PC_FREE1 &&
2140                     pc->pc_map[2] == PC_FREE2) {
2141                         PV_STAT(atomic_subtract_int(&pv_entry_spare, _NPCPV));
2142                         PV_STAT(atomic_subtract_int(&pc_chunk_count, 1));
2143                         PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
2144                         /* Entire chunk is free; return it. */
2145                         m_pc = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
2146                         dump_drop_page(m_pc->phys_addr);
2147                         mtx_lock(&pv_chunks_mutex);
2148                         TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
2149                         break;
2150                 }
2151                 TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
2152                 mtx_lock(&pv_chunks_mutex);
2153                 /* One freed pv entry in locked_pmap is sufficient. */
2154                 if (pmap == locked_pmap)
2155                         break;
2156
2157 next_chunk:
2158                 TAILQ_REMOVE(&pv_chunks, pc_marker, pc_lru);
2159                 TAILQ_INSERT_AFTER(&pv_chunks, pc, pc_marker, pc_lru);
2160                 if (active_reclaims == 1 && pmap != NULL) {
2161                         /*
2162                          * Rotate the pv chunks list so that we do not
2163                          * scan the same pv chunks that could not be
2164                          * freed (because they contained a wired
2165                          * and/or superpage mapping) on every
2166                          * invocation of reclaim_pv_chunk().
2167                          */
2168                         while ((pc = TAILQ_FIRST(&pv_chunks)) != pc_marker) {
2169                                 MPASS(pc->pc_pmap != NULL);
2170                                 TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
2171                                 TAILQ_INSERT_TAIL(&pv_chunks, pc, pc_lru);
2172                         }
2173                 }
2174         }
2175         TAILQ_REMOVE(&pv_chunks, pc_marker, pc_lru);
2176         TAILQ_REMOVE(&pv_chunks, pc_marker_end, pc_lru);
2177         active_reclaims--;
2178         mtx_unlock(&pv_chunks_mutex);
2179         if (pmap != NULL && pmap != locked_pmap)
2180                 PMAP_UNLOCK(pmap);
2181         if (m_pc == NULL && !SLIST_EMPTY(&free)) {
2182                 m_pc = SLIST_FIRST(&free);
2183                 SLIST_REMOVE_HEAD(&free, plinks.s.ss);
2184                 /* Recycle a freed page table page. */
2185                 m_pc->ref_count = 1;
2186         }
2187         vm_page_free_pages_toq(&free, true);
2188         return (m_pc);
2189 }
2190
2191 /*
2192  * free the pv_entry back to the free list
2193  */
2194 static void
2195 free_pv_entry(pmap_t pmap, pv_entry_t pv)
2196 {
2197         struct pv_chunk *pc;
2198         int idx, field, bit;
2199
2200         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2201         PV_STAT(atomic_add_long(&pv_entry_frees, 1));
2202         PV_STAT(atomic_add_int(&pv_entry_spare, 1));
2203         PV_STAT(atomic_subtract_long(&pv_entry_count, 1));
2204         pc = pv_to_chunk(pv);
2205         idx = pv - &pc->pc_pventry[0];
2206         field = idx / 64;
2207         bit = idx % 64;
2208         pc->pc_map[field] |= 1ul << bit;
2209         if (pc->pc_map[0] != PC_FREE0 || pc->pc_map[1] != PC_FREE1 ||
2210             pc->pc_map[2] != PC_FREE2) {
2211                 /* 98% of the time, pc is already at the head of the list. */
2212                 if (__predict_false(pc != TAILQ_FIRST(&pmap->pm_pvchunk))) {
2213                         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2214                         TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
2215                 }
2216                 return;
2217         }
2218         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2219         free_pv_chunk(pc);
2220 }
2221
2222 static void
2223 free_pv_chunk(struct pv_chunk *pc)
2224 {
2225         vm_page_t m;
2226
2227         mtx_lock(&pv_chunks_mutex);
2228         TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
2229         mtx_unlock(&pv_chunks_mutex);
2230         PV_STAT(atomic_subtract_int(&pv_entry_spare, _NPCPV));
2231         PV_STAT(atomic_subtract_int(&pc_chunk_count, 1));
2232         PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
2233         /* entire chunk is free, return it */
2234         m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
2235         dump_drop_page(m->phys_addr);
2236         vm_page_unwire_noq(m);
2237         vm_page_free(m);
2238 }
2239
2240 /*
2241  * Returns a new PV entry, allocating a new PV chunk from the system when
2242  * needed.  If this PV chunk allocation fails and a PV list lock pointer was
2243  * given, a PV chunk is reclaimed from an arbitrary pmap.  Otherwise, NULL is
2244  * returned.
2245  *
2246  * The given PV list lock may be released.
2247  */
2248 static pv_entry_t
2249 get_pv_entry(pmap_t pmap, struct rwlock **lockp)
2250 {
2251         int bit, field;
2252         pv_entry_t pv;
2253         struct pv_chunk *pc;
2254         vm_page_t m;
2255
2256         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2257         PV_STAT(atomic_add_long(&pv_entry_allocs, 1));
2258 retry:
2259         pc = TAILQ_FIRST(&pmap->pm_pvchunk);
2260         if (pc != NULL) {
2261                 for (field = 0; field < _NPCM; field++) {
2262                         if (pc->pc_map[field]) {
2263                                 bit = ffsl(pc->pc_map[field]) - 1;
2264                                 break;
2265                         }
2266                 }
2267                 if (field < _NPCM) {
2268                         pv = &pc->pc_pventry[field * 64 + bit];
2269                         pc->pc_map[field] &= ~(1ul << bit);
2270                         /* If this was the last item, move it to tail */
2271                         if (pc->pc_map[0] == 0 && pc->pc_map[1] == 0 &&
2272                             pc->pc_map[2] == 0) {
2273                                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2274                                 TAILQ_INSERT_TAIL(&pmap->pm_pvchunk, pc,
2275                                     pc_list);
2276                         }
2277                         PV_STAT(atomic_add_long(&pv_entry_count, 1));
2278                         PV_STAT(atomic_subtract_int(&pv_entry_spare, 1));
2279                         return (pv);
2280                 }
2281         }
2282         /* No free items, allocate another chunk */
2283         m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ |
2284             VM_ALLOC_WIRED);
2285         if (m == NULL) {
2286                 if (lockp == NULL) {
2287                         PV_STAT(pc_chunk_tryfail++);
2288                         return (NULL);
2289                 }
2290                 m = reclaim_pv_chunk(pmap, lockp);
2291                 if (m == NULL)
2292                         goto retry;
2293         }
2294         PV_STAT(atomic_add_int(&pc_chunk_count, 1));
2295         PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
2296         dump_add_page(m->phys_addr);
2297         pc = (void *)PHYS_TO_DMAP(m->phys_addr);
2298         pc->pc_pmap = pmap;
2299         pc->pc_map[0] = PC_FREE0 & ~1ul;        /* preallocated bit 0 */
2300         pc->pc_map[1] = PC_FREE1;
2301         pc->pc_map[2] = PC_FREE2;
2302         mtx_lock(&pv_chunks_mutex);
2303         TAILQ_INSERT_TAIL(&pv_chunks, pc, pc_lru);
2304         mtx_unlock(&pv_chunks_mutex);
2305         pv = &pc->pc_pventry[0];
2306         TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
2307         PV_STAT(atomic_add_long(&pv_entry_count, 1));
2308         PV_STAT(atomic_add_int(&pv_entry_spare, _NPCPV - 1));
2309         return (pv);
2310 }
2311
2312 /*
2313  * Ensure that the number of spare PV entries in the specified pmap meets or
2314  * exceeds the given count, "needed".
2315  *
2316  * The given PV list lock may be released.
2317  */
2318 static void
2319 reserve_pv_entries(pmap_t pmap, int needed, struct rwlock **lockp)
2320 {
2321         struct pch new_tail;
2322         struct pv_chunk *pc;
2323         vm_page_t m;
2324         int avail, free;
2325         bool reclaimed;
2326
2327         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2328         KASSERT(lockp != NULL, ("reserve_pv_entries: lockp is NULL"));
2329
2330         /*
2331          * Newly allocated PV chunks must be stored in a private list until
2332          * the required number of PV chunks have been allocated.  Otherwise,
2333          * reclaim_pv_chunk() could recycle one of these chunks.  In
2334          * contrast, these chunks must be added to the pmap upon allocation.
2335          */
2336         TAILQ_INIT(&new_tail);
2337 retry:
2338         avail = 0;
2339         TAILQ_FOREACH(pc, &pmap->pm_pvchunk, pc_list) {
2340                 bit_count((bitstr_t *)pc->pc_map, 0,
2341                     sizeof(pc->pc_map) * NBBY, &free);
2342                 if (free == 0)
2343                         break;
2344                 avail += free;
2345                 if (avail >= needed)
2346                         break;
2347         }
2348         for (reclaimed = false; avail < needed; avail += _NPCPV) {
2349                 m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ |
2350                     VM_ALLOC_WIRED);
2351                 if (m == NULL) {
2352                         m = reclaim_pv_chunk(pmap, lockp);
2353                         if (m == NULL)
2354                                 goto retry;
2355                         reclaimed = true;
2356                 }
2357                 PV_STAT(atomic_add_int(&pc_chunk_count, 1));
2358                 PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
2359                 dump_add_page(m->phys_addr);
2360                 pc = (void *)PHYS_TO_DMAP(m->phys_addr);
2361                 pc->pc_pmap = pmap;
2362                 pc->pc_map[0] = PC_FREE0;
2363                 pc->pc_map[1] = PC_FREE1;
2364                 pc->pc_map[2] = PC_FREE2;
2365                 TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
2366                 TAILQ_INSERT_TAIL(&new_tail, pc, pc_lru);
2367                 PV_STAT(atomic_add_int(&pv_entry_spare, _NPCPV));
2368
2369                 /*
2370                  * The reclaim might have freed a chunk from the current pmap.
2371                  * If that chunk contained available entries, we need to
2372                  * re-count the number of available entries.
2373                  */
2374                 if (reclaimed)
2375                         goto retry;
2376         }
2377         if (!TAILQ_EMPTY(&new_tail)) {
2378                 mtx_lock(&pv_chunks_mutex);
2379                 TAILQ_CONCAT(&pv_chunks, &new_tail, pc_lru);
2380                 mtx_unlock(&pv_chunks_mutex);
2381         }
2382 }
2383
2384 /*
2385  * First find and then remove the pv entry for the specified pmap and virtual
2386  * address from the specified pv list.  Returns the pv entry if found and NULL
2387  * otherwise.  This operation can be performed on pv lists for either 4KB or
2388  * 2MB page mappings.
2389  */
2390 static __inline pv_entry_t
2391 pmap_pvh_remove(struct md_page *pvh, pmap_t pmap, vm_offset_t va)
2392 {
2393         pv_entry_t pv;
2394
2395         TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
2396                 if (pmap == PV_PMAP(pv) && va == pv->pv_va) {
2397                         TAILQ_REMOVE(&pvh->pv_list, pv, pv_next);
2398                         pvh->pv_gen++;
2399                         break;
2400                 }
2401         }
2402         return (pv);
2403 }
2404
2405 /*
2406  * After demotion from a 2MB page mapping to 512 4KB page mappings,
2407  * destroy the pv entry for the 2MB page mapping and reinstantiate the pv
2408  * entries for each of the 4KB page mappings.
2409  */
2410 static void
2411 pmap_pv_demote_l2(pmap_t pmap, vm_offset_t va, vm_paddr_t pa,
2412     struct rwlock **lockp)
2413 {
2414         struct md_page *pvh;
2415         struct pv_chunk *pc;
2416         pv_entry_t pv;
2417         vm_offset_t va_last;
2418         vm_page_t m;
2419         int bit, field;
2420
2421         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2422         KASSERT((va & L2_OFFSET) == 0,
2423             ("pmap_pv_demote_l2: va is not 2mpage aligned"));
2424         KASSERT((pa & L2_OFFSET) == 0,
2425             ("pmap_pv_demote_l2: pa is not 2mpage aligned"));
2426         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa);
2427
2428         /*
2429          * Transfer the 2mpage's pv entry for this mapping to the first
2430          * page's pv list.  Once this transfer begins, the pv list lock
2431          * must not be released until the last pv entry is reinstantiated.
2432          */
2433         pvh = pa_to_pvh(pa);
2434         pv = pmap_pvh_remove(pvh, pmap, va);
2435         KASSERT(pv != NULL, ("pmap_pv_demote_l2: pv not found"));
2436         m = PHYS_TO_VM_PAGE(pa);
2437         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
2438         m->md.pv_gen++;
2439         /* Instantiate the remaining Ln_ENTRIES - 1 pv entries. */
2440         PV_STAT(atomic_add_long(&pv_entry_allocs, Ln_ENTRIES - 1));
2441         va_last = va + L2_SIZE - PAGE_SIZE;
2442         for (;;) {
2443                 pc = TAILQ_FIRST(&pmap->pm_pvchunk);
2444                 KASSERT(pc->pc_map[0] != 0 || pc->pc_map[1] != 0 ||
2445                     pc->pc_map[2] != 0, ("pmap_pv_demote_l2: missing spare"));
2446                 for (field = 0; field < _NPCM; field++) {
2447                         while (pc->pc_map[field]) {
2448                                 bit = ffsl(pc->pc_map[field]) - 1;
2449                                 pc->pc_map[field] &= ~(1ul << bit);
2450                                 pv = &pc->pc_pventry[field * 64 + bit];
2451                                 va += PAGE_SIZE;
2452                                 pv->pv_va = va;
2453                                 m++;
2454                                 KASSERT((m->oflags & VPO_UNMANAGED) == 0,
2455                             ("pmap_pv_demote_l2: page %p is not managed", m));
2456                                 TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
2457                                 m->md.pv_gen++;
2458                                 if (va == va_last)
2459                                         goto out;
2460                         }
2461                 }
2462                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2463                 TAILQ_INSERT_TAIL(&pmap->pm_pvchunk, pc, pc_list);
2464         }
2465 out:
2466         if (pc->pc_map[0] == 0 && pc->pc_map[1] == 0 && pc->pc_map[2] == 0) {
2467                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2468                 TAILQ_INSERT_TAIL(&pmap->pm_pvchunk, pc, pc_list);
2469         }
2470         PV_STAT(atomic_add_long(&pv_entry_count, Ln_ENTRIES - 1));
2471         PV_STAT(atomic_subtract_int(&pv_entry_spare, Ln_ENTRIES - 1));
2472 }
2473
2474 /*
2475  * First find and then destroy the pv entry for the specified pmap and virtual
2476  * address.  This operation can be performed on pv lists for either 4KB or 2MB
2477  * page mappings.
2478  */
2479 static void
2480 pmap_pvh_free(struct md_page *pvh, pmap_t pmap, vm_offset_t va)
2481 {
2482         pv_entry_t pv;
2483
2484         pv = pmap_pvh_remove(pvh, pmap, va);
2485         KASSERT(pv != NULL, ("pmap_pvh_free: pv not found"));
2486         free_pv_entry(pmap, pv);
2487 }
2488
2489 /*
2490  * Conditionally create the PV entry for a 4KB page mapping if the required
2491  * memory can be allocated without resorting to reclamation.
2492  */
2493 static boolean_t
2494 pmap_try_insert_pv_entry(pmap_t pmap, vm_offset_t va, vm_page_t m,
2495     struct rwlock **lockp)
2496 {
2497         pv_entry_t pv;
2498
2499         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2500         /* Pass NULL instead of the lock pointer to disable reclamation. */
2501         if ((pv = get_pv_entry(pmap, NULL)) != NULL) {
2502                 pv->pv_va = va;
2503                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m);
2504                 TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
2505                 m->md.pv_gen++;
2506                 return (TRUE);
2507         } else
2508                 return (FALSE);
2509 }
2510
2511 /*
2512  * Create the PV entry for a 2MB page mapping.  Always returns true unless the
2513  * flag PMAP_ENTER_NORECLAIM is specified.  If that flag is specified, returns
2514  * false if the PV entry cannot be allocated without resorting to reclamation.
2515  */
2516 static bool
2517 pmap_pv_insert_l2(pmap_t pmap, vm_offset_t va, pd_entry_t l2e, u_int flags,
2518     struct rwlock **lockp)
2519 {
2520         struct md_page *pvh;
2521         pv_entry_t pv;
2522         vm_paddr_t pa;
2523
2524         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2525         /* Pass NULL instead of the lock pointer to disable reclamation. */
2526         if ((pv = get_pv_entry(pmap, (flags & PMAP_ENTER_NORECLAIM) != 0 ?
2527             NULL : lockp)) == NULL)
2528                 return (false);
2529         pv->pv_va = va;
2530         pa = l2e & ~ATTR_MASK;
2531         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa);
2532         pvh = pa_to_pvh(pa);
2533         TAILQ_INSERT_TAIL(&pvh->pv_list, pv, pv_next);
2534         pvh->pv_gen++;
2535         return (true);
2536 }
2537
2538 static void
2539 pmap_remove_kernel_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t va)
2540 {
2541         pt_entry_t newl2, oldl2;
2542         vm_page_t ml3;
2543         vm_paddr_t ml3pa;
2544
2545         KASSERT(!VIRT_IN_DMAP(va), ("removing direct mapping of %#lx", va));
2546         KASSERT(pmap == kernel_pmap, ("pmap %p is not kernel_pmap", pmap));
2547         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2548
2549         ml3 = pmap_remove_pt_page(pmap, va);
2550         if (ml3 == NULL)
2551                 panic("pmap_remove_kernel_l2: Missing pt page");
2552
2553         ml3pa = VM_PAGE_TO_PHYS(ml3);
2554         newl2 = ml3pa | L2_TABLE;
2555
2556         /*
2557          * If this page table page was unmapped by a promotion, then it
2558          * contains valid mappings.  Zero it to invalidate those mappings.
2559          */
2560         if (ml3->valid != 0)
2561                 pagezero((void *)PHYS_TO_DMAP(ml3pa));
2562
2563         /*
2564          * Demote the mapping.  The caller must have already invalidated the
2565          * mapping (i.e., the "break" in break-before-make).
2566          */
2567         oldl2 = pmap_load_store(l2, newl2);
2568         KASSERT(oldl2 == 0, ("%s: found existing mapping at %p: %#lx",
2569             __func__, l2, oldl2));
2570 }
2571
2572 /*
2573  * pmap_remove_l2: Do the things to unmap a level 2 superpage.
2574  */
2575 static int
2576 pmap_remove_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t sva,
2577     pd_entry_t l1e, struct spglist *free, struct rwlock **lockp)
2578 {
2579         struct md_page *pvh;
2580         pt_entry_t old_l2;
2581         vm_offset_t eva, va;
2582         vm_page_t m, ml3;
2583
2584         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2585         KASSERT((sva & L2_OFFSET) == 0, ("pmap_remove_l2: sva is not aligned"));
2586         old_l2 = pmap_load_clear(l2);
2587         KASSERT((old_l2 & ATTR_DESCR_MASK) == L2_BLOCK,
2588             ("pmap_remove_l2: L2e %lx is not a block mapping", old_l2));
2589
2590         /*
2591          * Since a promotion must break the 4KB page mappings before making
2592          * the 2MB page mapping, a pmap_invalidate_page() suffices.
2593          */
2594         pmap_invalidate_page(pmap, sva);
2595
2596         if (old_l2 & ATTR_SW_WIRED)
2597                 pmap->pm_stats.wired_count -= L2_SIZE / PAGE_SIZE;
2598         pmap_resident_count_dec(pmap, L2_SIZE / PAGE_SIZE);
2599         if (old_l2 & ATTR_SW_MANAGED) {
2600                 CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, old_l2 & ~ATTR_MASK);
2601                 pvh = pa_to_pvh(old_l2 & ~ATTR_MASK);
2602                 pmap_pvh_free(pvh, pmap, sva);
2603                 eva = sva + L2_SIZE;
2604                 for (va = sva, m = PHYS_TO_VM_PAGE(old_l2 & ~ATTR_MASK);
2605                     va < eva; va += PAGE_SIZE, m++) {
2606                         if (pmap_pte_dirty(pmap, old_l2))
2607                                 vm_page_dirty(m);
2608                         if (old_l2 & ATTR_AF)
2609                                 vm_page_aflag_set(m, PGA_REFERENCED);
2610                         if (TAILQ_EMPTY(&m->md.pv_list) &&
2611                             TAILQ_EMPTY(&pvh->pv_list))
2612                                 vm_page_aflag_clear(m, PGA_WRITEABLE);
2613                 }
2614         }
2615         if (pmap == kernel_pmap) {
2616                 pmap_remove_kernel_l2(pmap, l2, sva);
2617         } else {
2618                 ml3 = pmap_remove_pt_page(pmap, sva);
2619                 if (ml3 != NULL) {
2620                         KASSERT(ml3->valid == VM_PAGE_BITS_ALL,
2621                             ("pmap_remove_l2: l3 page not promoted"));
2622                         pmap_resident_count_dec(pmap, 1);
2623                         KASSERT(ml3->ref_count == NL3PG,
2624                             ("pmap_remove_l2: l3 page ref count error"));
2625                         ml3->ref_count = 0;
2626                         pmap_add_delayed_free_list(ml3, free, FALSE);
2627                 }
2628         }
2629         return (pmap_unuse_pt(pmap, sva, l1e, free));
2630 }
2631
2632 /*
2633  * pmap_remove_l3: do the things to unmap a page in a process
2634  */
2635 static int
2636 pmap_remove_l3(pmap_t pmap, pt_entry_t *l3, vm_offset_t va,
2637     pd_entry_t l2e, struct spglist *free, struct rwlock **lockp)
2638 {
2639         struct md_page *pvh;
2640         pt_entry_t old_l3;
2641         vm_page_t m;
2642
2643         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2644         old_l3 = pmap_load_clear(l3);
2645         pmap_invalidate_page(pmap, va);
2646         if (old_l3 & ATTR_SW_WIRED)
2647                 pmap->pm_stats.wired_count -= 1;
2648         pmap_resident_count_dec(pmap, 1);
2649         if (old_l3 & ATTR_SW_MANAGED) {
2650                 m = PHYS_TO_VM_PAGE(old_l3 & ~ATTR_MASK);
2651                 if (pmap_pte_dirty(pmap, old_l3))
2652                         vm_page_dirty(m);
2653                 if (old_l3 & ATTR_AF)
2654                         vm_page_aflag_set(m, PGA_REFERENCED);
2655                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m);
2656                 pmap_pvh_free(&m->md, pmap, va);
2657                 if (TAILQ_EMPTY(&m->md.pv_list) &&
2658                     (m->flags & PG_FICTITIOUS) == 0) {
2659                         pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
2660                         if (TAILQ_EMPTY(&pvh->pv_list))
2661                                 vm_page_aflag_clear(m, PGA_WRITEABLE);
2662                 }
2663         }
2664         return (pmap_unuse_pt(pmap, va, l2e, free));
2665 }
2666
2667 /*
2668  * Remove the specified range of addresses from the L3 page table that is
2669  * identified by the given L2 entry.
2670  */
2671 static void
2672 pmap_remove_l3_range(pmap_t pmap, pd_entry_t l2e, vm_offset_t sva,
2673     vm_offset_t eva, struct spglist *free, struct rwlock **lockp)
2674 {
2675         struct md_page *pvh;
2676         struct rwlock *new_lock;
2677         pt_entry_t *l3, old_l3;
2678         vm_offset_t va;
2679         vm_page_t l3pg, m;
2680
2681         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2682         KASSERT(rounddown2(sva, L2_SIZE) + L2_SIZE == roundup2(eva, L2_SIZE),
2683             ("pmap_remove_l3_range: range crosses an L3 page table boundary"));
2684         l3pg = sva < VM_MAXUSER_ADDRESS ? PHYS_TO_VM_PAGE(l2e & ~ATTR_MASK) :
2685             NULL;
2686         va = eva;
2687         for (l3 = pmap_l2_to_l3(&l2e, sva); sva != eva; l3++, sva += L3_SIZE) {
2688                 if (!pmap_l3_valid(pmap_load(l3))) {
2689                         if (va != eva) {
2690                                 pmap_invalidate_range(pmap, va, sva);
2691                                 va = eva;
2692                         }
2693                         continue;
2694                 }
2695                 old_l3 = pmap_load_clear(l3);
2696                 if ((old_l3 & ATTR_SW_WIRED) != 0)
2697                         pmap->pm_stats.wired_count--;
2698                 pmap_resident_count_dec(pmap, 1);
2699                 if ((old_l3 & ATTR_SW_MANAGED) != 0) {
2700                         m = PHYS_TO_VM_PAGE(old_l3 & ~ATTR_MASK);
2701                         if (pmap_pte_dirty(pmap, old_l3))
2702                                 vm_page_dirty(m);
2703                         if ((old_l3 & ATTR_AF) != 0)
2704                                 vm_page_aflag_set(m, PGA_REFERENCED);
2705                         new_lock = PHYS_TO_PV_LIST_LOCK(VM_PAGE_TO_PHYS(m));
2706                         if (new_lock != *lockp) {
2707                                 if (*lockp != NULL) {
2708                                         /*
2709                                          * Pending TLB invalidations must be
2710                                          * performed before the PV list lock is
2711                                          * released.  Otherwise, a concurrent
2712                                          * pmap_remove_all() on a physical page
2713                                          * could return while a stale TLB entry
2714                                          * still provides access to that page.
2715                                          */
2716                                         if (va != eva) {
2717                                                 pmap_invalidate_range(pmap, va,
2718                                                     sva);
2719                                                 va = eva;
2720                                         }
2721                                         rw_wunlock(*lockp);
2722                                 }
2723                                 *lockp = new_lock;
2724                                 rw_wlock(*lockp);
2725                         }
2726                         pmap_pvh_free(&m->md, pmap, sva);
2727                         if (TAILQ_EMPTY(&m->md.pv_list) &&
2728                             (m->flags & PG_FICTITIOUS) == 0) {
2729                                 pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
2730                                 if (TAILQ_EMPTY(&pvh->pv_list))
2731                                         vm_page_aflag_clear(m, PGA_WRITEABLE);
2732                         }
2733                 }
2734                 if (va == eva)
2735                         va = sva;
2736                 if (l3pg != NULL && pmap_unwire_l3(pmap, sva, l3pg, free)) {
2737                         sva += L3_SIZE;
2738                         break;
2739                 }
2740         }
2741         if (va != eva)
2742                 pmap_invalidate_range(pmap, va, sva);
2743 }
2744
2745 /*
2746  *      Remove the given range of addresses from the specified map.
2747  *
2748  *      It is assumed that the start and end are properly
2749  *      rounded to the page size.
2750  */
2751 void
2752 pmap_remove(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
2753 {
2754         struct rwlock *lock;
2755         vm_offset_t va_next;
2756         pd_entry_t *l0, *l1, *l2;
2757         pt_entry_t l3_paddr;
2758         struct spglist free;
2759
2760         /*
2761          * Perform an unsynchronized read.  This is, however, safe.
2762          */
2763         if (pmap->pm_stats.resident_count == 0)
2764                 return;
2765
2766         SLIST_INIT(&free);
2767
2768         PMAP_LOCK(pmap);
2769
2770         lock = NULL;
2771         for (; sva < eva; sva = va_next) {
2772
2773                 if (pmap->pm_stats.resident_count == 0)
2774                         break;
2775
2776                 l0 = pmap_l0(pmap, sva);
2777                 if (pmap_load(l0) == 0) {
2778                         va_next = (sva + L0_SIZE) & ~L0_OFFSET;
2779                         if (va_next < sva)
2780                                 va_next = eva;
2781                         continue;
2782                 }
2783
2784                 l1 = pmap_l0_to_l1(l0, sva);
2785                 if (pmap_load(l1) == 0) {
2786                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
2787                         if (va_next < sva)
2788                                 va_next = eva;
2789                         continue;
2790                 }
2791
2792                 /*
2793                  * Calculate index for next page table.
2794                  */
2795                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
2796                 if (va_next < sva)
2797                         va_next = eva;
2798
2799                 l2 = pmap_l1_to_l2(l1, sva);
2800                 if (l2 == NULL)
2801                         continue;
2802
2803                 l3_paddr = pmap_load(l2);
2804
2805                 if ((l3_paddr & ATTR_DESCR_MASK) == L2_BLOCK) {
2806                         if (sva + L2_SIZE == va_next && eva >= va_next) {
2807                                 pmap_remove_l2(pmap, l2, sva, pmap_load(l1),
2808                                     &free, &lock);
2809                                 continue;
2810                         } else if (pmap_demote_l2_locked(pmap, l2, sva,
2811                             &lock) == NULL)
2812                                 continue;
2813                         l3_paddr = pmap_load(l2);
2814                 }
2815
2816                 /*
2817                  * Weed out invalid mappings.
2818                  */
2819                 if ((l3_paddr & ATTR_DESCR_MASK) != L2_TABLE)
2820                         continue;
2821
2822                 /*
2823                  * Limit our scan to either the end of the va represented
2824                  * by the current page table page, or to the end of the
2825                  * range being removed.
2826                  */
2827                 if (va_next > eva)
2828                         va_next = eva;
2829
2830                 pmap_remove_l3_range(pmap, l3_paddr, sva, va_next, &free,
2831                     &lock);
2832         }
2833         if (lock != NULL)
2834                 rw_wunlock(lock);
2835         PMAP_UNLOCK(pmap);
2836         vm_page_free_pages_toq(&free, true);
2837 }
2838
2839 /*
2840  *      Routine:        pmap_remove_all
2841  *      Function:
2842  *              Removes this physical page from
2843  *              all physical maps in which it resides.
2844  *              Reflects back modify bits to the pager.
2845  *
2846  *      Notes:
2847  *              Original versions of this routine were very
2848  *              inefficient because they iteratively called
2849  *              pmap_remove (slow...)
2850  */
2851
2852 void
2853 pmap_remove_all(vm_page_t m)
2854 {
2855         struct md_page *pvh;
2856         pv_entry_t pv;
2857         pmap_t pmap;
2858         struct rwlock *lock;
2859         pd_entry_t *pde, tpde;
2860         pt_entry_t *pte, tpte;
2861         vm_offset_t va;
2862         struct spglist free;
2863         int lvl, pvh_gen, md_gen;
2864
2865         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
2866             ("pmap_remove_all: page %p is not managed", m));
2867         SLIST_INIT(&free);
2868         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
2869         pvh = (m->flags & PG_FICTITIOUS) != 0 ? &pv_dummy :
2870             pa_to_pvh(VM_PAGE_TO_PHYS(m));
2871 retry:
2872         rw_wlock(lock);
2873         while ((pv = TAILQ_FIRST(&pvh->pv_list)) != NULL) {
2874                 pmap = PV_PMAP(pv);
2875                 if (!PMAP_TRYLOCK(pmap)) {
2876                         pvh_gen = pvh->pv_gen;
2877                         rw_wunlock(lock);
2878                         PMAP_LOCK(pmap);
2879                         rw_wlock(lock);
2880                         if (pvh_gen != pvh->pv_gen) {
2881                                 rw_wunlock(lock);
2882                                 PMAP_UNLOCK(pmap);
2883                                 goto retry;
2884                         }
2885                 }
2886                 va = pv->pv_va;
2887                 pte = pmap_pte(pmap, va, &lvl);
2888                 KASSERT(pte != NULL,
2889                     ("pmap_remove_all: no page table entry found"));
2890                 KASSERT(lvl == 2,
2891                     ("pmap_remove_all: invalid pte level %d", lvl));
2892
2893                 pmap_demote_l2_locked(pmap, pte, va, &lock);
2894                 PMAP_UNLOCK(pmap);
2895         }
2896         while ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
2897                 pmap = PV_PMAP(pv);
2898                 PMAP_ASSERT_STAGE1(pmap);
2899                 if (!PMAP_TRYLOCK(pmap)) {
2900                         pvh_gen = pvh->pv_gen;
2901                         md_gen = m->md.pv_gen;
2902                         rw_wunlock(lock);
2903                         PMAP_LOCK(pmap);
2904                         rw_wlock(lock);
2905                         if (pvh_gen != pvh->pv_gen || md_gen != m->md.pv_gen) {
2906                                 rw_wunlock(lock);
2907                                 PMAP_UNLOCK(pmap);
2908                                 goto retry;
2909                         }
2910                 }
2911                 pmap_resident_count_dec(pmap, 1);
2912
2913                 pde = pmap_pde(pmap, pv->pv_va, &lvl);
2914                 KASSERT(pde != NULL,
2915                     ("pmap_remove_all: no page directory entry found"));
2916                 KASSERT(lvl == 2,
2917                     ("pmap_remove_all: invalid pde level %d", lvl));
2918                 tpde = pmap_load(pde);
2919
2920                 pte = pmap_l2_to_l3(pde, pv->pv_va);
2921                 tpte = pmap_load_clear(pte);
2922                 if (tpte & ATTR_SW_WIRED)
2923                         pmap->pm_stats.wired_count--;
2924                 if ((tpte & ATTR_AF) != 0) {
2925                         pmap_invalidate_page(pmap, pv->pv_va);
2926                         vm_page_aflag_set(m, PGA_REFERENCED);
2927                 }
2928
2929                 /*
2930                  * Update the vm_page_t clean and reference bits.
2931                  */
2932                 if (pmap_pte_dirty(pmap, tpte))
2933                         vm_page_dirty(m);
2934                 pmap_unuse_pt(pmap, pv->pv_va, tpde, &free);
2935                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
2936                 m->md.pv_gen++;
2937                 free_pv_entry(pmap, pv);
2938                 PMAP_UNLOCK(pmap);
2939         }
2940         vm_page_aflag_clear(m, PGA_WRITEABLE);
2941         rw_wunlock(lock);
2942         vm_page_free_pages_toq(&free, true);
2943 }
2944
2945 /*
2946  * pmap_protect_l2: do the things to protect a 2MB page in a pmap
2947  */
2948 static void
2949 pmap_protect_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t sva, pt_entry_t mask,
2950     pt_entry_t nbits)
2951 {
2952         pd_entry_t old_l2;
2953         vm_page_t m, mt;
2954
2955         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2956         PMAP_ASSERT_STAGE1(pmap);
2957         KASSERT((sva & L2_OFFSET) == 0,
2958             ("pmap_protect_l2: sva is not 2mpage aligned"));
2959         old_l2 = pmap_load(l2);
2960         KASSERT((old_l2 & ATTR_DESCR_MASK) == L2_BLOCK,
2961             ("pmap_protect_l2: L2e %lx is not a block mapping", old_l2));
2962
2963         /*
2964          * Return if the L2 entry already has the desired access restrictions
2965          * in place.
2966          */
2967 retry:
2968         if ((old_l2 & mask) == nbits)
2969                 return;
2970
2971         /*
2972          * When a dirty read/write superpage mapping is write protected,
2973          * update the dirty field of each of the superpage's constituent 4KB
2974          * pages.
2975          */
2976         if ((old_l2 & ATTR_SW_MANAGED) != 0 &&
2977             (nbits & ATTR_S1_AP(ATTR_S1_AP_RO)) != 0 &&
2978             pmap_pte_dirty(pmap, old_l2)) {
2979                 m = PHYS_TO_VM_PAGE(old_l2 & ~ATTR_MASK);
2980                 for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)
2981                         vm_page_dirty(mt);
2982         }
2983
2984         if (!atomic_fcmpset_64(l2, &old_l2, (old_l2 & ~mask) | nbits))
2985                 goto retry;
2986
2987         /*
2988          * Since a promotion must break the 4KB page mappings before making
2989          * the 2MB page mapping, a pmap_invalidate_page() suffices.
2990          */
2991         pmap_invalidate_page(pmap, sva);
2992 }
2993
2994 /*
2995  *      Set the physical protection on the
2996  *      specified range of this map as requested.
2997  */
2998 void
2999 pmap_protect(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, vm_prot_t prot)
3000 {
3001         vm_offset_t va, va_next;
3002         pd_entry_t *l0, *l1, *l2;
3003         pt_entry_t *l3p, l3, mask, nbits;
3004
3005         PMAP_ASSERT_STAGE1(pmap);
3006         KASSERT((prot & ~VM_PROT_ALL) == 0, ("invalid prot %x", prot));
3007         if (prot == VM_PROT_NONE) {
3008                 pmap_remove(pmap, sva, eva);
3009                 return;
3010         }
3011
3012         mask = nbits = 0;
3013         if ((prot & VM_PROT_WRITE) == 0) {
3014                 mask |= ATTR_S1_AP_RW_BIT | ATTR_SW_DBM;
3015                 nbits |= ATTR_S1_AP(ATTR_S1_AP_RO);
3016         }
3017         if ((prot & VM_PROT_EXECUTE) == 0) {
3018                 mask |= ATTR_S1_XN;
3019                 nbits |= ATTR_S1_XN;
3020         }
3021         if (mask == 0)
3022                 return;
3023
3024         PMAP_LOCK(pmap);
3025         for (; sva < eva; sva = va_next) {
3026
3027                 l0 = pmap_l0(pmap, sva);
3028                 if (pmap_load(l0) == 0) {
3029                         va_next = (sva + L0_SIZE) & ~L0_OFFSET;
3030                         if (va_next < sva)
3031                                 va_next = eva;
3032                         continue;
3033                 }
3034
3035                 l1 = pmap_l0_to_l1(l0, sva);
3036                 if (pmap_load(l1) == 0) {
3037                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
3038                         if (va_next < sva)
3039                                 va_next = eva;
3040                         continue;
3041                 }
3042
3043                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
3044                 if (va_next < sva)
3045                         va_next = eva;
3046
3047                 l2 = pmap_l1_to_l2(l1, sva);
3048                 if (pmap_load(l2) == 0)
3049                         continue;
3050
3051                 if ((pmap_load(l2) & ATTR_DESCR_MASK) == L2_BLOCK) {
3052                         if (sva + L2_SIZE == va_next && eva >= va_next) {
3053                                 pmap_protect_l2(pmap, l2, sva, mask, nbits);
3054                                 continue;
3055                         } else if (pmap_demote_l2(pmap, l2, sva) == NULL)
3056                                 continue;
3057                 }
3058                 KASSERT((pmap_load(l2) & ATTR_DESCR_MASK) == L2_TABLE,
3059                     ("pmap_protect: Invalid L2 entry after demotion"));
3060
3061                 if (va_next > eva)
3062                         va_next = eva;
3063
3064                 va = va_next;
3065                 for (l3p = pmap_l2_to_l3(l2, sva); sva != va_next; l3p++,
3066                     sva += L3_SIZE) {
3067                         l3 = pmap_load(l3p);
3068 retry:
3069                         /*
3070                          * Go to the next L3 entry if the current one is
3071                          * invalid or already has the desired access
3072                          * restrictions in place.  (The latter case occurs
3073                          * frequently.  For example, in a "buildworld"
3074                          * workload, almost 1 out of 4 L3 entries already
3075                          * have the desired restrictions.)
3076                          */
3077                         if (!pmap_l3_valid(l3) || (l3 & mask) == nbits) {
3078                                 if (va != va_next) {
3079                                         pmap_invalidate_range(pmap, va, sva);
3080                                         va = va_next;
3081                                 }
3082                                 continue;
3083                         }
3084
3085                         /*
3086                          * When a dirty read/write mapping is write protected,
3087                          * update the page's dirty field.
3088                          */
3089                         if ((l3 & ATTR_SW_MANAGED) != 0 &&
3090                             (nbits & ATTR_S1_AP(ATTR_S1_AP_RO)) != 0 &&
3091                             pmap_pte_dirty(pmap, l3))
3092                                 vm_page_dirty(PHYS_TO_VM_PAGE(l3 & ~ATTR_MASK));
3093
3094                         if (!atomic_fcmpset_64(l3p, &l3, (l3 & ~mask) | nbits))
3095                                 goto retry;
3096                         if (va == va_next)
3097                                 va = sva;
3098                 }
3099                 if (va != va_next)
3100                         pmap_invalidate_range(pmap, va, sva);
3101         }
3102         PMAP_UNLOCK(pmap);
3103 }
3104
3105 /*
3106  * Inserts the specified page table page into the specified pmap's collection
3107  * of idle page table pages.  Each of a pmap's page table pages is responsible
3108  * for mapping a distinct range of virtual addresses.  The pmap's collection is
3109  * ordered by this virtual address range.
3110  *
3111  * If "promoted" is false, then the page table page "mpte" must be zero filled.
3112  */
3113 static __inline int
3114 pmap_insert_pt_page(pmap_t pmap, vm_page_t mpte, bool promoted)
3115 {
3116
3117         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3118         mpte->valid = promoted ? VM_PAGE_BITS_ALL : 0;
3119         return (vm_radix_insert(&pmap->pm_root, mpte));
3120 }
3121
3122 /*
3123  * Removes the page table page mapping the specified virtual address from the
3124  * specified pmap's collection of idle page table pages, and returns it.
3125  * Otherwise, returns NULL if there is no page table page corresponding to the
3126  * specified virtual address.
3127  */
3128 static __inline vm_page_t
3129 pmap_remove_pt_page(pmap_t pmap, vm_offset_t va)
3130 {
3131
3132         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3133         return (vm_radix_remove(&pmap->pm_root, pmap_l2_pindex(va)));
3134 }
3135
3136 /*
3137  * Performs a break-before-make update of a pmap entry. This is needed when
3138  * either promoting or demoting pages to ensure the TLB doesn't get into an
3139  * inconsistent state.
3140  */
3141 static void
3142 pmap_update_entry(pmap_t pmap, pd_entry_t *pte, pd_entry_t newpte,
3143     vm_offset_t va, vm_size_t size)
3144 {
3145         register_t intr;
3146
3147         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3148
3149         /*
3150          * Ensure we don't get switched out with the page table in an
3151          * inconsistent state. We also need to ensure no interrupts fire
3152          * as they may make use of an address we are about to invalidate.
3153          */
3154         intr = intr_disable();
3155
3156         /*
3157          * Clear the old mapping's valid bit, but leave the rest of the entry
3158          * unchanged, so that a lockless, concurrent pmap_kextract() can still
3159          * lookup the physical address.
3160          */
3161         pmap_clear_bits(pte, ATTR_DESCR_VALID);
3162         pmap_invalidate_range(pmap, va, va + size);
3163
3164         /* Create the new mapping */
3165         pmap_store(pte, newpte);
3166         dsb(ishst);
3167
3168         intr_restore(intr);
3169 }
3170
3171 #if VM_NRESERVLEVEL > 0
3172 /*
3173  * After promotion from 512 4KB page mappings to a single 2MB page mapping,
3174  * replace the many pv entries for the 4KB page mappings by a single pv entry
3175  * for the 2MB page mapping.
3176  */
3177 static void
3178 pmap_pv_promote_l2(pmap_t pmap, vm_offset_t va, vm_paddr_t pa,
3179     struct rwlock **lockp)
3180 {
3181         struct md_page *pvh;
3182         pv_entry_t pv;
3183         vm_offset_t va_last;
3184         vm_page_t m;
3185
3186         KASSERT((pa & L2_OFFSET) == 0,
3187             ("pmap_pv_promote_l2: pa is not 2mpage aligned"));
3188         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa);
3189
3190         /*
3191          * Transfer the first page's pv entry for this mapping to the 2mpage's
3192          * pv list.  Aside from avoiding the cost of a call to get_pv_entry(),
3193          * a transfer avoids the possibility that get_pv_entry() calls
3194          * reclaim_pv_chunk() and that reclaim_pv_chunk() removes one of the
3195          * mappings that is being promoted.
3196          */
3197         m = PHYS_TO_VM_PAGE(pa);
3198         va = va & ~L2_OFFSET;
3199         pv = pmap_pvh_remove(&m->md, pmap, va);
3200         KASSERT(pv != NULL, ("pmap_pv_promote_l2: pv not found"));
3201         pvh = pa_to_pvh(pa);
3202         TAILQ_INSERT_TAIL(&pvh->pv_list, pv, pv_next);
3203         pvh->pv_gen++;
3204         /* Free the remaining NPTEPG - 1 pv entries. */
3205         va_last = va + L2_SIZE - PAGE_SIZE;
3206         do {
3207                 m++;
3208                 va += PAGE_SIZE;
3209                 pmap_pvh_free(&m->md, pmap, va);
3210         } while (va < va_last);
3211 }
3212
3213 /*
3214  * Tries to promote the 512, contiguous 4KB page mappings that are within a
3215  * single level 2 table entry to a single 2MB page mapping.  For promotion
3216  * to occur, two conditions must be met: (1) the 4KB page mappings must map
3217  * aligned, contiguous physical memory and (2) the 4KB page mappings must have
3218  * identical characteristics.
3219  */
3220 static void
3221 pmap_promote_l2(pmap_t pmap, pd_entry_t *l2, vm_offset_t va,
3222     struct rwlock **lockp)
3223 {
3224         pt_entry_t *firstl3, *l3, newl2, oldl3, pa;
3225         vm_page_t mpte;
3226         vm_offset_t sva;
3227
3228         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3229         PMAP_ASSERT_STAGE1(pmap);
3230
3231         sva = va & ~L2_OFFSET;
3232         firstl3 = pmap_l2_to_l3(l2, sva);
3233         newl2 = pmap_load(firstl3);
3234
3235 setl2:
3236         if (((newl2 & (~ATTR_MASK | ATTR_AF)) & L2_OFFSET) != ATTR_AF) {
3237                 atomic_add_long(&pmap_l2_p_failures, 1);
3238                 CTR2(KTR_PMAP, "pmap_promote_l2: failure for va %#lx"
3239                     " in pmap %p", va, pmap);
3240                 return;
3241         }
3242
3243         if ((newl2 & (ATTR_S1_AP_RW_BIT | ATTR_SW_DBM)) ==
3244             (ATTR_S1_AP(ATTR_S1_AP_RO) | ATTR_SW_DBM)) {
3245                 if (!atomic_fcmpset_64(l2, &newl2, newl2 & ~ATTR_SW_DBM))
3246                         goto setl2;
3247                 newl2 &= ~ATTR_SW_DBM;
3248         }
3249
3250         pa = newl2 + L2_SIZE - PAGE_SIZE;
3251         for (l3 = firstl3 + NL3PG - 1; l3 > firstl3; l3--) {
3252                 oldl3 = pmap_load(l3);
3253 setl3:
3254                 if ((oldl3 & (ATTR_S1_AP_RW_BIT | ATTR_SW_DBM)) ==
3255                     (ATTR_S1_AP(ATTR_S1_AP_RO) | ATTR_SW_DBM)) {
3256                         if (!atomic_fcmpset_64(l3, &oldl3, oldl3 &
3257                             ~ATTR_SW_DBM))
3258                                 goto setl3;
3259                         oldl3 &= ~ATTR_SW_DBM;
3260                 }
3261                 if (oldl3 != pa) {
3262                         atomic_add_long(&pmap_l2_p_failures, 1);
3263                         CTR2(KTR_PMAP, "pmap_promote_l2: failure for va %#lx"
3264                             " in pmap %p", va, pmap);
3265                         return;
3266                 }
3267                 pa -= PAGE_SIZE;
3268         }
3269
3270         /*
3271          * Save the page table page in its current state until the L2
3272          * mapping the superpage is demoted by pmap_demote_l2() or
3273          * destroyed by pmap_remove_l3().
3274          */
3275         mpte = PHYS_TO_VM_PAGE(pmap_load(l2) & ~ATTR_MASK);
3276         KASSERT(mpte >= vm_page_array &&
3277             mpte < &vm_page_array[vm_page_array_size],
3278             ("pmap_promote_l2: page table page is out of range"));
3279         KASSERT(mpte->pindex == pmap_l2_pindex(va),
3280             ("pmap_promote_l2: page table page's pindex is wrong"));
3281         if (pmap_insert_pt_page(pmap, mpte, true)) {
3282                 atomic_add_long(&pmap_l2_p_failures, 1);
3283                 CTR2(KTR_PMAP,
3284                     "pmap_promote_l2: failure for va %#lx in pmap %p", va,
3285                     pmap);
3286                 return;
3287         }
3288
3289         if ((newl2 & ATTR_SW_MANAGED) != 0)
3290                 pmap_pv_promote_l2(pmap, va, newl2 & ~ATTR_MASK, lockp);
3291
3292         newl2 &= ~ATTR_DESCR_MASK;
3293         newl2 |= L2_BLOCK;
3294
3295         pmap_update_entry(pmap, l2, newl2, sva, L2_SIZE);
3296
3297         atomic_add_long(&pmap_l2_promotions, 1);
3298         CTR2(KTR_PMAP, "pmap_promote_l2: success for va %#lx in pmap %p", va,
3299                     pmap);
3300 }
3301 #endif /* VM_NRESERVLEVEL > 0 */
3302
3303 /*
3304  *      Insert the given physical page (p) at
3305  *      the specified virtual address (v) in the
3306  *      target physical map with the protection requested.
3307  *
3308  *      If specified, the page will be wired down, meaning
3309  *      that the related pte can not be reclaimed.
3310  *
3311  *      NB:  This is the only routine which MAY NOT lazy-evaluate
3312  *      or lose information.  That is, this routine must actually
3313  *      insert this page into the given map NOW.
3314  */
3315 int
3316 pmap_enter(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
3317     u_int flags, int8_t psind)
3318 {
3319         struct rwlock *lock;
3320         pd_entry_t *pde;
3321         pt_entry_t new_l3, orig_l3;
3322         pt_entry_t *l2, *l3;
3323         pv_entry_t pv;
3324         vm_paddr_t opa, pa;
3325         vm_page_t mpte, om;
3326         boolean_t nosleep;
3327         int lvl, rv;
3328
3329         PMAP_ASSERT_STAGE1(pmap);
3330
3331         va = trunc_page(va);
3332         if ((m->oflags & VPO_UNMANAGED) == 0)
3333                 VM_PAGE_OBJECT_BUSY_ASSERT(m);
3334         pa = VM_PAGE_TO_PHYS(m);
3335         new_l3 = (pt_entry_t)(pa | ATTR_DEFAULT | ATTR_S1_IDX(m->md.pv_memattr) |
3336             L3_PAGE);
3337         if ((prot & VM_PROT_WRITE) == 0)
3338                 new_l3 |= ATTR_S1_AP(ATTR_S1_AP_RO);
3339         if ((prot & VM_PROT_EXECUTE) == 0 ||
3340             m->md.pv_memattr == VM_MEMATTR_DEVICE)
3341                 new_l3 |= ATTR_S1_XN;
3342         if ((flags & PMAP_ENTER_WIRED) != 0)
3343                 new_l3 |= ATTR_SW_WIRED;
3344         if (va < VM_MAXUSER_ADDRESS)
3345                 new_l3 |= ATTR_S1_AP(ATTR_S1_AP_USER) | ATTR_S1_PXN;
3346         else
3347                 new_l3 |= ATTR_S1_UXN;
3348         if (pmap != kernel_pmap)
3349                 new_l3 |= ATTR_S1_nG;
3350         if ((m->oflags & VPO_UNMANAGED) == 0) {
3351                 new_l3 |= ATTR_SW_MANAGED;
3352                 if ((prot & VM_PROT_WRITE) != 0) {
3353                         new_l3 |= ATTR_SW_DBM;
3354                         if ((flags & VM_PROT_WRITE) == 0)
3355                                 new_l3 |= ATTR_S1_AP(ATTR_S1_AP_RO);
3356                 }
3357         }
3358
3359         CTR2(KTR_PMAP, "pmap_enter: %.16lx -> %.16lx", va, pa);
3360
3361         lock = NULL;
3362         PMAP_LOCK(pmap);
3363         if (psind == 1) {
3364                 /* Assert the required virtual and physical alignment. */
3365                 KASSERT((va & L2_OFFSET) == 0, ("pmap_enter: va unaligned"));
3366                 KASSERT(m->psind > 0, ("pmap_enter: m->psind < psind"));
3367                 rv = pmap_enter_l2(pmap, va, (new_l3 & ~L3_PAGE) | L2_BLOCK,
3368                     flags, m, &lock);
3369                 goto out;
3370         }
3371         mpte = NULL;
3372
3373         /*
3374          * In the case that a page table page is not
3375          * resident, we are creating it here.
3376          */
3377 retry:
3378         pde = pmap_pde(pmap, va, &lvl);
3379         if (pde != NULL && lvl == 2) {
3380                 l3 = pmap_l2_to_l3(pde, va);
3381                 if (va < VM_MAXUSER_ADDRESS && mpte == NULL) {
3382                         mpte = PHYS_TO_VM_PAGE(pmap_load(pde) & ~ATTR_MASK);
3383                         mpte->ref_count++;
3384                 }
3385                 goto havel3;
3386         } else if (pde != NULL && lvl == 1) {
3387                 l2 = pmap_l1_to_l2(pde, va);
3388                 if ((pmap_load(l2) & ATTR_DESCR_MASK) == L2_BLOCK &&
3389                     (l3 = pmap_demote_l2_locked(pmap, l2, va, &lock)) != NULL) {
3390                         l3 = &l3[pmap_l3_index(va)];
3391                         if (va < VM_MAXUSER_ADDRESS) {
3392                                 mpte = PHYS_TO_VM_PAGE(
3393                                     pmap_load(l2) & ~ATTR_MASK);
3394                                 mpte->ref_count++;
3395                         }
3396                         goto havel3;
3397                 }
3398                 /* We need to allocate an L3 table. */
3399         }
3400         if (va < VM_MAXUSER_ADDRESS) {
3401                 nosleep = (flags & PMAP_ENTER_NOSLEEP) != 0;
3402
3403                 /*
3404                  * We use _pmap_alloc_l3() instead of pmap_alloc_l3() in order
3405                  * to handle the possibility that a superpage mapping for "va"
3406                  * was created while we slept.
3407                  */
3408                 mpte = _pmap_alloc_l3(pmap, pmap_l2_pindex(va),
3409                     nosleep ? NULL : &lock);
3410                 if (mpte == NULL && nosleep) {
3411                         CTR0(KTR_PMAP, "pmap_enter: mpte == NULL");
3412                         rv = KERN_RESOURCE_SHORTAGE;
3413                         goto out;
3414                 }
3415                 goto retry;
3416         } else
3417                 panic("pmap_enter: missing L3 table for kernel va %#lx", va);
3418
3419 havel3:
3420         orig_l3 = pmap_load(l3);
3421         opa = orig_l3 & ~ATTR_MASK;
3422         pv = NULL;
3423
3424         /*
3425          * Is the specified virtual address already mapped?
3426          */
3427         if (pmap_l3_valid(orig_l3)) {
3428                 /*
3429                  * Wiring change, just update stats. We don't worry about
3430                  * wiring PT pages as they remain resident as long as there
3431                  * are valid mappings in them. Hence, if a user page is wired,
3432                  * the PT page will be also.
3433                  */
3434                 if ((flags & PMAP_ENTER_WIRED) != 0 &&
3435                     (orig_l3 & ATTR_SW_WIRED) == 0)
3436                         pmap->pm_stats.wired_count++;
3437                 else if ((flags & PMAP_ENTER_WIRED) == 0 &&
3438                     (orig_l3 & ATTR_SW_WIRED) != 0)
3439                         pmap->pm_stats.wired_count--;
3440
3441                 /*
3442                  * Remove the extra PT page reference.
3443                  */
3444                 if (mpte != NULL) {
3445                         mpte->ref_count--;
3446                         KASSERT(mpte->ref_count > 0,
3447                             ("pmap_enter: missing reference to page table page,"
3448                              " va: 0x%lx", va));
3449                 }
3450
3451                 /*
3452                  * Has the physical page changed?
3453                  */
3454                 if (opa == pa) {
3455                         /*
3456                          * No, might be a protection or wiring change.
3457                          */
3458                         if ((orig_l3 & ATTR_SW_MANAGED) != 0 &&
3459                             (new_l3 & ATTR_SW_DBM) != 0)
3460                                 vm_page_aflag_set(m, PGA_WRITEABLE);
3461                         goto validate;
3462                 }
3463
3464                 /*
3465                  * The physical page has changed.  Temporarily invalidate
3466                  * the mapping.
3467                  */
3468                 orig_l3 = pmap_load_clear(l3);
3469                 KASSERT((orig_l3 & ~ATTR_MASK) == opa,
3470                     ("pmap_enter: unexpected pa update for %#lx", va));
3471                 if ((orig_l3 & ATTR_SW_MANAGED) != 0) {
3472                         om = PHYS_TO_VM_PAGE(opa);
3473
3474                         /*
3475                          * The pmap lock is sufficient to synchronize with
3476                          * concurrent calls to pmap_page_test_mappings() and
3477                          * pmap_ts_referenced().
3478                          */
3479                         if (pmap_pte_dirty(pmap, orig_l3))
3480                                 vm_page_dirty(om);
3481                         if ((orig_l3 & ATTR_AF) != 0) {
3482                                 pmap_invalidate_page(pmap, va);
3483                                 vm_page_aflag_set(om, PGA_REFERENCED);
3484                         }
3485                         CHANGE_PV_LIST_LOCK_TO_PHYS(&lock, opa);
3486                         pv = pmap_pvh_remove(&om->md, pmap, va);
3487                         if ((m->oflags & VPO_UNMANAGED) != 0)
3488                                 free_pv_entry(pmap, pv);
3489                         if ((om->a.flags & PGA_WRITEABLE) != 0 &&
3490                             TAILQ_EMPTY(&om->md.pv_list) &&
3491                             ((om->flags & PG_FICTITIOUS) != 0 ||
3492                             TAILQ_EMPTY(&pa_to_pvh(opa)->pv_list)))
3493                                 vm_page_aflag_clear(om, PGA_WRITEABLE);
3494                 } else {
3495                         KASSERT((orig_l3 & ATTR_AF) != 0,
3496                             ("pmap_enter: unmanaged mapping lacks ATTR_AF"));
3497                         pmap_invalidate_page(pmap, va);
3498                 }
3499                 orig_l3 = 0;
3500         } else {
3501                 /*
3502                  * Increment the counters.
3503                  */
3504                 if ((new_l3 & ATTR_SW_WIRED) != 0)
3505                         pmap->pm_stats.wired_count++;
3506                 pmap_resident_count_inc(pmap, 1);
3507         }
3508         /*
3509          * Enter on the PV list if part of our managed memory.
3510          */
3511         if ((m->oflags & VPO_UNMANAGED) == 0) {
3512                 if (pv == NULL) {
3513                         pv = get_pv_entry(pmap, &lock);
3514                         pv->pv_va = va;
3515                 }
3516                 CHANGE_PV_LIST_LOCK_TO_PHYS(&lock, pa);
3517                 TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
3518                 m->md.pv_gen++;
3519                 if ((new_l3 & ATTR_SW_DBM) != 0)
3520                         vm_page_aflag_set(m, PGA_WRITEABLE);
3521         }
3522
3523 validate:
3524         /*
3525          * Sync icache if exec permission and attribute VM_MEMATTR_WRITE_BACK
3526          * is set. Do it now, before the mapping is stored and made
3527          * valid for hardware table walk. If done later, then other can
3528          * access this page before caches are properly synced.
3529          * Don't do it for kernel memory which is mapped with exec
3530          * permission even if the memory isn't going to hold executable
3531          * code. The only time when icache sync is needed is after
3532          * kernel module is loaded and the relocation info is processed.
3533          * And it's done in elf_cpu_load_file().
3534         */
3535         if ((prot & VM_PROT_EXECUTE) &&  pmap != kernel_pmap &&
3536             m->md.pv_memattr == VM_MEMATTR_WRITE_BACK &&
3537             (opa != pa || (orig_l3 & ATTR_S1_XN)))
3538                 cpu_icache_sync_range(PHYS_TO_DMAP(pa), PAGE_SIZE);
3539
3540         /*
3541          * Update the L3 entry
3542          */
3543         if (pmap_l3_valid(orig_l3)) {
3544                 KASSERT(opa == pa, ("pmap_enter: invalid update"));
3545                 if ((orig_l3 & ~ATTR_AF) != (new_l3 & ~ATTR_AF)) {
3546                         /* same PA, different attributes */
3547                         orig_l3 = pmap_load_store(l3, new_l3);
3548                         pmap_invalidate_page(pmap, va);
3549                         if ((orig_l3 & ATTR_SW_MANAGED) != 0 &&
3550                             pmap_pte_dirty(pmap, orig_l3))
3551                                 vm_page_dirty(m);
3552                 } else {
3553                         /*
3554                          * orig_l3 == new_l3
3555                          * This can happens if multiple threads simultaneously
3556                          * access not yet mapped page. This bad for performance
3557                          * since this can cause full demotion-NOP-promotion
3558                          * cycle.
3559                          * Another possible reasons are:
3560                          * - VM and pmap memory layout are diverged
3561                          * - tlb flush is missing somewhere and CPU doesn't see
3562                          *   actual mapping.
3563                          */
3564                         CTR4(KTR_PMAP, "%s: already mapped page - "
3565                             "pmap %p va 0x%#lx pte 0x%lx",
3566                             __func__, pmap, va, new_l3);
3567                 }
3568         } else {
3569                 /* New mapping */
3570                 pmap_store(l3, new_l3);
3571                 dsb(ishst);
3572         }
3573
3574 #if VM_NRESERVLEVEL > 0
3575         if ((mpte == NULL || mpte->ref_count == NL3PG) &&
3576             pmap_ps_enabled(pmap) &&
3577             (m->flags & PG_FICTITIOUS) == 0 &&
3578             vm_reserv_level_iffullpop(m) == 0) {
3579                 pmap_promote_l2(pmap, pde, va, &lock);
3580         }
3581 #endif
3582
3583         rv = KERN_SUCCESS;
3584 out:
3585         if (lock != NULL)
3586                 rw_wunlock(lock);
3587         PMAP_UNLOCK(pmap);
3588         return (rv);
3589 }
3590
3591 /*
3592  * Tries to create a read- and/or execute-only 2MB page mapping.  Returns true
3593  * if successful.  Returns false if (1) a page table page cannot be allocated
3594  * without sleeping, (2) a mapping already exists at the specified virtual
3595  * address, or (3) a PV entry cannot be allocated without reclaiming another
3596  * PV entry.
3597  */
3598 static bool
3599 pmap_enter_2mpage(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
3600     struct rwlock **lockp)
3601 {
3602         pd_entry_t new_l2;
3603
3604         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3605         PMAP_ASSERT_STAGE1(pmap);
3606
3607         new_l2 = (pd_entry_t)(VM_PAGE_TO_PHYS(m) | ATTR_DEFAULT |
3608             ATTR_S1_IDX(m->md.pv_memattr) | ATTR_S1_AP(ATTR_S1_AP_RO) |
3609             L2_BLOCK);
3610         if ((m->oflags & VPO_UNMANAGED) == 0) {
3611                 new_l2 |= ATTR_SW_MANAGED;
3612                 new_l2 &= ~ATTR_AF;
3613         }
3614         if ((prot & VM_PROT_EXECUTE) == 0 ||
3615             m->md.pv_memattr == VM_MEMATTR_DEVICE)
3616                 new_l2 |= ATTR_S1_XN;
3617         if (va < VM_MAXUSER_ADDRESS)
3618                 new_l2 |= ATTR_S1_AP(ATTR_S1_AP_USER) | ATTR_S1_PXN;
3619         else
3620                 new_l2 |= ATTR_S1_UXN;
3621         if (pmap != kernel_pmap)
3622                 new_l2 |= ATTR_S1_nG;
3623         return (pmap_enter_l2(pmap, va, new_l2, PMAP_ENTER_NOSLEEP |
3624             PMAP_ENTER_NOREPLACE | PMAP_ENTER_NORECLAIM, NULL, lockp) ==
3625             KERN_SUCCESS);
3626 }
3627
3628 /*
3629  * Returns true if every page table entry in the specified page table is
3630  * zero.
3631  */
3632 static bool
3633 pmap_every_pte_zero(vm_paddr_t pa)
3634 {
3635         pt_entry_t *pt_end, *pte;
3636
3637         KASSERT((pa & PAGE_MASK) == 0, ("pa is misaligned"));
3638         pte = (pt_entry_t *)PHYS_TO_DMAP(pa);
3639         for (pt_end = pte + Ln_ENTRIES; pte < pt_end; pte++) {
3640                 if (*pte != 0)
3641                         return (false);
3642         }
3643         return (true);
3644 }
3645
3646 /*
3647  * Tries to create the specified 2MB page mapping.  Returns KERN_SUCCESS if
3648  * the mapping was created, and either KERN_FAILURE or KERN_RESOURCE_SHORTAGE
3649  * otherwise.  Returns KERN_FAILURE if PMAP_ENTER_NOREPLACE was specified and
3650  * a mapping already exists at the specified virtual address.  Returns
3651  * KERN_RESOURCE_SHORTAGE if PMAP_ENTER_NOSLEEP was specified and a page table
3652  * page allocation failed.  Returns KERN_RESOURCE_SHORTAGE if
3653  * PMAP_ENTER_NORECLAIM was specified and a PV entry allocation failed.
3654  *
3655  * The parameter "m" is only used when creating a managed, writeable mapping.
3656  */
3657 static int
3658 pmap_enter_l2(pmap_t pmap, vm_offset_t va, pd_entry_t new_l2, u_int flags,
3659     vm_page_t m, struct rwlock **lockp)
3660 {
3661         struct spglist free;
3662         pd_entry_t *l2, old_l2;
3663         vm_page_t l2pg, mt;
3664
3665         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3666
3667         if ((l2 = pmap_alloc_l2(pmap, va, &l2pg, (flags &
3668             PMAP_ENTER_NOSLEEP) != 0 ? NULL : lockp)) == NULL) {
3669                 CTR2(KTR_PMAP, "pmap_enter_l2: failure for va %#lx in pmap %p",
3670                     va, pmap);
3671                 return (KERN_RESOURCE_SHORTAGE);
3672         }
3673
3674         /*
3675          * If there are existing mappings, either abort or remove them.
3676          */
3677         if ((old_l2 = pmap_load(l2)) != 0) {
3678                 KASSERT(l2pg == NULL || l2pg->ref_count > 1,
3679                     ("pmap_enter_l2: l2pg's ref count is too low"));
3680                 if ((flags & PMAP_ENTER_NOREPLACE) != 0 && (va <
3681                     VM_MAXUSER_ADDRESS || (old_l2 & ATTR_DESCR_MASK) ==
3682                     L2_BLOCK || !pmap_every_pte_zero(old_l2 & ~ATTR_MASK))) {
3683                         if (l2pg != NULL)
3684                                 l2pg->ref_count--;
3685                         CTR2(KTR_PMAP, "pmap_enter_l2: failure for va %#lx"
3686                             " in pmap %p", va, pmap);
3687                         return (KERN_FAILURE);
3688                 }
3689                 SLIST_INIT(&free);
3690                 if ((old_l2 & ATTR_DESCR_MASK) == L2_BLOCK)
3691                         (void)pmap_remove_l2(pmap, l2, va,
3692                             pmap_load(pmap_l1(pmap, va)), &free, lockp);
3693                 else
3694                         pmap_remove_l3_range(pmap, old_l2, va, va + L2_SIZE,
3695                             &free, lockp);
3696                 if (va < VM_MAXUSER_ADDRESS) {
3697                         vm_page_free_pages_toq(&free, true);
3698                         KASSERT(pmap_load(l2) == 0,
3699                             ("pmap_enter_l2: non-zero L2 entry %p", l2));
3700                 } else {
3701                         KASSERT(SLIST_EMPTY(&free),
3702                             ("pmap_enter_l2: freed kernel page table page"));
3703
3704                         /*
3705                          * Both pmap_remove_l2() and pmap_remove_l3_range()
3706                          * will leave the kernel page table page zero filled.
3707                          * Nonetheless, the TLB could have an intermediate
3708                          * entry for the kernel page table page.
3709                          */
3710                         mt = PHYS_TO_VM_PAGE(pmap_load(l2) & ~ATTR_MASK);
3711                         if (pmap_insert_pt_page(pmap, mt, false))
3712                                 panic("pmap_enter_l2: trie insert failed");
3713                         pmap_clear(l2);
3714                         pmap_invalidate_page(pmap, va);
3715                 }
3716         }
3717
3718         if ((new_l2 & ATTR_SW_MANAGED) != 0) {
3719                 /*
3720                  * Abort this mapping if its PV entry could not be created.
3721                  */
3722                 if (!pmap_pv_insert_l2(pmap, va, new_l2, flags, lockp)) {
3723                         if (l2pg != NULL)
3724                                 pmap_abort_ptp(pmap, va, l2pg);
3725                         CTR2(KTR_PMAP,
3726                             "pmap_enter_l2: failure for va %#lx in pmap %p",
3727                             va, pmap);
3728                         return (KERN_RESOURCE_SHORTAGE);
3729                 }
3730                 if ((new_l2 & ATTR_SW_DBM) != 0)
3731                         for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)
3732                                 vm_page_aflag_set(mt, PGA_WRITEABLE);
3733         }
3734
3735         /*
3736          * Increment counters.
3737          */
3738         if ((new_l2 & ATTR_SW_WIRED) != 0)
3739                 pmap->pm_stats.wired_count += L2_SIZE / PAGE_SIZE;
3740         pmap->pm_stats.resident_count += L2_SIZE / PAGE_SIZE;
3741
3742         /*
3743          * Map the superpage.
3744          */
3745         pmap_store(l2, new_l2);
3746         dsb(ishst);
3747
3748         atomic_add_long(&pmap_l2_mappings, 1);
3749         CTR2(KTR_PMAP, "pmap_enter_l2: success for va %#lx in pmap %p",
3750             va, pmap);
3751
3752         return (KERN_SUCCESS);
3753 }
3754
3755 /*
3756  * Maps a sequence of resident pages belonging to the same object.
3757  * The sequence begins with the given page m_start.  This page is
3758  * mapped at the given virtual address start.  Each subsequent page is
3759  * mapped at a virtual address that is offset from start by the same
3760  * amount as the page is offset from m_start within the object.  The
3761  * last page in the sequence is the page with the largest offset from
3762  * m_start that can be mapped at a virtual address less than the given
3763  * virtual address end.  Not every virtual page between start and end
3764  * is mapped; only those for which a resident page exists with the
3765  * corresponding offset from m_start are mapped.
3766  */
3767 void
3768 pmap_enter_object(pmap_t pmap, vm_offset_t start, vm_offset_t end,
3769     vm_page_t m_start, vm_prot_t prot)
3770 {
3771         struct rwlock *lock;
3772         vm_offset_t va;
3773         vm_page_t m, mpte;
3774         vm_pindex_t diff, psize;
3775
3776         VM_OBJECT_ASSERT_LOCKED(m_start->object);
3777
3778         psize = atop(end - start);
3779         mpte = NULL;
3780         m = m_start;
3781         lock = NULL;
3782         PMAP_LOCK(pmap);
3783         while (m != NULL && (diff = m->pindex - m_start->pindex) < psize) {
3784                 va = start + ptoa(diff);
3785                 if ((va & L2_OFFSET) == 0 && va + L2_SIZE <= end &&
3786                     m->psind == 1 && pmap_ps_enabled(pmap) &&
3787                     pmap_enter_2mpage(pmap, va, m, prot, &lock))
3788                         m = &m[L2_SIZE / PAGE_SIZE - 1];
3789                 else
3790                         mpte = pmap_enter_quick_locked(pmap, va, m, prot, mpte,
3791                             &lock);
3792                 m = TAILQ_NEXT(m, listq);
3793         }
3794         if (lock != NULL)
3795                 rw_wunlock(lock);
3796         PMAP_UNLOCK(pmap);
3797 }
3798
3799 /*
3800  * this code makes some *MAJOR* assumptions:
3801  * 1. Current pmap & pmap exists.
3802  * 2. Not wired.
3803  * 3. Read access.
3804  * 4. No page table pages.
3805  * but is *MUCH* faster than pmap_enter...
3806  */
3807
3808 void
3809 pmap_enter_quick(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot)
3810 {
3811         struct rwlock *lock;
3812
3813         lock = NULL;
3814         PMAP_LOCK(pmap);
3815         (void)pmap_enter_quick_locked(pmap, va, m, prot, NULL, &lock);
3816         if (lock != NULL)
3817                 rw_wunlock(lock);
3818         PMAP_UNLOCK(pmap);
3819 }
3820
3821 static vm_page_t
3822 pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va, vm_page_t m,
3823     vm_prot_t prot, vm_page_t mpte, struct rwlock **lockp)
3824 {
3825         pd_entry_t *pde;
3826         pt_entry_t *l2, *l3, l3_val;
3827         vm_paddr_t pa;
3828         int lvl;
3829
3830         KASSERT(va < kmi.clean_sva || va >= kmi.clean_eva ||
3831             (m->oflags & VPO_UNMANAGED) != 0,
3832             ("pmap_enter_quick_locked: managed mapping within the clean submap"));
3833         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3834         PMAP_ASSERT_STAGE1(pmap);
3835
3836         CTR2(KTR_PMAP, "pmap_enter_quick_locked: %p %lx", pmap, va);
3837         /*
3838          * In the case that a page table page is not
3839          * resident, we are creating it here.
3840          */
3841         if (va < VM_MAXUSER_ADDRESS) {
3842                 vm_pindex_t l2pindex;
3843
3844                 /*
3845                  * Calculate pagetable page index
3846                  */
3847                 l2pindex = pmap_l2_pindex(va);
3848                 if (mpte && (mpte->pindex == l2pindex)) {
3849                         mpte->ref_count++;
3850                 } else {
3851                         /*
3852                          * Get the l2 entry
3853                          */
3854                         pde = pmap_pde(pmap, va, &lvl);
3855
3856                         /*
3857                          * If the page table page is mapped, we just increment
3858                          * the hold count, and activate it.  Otherwise, we
3859                          * attempt to allocate a page table page.  If this
3860                          * attempt fails, we don't retry.  Instead, we give up.
3861                          */
3862                         if (lvl == 1) {
3863                                 l2 = pmap_l1_to_l2(pde, va);
3864                                 if ((pmap_load(l2) & ATTR_DESCR_MASK) ==
3865                                     L2_BLOCK)
3866                                         return (NULL);
3867                         }
3868                         if (lvl == 2 && pmap_load(pde) != 0) {
3869                                 mpte =
3870                                     PHYS_TO_VM_PAGE(pmap_load(pde) & ~ATTR_MASK);
3871                                 mpte->ref_count++;
3872                         } else {
3873                                 /*
3874                                  * Pass NULL instead of the PV list lock
3875                                  * pointer, because we don't intend to sleep.
3876                                  */
3877                                 mpte = _pmap_alloc_l3(pmap, l2pindex, NULL);
3878                                 if (mpte == NULL)
3879                                         return (mpte);
3880                         }
3881                 }
3882                 l3 = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
3883                 l3 = &l3[pmap_l3_index(va)];
3884         } else {
3885                 mpte = NULL;
3886                 pde = pmap_pde(kernel_pmap, va, &lvl);
3887                 KASSERT(pde != NULL,
3888                     ("pmap_enter_quick_locked: Invalid page entry, va: 0x%lx",
3889                      va));
3890                 KASSERT(lvl == 2,
3891                     ("pmap_enter_quick_locked: Invalid level %d", lvl));
3892                 l3 = pmap_l2_to_l3(pde, va);
3893         }
3894
3895         /*
3896          * Abort if a mapping already exists.
3897          */
3898         if (pmap_load(l3) != 0) {
3899                 if (mpte != NULL)
3900                         mpte->ref_count--;
3901                 return (NULL);
3902         }
3903
3904         /*
3905          * Enter on the PV list if part of our managed memory.
3906          */
3907         if ((m->oflags & VPO_UNMANAGED) == 0 &&
3908             !pmap_try_insert_pv_entry(pmap, va, m, lockp)) {
3909                 if (mpte != NULL)
3910                         pmap_abort_ptp(pmap, va, mpte);
3911                 return (NULL);
3912         }
3913
3914         /*
3915          * Increment counters
3916          */
3917         pmap_resident_count_inc(pmap, 1);
3918
3919         pa = VM_PAGE_TO_PHYS(m);
3920         l3_val = pa | ATTR_DEFAULT | ATTR_S1_IDX(m->md.pv_memattr) |
3921             ATTR_S1_AP(ATTR_S1_AP_RO) | L3_PAGE;
3922         if ((prot & VM_PROT_EXECUTE) == 0 ||
3923             m->md.pv_memattr == VM_MEMATTR_DEVICE)
3924                 l3_val |= ATTR_S1_XN;
3925         if (va < VM_MAXUSER_ADDRESS)
3926                 l3_val |= ATTR_S1_AP(ATTR_S1_AP_USER) | ATTR_S1_PXN;
3927         else
3928                 l3_val |= ATTR_S1_UXN;
3929         if (pmap != kernel_pmap)
3930                 l3_val |= ATTR_S1_nG;
3931
3932         /*
3933          * Now validate mapping with RO protection
3934          */
3935         if ((m->oflags & VPO_UNMANAGED) == 0) {
3936                 l3_val |= ATTR_SW_MANAGED;
3937                 l3_val &= ~ATTR_AF;
3938         }
3939
3940         /* Sync icache before the mapping is stored to PTE */
3941         if ((prot & VM_PROT_EXECUTE) && pmap != kernel_pmap &&
3942             m->md.pv_memattr == VM_MEMATTR_WRITE_BACK)
3943                 cpu_icache_sync_range(PHYS_TO_DMAP(pa), PAGE_SIZE);
3944
3945         pmap_store(l3, l3_val);
3946         dsb(ishst);
3947
3948         return (mpte);
3949 }
3950
3951 /*
3952  * This code maps large physical mmap regions into the
3953  * processor address space.  Note that some shortcuts
3954  * are taken, but the code works.
3955  */
3956 void
3957 pmap_object_init_pt(pmap_t pmap, vm_offset_t addr, vm_object_t object,
3958     vm_pindex_t pindex, vm_size_t size)
3959 {
3960
3961         VM_OBJECT_ASSERT_WLOCKED(object);
3962         KASSERT(object->type == OBJT_DEVICE || object->type == OBJT_SG,
3963             ("pmap_object_init_pt: non-device object"));
3964 }
3965
3966 /*
3967  *      Clear the wired attribute from the mappings for the specified range of
3968  *      addresses in the given pmap.  Every valid mapping within that range
3969  *      must have the wired attribute set.  In contrast, invalid mappings
3970  *      cannot have the wired attribute set, so they are ignored.
3971  *
3972  *      The wired attribute of the page table entry is not a hardware feature,
3973  *      so there is no need to invalidate any TLB entries.
3974  */
3975 void
3976 pmap_unwire(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
3977 {
3978         vm_offset_t va_next;
3979         pd_entry_t *l0, *l1, *l2;
3980         pt_entry_t *l3;
3981
3982         PMAP_LOCK(pmap);
3983         for (; sva < eva; sva = va_next) {
3984                 l0 = pmap_l0(pmap, sva);
3985                 if (pmap_load(l0) == 0) {
3986                         va_next = (sva + L0_SIZE) & ~L0_OFFSET;
3987                         if (va_next < sva)
3988                                 va_next = eva;
3989                         continue;
3990                 }
3991
3992                 l1 = pmap_l0_to_l1(l0, sva);
3993                 if (pmap_load(l1) == 0) {
3994                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
3995                         if (va_next < sva)
3996                                 va_next = eva;
3997                         continue;
3998                 }
3999
4000                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
4001                 if (va_next < sva)
4002                         va_next = eva;
4003
4004                 l2 = pmap_l1_to_l2(l1, sva);
4005                 if (pmap_load(l2) == 0)
4006                         continue;
4007
4008                 if ((pmap_load(l2) & ATTR_DESCR_MASK) == L2_BLOCK) {
4009                         if ((pmap_load(l2) & ATTR_SW_WIRED) == 0)
4010                                 panic("pmap_unwire: l2 %#jx is missing "
4011                                     "ATTR_SW_WIRED", (uintmax_t)pmap_load(l2));
4012
4013                         /*
4014                          * Are we unwiring the entire large page?  If not,
4015                          * demote the mapping and fall through.
4016                          */
4017                         if (sva + L2_SIZE == va_next && eva >= va_next) {
4018                                 pmap_clear_bits(l2, ATTR_SW_WIRED);
4019                                 pmap->pm_stats.wired_count -= L2_SIZE /
4020                                     PAGE_SIZE;
4021                                 continue;
4022                         } else if (pmap_demote_l2(pmap, l2, sva) == NULL)
4023                                 panic("pmap_unwire: demotion failed");
4024                 }
4025                 KASSERT((pmap_load(l2) & ATTR_DESCR_MASK) == L2_TABLE,
4026                     ("pmap_unwire: Invalid l2 entry after demotion"));
4027
4028                 if (va_next > eva)
4029                         va_next = eva;
4030                 for (l3 = pmap_l2_to_l3(l2, sva); sva != va_next; l3++,
4031                     sva += L3_SIZE) {
4032                         if (pmap_load(l3) == 0)
4033                                 continue;
4034                         if ((pmap_load(l3) & ATTR_SW_WIRED) == 0)
4035                                 panic("pmap_unwire: l3 %#jx is missing "
4036                                     "ATTR_SW_WIRED", (uintmax_t)pmap_load(l3));
4037
4038                         /*
4039                          * ATTR_SW_WIRED must be cleared atomically.  Although
4040                          * the pmap lock synchronizes access to ATTR_SW_WIRED,
4041                          * the System MMU may write to the entry concurrently.
4042                          */
4043                         pmap_clear_bits(l3, ATTR_SW_WIRED);
4044                         pmap->pm_stats.wired_count--;
4045                 }
4046         }
4047         PMAP_UNLOCK(pmap);
4048 }
4049
4050 /*
4051  *      Copy the range specified by src_addr/len
4052  *      from the source map to the range dst_addr/len
4053  *      in the destination map.
4054  *
4055  *      This routine is only advisory and need not do anything.
4056  *
4057  *      Because the executable mappings created by this routine are copied,
4058  *      it should not have to flush the instruction cache.
4059  */
4060 void
4061 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, vm_size_t len,
4062     vm_offset_t src_addr)
4063 {
4064         struct rwlock *lock;
4065         pd_entry_t *l0, *l1, *l2, srcptepaddr;
4066         pt_entry_t *dst_pte, mask, nbits, ptetemp, *src_pte;
4067         vm_offset_t addr, end_addr, va_next;
4068         vm_page_t dst_l2pg, dstmpte, srcmpte;
4069
4070         PMAP_ASSERT_STAGE1(dst_pmap);
4071         PMAP_ASSERT_STAGE1(src_pmap);
4072
4073         if (dst_addr != src_addr)
4074                 return;
4075         end_addr = src_addr + len;
4076         lock = NULL;
4077         if (dst_pmap < src_pmap) {
4078                 PMAP_LOCK(dst_pmap);
4079                 PMAP_LOCK(src_pmap);
4080         } else {
4081                 PMAP_LOCK(src_pmap);
4082                 PMAP_LOCK(dst_pmap);
4083         }
4084         for (addr = src_addr; addr < end_addr; addr = va_next) {
4085                 l0 = pmap_l0(src_pmap, addr);
4086                 if (pmap_load(l0) == 0) {
4087                         va_next = (addr + L0_SIZE) & ~L0_OFFSET;
4088                         if (va_next < addr)
4089                                 va_next = end_addr;
4090                         continue;
4091                 }
4092                 l1 = pmap_l0_to_l1(l0, addr);
4093                 if (pmap_load(l1) == 0) {
4094                         va_next = (addr + L1_SIZE) & ~L1_OFFSET;
4095                         if (va_next < addr)
4096                                 va_next = end_addr;
4097                         continue;
4098                 }
4099                 va_next = (addr + L2_SIZE) & ~L2_OFFSET;
4100                 if (va_next < addr)
4101                         va_next = end_addr;
4102                 l2 = pmap_l1_to_l2(l1, addr);
4103                 srcptepaddr = pmap_load(l2);
4104                 if (srcptepaddr == 0)
4105                         continue;
4106                 if ((srcptepaddr & ATTR_DESCR_MASK) == L2_BLOCK) {
4107                         if ((addr & L2_OFFSET) != 0 ||
4108                             addr + L2_SIZE > end_addr)
4109                                 continue;
4110                         l2 = pmap_alloc_l2(dst_pmap, addr, &dst_l2pg, NULL);
4111                         if (l2 == NULL)
4112                                 break;
4113                         if (pmap_load(l2) == 0 &&
4114                             ((srcptepaddr & ATTR_SW_MANAGED) == 0 ||
4115                             pmap_pv_insert_l2(dst_pmap, addr, srcptepaddr,
4116                             PMAP_ENTER_NORECLAIM, &lock))) {
4117                                 mask = ATTR_AF | ATTR_SW_WIRED;
4118                                 nbits = 0;
4119                                 if ((srcptepaddr & ATTR_SW_DBM) != 0)
4120                                         nbits |= ATTR_S1_AP_RW_BIT;
4121                                 pmap_store(l2, (srcptepaddr & ~mask) | nbits);
4122                                 pmap_resident_count_inc(dst_pmap, L2_SIZE /
4123                                     PAGE_SIZE);
4124                                 atomic_add_long(&pmap_l2_mappings, 1);
4125                         } else
4126                                 pmap_abort_ptp(dst_pmap, addr, dst_l2pg);
4127                         continue;
4128                 }
4129                 KASSERT((srcptepaddr & ATTR_DESCR_MASK) == L2_TABLE,
4130                     ("pmap_copy: invalid L2 entry"));
4131                 srcptepaddr &= ~ATTR_MASK;
4132                 srcmpte = PHYS_TO_VM_PAGE(srcptepaddr);
4133                 KASSERT(srcmpte->ref_count > 0,
4134                     ("pmap_copy: source page table page is unused"));
4135                 if (va_next > end_addr)
4136                         va_next = end_addr;
4137                 src_pte = (pt_entry_t *)PHYS_TO_DMAP(srcptepaddr);
4138                 src_pte = &src_pte[pmap_l3_index(addr)];
4139                 dstmpte = NULL;
4140                 for (; addr < va_next; addr += PAGE_SIZE, src_pte++) {
4141                         ptetemp = pmap_load(src_pte);
4142
4143                         /*
4144                          * We only virtual copy managed pages.
4145                          */
4146                         if ((ptetemp & ATTR_SW_MANAGED) == 0)
4147                                 continue;
4148
4149                         if (dstmpte != NULL) {
4150                                 KASSERT(dstmpte->pindex == pmap_l2_pindex(addr),
4151                                     ("dstmpte pindex/addr mismatch"));
4152                                 dstmpte->ref_count++;
4153                         } else if ((dstmpte = pmap_alloc_l3(dst_pmap, addr,
4154                             NULL)) == NULL)
4155                                 goto out;
4156                         dst_pte = (pt_entry_t *)
4157                             PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dstmpte));
4158                         dst_pte = &dst_pte[pmap_l3_index(addr)];
4159                         if (pmap_load(dst_pte) == 0 &&
4160                             pmap_try_insert_pv_entry(dst_pmap, addr,
4161                             PHYS_TO_VM_PAGE(ptetemp & ~ATTR_MASK), &lock)) {
4162                                 /*
4163                                  * Clear the wired, modified, and accessed
4164                                  * (referenced) bits during the copy.
4165                                  */
4166                                 mask = ATTR_AF | ATTR_SW_WIRED;
4167                                 nbits = 0;
4168                                 if ((ptetemp & ATTR_SW_DBM) != 0)
4169                                         nbits |= ATTR_S1_AP_RW_BIT;
4170                                 pmap_store(dst_pte, (ptetemp & ~mask) | nbits);
4171                                 pmap_resident_count_inc(dst_pmap, 1);
4172                         } else {
4173                                 pmap_abort_ptp(dst_pmap, addr, dstmpte);
4174                                 goto out;
4175                         }
4176                         /* Have we copied all of the valid mappings? */
4177                         if (dstmpte->ref_count >= srcmpte->ref_count)
4178                                 break;
4179                 }
4180         }
4181 out:
4182         /*
4183          * XXX This barrier may not be needed because the destination pmap is
4184          * not active.
4185          */
4186         dsb(ishst);
4187
4188         if (lock != NULL)
4189                 rw_wunlock(lock);
4190         PMAP_UNLOCK(src_pmap);
4191         PMAP_UNLOCK(dst_pmap);
4192 }
4193
4194 /*
4195  *      pmap_zero_page zeros the specified hardware page by mapping
4196  *      the page into KVM and using bzero to clear its contents.
4197  */
4198 void
4199 pmap_zero_page(vm_page_t m)
4200 {
4201         vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
4202
4203         pagezero((void *)va);
4204 }
4205
4206 /*
4207  *      pmap_zero_page_area zeros the specified hardware page by mapping
4208  *      the page into KVM and using bzero to clear its contents.
4209  *
4210  *      off and size may not cover an area beyond a single hardware page.
4211  */
4212 void
4213 pmap_zero_page_area(vm_page_t m, int off, int size)
4214 {
4215         vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
4216
4217         if (off == 0 && size == PAGE_SIZE)
4218                 pagezero((void *)va);
4219         else
4220                 bzero((char *)va + off, size);
4221 }
4222
4223 /*
4224  *      pmap_copy_page copies the specified (machine independent)
4225  *      page by mapping the page into virtual memory and using
4226  *      bcopy to copy the page, one machine dependent page at a
4227  *      time.
4228  */
4229 void
4230 pmap_copy_page(vm_page_t msrc, vm_page_t mdst)
4231 {
4232         vm_offset_t src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
4233         vm_offset_t dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
4234
4235         pagecopy((void *)src, (void *)dst);
4236 }
4237
4238 int unmapped_buf_allowed = 1;
4239
4240 void
4241 pmap_copy_pages(vm_page_t ma[], vm_offset_t a_offset, vm_page_t mb[],
4242     vm_offset_t b_offset, int xfersize)
4243 {
4244         void *a_cp, *b_cp;
4245         vm_page_t m_a, m_b;
4246         vm_paddr_t p_a, p_b;
4247         vm_offset_t a_pg_offset, b_pg_offset;
4248         int cnt;
4249
4250         while (xfersize > 0) {
4251                 a_pg_offset = a_offset & PAGE_MASK;
4252                 m_a = ma[a_offset >> PAGE_SHIFT];
4253                 p_a = m_a->phys_addr;
4254                 b_pg_offset = b_offset & PAGE_MASK;
4255                 m_b = mb[b_offset >> PAGE_SHIFT];
4256                 p_b = m_b->phys_addr;
4257                 cnt = min(xfersize, PAGE_SIZE - a_pg_offset);
4258                 cnt = min(cnt, PAGE_SIZE - b_pg_offset);
4259                 if (__predict_false(!PHYS_IN_DMAP(p_a))) {
4260                         panic("!DMAP a %lx", p_a);
4261                 } else {
4262                         a_cp = (char *)PHYS_TO_DMAP(p_a) + a_pg_offset;
4263                 }
4264                 if (__predict_false(!PHYS_IN_DMAP(p_b))) {
4265                         panic("!DMAP b %lx", p_b);
4266                 } else {
4267                         b_cp = (char *)PHYS_TO_DMAP(p_b) + b_pg_offset;
4268                 }
4269                 bcopy(a_cp, b_cp, cnt);
4270                 a_offset += cnt;
4271                 b_offset += cnt;
4272                 xfersize -= cnt;
4273         }
4274 }
4275
4276 vm_offset_t
4277 pmap_quick_enter_page(vm_page_t m)
4278 {
4279
4280         return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
4281 }
4282
4283 void
4284 pmap_quick_remove_page(vm_offset_t addr)
4285 {
4286 }
4287
4288 /*
4289  * Returns true if the pmap's pv is one of the first
4290  * 16 pvs linked to from this page.  This count may
4291  * be changed upwards or downwards in the future; it
4292  * is only necessary that true be returned for a small
4293  * subset of pmaps for proper page aging.
4294  */
4295 boolean_t
4296 pmap_page_exists_quick(pmap_t pmap, vm_page_t m)
4297 {
4298         struct md_page *pvh;
4299         struct rwlock *lock;
4300         pv_entry_t pv;
4301         int loops = 0;
4302         boolean_t rv;
4303
4304         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4305             ("pmap_page_exists_quick: page %p is not managed", m));
4306         rv = FALSE;
4307         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
4308         rw_rlock(lock);
4309         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
4310                 if (PV_PMAP(pv) == pmap) {
4311                         rv = TRUE;
4312                         break;
4313                 }
4314                 loops++;
4315                 if (loops >= 16)
4316                         break;
4317         }
4318         if (!rv && loops < 16 && (m->flags & PG_FICTITIOUS) == 0) {
4319                 pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
4320                 TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
4321                         if (PV_PMAP(pv) == pmap) {
4322                                 rv = TRUE;
4323                                 break;
4324                         }
4325                         loops++;
4326                         if (loops >= 16)
4327                                 break;
4328                 }
4329         }
4330         rw_runlock(lock);
4331         return (rv);
4332 }
4333
4334 /*
4335  *      pmap_page_wired_mappings:
4336  *
4337  *      Return the number of managed mappings to the given physical page
4338  *      that are wired.
4339  */
4340 int
4341 pmap_page_wired_mappings(vm_page_t m)
4342 {
4343         struct rwlock *lock;
4344         struct md_page *pvh;
4345         pmap_t pmap;
4346         pt_entry_t *pte;
4347         pv_entry_t pv;
4348         int count, lvl, md_gen, pvh_gen;
4349
4350         if ((m->oflags & VPO_UNMANAGED) != 0)
4351                 return (0);
4352         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
4353         rw_rlock(lock);
4354 restart:
4355         count = 0;
4356         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
4357                 pmap = PV_PMAP(pv);
4358                 if (!PMAP_TRYLOCK(pmap)) {
4359                         md_gen = m->md.pv_gen;
4360                         rw_runlock(lock);
4361                         PMAP_LOCK(pmap);
4362                         rw_rlock(lock);
4363                         if (md_gen != m->md.pv_gen) {
4364                                 PMAP_UNLOCK(pmap);
4365                                 goto restart;
4366                         }
4367                 }
4368                 pte = pmap_pte(pmap, pv->pv_va, &lvl);
4369                 if (pte != NULL && (pmap_load(pte) & ATTR_SW_WIRED) != 0)
4370                         count++;
4371                 PMAP_UNLOCK(pmap);
4372         }
4373         if ((m->flags & PG_FICTITIOUS) == 0) {
4374                 pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
4375                 TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
4376                         pmap = PV_PMAP(pv);
4377                         if (!PMAP_TRYLOCK(pmap)) {
4378                                 md_gen = m->md.pv_gen;
4379                                 pvh_gen = pvh->pv_gen;
4380                                 rw_runlock(lock);
4381                                 PMAP_LOCK(pmap);
4382                                 rw_rlock(lock);
4383                                 if (md_gen != m->md.pv_gen ||
4384                                     pvh_gen != pvh->pv_gen) {
4385                                         PMAP_UNLOCK(pmap);
4386                                         goto restart;
4387                                 }
4388                         }
4389                         pte = pmap_pte(pmap, pv->pv_va, &lvl);
4390                         if (pte != NULL &&
4391                             (pmap_load(pte) & ATTR_SW_WIRED) != 0)
4392                                 count++;
4393                         PMAP_UNLOCK(pmap);
4394                 }
4395         }
4396         rw_runlock(lock);
4397         return (count);
4398 }
4399
4400 /*
4401  * Returns true if the given page is mapped individually or as part of
4402  * a 2mpage.  Otherwise, returns false.
4403  */
4404 bool
4405 pmap_page_is_mapped(vm_page_t m)
4406 {
4407         struct rwlock *lock;
4408         bool rv;
4409
4410         if ((m->oflags & VPO_UNMANAGED) != 0)
4411                 return (false);
4412         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
4413         rw_rlock(lock);
4414         rv = !TAILQ_EMPTY(&m->md.pv_list) ||
4415             ((m->flags & PG_FICTITIOUS) == 0 &&
4416             !TAILQ_EMPTY(&pa_to_pvh(VM_PAGE_TO_PHYS(m))->pv_list));
4417         rw_runlock(lock);
4418         return (rv);
4419 }
4420
4421 /*
4422  * Destroy all managed, non-wired mappings in the given user-space
4423  * pmap.  This pmap cannot be active on any processor besides the
4424  * caller.
4425  *
4426  * This function cannot be applied to the kernel pmap.  Moreover, it
4427  * is not intended for general use.  It is only to be used during
4428  * process termination.  Consequently, it can be implemented in ways
4429  * that make it faster than pmap_remove().  First, it can more quickly
4430  * destroy mappings by iterating over the pmap's collection of PV
4431  * entries, rather than searching the page table.  Second, it doesn't
4432  * have to test and clear the page table entries atomically, because
4433  * no processor is currently accessing the user address space.  In
4434  * particular, a page table entry's dirty bit won't change state once
4435  * this function starts.
4436  */
4437 void
4438 pmap_remove_pages(pmap_t pmap)
4439 {
4440         pd_entry_t *pde;
4441         pt_entry_t *pte, tpte;
4442         struct spglist free;
4443         vm_page_t m, ml3, mt;
4444         pv_entry_t pv;
4445         struct md_page *pvh;
4446         struct pv_chunk *pc, *npc;
4447         struct rwlock *lock;
4448         int64_t bit;
4449         uint64_t inuse, bitmask;
4450         int allfree, field, freed, idx, lvl;
4451         vm_paddr_t pa;
4452
4453         KASSERT(pmap == PCPU_GET(curpmap), ("non-current pmap %p", pmap));
4454
4455         lock = NULL;
4456
4457         SLIST_INIT(&free);
4458         PMAP_LOCK(pmap);
4459         TAILQ_FOREACH_SAFE(pc, &pmap->pm_pvchunk, pc_list, npc) {
4460                 allfree = 1;
4461                 freed = 0;
4462                 for (field = 0; field < _NPCM; field++) {
4463                         inuse = ~pc->pc_map[field] & pc_freemask[field];
4464                         while (inuse != 0) {
4465                                 bit = ffsl(inuse) - 1;
4466                                 bitmask = 1UL << bit;
4467                                 idx = field * 64 + bit;
4468                                 pv = &pc->pc_pventry[idx];
4469                                 inuse &= ~bitmask;
4470
4471                                 pde = pmap_pde(pmap, pv->pv_va, &lvl);
4472                                 KASSERT(pde != NULL,
4473                                     ("Attempting to remove an unmapped page"));
4474
4475                                 switch(lvl) {
4476                                 case 1:
4477                                         pte = pmap_l1_to_l2(pde, pv->pv_va);
4478                                         tpte = pmap_load(pte);
4479                                         KASSERT((tpte & ATTR_DESCR_MASK) ==
4480                                             L2_BLOCK,
4481                                             ("Attempting to remove an invalid "
4482                                             "block: %lx", tpte));
4483                                         break;
4484                                 case 2:
4485                                         pte = pmap_l2_to_l3(pde, pv->pv_va);
4486                                         tpte = pmap_load(pte);
4487                                         KASSERT((tpte & ATTR_DESCR_MASK) ==
4488                                             L3_PAGE,
4489                                             ("Attempting to remove an invalid "
4490                                              "page: %lx", tpte));
4491                                         break;
4492                                 default:
4493                                         panic(
4494                                             "Invalid page directory level: %d",
4495                                             lvl);
4496                                 }
4497
4498 /*
4499  * We cannot remove wired pages from a process' mapping at this time
4500  */
4501                                 if (tpte & ATTR_SW_WIRED) {
4502                                         allfree = 0;
4503                                         continue;
4504                                 }
4505
4506                                 pa = tpte & ~ATTR_MASK;
4507
4508                                 m = PHYS_TO_VM_PAGE(pa);
4509                                 KASSERT(m->phys_addr == pa,
4510                                     ("vm_page_t %p phys_addr mismatch %016jx %016jx",
4511                                     m, (uintmax_t)m->phys_addr,
4512                                     (uintmax_t)tpte));
4513
4514                                 KASSERT((m->flags & PG_FICTITIOUS) != 0 ||
4515                                     m < &vm_page_array[vm_page_array_size],
4516                                     ("pmap_remove_pages: bad pte %#jx",
4517                                     (uintmax_t)tpte));
4518
4519                                 /*
4520                                  * Because this pmap is not active on other
4521                                  * processors, the dirty bit cannot have
4522                                  * changed state since we last loaded pte.
4523                                  */
4524                                 pmap_clear(pte);
4525
4526                                 /*
4527                                  * Update the vm_page_t clean/reference bits.
4528                                  */
4529                                 if (pmap_pte_dirty(pmap, tpte)) {
4530                                         switch (lvl) {
4531                                         case 1:
4532                                                 for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)
4533                                                         vm_page_dirty(mt);
4534                                                 break;
4535                                         case 2:
4536                                                 vm_page_dirty(m);
4537                                                 break;
4538                                         }
4539                                 }
4540
4541                                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(&lock, m);
4542
4543                                 /* Mark free */
4544                                 pc->pc_map[field] |= bitmask;
4545                                 switch (lvl) {
4546                                 case 1:
4547                                         pmap_resident_count_dec(pmap,
4548                                             L2_SIZE / PAGE_SIZE);
4549                                         pvh = pa_to_pvh(tpte & ~ATTR_MASK);
4550                                         TAILQ_REMOVE(&pvh->pv_list, pv,pv_next);
4551                                         pvh->pv_gen++;
4552                                         if (TAILQ_EMPTY(&pvh->pv_list)) {
4553                                                 for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)
4554                                                         if ((mt->a.flags & PGA_WRITEABLE) != 0 &&
4555                                                             TAILQ_EMPTY(&mt->md.pv_list))
4556                                                                 vm_page_aflag_clear(mt, PGA_WRITEABLE);
4557                                         }
4558                                         ml3 = pmap_remove_pt_page(pmap,
4559                                             pv->pv_va);
4560                                         if (ml3 != NULL) {
4561                                                 KASSERT(ml3->valid == VM_PAGE_BITS_ALL,
4562                                                     ("pmap_remove_pages: l3 page not promoted"));
4563                                                 pmap_resident_count_dec(pmap,1);
4564                                                 KASSERT(ml3->ref_count == NL3PG,
4565                                                     ("pmap_remove_pages: l3 page ref count error"));
4566                                                 ml3->ref_count = 0;
4567                                                 pmap_add_delayed_free_list(ml3,
4568                                                     &free, FALSE);
4569                                         }
4570                                         break;
4571                                 case 2:
4572                                         pmap_resident_count_dec(pmap, 1);
4573                                         TAILQ_REMOVE(&m->md.pv_list, pv,
4574                                             pv_next);
4575                                         m->md.pv_gen++;
4576                                         if ((m->a.flags & PGA_WRITEABLE) != 0 &&
4577                                             TAILQ_EMPTY(&m->md.pv_list) &&
4578                                             (m->flags & PG_FICTITIOUS) == 0) {
4579                                                 pvh = pa_to_pvh(
4580                                                     VM_PAGE_TO_PHYS(m));
4581                                                 if (TAILQ_EMPTY(&pvh->pv_list))
4582                                                         vm_page_aflag_clear(m,
4583                                                             PGA_WRITEABLE);
4584                                         }
4585                                         break;
4586                                 }
4587                                 pmap_unuse_pt(pmap, pv->pv_va, pmap_load(pde),
4588                                     &free);
4589                                 freed++;
4590                         }
4591                 }
4592                 PV_STAT(atomic_add_long(&pv_entry_frees, freed));
4593                 PV_STAT(atomic_add_int(&pv_entry_spare, freed));
4594                 PV_STAT(atomic_subtract_long(&pv_entry_count, freed));
4595                 if (allfree) {
4596                         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
4597                         free_pv_chunk(pc);
4598                 }
4599         }
4600         if (lock != NULL)
4601                 rw_wunlock(lock);
4602         pmap_invalidate_all(pmap);
4603         PMAP_UNLOCK(pmap);
4604         vm_page_free_pages_toq(&free, true);
4605 }
4606
4607 /*
4608  * This is used to check if a page has been accessed or modified.
4609  */
4610 static boolean_t
4611 pmap_page_test_mappings(vm_page_t m, boolean_t accessed, boolean_t modified)
4612 {
4613         struct rwlock *lock;
4614         pv_entry_t pv;
4615         struct md_page *pvh;
4616         pt_entry_t *pte, mask, value;
4617         pmap_t pmap;
4618         int lvl, md_gen, pvh_gen;
4619         boolean_t rv;
4620
4621         rv = FALSE;
4622         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
4623         rw_rlock(lock);
4624 restart:
4625         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
4626                 pmap = PV_PMAP(pv);
4627                 PMAP_ASSERT_STAGE1(pmap);
4628                 if (!PMAP_TRYLOCK(pmap)) {
4629                         md_gen = m->md.pv_gen;
4630                         rw_runlock(lock);
4631                         PMAP_LOCK(pmap);
4632                         rw_rlock(lock);
4633                         if (md_gen != m->md.pv_gen) {
4634                                 PMAP_UNLOCK(pmap);
4635                                 goto restart;
4636                         }
4637                 }
4638                 pte = pmap_pte(pmap, pv->pv_va, &lvl);
4639                 KASSERT(lvl == 3,
4640                     ("pmap_page_test_mappings: Invalid level %d", lvl));
4641                 mask = 0;
4642                 value = 0;
4643                 if (modified) {
4644                         mask |= ATTR_S1_AP_RW_BIT;
4645                         value |= ATTR_S1_AP(ATTR_S1_AP_RW);
4646                 }
4647                 if (accessed) {
4648                         mask |= ATTR_AF | ATTR_DESCR_MASK;
4649                         value |= ATTR_AF | L3_PAGE;
4650                 }
4651                 rv = (pmap_load(pte) & mask) == value;
4652                 PMAP_UNLOCK(pmap);
4653                 if (rv)
4654                         goto out;
4655         }
4656         if ((m->flags & PG_FICTITIOUS) == 0) {
4657                 pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
4658                 TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
4659                         pmap = PV_PMAP(pv);
4660                         PMAP_ASSERT_STAGE1(pmap);
4661                         if (!PMAP_TRYLOCK(pmap)) {
4662                                 md_gen = m->md.pv_gen;
4663                                 pvh_gen = pvh->pv_gen;
4664                                 rw_runlock(lock);
4665                                 PMAP_LOCK(pmap);
4666                                 rw_rlock(lock);
4667                                 if (md_gen != m->md.pv_gen ||
4668                                     pvh_gen != pvh->pv_gen) {
4669                                         PMAP_UNLOCK(pmap);
4670                                         goto restart;
4671                                 }
4672                         }
4673                         pte = pmap_pte(pmap, pv->pv_va, &lvl);
4674                         KASSERT(lvl == 2,
4675                             ("pmap_page_test_mappings: Invalid level %d", lvl));
4676                         mask = 0;
4677                         value = 0;
4678                         if (modified) {
4679                                 mask |= ATTR_S1_AP_RW_BIT;
4680                                 value |= ATTR_S1_AP(ATTR_S1_AP_RW);
4681                         }
4682                         if (accessed) {
4683                                 mask |= ATTR_AF | ATTR_DESCR_MASK;
4684                                 value |= ATTR_AF | L2_BLOCK;
4685                         }
4686                         rv = (pmap_load(pte) & mask) == value;
4687                         PMAP_UNLOCK(pmap);
4688                         if (rv)
4689                                 goto out;
4690                 }
4691         }
4692 out:
4693         rw_runlock(lock);
4694         return (rv);
4695 }
4696
4697 /*
4698  *      pmap_is_modified:
4699  *
4700  *      Return whether or not the specified physical page was modified
4701  *      in any physical maps.
4702  */
4703 boolean_t
4704 pmap_is_modified(vm_page_t m)
4705 {
4706
4707         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4708             ("pmap_is_modified: page %p is not managed", m));
4709
4710         /*
4711          * If the page is not busied then this check is racy.
4712          */
4713         if (!pmap_page_is_write_mapped(m))
4714                 return (FALSE);
4715         return (pmap_page_test_mappings(m, FALSE, TRUE));
4716 }
4717
4718 /*
4719  *      pmap_is_prefaultable:
4720  *
4721  *      Return whether or not the specified virtual address is eligible
4722  *      for prefault.
4723  */
4724 boolean_t
4725 pmap_is_prefaultable(pmap_t pmap, vm_offset_t addr)
4726 {
4727         pt_entry_t *pte;
4728         boolean_t rv;
4729         int lvl;
4730
4731         rv = FALSE;
4732         PMAP_LOCK(pmap);
4733         pte = pmap_pte(pmap, addr, &lvl);
4734         if (pte != NULL && pmap_load(pte) != 0) {
4735                 rv = TRUE;
4736         }
4737         PMAP_UNLOCK(pmap);
4738         return (rv);
4739 }
4740
4741 /*
4742  *      pmap_is_referenced:
4743  *
4744  *      Return whether or not the specified physical page was referenced
4745  *      in any physical maps.
4746  */
4747 boolean_t
4748 pmap_is_referenced(vm_page_t m)
4749 {
4750
4751         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4752             ("pmap_is_referenced: page %p is not managed", m));
4753         return (pmap_page_test_mappings(m, TRUE, FALSE));
4754 }
4755
4756 /*
4757  * Clear the write and modified bits in each of the given page's mappings.
4758  */
4759 void
4760 pmap_remove_write(vm_page_t m)
4761 {
4762         struct md_page *pvh;
4763         pmap_t pmap;
4764         struct rwlock *lock;
4765         pv_entry_t next_pv, pv;
4766         pt_entry_t oldpte, *pte;
4767         vm_offset_t va;
4768         int lvl, md_gen, pvh_gen;
4769
4770         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4771             ("pmap_remove_write: page %p is not managed", m));
4772         vm_page_assert_busied(m);
4773
4774         if (!pmap_page_is_write_mapped(m))
4775                 return;
4776         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
4777         pvh = (m->flags & PG_FICTITIOUS) != 0 ? &pv_dummy :
4778             pa_to_pvh(VM_PAGE_TO_PHYS(m));
4779 retry_pv_loop:
4780         rw_wlock(lock);
4781         TAILQ_FOREACH_SAFE(pv, &pvh->pv_list, pv_next, next_pv) {
4782                 pmap = PV_PMAP(pv);
4783                 PMAP_ASSERT_STAGE1(pmap);
4784                 if (!PMAP_TRYLOCK(pmap)) {
4785                         pvh_gen = pvh->pv_gen;
4786                         rw_wunlock(lock);
4787                         PMAP_LOCK(pmap);
4788                         rw_wlock(lock);
4789                         if (pvh_gen != pvh->pv_gen) {
4790                                 PMAP_UNLOCK(pmap);
4791                                 rw_wunlock(lock);
4792                                 goto retry_pv_loop;
4793                         }
4794                 }
4795                 va = pv->pv_va;
4796                 pte = pmap_pte(pmap, pv->pv_va, &lvl);
4797                 if ((pmap_load(pte) & ATTR_SW_DBM) != 0)
4798                         (void)pmap_demote_l2_locked(pmap, pte, va, &lock);
4799                 KASSERT(lock == VM_PAGE_TO_PV_LIST_LOCK(m),
4800                     ("inconsistent pv lock %p %p for page %p",
4801                     lock, VM_PAGE_TO_PV_LIST_LOCK(m), m));
4802                 PMAP_UNLOCK(pmap);
4803         }
4804         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
4805                 pmap = PV_PMAP(pv);
4806                 PMAP_ASSERT_STAGE1(pmap);
4807                 if (!PMAP_TRYLOCK(pmap)) {
4808                         pvh_gen = pvh->pv_gen;
4809                         md_gen = m->md.pv_gen;
4810                         rw_wunlock(lock);
4811                         PMAP_LOCK(pmap);
4812                         rw_wlock(lock);
4813                         if (pvh_gen != pvh->pv_gen ||
4814                             md_gen != m->md.pv_gen) {
4815                                 PMAP_UNLOCK(pmap);
4816                                 rw_wunlock(lock);
4817                                 goto retry_pv_loop;
4818                         }
4819                 }
4820                 pte = pmap_pte(pmap, pv->pv_va, &lvl);
4821                 oldpte = pmap_load(pte);
4822 retry:
4823                 if ((oldpte & ATTR_SW_DBM) != 0) {
4824                         if (!atomic_fcmpset_long(pte, &oldpte,
4825                             (oldpte | ATTR_S1_AP_RW_BIT) & ~ATTR_SW_DBM))
4826                                 goto retry;
4827                         if ((oldpte & ATTR_S1_AP_RW_BIT) ==
4828                             ATTR_S1_AP(ATTR_S1_AP_RW))
4829                                 vm_page_dirty(m);
4830                         pmap_invalidate_page(pmap, pv->pv_va);
4831                 }
4832                 PMAP_UNLOCK(pmap);
4833         }
4834         rw_wunlock(lock);
4835         vm_page_aflag_clear(m, PGA_WRITEABLE);
4836 }
4837
4838 /*
4839  *      pmap_ts_referenced:
4840  *
4841  *      Return a count of reference bits for a page, clearing those bits.
4842  *      It is not necessary for every reference bit to be cleared, but it
4843  *      is necessary that 0 only be returned when there are truly no
4844  *      reference bits set.
4845  *
4846  *      As an optimization, update the page's dirty field if a modified bit is
4847  *      found while counting reference bits.  This opportunistic update can be
4848  *      performed at low cost and can eliminate the need for some future calls
4849  *      to pmap_is_modified().  However, since this function stops after
4850  *      finding PMAP_TS_REFERENCED_MAX reference bits, it may not detect some
4851  *      dirty pages.  Those dirty pages will only be detected by a future call
4852  *      to pmap_is_modified().
4853  */
4854 int
4855 pmap_ts_referenced(vm_page_t m)
4856 {
4857         struct md_page *pvh;
4858         pv_entry_t pv, pvf;
4859         pmap_t pmap;
4860         struct rwlock *lock;
4861         pd_entry_t *pde, tpde;
4862         pt_entry_t *pte, tpte;
4863         vm_offset_t va;
4864         vm_paddr_t pa;
4865         int cleared, lvl, md_gen, not_cleared, pvh_gen;
4866         struct spglist free;
4867
4868         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4869             ("pmap_ts_referenced: page %p is not managed", m));
4870         SLIST_INIT(&free);
4871         cleared = 0;
4872         pa = VM_PAGE_TO_PHYS(m);
4873         lock = PHYS_TO_PV_LIST_LOCK(pa);
4874         pvh = (m->flags & PG_FICTITIOUS) != 0 ? &pv_dummy : pa_to_pvh(pa);
4875         rw_wlock(lock);
4876 retry:
4877         not_cleared = 0;
4878         if ((pvf = TAILQ_FIRST(&pvh->pv_list)) == NULL)
4879                 goto small_mappings;
4880         pv = pvf;
4881         do {
4882                 if (pvf == NULL)
4883                         pvf = pv;
4884                 pmap = PV_PMAP(pv);
4885                 if (!PMAP_TRYLOCK(pmap)) {
4886                         pvh_gen = pvh->pv_gen;
4887                         rw_wunlock(lock);
4888                         PMAP_LOCK(pmap);
4889                         rw_wlock(lock);
4890                         if (pvh_gen != pvh->pv_gen) {
4891                                 PMAP_UNLOCK(pmap);
4892                                 goto retry;
4893                         }
4894                 }
4895                 va = pv->pv_va;
4896                 pde = pmap_pde(pmap, pv->pv_va, &lvl);
4897                 KASSERT(pde != NULL, ("pmap_ts_referenced: no l1 table found"));
4898                 KASSERT(lvl == 1,
4899                     ("pmap_ts_referenced: invalid pde level %d", lvl));
4900                 tpde = pmap_load(pde);
4901                 KASSERT((tpde & ATTR_DESCR_MASK) == L1_TABLE,
4902                     ("pmap_ts_referenced: found an invalid l1 table"));
4903                 pte = pmap_l1_to_l2(pde, pv->pv_va);
4904                 tpte = pmap_load(pte);
4905                 if (pmap_pte_dirty(pmap, tpte)) {
4906                         /*
4907                          * Although "tpte" is mapping a 2MB page, because
4908                          * this function is called at a 4KB page granularity,
4909                          * we only update the 4KB page under test.
4910                          */
4911                         vm_page_dirty(m);
4912                 }
4913
4914                 if ((tpte & ATTR_AF) != 0) {
4915                         /*
4916                          * Since this reference bit is shared by 512 4KB pages,
4917                          * it should not be cleared every time it is tested.
4918                          * Apply a simple "hash" function on the physical page
4919                          * number, the virtual superpage number, and the pmap
4920                          * address to select one 4KB page out of the 512 on
4921                          * which testing the reference bit will result in
4922                          * clearing that reference bit.  This function is
4923                          * designed to avoid the selection of the same 4KB page
4924                          * for every 2MB page mapping.
4925                          *
4926                          * On demotion, a mapping that hasn't been referenced
4927                          * is simply destroyed.  To avoid the possibility of a
4928                          * subsequent page fault on a demoted wired mapping,
4929                          * always leave its reference bit set.  Moreover,
4930                          * since the superpage is wired, the current state of
4931                          * its reference bit won't affect page replacement.
4932                          */
4933                         if ((((pa >> PAGE_SHIFT) ^ (pv->pv_va >> L2_SHIFT) ^
4934                             (uintptr_t)pmap) & (Ln_ENTRIES - 1)) == 0 &&
4935                             (tpte & ATTR_SW_WIRED) == 0) {
4936                                 pmap_clear_bits(pte, ATTR_AF);
4937                                 pmap_invalidate_page(pmap, pv->pv_va);
4938                                 cleared++;
4939                         } else
4940                                 not_cleared++;
4941                 }
4942                 PMAP_UNLOCK(pmap);
4943                 /* Rotate the PV list if it has more than one entry. */
4944                 if (pv != NULL && TAILQ_NEXT(pv, pv_next) != NULL) {
4945                         TAILQ_REMOVE(&pvh->pv_list, pv, pv_next);
4946                         TAILQ_INSERT_TAIL(&pvh->pv_list, pv, pv_next);
4947                         pvh->pv_gen++;
4948                 }
4949                 if (cleared + not_cleared >= PMAP_TS_REFERENCED_MAX)
4950                         goto out;
4951         } while ((pv = TAILQ_FIRST(&pvh->pv_list)) != pvf);
4952 small_mappings:
4953         if ((pvf = TAILQ_FIRST(&m->md.pv_list)) == NULL)
4954                 goto out;
4955         pv = pvf;
4956         do {
4957                 if (pvf == NULL)
4958                         pvf = pv;
4959                 pmap = PV_PMAP(pv);
4960                 if (!PMAP_TRYLOCK(pmap)) {
4961                         pvh_gen = pvh->pv_gen;
4962                         md_gen = m->md.pv_gen;
4963                         rw_wunlock(lock);
4964                         PMAP_LOCK(pmap);
4965                         rw_wlock(lock);
4966                         if (pvh_gen != pvh->pv_gen || md_gen != m->md.pv_gen) {
4967                                 PMAP_UNLOCK(pmap);
4968                                 goto retry;
4969                         }
4970                 }
4971                 pde = pmap_pde(pmap, pv->pv_va, &lvl);
4972                 KASSERT(pde != NULL, ("pmap_ts_referenced: no l2 table found"));
4973                 KASSERT(lvl == 2,
4974                     ("pmap_ts_referenced: invalid pde level %d", lvl));
4975                 tpde = pmap_load(pde);
4976                 KASSERT((tpde & ATTR_DESCR_MASK) == L2_TABLE,
4977                     ("pmap_ts_referenced: found an invalid l2 table"));
4978                 pte = pmap_l2_to_l3(pde, pv->pv_va);
4979                 tpte = pmap_load(pte);
4980                 if (pmap_pte_dirty(pmap, tpte))
4981                         vm_page_dirty(m);
4982                 if ((tpte & ATTR_AF) != 0) {
4983                         if ((tpte & ATTR_SW_WIRED) == 0) {
4984                                 pmap_clear_bits(pte, ATTR_AF);
4985                                 pmap_invalidate_page(pmap, pv->pv_va);
4986                                 cleared++;
4987                         } else
4988                                 not_cleared++;
4989                 }
4990                 PMAP_UNLOCK(pmap);
4991                 /* Rotate the PV list if it has more than one entry. */
4992                 if (pv != NULL && TAILQ_NEXT(pv, pv_next) != NULL) {
4993                         TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
4994                         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
4995                         m->md.pv_gen++;
4996                 }
4997         } while ((pv = TAILQ_FIRST(&m->md.pv_list)) != pvf && cleared +
4998             not_cleared < PMAP_TS_REFERENCED_MAX);
4999 out:
5000         rw_wunlock(lock);
5001         vm_page_free_pages_toq(&free, true);
5002         return (cleared + not_cleared);
5003 }
5004
5005 /*
5006  *      Apply the given advice to the specified range of addresses within the
5007  *      given pmap.  Depending on the advice, clear the referenced and/or
5008  *      modified flags in each mapping and set the mapped page's dirty field.
5009  */
5010 void
5011 pmap_advise(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, int advice)
5012 {
5013         struct rwlock *lock;
5014         vm_offset_t va, va_next;
5015         vm_page_t m;
5016         pd_entry_t *l0, *l1, *l2, oldl2;
5017         pt_entry_t *l3, oldl3;
5018
5019         PMAP_ASSERT_STAGE1(pmap);
5020
5021         if (advice != MADV_DONTNEED && advice != MADV_FREE)
5022                 return;
5023
5024         PMAP_LOCK(pmap);
5025         for (; sva < eva; sva = va_next) {
5026                 l0 = pmap_l0(pmap, sva);
5027                 if (pmap_load(l0) == 0) {
5028                         va_next = (sva + L0_SIZE) & ~L0_OFFSET;
5029                         if (va_next < sva)
5030                                 va_next = eva;
5031                         continue;
5032                 }
5033                 l1 = pmap_l0_to_l1(l0, sva);
5034                 if (pmap_load(l1) == 0) {
5035                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
5036                         if (va_next < sva)
5037                                 va_next = eva;
5038                         continue;
5039                 }
5040                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
5041                 if (va_next < sva)
5042                         va_next = eva;
5043                 l2 = pmap_l1_to_l2(l1, sva);
5044                 oldl2 = pmap_load(l2);
5045                 if (oldl2 == 0)
5046                         continue;
5047                 if ((oldl2 & ATTR_DESCR_MASK) == L2_BLOCK) {
5048                         if ((oldl2 & ATTR_SW_MANAGED) == 0)
5049                                 continue;
5050                         lock = NULL;
5051                         if (!pmap_demote_l2_locked(pmap, l2, sva, &lock)) {
5052                                 if (lock != NULL)
5053                                         rw_wunlock(lock);
5054
5055                                 /*
5056                                  * The 2MB page mapping was destroyed.
5057                                  */
5058                                 continue;
5059                         }
5060
5061                         /*
5062                          * Unless the page mappings are wired, remove the
5063                          * mapping to a single page so that a subsequent
5064                          * access may repromote.  Choosing the last page
5065                          * within the address range [sva, min(va_next, eva))
5066                          * generally results in more repromotions.  Since the
5067                          * underlying page table page is fully populated, this
5068                          * removal never frees a page table page.
5069                          */
5070                         if ((oldl2 & ATTR_SW_WIRED) == 0) {
5071                                 va = eva;
5072                                 if (va > va_next)
5073                                         va = va_next;
5074                                 va -= PAGE_SIZE;
5075                                 KASSERT(va >= sva,
5076                                     ("pmap_advise: no address gap"));
5077                                 l3 = pmap_l2_to_l3(l2, va);
5078                                 KASSERT(pmap_load(l3) != 0,
5079                                     ("pmap_advise: invalid PTE"));
5080                                 pmap_remove_l3(pmap, l3, va, pmap_load(l2),
5081                                     NULL, &lock);
5082                         }
5083                         if (lock != NULL)
5084                                 rw_wunlock(lock);
5085                 }
5086                 KASSERT((pmap_load(l2) & ATTR_DESCR_MASK) == L2_TABLE,
5087                     ("pmap_advise: invalid L2 entry after demotion"));
5088                 if (va_next > eva)
5089                         va_next = eva;
5090                 va = va_next;
5091                 for (l3 = pmap_l2_to_l3(l2, sva); sva != va_next; l3++,
5092                     sva += L3_SIZE) {
5093                         oldl3 = pmap_load(l3);
5094                         if ((oldl3 & (ATTR_SW_MANAGED | ATTR_DESCR_MASK)) !=
5095                             (ATTR_SW_MANAGED | L3_PAGE))
5096                                 goto maybe_invlrng;
5097                         else if (pmap_pte_dirty(pmap, oldl3)) {
5098                                 if (advice == MADV_DONTNEED) {
5099                                         /*
5100                                          * Future calls to pmap_is_modified()
5101                                          * can be avoided by making the page
5102                                          * dirty now.
5103                                          */
5104                                         m = PHYS_TO_VM_PAGE(oldl3 & ~ATTR_MASK);
5105                                         vm_page_dirty(m);
5106                                 }
5107                                 while (!atomic_fcmpset_long(l3, &oldl3,
5108                                     (oldl3 & ~ATTR_AF) |
5109                                     ATTR_S1_AP(ATTR_S1_AP_RO)))
5110                                         cpu_spinwait();
5111                         } else if ((oldl3 & ATTR_AF) != 0)
5112                                 pmap_clear_bits(l3, ATTR_AF);
5113                         else
5114                                 goto maybe_invlrng;
5115                         if (va == va_next)
5116                                 va = sva;
5117                         continue;
5118 maybe_invlrng:
5119                         if (va != va_next) {
5120                                 pmap_invalidate_range(pmap, va, sva);
5121                                 va = va_next;
5122                         }
5123                 }
5124                 if (va != va_next)
5125                         pmap_invalidate_range(pmap, va, sva);
5126         }
5127         PMAP_UNLOCK(pmap);
5128 }
5129
5130 /*
5131  *      Clear the modify bits on the specified physical page.
5132  */
5133 void
5134 pmap_clear_modify(vm_page_t m)
5135 {
5136         struct md_page *pvh;
5137         struct rwlock *lock;
5138         pmap_t pmap;
5139         pv_entry_t next_pv, pv;
5140         pd_entry_t *l2, oldl2;
5141         pt_entry_t *l3, oldl3;
5142         vm_offset_t va;
5143         int md_gen, pvh_gen;
5144
5145         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
5146             ("pmap_clear_modify: page %p is not managed", m));
5147         vm_page_assert_busied(m);
5148
5149         if (!pmap_page_is_write_mapped(m))
5150                 return;
5151         pvh = (m->flags & PG_FICTITIOUS) != 0 ? &pv_dummy :
5152             pa_to_pvh(VM_PAGE_TO_PHYS(m));
5153         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
5154         rw_wlock(lock);
5155 restart:
5156         TAILQ_FOREACH_SAFE(pv, &pvh->pv_list, pv_next, next_pv) {
5157                 pmap = PV_PMAP(pv);
5158                 PMAP_ASSERT_STAGE1(pmap);
5159                 if (!PMAP_TRYLOCK(pmap)) {
5160                         pvh_gen = pvh->pv_gen;
5161                         rw_wunlock(lock);
5162                         PMAP_LOCK(pmap);
5163                         rw_wlock(lock);
5164                         if (pvh_gen != pvh->pv_gen) {
5165                                 PMAP_UNLOCK(pmap);
5166                                 goto restart;
5167                         }
5168                 }
5169                 va = pv->pv_va;
5170                 l2 = pmap_l2(pmap, va);
5171                 oldl2 = pmap_load(l2);
5172                 /* If oldl2 has ATTR_SW_DBM set, then it is also dirty. */
5173                 if ((oldl2 & ATTR_SW_DBM) != 0 &&
5174                     pmap_demote_l2_locked(pmap, l2, va, &lock) &&
5175                     (oldl2 & ATTR_SW_WIRED) == 0) {
5176                         /*
5177                          * Write protect the mapping to a single page so that
5178                          * a subsequent write access may repromote.
5179                          */
5180                         va += VM_PAGE_TO_PHYS(m) - (oldl2 & ~ATTR_MASK);
5181                         l3 = pmap_l2_to_l3(l2, va);
5182                         oldl3 = pmap_load(l3);
5183                         while (!atomic_fcmpset_long(l3, &oldl3,
5184                             (oldl3 & ~ATTR_SW_DBM) | ATTR_S1_AP(ATTR_S1_AP_RO)))
5185                                 cpu_spinwait();
5186                         vm_page_dirty(m);
5187                         pmap_invalidate_page(pmap, va);
5188                 }
5189                 PMAP_UNLOCK(pmap);
5190         }
5191         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
5192                 pmap = PV_PMAP(pv);
5193                 PMAP_ASSERT_STAGE1(pmap);
5194                 if (!PMAP_TRYLOCK(pmap)) {
5195                         md_gen = m->md.pv_gen;
5196                         pvh_gen = pvh->pv_gen;
5197                         rw_wunlock(lock);
5198                         PMAP_LOCK(pmap);
5199                         rw_wlock(lock);
5200                         if (pvh_gen != pvh->pv_gen || md_gen != m->md.pv_gen) {
5201                                 PMAP_UNLOCK(pmap);
5202                                 goto restart;
5203                         }
5204                 }
5205                 l2 = pmap_l2(pmap, pv->pv_va);
5206                 l3 = pmap_l2_to_l3(l2, pv->pv_va);
5207                 oldl3 = pmap_load(l3);
5208                 if (pmap_l3_valid(oldl3) &&
5209                     (oldl3 & (ATTR_S1_AP_RW_BIT | ATTR_SW_DBM)) == ATTR_SW_DBM){
5210                         pmap_set_bits(l3, ATTR_S1_AP(ATTR_S1_AP_RO));
5211                         pmap_invalidate_page(pmap, pv->pv_va);
5212                 }
5213                 PMAP_UNLOCK(pmap);
5214         }
5215         rw_wunlock(lock);
5216 }
5217
5218 void *
5219 pmap_mapbios(vm_paddr_t pa, vm_size_t size)
5220 {
5221         struct pmap_preinit_mapping *ppim;
5222         vm_offset_t va, offset;
5223         pd_entry_t *pde;
5224         pt_entry_t *l2;
5225         int i, lvl, l2_blocks, free_l2_count, start_idx;
5226
5227         if (!vm_initialized) {
5228                 /*
5229                  * No L3 ptables so map entire L2 blocks where start VA is:
5230                  *      preinit_map_va + start_idx * L2_SIZE
5231                  * There may be duplicate mappings (multiple VA -> same PA) but
5232                  * ARM64 dcache is always PIPT so that's acceptable.
5233                  */
5234                  if (size == 0)
5235                          return (NULL);
5236
5237                  /* Calculate how many L2 blocks are needed for the mapping */
5238                 l2_blocks = (roundup2(pa + size, L2_SIZE) -
5239                     rounddown2(pa, L2_SIZE)) >> L2_SHIFT;
5240
5241                 offset = pa & L2_OFFSET;
5242
5243                 if (preinit_map_va == 0)
5244                         return (NULL);
5245
5246                 /* Map 2MiB L2 blocks from reserved VA space */
5247
5248                 free_l2_count = 0;
5249                 start_idx = -1;
5250                 /* Find enough free contiguous VA space */
5251                 for (i = 0; i < PMAP_PREINIT_MAPPING_COUNT; i++) {
5252                         ppim = pmap_preinit_mapping + i;
5253                         if (free_l2_count > 0 && ppim->pa != 0) {
5254                                 /* Not enough space here */
5255                                 free_l2_count = 0;
5256                                 start_idx = -1;
5257                                 continue;
5258                         }
5259
5260                         if (ppim->pa == 0) {
5261                                 /* Free L2 block */
5262                                 if (start_idx == -1)
5263                                         start_idx = i;
5264                                 free_l2_count++;
5265                                 if (free_l2_count == l2_blocks)
5266                                         break;
5267                         }
5268                 }
5269                 if (free_l2_count != l2_blocks)
5270                         panic("%s: too many preinit mappings", __func__);
5271
5272                 va = preinit_map_va + (start_idx * L2_SIZE);
5273                 for (i = start_idx; i < start_idx + l2_blocks; i++) {
5274                         /* Mark entries as allocated */
5275                         ppim = pmap_preinit_mapping + i;
5276                         ppim->pa = pa;
5277                         ppim->va = va + offset;
5278                         ppim->size = size;
5279                 }
5280
5281                 /* Map L2 blocks */
5282                 pa = rounddown2(pa, L2_SIZE);
5283                 for (i = 0; i < l2_blocks; i++) {
5284                         pde = pmap_pde(kernel_pmap, va, &lvl);
5285                         KASSERT(pde != NULL,
5286                             ("pmap_mapbios: Invalid page entry, va: 0x%lx",
5287                             va));
5288                         KASSERT(lvl == 1,
5289                             ("pmap_mapbios: Invalid level %d", lvl));
5290
5291                         /* Insert L2_BLOCK */
5292                         l2 = pmap_l1_to_l2(pde, va);
5293                         pmap_load_store(l2,
5294                             pa | ATTR_DEFAULT | ATTR_S1_XN |
5295                             ATTR_S1_IDX(VM_MEMATTR_WRITE_BACK) | L2_BLOCK);
5296
5297                         va += L2_SIZE;
5298                         pa += L2_SIZE;
5299                 }
5300                 pmap_invalidate_all(kernel_pmap);
5301
5302                 va = preinit_map_va + (start_idx * L2_SIZE);
5303
5304         } else {
5305                 /* kva_alloc may be used to map the pages */
5306                 offset = pa & PAGE_MASK;
5307                 size = round_page(offset + size);
5308
5309                 va = kva_alloc(size);
5310                 if (va == 0)
5311                         panic("%s: Couldn't allocate KVA", __func__);
5312
5313                 pde = pmap_pde(kernel_pmap, va, &lvl);
5314                 KASSERT(lvl == 2, ("pmap_mapbios: Invalid level %d", lvl));
5315
5316                 /* L3 table is linked */
5317                 va = trunc_page(va);
5318                 pa = trunc_page(pa);
5319                 pmap_kenter(va, size, pa, VM_MEMATTR_WRITE_BACK);
5320         }
5321
5322         return ((void *)(va + offset));
5323 }
5324
5325 void
5326 pmap_unmapbios(vm_offset_t va, vm_size_t size)
5327 {
5328         struct pmap_preinit_mapping *ppim;
5329         vm_offset_t offset, tmpsize, va_trunc;
5330         pd_entry_t *pde;
5331         pt_entry_t *l2;
5332         int i, lvl, l2_blocks, block;
5333         bool preinit_map;
5334
5335         l2_blocks =
5336            (roundup2(va + size, L2_SIZE) - rounddown2(va, L2_SIZE)) >> L2_SHIFT;
5337         KASSERT(l2_blocks > 0, ("pmap_unmapbios: invalid size %lx", size));
5338
5339         /* Remove preinit mapping */
5340         preinit_map = false;
5341         block = 0;
5342         for (i = 0; i < PMAP_PREINIT_MAPPING_COUNT; i++) {
5343                 ppim = pmap_preinit_mapping + i;
5344                 if (ppim->va == va) {
5345                         KASSERT(ppim->size == size,
5346                             ("pmap_unmapbios: size mismatch"));
5347                         ppim->va = 0;
5348                         ppim->pa = 0;
5349                         ppim->size = 0;
5350                         preinit_map = true;
5351                         offset = block * L2_SIZE;
5352                         va_trunc = rounddown2(va, L2_SIZE) + offset;
5353
5354                         /* Remove L2_BLOCK */
5355                         pde = pmap_pde(kernel_pmap, va_trunc, &lvl);
5356                         KASSERT(pde != NULL,
5357                             ("pmap_unmapbios: Invalid page entry, va: 0x%lx",
5358                             va_trunc));
5359                         l2 = pmap_l1_to_l2(pde, va_trunc);
5360                         pmap_clear(l2);
5361
5362                         if (block == (l2_blocks - 1))
5363                                 break;
5364                         block++;
5365                 }
5366         }
5367         if (preinit_map) {
5368                 pmap_invalidate_all(kernel_pmap);
5369                 return;
5370         }
5371
5372         /* Unmap the pages reserved with kva_alloc. */
5373         if (vm_initialized) {
5374                 offset = va & PAGE_MASK;
5375                 size = round_page(offset + size);
5376                 va = trunc_page(va);
5377
5378                 pde = pmap_pde(kernel_pmap, va, &lvl);
5379                 KASSERT(pde != NULL,
5380                     ("pmap_unmapbios: Invalid page entry, va: 0x%lx", va));
5381                 KASSERT(lvl == 2, ("pmap_unmapbios: Invalid level %d", lvl));
5382
5383                 /* Unmap and invalidate the pages */
5384                 for (tmpsize = 0; tmpsize < size; tmpsize += PAGE_SIZE)
5385                         pmap_kremove(va + tmpsize);
5386
5387                 kva_free(va, size);
5388         }
5389 }
5390
5391 /*
5392  * Sets the memory attribute for the specified page.
5393  */
5394 void
5395 pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
5396 {
5397
5398         m->md.pv_memattr = ma;
5399
5400         /*
5401          * If "m" is a normal page, update its direct mapping.  This update
5402          * can be relied upon to perform any cache operations that are
5403          * required for data coherence.
5404          */
5405         if ((m->flags & PG_FICTITIOUS) == 0 &&
5406             pmap_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,
5407             m->md.pv_memattr) != 0)
5408                 panic("memory attribute change on the direct map failed");
5409 }
5410
5411 /*
5412  * Changes the specified virtual address range's memory type to that given by
5413  * the parameter "mode".  The specified virtual address range must be
5414  * completely contained within either the direct map or the kernel map.  If
5415  * the virtual address range is contained within the kernel map, then the
5416  * memory type for each of the corresponding ranges of the direct map is also
5417  * changed.  (The corresponding ranges of the direct map are those ranges that
5418  * map the same physical pages as the specified virtual address range.)  These
5419  * changes to the direct map are necessary because Intel describes the
5420  * behavior of their processors as "undefined" if two or more mappings to the
5421  * same physical page have different memory types.
5422  *
5423  * Returns zero if the change completed successfully, and either EINVAL or
5424  * ENOMEM if the change failed.  Specifically, EINVAL is returned if some part
5425  * of the virtual address range was not mapped, and ENOMEM is returned if
5426  * there was insufficient memory available to complete the change.  In the
5427  * latter case, the memory type may have been changed on some part of the
5428  * virtual address range or the direct map.
5429  */
5430 int
5431 pmap_change_attr(vm_offset_t va, vm_size_t size, int mode)
5432 {
5433         int error;
5434
5435         PMAP_LOCK(kernel_pmap);
5436         error = pmap_change_attr_locked(va, size, mode);
5437         PMAP_UNLOCK(kernel_pmap);
5438         return (error);
5439 }
5440
5441 static int
5442 pmap_change_attr_locked(vm_offset_t va, vm_size_t size, int mode)
5443 {
5444         vm_offset_t base, offset, tmpva;
5445         pt_entry_t l3, *pte, *newpte;
5446         int lvl;
5447
5448         PMAP_LOCK_ASSERT(kernel_pmap, MA_OWNED);
5449         base = trunc_page(va);
5450         offset = va & PAGE_MASK;
5451         size = round_page(offset + size);
5452
5453         if (!VIRT_IN_DMAP(base) &&
5454             !(base >= VM_MIN_KERNEL_ADDRESS && base < VM_MAX_KERNEL_ADDRESS))
5455                 return (EINVAL);
5456
5457         for (tmpva = base; tmpva < base + size; ) {
5458                 pte = pmap_pte(kernel_pmap, tmpva, &lvl);
5459                 if (pte == NULL)
5460                         return (EINVAL);
5461
5462                 if ((pmap_load(pte) & ATTR_S1_IDX_MASK) == ATTR_S1_IDX(mode)) {
5463                         /*
5464                          * We already have the correct attribute,
5465                          * ignore this entry.
5466                          */
5467                         switch (lvl) {
5468                         default:
5469                                 panic("Invalid DMAP table level: %d\n", lvl);
5470                         case 1:
5471                                 tmpva = (tmpva & ~L1_OFFSET) + L1_SIZE;
5472                                 break;
5473                         case 2:
5474                                 tmpva = (tmpva & ~L2_OFFSET) + L2_SIZE;
5475                                 break;
5476                         case 3:
5477                                 tmpva += PAGE_SIZE;
5478                                 break;
5479                         }
5480                 } else {
5481                         /*
5482                          * Split the entry to an level 3 table, then
5483                          * set the new attribute.
5484                          */
5485                         switch (lvl) {
5486                         default:
5487                                 panic("Invalid DMAP table level: %d\n", lvl);
5488                         case 1:
5489                                 newpte = pmap_demote_l1(kernel_pmap, pte,
5490                                     tmpva & ~L1_OFFSET);
5491                                 if (newpte == NULL)
5492                                         return (EINVAL);
5493                                 pte = pmap_l1_to_l2(pte, tmpva);
5494                         case 2:
5495                                 newpte = pmap_demote_l2(kernel_pmap, pte,
5496                                     tmpva);
5497                                 if (newpte == NULL)
5498                                         return (EINVAL);
5499                                 pte = pmap_l2_to_l3(pte, tmpva);
5500                         case 3:
5501                                 /* Update the entry */
5502                                 l3 = pmap_load(pte);
5503                                 l3 &= ~ATTR_S1_IDX_MASK;
5504                                 l3 |= ATTR_S1_IDX(mode);
5505                                 if (mode == VM_MEMATTR_DEVICE)
5506                                         l3 |= ATTR_S1_XN;
5507
5508                                 pmap_update_entry(kernel_pmap, pte, l3, tmpva,
5509                                     PAGE_SIZE);
5510
5511                                 /*
5512                                  * If moving to a non-cacheable entry flush
5513                                  * the cache.
5514                                  */
5515                                 if (mode == VM_MEMATTR_UNCACHEABLE)
5516                                         cpu_dcache_wbinv_range(tmpva, L3_SIZE);
5517
5518                                 break;
5519                         }
5520                         tmpva += PAGE_SIZE;
5521                 }
5522         }
5523
5524         return (0);
5525 }
5526
5527 /*
5528  * Create an L2 table to map all addresses within an L1 mapping.
5529  */
5530 static pt_entry_t *
5531 pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va)
5532 {
5533         pt_entry_t *l2, newl2, oldl1;
5534         vm_offset_t tmpl1;
5535         vm_paddr_t l2phys, phys;
5536         vm_page_t ml2;
5537         int i;
5538
5539         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
5540         oldl1 = pmap_load(l1);
5541         KASSERT((oldl1 & ATTR_DESCR_MASK) == L1_BLOCK,
5542             ("pmap_demote_l1: Demoting a non-block entry"));
5543         KASSERT((va & L1_OFFSET) == 0,
5544             ("pmap_demote_l1: Invalid virtual address %#lx", va));
5545         KASSERT((oldl1 & ATTR_SW_MANAGED) == 0,
5546             ("pmap_demote_l1: Level 1 table shouldn't be managed"));
5547
5548         tmpl1 = 0;
5549         if (va <= (vm_offset_t)l1 && va + L1_SIZE > (vm_offset_t)l1) {
5550                 tmpl1 = kva_alloc(PAGE_SIZE);
5551                 if (tmpl1 == 0)
5552                         return (NULL);
5553         }
5554
5555         if ((ml2 = vm_page_alloc(NULL, 0, VM_ALLOC_INTERRUPT |
5556             VM_ALLOC_NOOBJ | VM_ALLOC_WIRED)) == NULL) {
5557                 CTR2(KTR_PMAP, "pmap_demote_l1: failure for va %#lx"
5558                     " in pmap %p", va, pmap);
5559                 return (NULL);
5560         }
5561
5562         l2phys = VM_PAGE_TO_PHYS(ml2);
5563         l2 = (pt_entry_t *)PHYS_TO_DMAP(l2phys);
5564
5565         /* Address the range points at */
5566         phys = oldl1 & ~ATTR_MASK;
5567         /* The attributed from the old l1 table to be copied */
5568         newl2 = oldl1 & ATTR_MASK;
5569
5570         /* Create the new entries */
5571         for (i = 0; i < Ln_ENTRIES; i++) {
5572                 l2[i] = newl2 | phys;
5573                 phys += L2_SIZE;
5574         }
5575         KASSERT(l2[0] == ((oldl1 & ~ATTR_DESCR_MASK) | L2_BLOCK),
5576             ("Invalid l2 page (%lx != %lx)", l2[0],
5577             (oldl1 & ~ATTR_DESCR_MASK) | L2_BLOCK));
5578
5579         if (tmpl1 != 0) {
5580                 pmap_kenter(tmpl1, PAGE_SIZE,
5581                     DMAP_TO_PHYS((vm_offset_t)l1) & ~L3_OFFSET,
5582                     VM_MEMATTR_WRITE_BACK);
5583                 l1 = (pt_entry_t *)(tmpl1 + ((vm_offset_t)l1 & PAGE_MASK));
5584         }
5585
5586         pmap_update_entry(pmap, l1, l2phys | L1_TABLE, va, PAGE_SIZE);
5587
5588         if (tmpl1 != 0) {
5589                 pmap_kremove(tmpl1);
5590                 kva_free(tmpl1, PAGE_SIZE);
5591         }
5592
5593         return (l2);
5594 }
5595
5596 static void
5597 pmap_fill_l3(pt_entry_t *firstl3, pt_entry_t newl3)
5598 {
5599         pt_entry_t *l3;
5600
5601         for (l3 = firstl3; l3 - firstl3 < Ln_ENTRIES; l3++) {
5602                 *l3 = newl3;
5603                 newl3 += L3_SIZE;
5604         }
5605 }
5606
5607 static void
5608 pmap_demote_l2_abort(pmap_t pmap, vm_offset_t va, pt_entry_t *l2,
5609     struct rwlock **lockp)
5610 {
5611         struct spglist free;
5612
5613         SLIST_INIT(&free);
5614         (void)pmap_remove_l2(pmap, l2, va, pmap_load(pmap_l1(pmap, va)), &free,
5615             lockp);
5616         vm_page_free_pages_toq(&free, true);
5617 }
5618
5619 /*
5620  * Create an L3 table to map all addresses within an L2 mapping.
5621  */
5622 static pt_entry_t *
5623 pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2, vm_offset_t va,
5624     struct rwlock **lockp)
5625 {
5626         pt_entry_t *l3, newl3, oldl2;
5627         vm_offset_t tmpl2;
5628         vm_paddr_t l3phys;
5629         vm_page_t ml3;
5630
5631         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
5632         PMAP_ASSERT_STAGE1(pmap);
5633         l3 = NULL;
5634         oldl2 = pmap_load(l2);
5635         KASSERT((oldl2 & ATTR_DESCR_MASK) == L2_BLOCK,
5636             ("pmap_demote_l2: Demoting a non-block entry"));
5637         va &= ~L2_OFFSET;
5638
5639         tmpl2 = 0;
5640         if (va <= (vm_offset_t)l2 && va + L2_SIZE > (vm_offset_t)l2) {
5641                 tmpl2 = kva_alloc(PAGE_SIZE);
5642                 if (tmpl2 == 0)
5643                         return (NULL);
5644         }
5645
5646         /*
5647          * Invalidate the 2MB page mapping and return "failure" if the
5648          * mapping was never accessed.
5649          */
5650         if ((oldl2 & ATTR_AF) == 0) {
5651                 KASSERT((oldl2 & ATTR_SW_WIRED) == 0,
5652                     ("pmap_demote_l2: a wired mapping is missing ATTR_AF"));
5653                 pmap_demote_l2_abort(pmap, va, l2, lockp);
5654                 CTR2(KTR_PMAP, "pmap_demote_l2: failure for va %#lx in pmap %p",
5655                     va, pmap);
5656                 goto fail;
5657         }
5658
5659         if ((ml3 = pmap_remove_pt_page(pmap, va)) == NULL) {
5660                 KASSERT((oldl2 & ATTR_SW_WIRED) == 0,
5661                     ("pmap_demote_l2: page table page for a wired mapping"
5662                     " is missing"));
5663
5664                 /*
5665                  * If the page table page is missing and the mapping
5666                  * is for a kernel address, the mapping must belong to
5667                  * the direct map.  Page table pages are preallocated
5668                  * for every other part of the kernel address space,
5669                  * so the direct map region is the only part of the
5670                  * kernel address space that must be handled here.
5671                  */
5672                 KASSERT(va < VM_MAXUSER_ADDRESS || VIRT_IN_DMAP(va),
5673                     ("pmap_demote_l2: No saved mpte for va %#lx", va));
5674
5675                 /*
5676                  * If the 2MB page mapping belongs to the direct map
5677                  * region of the kernel's address space, then the page
5678                  * allocation request specifies the highest possible
5679                  * priority (VM_ALLOC_INTERRUPT).  Otherwise, the
5680                  * priority is normal.
5681                  */
5682                 ml3 = vm_page_alloc(NULL, pmap_l2_pindex(va),
5683                     (VIRT_IN_DMAP(va) ? VM_ALLOC_INTERRUPT : VM_ALLOC_NORMAL) |
5684                     VM_ALLOC_NOOBJ | VM_ALLOC_WIRED);
5685
5686                 /*
5687                  * If the allocation of the new page table page fails,
5688                  * invalidate the 2MB page mapping and return "failure".
5689                  */
5690                 if (ml3 == NULL) {
5691                         pmap_demote_l2_abort(pmap, va, l2, lockp);
5692                         CTR2(KTR_PMAP, "pmap_demote_l2: failure for va %#lx"
5693                             " in pmap %p", va, pmap);
5694                         goto fail;
5695                 }
5696
5697                 if (va < VM_MAXUSER_ADDRESS) {
5698                         ml3->ref_count = NL3PG;
5699                         pmap_resident_count_inc(pmap, 1);
5700                 }
5701         }
5702         l3phys = VM_PAGE_TO_PHYS(ml3);
5703         l3 = (pt_entry_t *)PHYS_TO_DMAP(l3phys);
5704         newl3 = (oldl2 & ~ATTR_DESCR_MASK) | L3_PAGE;
5705         KASSERT((oldl2 & (ATTR_S1_AP_RW_BIT | ATTR_SW_DBM)) !=
5706             (ATTR_S1_AP(ATTR_S1_AP_RO) | ATTR_SW_DBM),
5707             ("pmap_demote_l2: L2 entry is writeable but not dirty"));
5708
5709         /*
5710          * If the page table page is not leftover from an earlier promotion,
5711          * or the mapping attributes have changed, (re)initialize the L3 table.
5712          *
5713          * When pmap_update_entry() clears the old L2 mapping, it (indirectly)
5714          * performs a dsb().  That dsb() ensures that the stores for filling
5715          * "l3" are visible before "l3" is added to the page table.
5716          */
5717         if (ml3->valid == 0 || (l3[0] & ATTR_MASK) != (newl3 & ATTR_MASK))
5718                 pmap_fill_l3(l3, newl3);
5719
5720         /*
5721          * Map the temporary page so we don't lose access to the l2 table.
5722          */
5723         if (tmpl2 != 0) {
5724                 pmap_kenter(tmpl2, PAGE_SIZE,
5725                     DMAP_TO_PHYS((vm_offset_t)l2) & ~L3_OFFSET,
5726                     VM_MEMATTR_WRITE_BACK);
5727                 l2 = (pt_entry_t *)(tmpl2 + ((vm_offset_t)l2 & PAGE_MASK));
5728         }
5729
5730         /*
5731          * The spare PV entries must be reserved prior to demoting the
5732          * mapping, that is, prior to changing the PDE.  Otherwise, the state
5733          * of the L2 and the PV lists will be inconsistent, which can result
5734          * in reclaim_pv_chunk() attempting to remove a PV entry from the
5735          * wrong PV list and pmap_pv_demote_l2() failing to find the expected
5736          * PV entry for the 2MB page mapping that is being demoted.
5737          */
5738         if ((oldl2 & ATTR_SW_MANAGED) != 0)
5739                 reserve_pv_entries(pmap, Ln_ENTRIES - 1, lockp);
5740
5741         /*
5742          * Pass PAGE_SIZE so that a single TLB invalidation is performed on
5743          * the 2MB page mapping.
5744          */
5745         pmap_update_entry(pmap, l2, l3phys | L2_TABLE, va, PAGE_SIZE);
5746
5747         /*
5748          * Demote the PV entry.
5749          */
5750         if ((oldl2 & ATTR_SW_MANAGED) != 0)
5751                 pmap_pv_demote_l2(pmap, va, oldl2 & ~ATTR_MASK, lockp);
5752
5753         atomic_add_long(&pmap_l2_demotions, 1);
5754         CTR3(KTR_PMAP, "pmap_demote_l2: success for va %#lx"
5755             " in pmap %p %lx", va, pmap, l3[0]);
5756
5757 fail:
5758         if (tmpl2 != 0) {
5759                 pmap_kremove(tmpl2);
5760                 kva_free(tmpl2, PAGE_SIZE);
5761         }
5762
5763         return (l3);
5764
5765 }
5766
5767 static pt_entry_t *
5768 pmap_demote_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t va)
5769 {
5770         struct rwlock *lock;
5771         pt_entry_t *l3;
5772
5773         lock = NULL;
5774         l3 = pmap_demote_l2_locked(pmap, l2, va, &lock);
5775         if (lock != NULL)
5776                 rw_wunlock(lock);
5777         return (l3);
5778 }
5779
5780 /*
5781  * Perform the pmap work for mincore(2).  If the page is not both referenced and
5782  * modified by this pmap, returns its physical address so that the caller can
5783  * find other mappings.
5784  */
5785 int
5786 pmap_mincore(pmap_t pmap, vm_offset_t addr, vm_paddr_t *pap)
5787 {
5788         pt_entry_t *pte, tpte;
5789         vm_paddr_t mask, pa;
5790         int lvl, val;
5791         bool managed;
5792
5793         PMAP_ASSERT_STAGE1(pmap);
5794         PMAP_LOCK(pmap);
5795         pte = pmap_pte(pmap, addr, &lvl);
5796         if (pte != NULL) {
5797                 tpte = pmap_load(pte);
5798
5799                 switch (lvl) {
5800                 case 3:
5801                         mask = L3_OFFSET;
5802                         break;
5803                 case 2:
5804                         mask = L2_OFFSET;
5805                         break;
5806                 case 1:
5807                         mask = L1_OFFSET;
5808                         break;
5809                 default:
5810                         panic("pmap_mincore: invalid level %d", lvl);
5811                 }
5812
5813                 managed = (tpte & ATTR_SW_MANAGED) != 0;
5814                 val = MINCORE_INCORE;
5815                 if (lvl != 3)
5816                         val |= MINCORE_SUPER;
5817                 if ((managed && pmap_pte_dirty(pmap, tpte)) || (!managed &&
5818                     (tpte & ATTR_S1_AP_RW_BIT) == ATTR_S1_AP(ATTR_S1_AP_RW)))
5819                         val |= MINCORE_MODIFIED | MINCORE_MODIFIED_OTHER;
5820                 if ((tpte & ATTR_AF) == ATTR_AF)
5821                         val |= MINCORE_REFERENCED | MINCORE_REFERENCED_OTHER;
5822
5823                 pa = (tpte & ~ATTR_MASK) | (addr & mask);
5824         } else {
5825                 managed = false;
5826                 val = 0;
5827         }
5828
5829         if ((val & (MINCORE_MODIFIED_OTHER | MINCORE_REFERENCED_OTHER)) !=
5830             (MINCORE_MODIFIED_OTHER | MINCORE_REFERENCED_OTHER) && managed) {
5831                 *pap = pa;
5832         }
5833         PMAP_UNLOCK(pmap);
5834         return (val);
5835 }
5836
5837 /*
5838  * Garbage collect every ASID that is neither active on a processor nor
5839  * reserved.
5840  */
5841 static void
5842 pmap_reset_asid_set(void)
5843 {
5844         pmap_t pmap;
5845         int asid, cpuid, epoch;
5846
5847         mtx_assert(&asid_set_mutex, MA_OWNED);
5848
5849         /*
5850          * Ensure that the store to asid_epoch is globally visible before the
5851          * loads from pc_curpmap are performed.
5852          */
5853         epoch = asid_epoch + 1;
5854         if (epoch == INT_MAX)
5855                 epoch = 0;
5856         asid_epoch = epoch;
5857         dsb(ishst);
5858         __asm __volatile("tlbi vmalle1is");
5859         dsb(ish);
5860         bit_nclear(asid_set, ASID_FIRST_AVAILABLE, asid_set_size - 1);
5861         CPU_FOREACH(cpuid) {
5862                 if (cpuid == curcpu)
5863                         continue;
5864                 pmap = pcpu_find(cpuid)->pc_curpmap;
5865                 PMAP_ASSERT_STAGE1(pmap);
5866                 asid = COOKIE_TO_ASID(pmap->pm_cookie);
5867                 if (asid == -1)
5868                         continue;
5869                 bit_set(asid_set, asid);
5870                 pmap->pm_cookie = COOKIE_FROM(asid, epoch);
5871         }
5872 }
5873
5874 /*
5875  * Allocate a new ASID for the specified pmap.
5876  */
5877 static void
5878 pmap_alloc_asid(pmap_t pmap)
5879 {
5880         int new_asid;
5881
5882         PMAP_ASSERT_STAGE1(pmap);
5883         mtx_lock_spin(&asid_set_mutex);
5884
5885         /*
5886          * While this processor was waiting to acquire the asid set mutex,
5887          * pmap_reset_asid_set() running on another processor might have
5888          * updated this pmap's cookie to the current epoch.  In which case, we
5889          * don't need to allocate a new ASID.
5890          */
5891         if (COOKIE_TO_EPOCH(pmap->pm_cookie) == asid_epoch)
5892                 goto out;
5893
5894         bit_ffc_at(asid_set, asid_next, asid_set_size, &new_asid);
5895         if (new_asid == -1) {
5896                 bit_ffc_at(asid_set, ASID_FIRST_AVAILABLE, asid_next,
5897                     &new_asid);
5898                 if (new_asid == -1) {
5899                         pmap_reset_asid_set();
5900                         bit_ffc_at(asid_set, ASID_FIRST_AVAILABLE,
5901                             asid_set_size, &new_asid);
5902                         KASSERT(new_asid != -1, ("ASID allocation failure"));
5903                 }
5904         }
5905         bit_set(asid_set, new_asid);
5906         asid_next = new_asid + 1;
5907         pmap->pm_cookie = COOKIE_FROM(new_asid, asid_epoch);
5908 out:
5909         mtx_unlock_spin(&asid_set_mutex);
5910 }
5911
5912 /*
5913  * Compute the value that should be stored in ttbr0 to activate the specified
5914  * pmap.  This value may change from time to time.
5915  */
5916 uint64_t
5917 pmap_to_ttbr0(pmap_t pmap)
5918 {
5919
5920         PMAP_ASSERT_STAGE1(pmap);
5921         return (ASID_TO_OPERAND(COOKIE_TO_ASID(pmap->pm_cookie)) |
5922             pmap->pm_l0_paddr);
5923 }
5924
5925 static bool
5926 pmap_activate_int(pmap_t pmap)
5927 {
5928         int epoch;
5929
5930         PMAP_ASSERT_STAGE1(pmap);
5931         KASSERT(PCPU_GET(curpmap) != NULL, ("no active pmap"));
5932         KASSERT(pmap != kernel_pmap, ("kernel pmap activation"));
5933         if (pmap == PCPU_GET(curpmap)) {
5934                 /*
5935                  * Handle the possibility that the old thread was preempted
5936                  * after an "ic" or "tlbi" instruction but before it performed
5937                  * a "dsb" instruction.  If the old thread migrates to a new
5938                  * processor, its completion of a "dsb" instruction on that
5939                  * new processor does not guarantee that the "ic" or "tlbi"
5940                  * instructions performed on the old processor have completed.
5941                  */
5942                 dsb(ish);
5943                 return (false);
5944         }
5945
5946         /*
5947          * Ensure that the store to curpmap is globally visible before the
5948          * load from asid_epoch is performed.
5949          */
5950         PCPU_SET(curpmap, pmap);
5951         dsb(ish);
5952         epoch = COOKIE_TO_EPOCH(pmap->pm_cookie);
5953         if (epoch >= 0 && epoch != asid_epoch)
5954                 pmap_alloc_asid(pmap);
5955
5956         set_ttbr0(pmap_to_ttbr0(pmap));
5957         if (PCPU_GET(bcast_tlbi_workaround) != 0)
5958                 invalidate_local_icache();
5959         return (true);
5960 }
5961
5962 void
5963 pmap_activate(struct thread *td)
5964 {
5965         pmap_t  pmap;
5966
5967         pmap = vmspace_pmap(td->td_proc->p_vmspace);
5968         PMAP_ASSERT_STAGE1(pmap);
5969         critical_enter();
5970         (void)pmap_activate_int(pmap);
5971         critical_exit();
5972 }
5973
5974 /*
5975  * To eliminate the unused parameter "old", we would have to add an instruction
5976  * to cpu_switch().
5977  */
5978 struct pcb *
5979 pmap_switch(struct thread *old __unused, struct thread *new)
5980 {
5981         pcpu_bp_harden bp_harden;
5982         struct pcb *pcb;
5983
5984         /* Store the new curthread */
5985         PCPU_SET(curthread, new);
5986
5987         /* And the new pcb */
5988         pcb = new->td_pcb;
5989         PCPU_SET(curpcb, pcb);
5990
5991         /*
5992          * TODO: We may need to flush the cache here if switching
5993          * to a user process.
5994          */
5995
5996         if (pmap_activate_int(vmspace_pmap(new->td_proc->p_vmspace))) {
5997                 /*
5998                  * Stop userspace from training the branch predictor against
5999                  * other processes. This will call into a CPU specific
6000                  * function that clears the branch predictor state.
6001                  */
6002                 bp_harden = PCPU_GET(bp_harden);
6003                 if (bp_harden != NULL)
6004                         bp_harden();
6005         }
6006
6007         return (pcb);
6008 }
6009
6010 void
6011 pmap_sync_icache(pmap_t pmap, vm_offset_t va, vm_size_t sz)
6012 {
6013
6014         PMAP_ASSERT_STAGE1(pmap);
6015         if (va >= VM_MIN_KERNEL_ADDRESS) {
6016                 cpu_icache_sync_range(va, sz);
6017         } else {
6018                 u_int len, offset;
6019                 vm_paddr_t pa;
6020
6021                 /* Find the length of data in this page to flush */
6022                 offset = va & PAGE_MASK;
6023                 len = imin(PAGE_SIZE - offset, sz);
6024
6025                 while (sz != 0) {
6026                         /* Extract the physical address & find it in the DMAP */
6027                         pa = pmap_extract(pmap, va);
6028                         if (pa != 0)
6029                                 cpu_icache_sync_range(PHYS_TO_DMAP(pa), len);
6030
6031                         /* Move to the next page */
6032                         sz -= len;
6033                         va += len;
6034                         /* Set the length for the next iteration */
6035                         len = imin(PAGE_SIZE, sz);
6036                 }
6037         }
6038 }
6039
6040 int
6041 pmap_fault(pmap_t pmap, uint64_t esr, uint64_t far)
6042 {
6043         pt_entry_t pte, *ptep;
6044         register_t intr;
6045         uint64_t ec, par;
6046         int lvl, rv;
6047
6048         PMAP_ASSERT_STAGE1(pmap);
6049         rv = KERN_FAILURE;
6050
6051         ec = ESR_ELx_EXCEPTION(esr);
6052         switch (ec) {
6053         case EXCP_INSN_ABORT_L:
6054         case EXCP_INSN_ABORT:
6055         case EXCP_DATA_ABORT_L:
6056         case EXCP_DATA_ABORT:
6057                 break;
6058         default:
6059                 return (rv);
6060         }
6061
6062         /* Data and insn aborts use same encoding for FSC field. */
6063         switch (esr & ISS_DATA_DFSC_MASK) {
6064         case ISS_DATA_DFSC_AFF_L1:
6065         case ISS_DATA_DFSC_AFF_L2:
6066         case ISS_DATA_DFSC_AFF_L3:
6067                 PMAP_LOCK(pmap);
6068                 ptep = pmap_pte(pmap, far, &lvl);
6069                 if (ptep != NULL) {
6070                         pmap_set_bits(ptep, ATTR_AF);
6071                         rv = KERN_SUCCESS;
6072                         /*
6073                          * XXXMJ as an optimization we could mark the entry
6074                          * dirty if this is a write fault.
6075                          */
6076                 }
6077                 PMAP_UNLOCK(pmap);
6078                 break;
6079         case ISS_DATA_DFSC_PF_L1:
6080         case ISS_DATA_DFSC_PF_L2:
6081         case ISS_DATA_DFSC_PF_L3:
6082                 if ((ec != EXCP_DATA_ABORT_L && ec != EXCP_DATA_ABORT) ||
6083                     (esr & ISS_DATA_WnR) == 0)
6084                         return (rv);
6085                 PMAP_LOCK(pmap);
6086                 ptep = pmap_pte(pmap, far, &lvl);
6087                 if (ptep != NULL &&
6088                     ((pte = pmap_load(ptep)) & ATTR_SW_DBM) != 0) {
6089                         if ((pte & ATTR_S1_AP_RW_BIT) ==
6090                             ATTR_S1_AP(ATTR_S1_AP_RO)) {
6091                                 pmap_clear_bits(ptep, ATTR_S1_AP_RW_BIT);
6092                                 pmap_invalidate_page(pmap, far);
6093                         }
6094                         rv = KERN_SUCCESS;
6095                 }
6096                 PMAP_UNLOCK(pmap);
6097                 break;
6098         case ISS_DATA_DFSC_TF_L0:
6099         case ISS_DATA_DFSC_TF_L1:
6100         case ISS_DATA_DFSC_TF_L2:
6101         case ISS_DATA_DFSC_TF_L3:
6102                 /*
6103                  * Retry the translation.  A break-before-make sequence can
6104                  * produce a transient fault.
6105                  */
6106                 if (pmap == kernel_pmap) {
6107                         /*
6108                          * The translation fault may have occurred within a
6109                          * critical section.  Therefore, we must check the
6110                          * address without acquiring the kernel pmap's lock.
6111                          */
6112                         if (pmap_kextract(far) != 0)
6113                                 rv = KERN_SUCCESS;
6114                 } else {
6115                         PMAP_LOCK(pmap);
6116                         /* Ask the MMU to check the address. */
6117                         intr = intr_disable();
6118                         par = arm64_address_translate_s1e0r(far);
6119                         intr_restore(intr);
6120                         PMAP_UNLOCK(pmap);
6121
6122                         /*
6123                          * If the translation was successful, then we can
6124                          * return success to the trap handler.
6125                          */
6126                         if (PAR_SUCCESS(par))
6127                                 rv = KERN_SUCCESS;
6128                 }
6129                 break;
6130         }
6131
6132         return (rv);
6133 }
6134
6135 /*
6136  *      Increase the starting virtual address of the given mapping if a
6137  *      different alignment might result in more superpage mappings.
6138  */
6139 void
6140 pmap_align_superpage(vm_object_t object, vm_ooffset_t offset,
6141     vm_offset_t *addr, vm_size_t size)
6142 {
6143         vm_offset_t superpage_offset;
6144
6145         if (size < L2_SIZE)
6146                 return;
6147         if (object != NULL && (object->flags & OBJ_COLORED) != 0)
6148                 offset += ptoa(object->pg_color);
6149         superpage_offset = offset & L2_OFFSET;
6150         if (size - ((L2_SIZE - superpage_offset) & L2_OFFSET) < L2_SIZE ||
6151             (*addr & L2_OFFSET) == superpage_offset)
6152                 return;
6153         if ((*addr & L2_OFFSET) < superpage_offset)
6154                 *addr = (*addr & ~L2_OFFSET) + superpage_offset;
6155         else
6156                 *addr = ((*addr + L2_OFFSET) & ~L2_OFFSET) + superpage_offset;
6157 }
6158
6159 /**
6160  * Get the kernel virtual address of a set of physical pages. If there are
6161  * physical addresses not covered by the DMAP perform a transient mapping
6162  * that will be removed when calling pmap_unmap_io_transient.
6163  *
6164  * \param page        The pages the caller wishes to obtain the virtual
6165  *                    address on the kernel memory map.
6166  * \param vaddr       On return contains the kernel virtual memory address
6167  *                    of the pages passed in the page parameter.
6168  * \param count       Number of pages passed in.
6169  * \param can_fault   TRUE if the thread using the mapped pages can take
6170  *                    page faults, FALSE otherwise.
6171  *
6172  * \returns TRUE if the caller must call pmap_unmap_io_transient when
6173  *          finished or FALSE otherwise.
6174  *
6175  */
6176 boolean_t
6177 pmap_map_io_transient(vm_page_t page[], vm_offset_t vaddr[], int count,
6178     boolean_t can_fault)
6179 {
6180         vm_paddr_t paddr;
6181         boolean_t needs_mapping;
6182         int error, i;
6183
6184         /*
6185          * Allocate any KVA space that we need, this is done in a separate
6186          * loop to prevent calling vmem_alloc while pinned.
6187          */
6188         needs_mapping = FALSE;
6189         for (i = 0; i < count; i++) {
6190                 paddr = VM_PAGE_TO_PHYS(page[i]);
6191                 if (__predict_false(!PHYS_IN_DMAP(paddr))) {
6192                         error = vmem_alloc(kernel_arena, PAGE_SIZE,
6193                             M_BESTFIT | M_WAITOK, &vaddr[i]);
6194                         KASSERT(error == 0, ("vmem_alloc failed: %d", error));
6195                         needs_mapping = TRUE;
6196                 } else {
6197                         vaddr[i] = PHYS_TO_DMAP(paddr);
6198                 }
6199         }
6200
6201         /* Exit early if everything is covered by the DMAP */
6202         if (!needs_mapping)
6203                 return (FALSE);
6204
6205         if (!can_fault)
6206                 sched_pin();
6207         for (i = 0; i < count; i++) {
6208                 paddr = VM_PAGE_TO_PHYS(page[i]);
6209                 if (!PHYS_IN_DMAP(paddr)) {
6210                         panic(
6211                            "pmap_map_io_transient: TODO: Map out of DMAP data");
6212                 }
6213         }
6214
6215         return (needs_mapping);
6216 }
6217
6218 void
6219 pmap_unmap_io_transient(vm_page_t page[], vm_offset_t vaddr[], int count,
6220     boolean_t can_fault)
6221 {
6222         vm_paddr_t paddr;
6223         int i;
6224
6225         if (!can_fault)
6226                 sched_unpin();
6227         for (i = 0; i < count; i++) {
6228                 paddr = VM_PAGE_TO_PHYS(page[i]);
6229                 if (!PHYS_IN_DMAP(paddr)) {
6230                         panic("ARM64TODO: pmap_unmap_io_transient: Unmap data");
6231                 }
6232         }
6233 }
6234
6235 boolean_t
6236 pmap_is_valid_memattr(pmap_t pmap __unused, vm_memattr_t mode)
6237 {
6238
6239         return (mode >= VM_MEMATTR_DEVICE && mode <= VM_MEMATTR_WRITE_THROUGH);
6240 }
6241
6242 /*
6243  * Track a range of the kernel's virtual address space that is contiguous
6244  * in various mapping attributes.
6245  */
6246 struct pmap_kernel_map_range {
6247         vm_offset_t sva;
6248         pt_entry_t attrs;
6249         int l3pages;
6250         int l3contig;
6251         int l2blocks;
6252         int l1blocks;
6253 };
6254
6255 static void
6256 sysctl_kmaps_dump(struct sbuf *sb, struct pmap_kernel_map_range *range,
6257     vm_offset_t eva)
6258 {
6259         const char *mode;
6260         int index;
6261
6262         if (eva <= range->sva)
6263                 return;
6264
6265         index = range->attrs & ATTR_S1_IDX_MASK;
6266         switch (index) {
6267         case ATTR_S1_IDX(VM_MEMATTR_DEVICE):
6268                 mode = "DEV";
6269                 break;
6270         case ATTR_S1_IDX(VM_MEMATTR_UNCACHEABLE):
6271                 mode = "UC";
6272                 break;
6273         case ATTR_S1_IDX(VM_MEMATTR_WRITE_BACK):
6274                 mode = "WB";
6275                 break;
6276         case ATTR_S1_IDX(VM_MEMATTR_WRITE_THROUGH):
6277                 mode = "WT";
6278                 break;
6279         default:
6280                 printf(
6281                     "%s: unknown memory type %x for range 0x%016lx-0x%016lx\n",
6282                     __func__, index, range->sva, eva);
6283                 mode = "??";
6284                 break;
6285         }
6286
6287         sbuf_printf(sb, "0x%016lx-0x%016lx r%c%c%c %3s %d %d %d %d\n",
6288             range->sva, eva,
6289             (range->attrs & ATTR_S1_AP_RW_BIT) == ATTR_S1_AP_RW ? 'w' : '-',
6290             (range->attrs & ATTR_S1_PXN) != 0 ? '-' : 'x',
6291             (range->attrs & ATTR_S1_AP_USER) != 0 ? 'u' : 's',
6292             mode, range->l1blocks, range->l2blocks, range->l3contig,
6293             range->l3pages);
6294
6295         /* Reset to sentinel value. */
6296         range->sva = 0xfffffffffffffffful;
6297 }
6298
6299 /*
6300  * Determine whether the attributes specified by a page table entry match those
6301  * being tracked by the current range.
6302  */
6303 static bool
6304 sysctl_kmaps_match(struct pmap_kernel_map_range *range, pt_entry_t attrs)
6305 {
6306
6307         return (range->attrs == attrs);
6308 }
6309
6310 static void
6311 sysctl_kmaps_reinit(struct pmap_kernel_map_range *range, vm_offset_t va,
6312     pt_entry_t attrs)
6313 {
6314
6315         memset(range, 0, sizeof(*range));
6316         range->sva = va;
6317         range->attrs = attrs;
6318 }
6319
6320 /*
6321  * Given a leaf PTE, derive the mapping's attributes.  If they do not match
6322  * those of the current run, dump the address range and its attributes, and
6323  * begin a new run.
6324  */
6325 static void
6326 sysctl_kmaps_check(struct sbuf *sb, struct pmap_kernel_map_range *range,
6327     vm_offset_t va, pd_entry_t l0e, pd_entry_t l1e, pd_entry_t l2e,
6328     pt_entry_t l3e)
6329 {
6330         pt_entry_t attrs;
6331
6332         attrs = l0e & (ATTR_S1_AP_MASK | ATTR_S1_XN);
6333         attrs |= l1e & (ATTR_S1_AP_MASK | ATTR_S1_XN);
6334         if ((l1e & ATTR_DESCR_MASK) == L1_BLOCK)
6335                 attrs |= l1e & ATTR_S1_IDX_MASK;
6336         attrs |= l2e & (ATTR_S1_AP_MASK | ATTR_S1_XN);
6337         if ((l2e & ATTR_DESCR_MASK) == L2_BLOCK)
6338                 attrs |= l2e & ATTR_S1_IDX_MASK;
6339         attrs |= l3e & (ATTR_S1_AP_MASK | ATTR_S1_XN | ATTR_S1_IDX_MASK);
6340
6341         if (range->sva > va || !sysctl_kmaps_match(range, attrs)) {
6342                 sysctl_kmaps_dump(sb, range, va);
6343                 sysctl_kmaps_reinit(range, va, attrs);
6344         }
6345 }
6346
6347 static int
6348 sysctl_kmaps(SYSCTL_HANDLER_ARGS)
6349 {
6350         struct pmap_kernel_map_range range;
6351         struct sbuf sbuf, *sb;
6352         pd_entry_t l0e, *l1, l1e, *l2, l2e;
6353         pt_entry_t *l3, l3e;
6354         vm_offset_t sva;
6355         vm_paddr_t pa;
6356         int error, i, j, k, l;
6357
6358         error = sysctl_wire_old_buffer(req, 0);
6359         if (error != 0)
6360                 return (error);
6361         sb = &sbuf;
6362         sbuf_new_for_sysctl(sb, NULL, PAGE_SIZE, req);
6363
6364         /* Sentinel value. */
6365         range.sva = 0xfffffffffffffffful;
6366
6367         /*
6368          * Iterate over the kernel page tables without holding the kernel pmap
6369          * lock.  Kernel page table pages are never freed, so at worst we will
6370          * observe inconsistencies in the output.
6371          */
6372         for (sva = 0xffff000000000000ul, i = pmap_l0_index(sva); i < Ln_ENTRIES;
6373             i++) {
6374                 if (i == pmap_l0_index(DMAP_MIN_ADDRESS))
6375                         sbuf_printf(sb, "\nDirect map:\n");
6376                 else if (i == pmap_l0_index(VM_MIN_KERNEL_ADDRESS))
6377                         sbuf_printf(sb, "\nKernel map:\n");
6378
6379                 l0e = kernel_pmap->pm_l0[i];
6380                 if ((l0e & ATTR_DESCR_VALID) == 0) {
6381                         sysctl_kmaps_dump(sb, &range, sva);
6382                         sva += L0_SIZE;
6383                         continue;
6384                 }
6385                 pa = l0e & ~ATTR_MASK;
6386                 l1 = (pd_entry_t *)PHYS_TO_DMAP(pa);
6387
6388                 for (j = pmap_l1_index(sva); j < Ln_ENTRIES; j++) {
6389                         l1e = l1[j];
6390                         if ((l1e & ATTR_DESCR_VALID) == 0) {
6391                                 sysctl_kmaps_dump(sb, &range, sva);
6392                                 sva += L1_SIZE;
6393                                 continue;
6394                         }
6395                         if ((l1e & ATTR_DESCR_MASK) == L1_BLOCK) {
6396                                 sysctl_kmaps_check(sb, &range, sva, l0e, l1e,
6397                                     0, 0);
6398                                 range.l1blocks++;
6399                                 sva += L1_SIZE;
6400                                 continue;
6401                         }
6402                         pa = l1e & ~ATTR_MASK;
6403                         l2 = (pd_entry_t *)PHYS_TO_DMAP(pa);
6404
6405                         for (k = pmap_l2_index(sva); k < Ln_ENTRIES; k++) {
6406                                 l2e = l2[k];
6407                                 if ((l2e & ATTR_DESCR_VALID) == 0) {
6408                                         sysctl_kmaps_dump(sb, &range, sva);
6409                                         sva += L2_SIZE;
6410                                         continue;
6411                                 }
6412                                 if ((l2e & ATTR_DESCR_MASK) == L2_BLOCK) {
6413                                         sysctl_kmaps_check(sb, &range, sva,
6414                                             l0e, l1e, l2e, 0);
6415                                         range.l2blocks++;
6416                                         sva += L2_SIZE;
6417                                         continue;
6418                                 }
6419                                 pa = l2e & ~ATTR_MASK;
6420                                 l3 = (pt_entry_t *)PHYS_TO_DMAP(pa);
6421
6422                                 for (l = pmap_l3_index(sva); l < Ln_ENTRIES;
6423                                     l++, sva += L3_SIZE) {
6424                                         l3e = l3[l];
6425                                         if ((l3e & ATTR_DESCR_VALID) == 0) {
6426                                                 sysctl_kmaps_dump(sb, &range,
6427                                                     sva);
6428                                                 continue;
6429                                         }
6430                                         sysctl_kmaps_check(sb, &range, sva,
6431                                             l0e, l1e, l2e, l3e);
6432                                         if ((l3e & ATTR_CONTIGUOUS) != 0)
6433                                                 range.l3contig += l % 16 == 0 ?
6434                                                     1 : 0;
6435                                         else
6436                                                 range.l3pages++;
6437                                 }
6438                         }
6439                 }
6440         }
6441
6442         error = sbuf_finish(sb);
6443         sbuf_delete(sb);
6444         return (error);
6445 }
6446 SYSCTL_OID(_vm_pmap, OID_AUTO, kernel_maps,
6447     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
6448     NULL, 0, sysctl_kmaps, "A",
6449     "Dump kernel address layout");