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/lock.h>
 117 #include <sys/malloc.h>
 118 #include <sys/mman.h>
 119 #include <sys/msgbuf.h>
 120 #include <sys/mutex.h>
 121 #include <sys/proc.h>
 122 #include <sys/rwlock.h>
 123 #include <sys/sx.h>
 124 #include <sys/vmem.h>
 125 #include <sys/vmmeter.h>
 126 #include <sys/sched.h>
 127 #include <sys/sysctl.h>
 128 #include <sys/_unrhdr.h>
 129 #include <sys/smp.h>
 130
 131 #include <vm/vm.h>
 132 #include <vm/vm_param.h>
 133 #include <vm/vm_kern.h>
 134 #include <vm/vm_page.h>
 135 #include <vm/vm_map.h>
 136 #include <vm/vm_object.h>
 137 #include <vm/vm_extern.h>
 138 #include <vm/vm_pageout.h>
 139 #include <vm/vm_pager.h>
 140 #include <vm/vm_phys.h>
 141 #include <vm/vm_radix.h>
 142 #include <vm/vm_reserv.h>
 143 #include <vm/uma.h>
 144
 145 #include <machine/machdep.h>
 146 #include <machine/md_var.h>
 147 #include <machine/pcb.h>
 148
 149 #include <arm/include/physmem.h>
 150
 151 #define NL0PG           (PAGE_SIZE/(sizeof (pd_entry_t)))
 152 #define NL1PG           (PAGE_SIZE/(sizeof (pd_entry_t)))
 153 #define NL2PG           (PAGE_SIZE/(sizeof (pd_entry_t)))
 154 #define NL3PG           (PAGE_SIZE/(sizeof (pt_entry_t)))
 155
 156 #define NUL0E           L0_ENTRIES
 157 #define NUL1E           (NUL0E * NL1PG)
 158 #define NUL2E           (NUL1E * NL2PG)
 159
 160 #if !defined(DIAGNOSTIC)
 161 #ifdef __GNUC_GNU_INLINE__
 162 #define PMAP_INLINE     __attribute__((__gnu_inline__)) inline
 163 #else
 164 #define PMAP_INLINE     extern inline
 165 #endif
 166 #else
 167 #define PMAP_INLINE
 168 #endif
 169
 170 /*
 171  * These are configured by the mair_el1 register. This is set up in locore.S
 172  */
 173 #define DEVICE_MEMORY   0
 174 #define UNCACHED_MEMORY 1
 175 #define CACHED_MEMORY   2
 176
 177
 178 #ifdef PV_STATS
 179 #define PV_STAT(x)      do { x ; } while (0)
 180 #else
 181 #define PV_STAT(x)      do { } while (0)
 182 #endif
 183
 184 #define pmap_l2_pindex(v)       ((v) >> L2_SHIFT)
 185 #define pa_to_pvh(pa)           (&pv_table[pmap_l2_pindex(pa)])
 186
 187 #define NPV_LIST_LOCKS  MAXCPU
 188
 189 #define PHYS_TO_PV_LIST_LOCK(pa)        \
 190                         (&pv_list_locks[pa_index(pa) % NPV_LIST_LOCKS])
 191
 192 #define CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa)  do {    \
 193         struct rwlock **_lockp = (lockp);               \
 194         struct rwlock *_new_lock;                       \
 195                                                         \
 196         _new_lock = PHYS_TO_PV_LIST_LOCK(pa);           \
 197         if (_new_lock != *_lockp) {                     \
 198                 if (*_lockp != NULL)                    \
 199                         rw_wunlock(*_lockp);            \
 200                 *_lockp = _new_lock;                    \
 201                 rw_wlock(*_lockp);                      \
 202         }                                               \
 203 } while (0)
 204
 205 #define CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m)        \
 206                         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, VM_PAGE_TO_PHYS(m))
 207
 208 #define RELEASE_PV_LIST_LOCK(lockp)             do {    \
 209         struct rwlock **_lockp = (lockp);               \
 210                                                         \
 211         if (*_lockp != NULL) {                          \
 212                 rw_wunlock(*_lockp);                    \
 213                 *_lockp = NULL;                         \
 214         }                                               \
 215 } while (0)
 216
 217 #define VM_PAGE_TO_PV_LIST_LOCK(m)      \
 218                         PHYS_TO_PV_LIST_LOCK(VM_PAGE_TO_PHYS(m))
 219
 220 struct pmap kernel_pmap_store;
 221
 222 /* Used for mapping ACPI memory before VM is initialized */
 223 #define PMAP_PREINIT_MAPPING_COUNT      32
 224 #define PMAP_PREINIT_MAPPING_SIZE       (PMAP_PREINIT_MAPPING_COUNT * L2_SIZE)
 225 static vm_offset_t preinit_map_va;      /* Start VA of pre-init mapping space */
 226 static int vm_initialized = 0;          /* No need to use pre-init maps when set */
 227
 228 /*
 229  * Reserve a few L2 blocks starting from 'preinit_map_va' pointer.
 230  * Always map entire L2 block for simplicity.
 231  * VA of L2 block = preinit_map_va + i * L2_SIZE
 232  */
 233 static struct pmap_preinit_mapping {
 234         vm_paddr_t      pa;
 235         vm_offset_t     va;
 236         vm_size_t       size;
 237 } pmap_preinit_mapping[PMAP_PREINIT_MAPPING_COUNT];
 238
 239 vm_offset_t virtual_avail;      /* VA of first avail page (after kernel bss) */
 240 vm_offset_t virtual_end;        /* VA of last avail page (end of kernel AS) */
 241 vm_offset_t kernel_vm_end = 0;
 242
 243 /*
 244  * Data for the pv entry allocation mechanism.
 245  */
 246 static TAILQ_HEAD(pch, pv_chunk) pv_chunks = TAILQ_HEAD_INITIALIZER(pv_chunks);
 247 static struct mtx pv_chunks_mutex;
 248 static struct rwlock pv_list_locks[NPV_LIST_LOCKS];
 249 static struct md_page *pv_table;
 250 static struct md_page pv_dummy;
 251
 252 vm_paddr_t dmap_phys_base;      /* The start of the dmap region */
 253 vm_paddr_t dmap_phys_max;       /* The limit of the dmap region */
 254 vm_offset_t dmap_max_addr;      /* The virtual address limit of the dmap */
 255
 256 /* This code assumes all L1 DMAP entries will be used */
 257 CTASSERT((DMAP_MIN_ADDRESS  & ~L0_OFFSET) == DMAP_MIN_ADDRESS);
 258 CTASSERT((DMAP_MAX_ADDRESS  & ~L0_OFFSET) == DMAP_MAX_ADDRESS);
 259
 260 #define DMAP_TABLES     ((DMAP_MAX_ADDRESS - DMAP_MIN_ADDRESS) >> L0_SHIFT)
 261 extern pt_entry_t pagetable_dmap[];
 262
 263 #define PHYSMAP_SIZE    (2 * (VM_PHYSSEG_MAX - 1))
 264 static vm_paddr_t physmap[PHYSMAP_SIZE];
 265 static u_int physmap_idx;
 266
 267 static SYSCTL_NODE(_vm, OID_AUTO, pmap, CTLFLAG_RD, 0, "VM/pmap parameters");
 268
 269 static int superpages_enabled = 1;
 270 SYSCTL_INT(_vm_pmap, OID_AUTO, superpages_enabled,
 271     CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &superpages_enabled, 0,
 272     "Are large page mappings enabled?");
 273
 274 /*
 275  * Internal flags for pmap_enter()'s helper functions.
 276  */
 277 #define PMAP_ENTER_NORECLAIM    0x1000000       /* Don't reclaim PV entries. */
 278 #define PMAP_ENTER_NOREPLACE    0x2000000       /* Don't replace mappings. */
 279
 280 static void     free_pv_chunk(struct pv_chunk *pc);
 281 static void     free_pv_entry(pmap_t pmap, pv_entry_t pv);
 282 static pv_entry_t get_pv_entry(pmap_t pmap, struct rwlock **lockp);
 283 static vm_page_t reclaim_pv_chunk(pmap_t locked_pmap, struct rwlock **lockp);
 284 static void     pmap_pvh_free(struct md_page *pvh, pmap_t pmap, vm_offset_t va);
 285 static pv_entry_t pmap_pvh_remove(struct md_page *pvh, pmap_t pmap,
 286                     vm_offset_t va);
 287
 288 static int pmap_change_attr(vm_offset_t va, vm_size_t size, int mode);
 289 static int pmap_change_attr_locked(vm_offset_t va, vm_size_t size, int mode);
 290 static pt_entry_t *pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va);
 291 static pt_entry_t *pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2,
 292     vm_offset_t va, struct rwlock **lockp);
 293 static pt_entry_t *pmap_demote_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t va);
 294 static vm_page_t pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va,
 295     vm_page_t m, vm_prot_t prot, vm_page_t mpte, struct rwlock **lockp);
 296 static int pmap_enter_l2(pmap_t pmap, vm_offset_t va, pd_entry_t new_l2,
 297     u_int flags, vm_page_t m, struct rwlock **lockp);
 298 static int pmap_remove_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t sva,
 299     pd_entry_t l1e, struct spglist *free, struct rwlock **lockp);
 300 static int pmap_remove_l3(pmap_t pmap, pt_entry_t *l3, vm_offset_t sva,
 301     pd_entry_t l2e, struct spglist *free, struct rwlock **lockp);
 302 static boolean_t pmap_try_insert_pv_entry(pmap_t pmap, vm_offset_t va,
 303     vm_page_t m, struct rwlock **lockp);
 304
 305 static vm_page_t _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex,
 306                 struct rwlock **lockp);
 307
 308 static void _pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m,
 309     struct spglist *free);
 310 static int pmap_unuse_pt(pmap_t, vm_offset_t, pd_entry_t, struct spglist *);
 311 static __inline vm_page_t pmap_remove_pt_page(pmap_t pmap, vm_offset_t va);
 312
 313 /*
 314  * These load the old table data and store the new value.
 315  * They need to be atomic as the System MMU may write to the table at
 316  * the same time as the CPU.
 317  */
 318 #define pmap_load_store(table, entry) atomic_swap_64(table, entry)
 319 #define pmap_set(table, mask) atomic_set_64(table, mask)
 320 #define pmap_load_clear(table) atomic_swap_64(table, 0)
 321 #define pmap_load(table) (*table)
 322
 323 /********************/
 324 /* Inline functions */
 325 /********************/
 326
 327 static __inline void
 328 pagecopy(void *s, void *d)
 329 {
 330
 331         memcpy(d, s, PAGE_SIZE);
 332 }
 333
 334 static __inline pd_entry_t *
 335 pmap_l0(pmap_t pmap, vm_offset_t va)
 336 {
 337
 338         return (&pmap->pm_l0[pmap_l0_index(va)]);
 339 }
 340
 341 static __inline pd_entry_t *
 342 pmap_l0_to_l1(pd_entry_t *l0, vm_offset_t va)
 343 {
 344         pd_entry_t *l1;
 345
 346         l1 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l0) & ~ATTR_MASK);
 347         return (&l1[pmap_l1_index(va)]);
 348 }
 349
 350 static __inline pd_entry_t *
 351 pmap_l1(pmap_t pmap, vm_offset_t va)
 352 {
 353         pd_entry_t *l0;
 354
 355         l0 = pmap_l0(pmap, va);
 356         if ((pmap_load(l0) & ATTR_DESCR_MASK) != L0_TABLE)
 357                 return (NULL);
 358
 359         return (pmap_l0_to_l1(l0, va));
 360 }
 361
 362 static __inline pd_entry_t *
 363 pmap_l1_to_l2(pd_entry_t *l1, vm_offset_t va)
 364 {
 365         pd_entry_t *l2;
 366
 367         l2 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l1) & ~ATTR_MASK);
 368         return (&l2[pmap_l2_index(va)]);
 369 }
 370
 371 static __inline pd_entry_t *
 372 pmap_l2(pmap_t pmap, vm_offset_t va)
 373 {
 374         pd_entry_t *l1;
 375
 376         l1 = pmap_l1(pmap, va);
 377         if ((pmap_load(l1) & ATTR_DESCR_MASK) != L1_TABLE)
 378                 return (NULL);
 379
 380         return (pmap_l1_to_l2(l1, va));
 381 }
 382
 383 static __inline pt_entry_t *
 384 pmap_l2_to_l3(pd_entry_t *l2, vm_offset_t va)
 385 {
 386         pt_entry_t *l3;
 387
 388         l3 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l2) & ~ATTR_MASK);
 389         return (&l3[pmap_l3_index(va)]);
 390 }
 391
 392 /*
 393  * Returns the lowest valid pde for a given virtual address.
 394  * The next level may or may not point to a valid page or block.
 395  */
 396 static __inline pd_entry_t *
 397 pmap_pde(pmap_t pmap, vm_offset_t va, int *level)
 398 {
 399         pd_entry_t *l0, *l1, *l2, desc;
 400
 401         l0 = pmap_l0(pmap, va);
 402         desc = pmap_load(l0) & ATTR_DESCR_MASK;
 403         if (desc != L0_TABLE) {
 404                 *level = -1;
 405                 return (NULL);
 406         }
 407
 408         l1 = pmap_l0_to_l1(l0, va);
 409         desc = pmap_load(l1) & ATTR_DESCR_MASK;
 410         if (desc != L1_TABLE) {
 411                 *level = 0;
 412                 return (l0);
 413         }
 414
 415         l2 = pmap_l1_to_l2(l1, va);
 416         desc = pmap_load(l2) & ATTR_DESCR_MASK;
 417         if (desc != L2_TABLE) {
 418                 *level = 1;
 419                 return (l1);
 420         }
 421
 422         *level = 2;
 423         return (l2);
 424 }
 425
 426 /*
 427  * Returns the lowest valid pte block or table entry for a given virtual
 428  * address. If there are no valid entries return NULL and set the level to
 429  * the first invalid level.
 430  */
 431 static __inline pt_entry_t *
 432 pmap_pte(pmap_t pmap, vm_offset_t va, int *level)
 433 {
 434         pd_entry_t *l1, *l2, desc;
 435         pt_entry_t *l3;
 436
 437         l1 = pmap_l1(pmap, va);
 438         if (l1 == NULL) {
 439                 *level = 0;
 440                 return (NULL);
 441         }
 442         desc = pmap_load(l1) & ATTR_DESCR_MASK;
 443         if (desc == L1_BLOCK) {
 444                 *level = 1;
 445                 return (l1);
 446         }
 447
 448         if (desc != L1_TABLE) {
 449                 *level = 1;
 450                 return (NULL);
 451         }
 452
 453         l2 = pmap_l1_to_l2(l1, va);
 454         desc = pmap_load(l2) & ATTR_DESCR_MASK;
 455         if (desc == L2_BLOCK) {
 456                 *level = 2;
 457                 return (l2);
 458         }
 459
 460         if (desc != L2_TABLE) {
 461                 *level = 2;
 462                 return (NULL);
 463         }
 464
 465         *level = 3;
 466         l3 = pmap_l2_to_l3(l2, va);
 467         if ((pmap_load(l3) & ATTR_DESCR_MASK) != L3_PAGE)
 468                 return (NULL);
 469
 470         return (l3);
 471 }
 472
 473 bool
 474 pmap_ps_enabled(pmap_t pmap __unused)
 475 {
 476
 477         return (superpages_enabled != 0);
 478 }
 479
 480 bool
 481 pmap_get_tables(pmap_t pmap, vm_offset_t va, pd_entry_t **l0, pd_entry_t **l1,
 482     pd_entry_t **l2, pt_entry_t **l3)
 483 {
 484         pd_entry_t *l0p, *l1p, *l2p;
 485
 486         if (pmap->pm_l0 == NULL)
 487                 return (false);
 488
 489         l0p = pmap_l0(pmap, va);
 490         *l0 = l0p;
 491
 492         if ((pmap_load(l0p) & ATTR_DESCR_MASK) != L0_TABLE)
 493                 return (false);
 494
 495         l1p = pmap_l0_to_l1(l0p, va);
 496         *l1 = l1p;
 497
 498         if ((pmap_load(l1p) & ATTR_DESCR_MASK) == L1_BLOCK) {
 499                 *l2 = NULL;
 500                 *l3 = NULL;
 501                 return (true);
 502         }
 503
 504         if ((pmap_load(l1p) & ATTR_DESCR_MASK) != L1_TABLE)
 505                 return (false);
 506
 507         l2p = pmap_l1_to_l2(l1p, va);
 508         *l2 = l2p;
 509
 510         if ((pmap_load(l2p) & ATTR_DESCR_MASK) == L2_BLOCK) {
 511                 *l3 = NULL;
 512                 return (true);
 513         }
 514
 515         if ((pmap_load(l2p) & ATTR_DESCR_MASK) != L2_TABLE)
 516                 return (false);
 517
 518         *l3 = pmap_l2_to_l3(l2p, va);
 519
 520         return (true);
 521 }
 522
 523 static __inline int
 524 pmap_l3_valid(pt_entry_t l3)
 525 {
 526
 527         return ((l3 & ATTR_DESCR_MASK) == L3_PAGE);
 528 }
 529
 530
 531 CTASSERT(L1_BLOCK == L2_BLOCK);
 532
 533 /*
 534  * Checks if the page is dirty. We currently lack proper tracking of this on
 535  * arm64 so for now assume is a page mapped as rw was accessed it is.
 536  */
 537 static inline int
 538 pmap_page_dirty(pt_entry_t pte)
 539 {
 540
 541         return ((pte & (ATTR_AF | ATTR_AP_RW_BIT)) ==
 542             (ATTR_AF | ATTR_AP(ATTR_AP_RW)));
 543 }
 544
 545 static __inline void
 546 pmap_resident_count_inc(pmap_t pmap, int count)
 547 {
 548
 549         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
 550         pmap->pm_stats.resident_count += count;
 551 }
 552
 553 static __inline void
 554 pmap_resident_count_dec(pmap_t pmap, int count)
 555 {
 556
 557         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
 558         KASSERT(pmap->pm_stats.resident_count >= count,
 559             ("pmap %p resident count underflow %ld %d", pmap,
 560             pmap->pm_stats.resident_count, count));
 561         pmap->pm_stats.resident_count -= count;
 562 }
 563
 564 static pt_entry_t *
 565 pmap_early_page_idx(vm_offset_t l1pt, vm_offset_t va, u_int *l1_slot,
 566     u_int *l2_slot)
 567 {
 568         pt_entry_t *l2;
 569         pd_entry_t *l1;
 570
 571         l1 = (pd_entry_t *)l1pt;
 572         *l1_slot = (va >> L1_SHIFT) & Ln_ADDR_MASK;
 573
 574         /* Check locore has used a table L1 map */
 575         KASSERT((l1[*l1_slot] & ATTR_DESCR_MASK) == L1_TABLE,
 576            ("Invalid bootstrap L1 table"));
 577         /* Find the address of the L2 table */
 578         l2 = (pt_entry_t *)init_pt_va;
 579         *l2_slot = pmap_l2_index(va);
 580
 581         return (l2);
 582 }
 583
 584 static vm_paddr_t
 585 pmap_early_vtophys(vm_offset_t l1pt, vm_offset_t va)
 586 {
 587         u_int l1_slot, l2_slot;
 588         pt_entry_t *l2;
 589
 590         l2 = pmap_early_page_idx(l1pt, va, &l1_slot, &l2_slot);
 591
 592         return ((l2[l2_slot] & ~ATTR_MASK) + (va & L2_OFFSET));
 593 }
 594
 595 static vm_offset_t
 596 pmap_bootstrap_dmap(vm_offset_t kern_l1, vm_paddr_t min_pa,
 597     vm_offset_t freemempos)
 598 {
 599         pt_entry_t *l2;
 600         vm_offset_t va;
 601         vm_paddr_t l2_pa, pa;
 602         u_int l1_slot, l2_slot, prev_l1_slot;
 603         int i;
 604
 605         dmap_phys_base = min_pa & ~L1_OFFSET;
 606         dmap_phys_max = 0;
 607         dmap_max_addr = 0;
 608         l2 = NULL;
 609         prev_l1_slot = -1;
 610
 611 #define DMAP_TABLES     ((DMAP_MAX_ADDRESS - DMAP_MIN_ADDRESS) >> L0_SHIFT)
 612         memset(pagetable_dmap, 0, PAGE_SIZE * DMAP_TABLES);
 613
 614         for (i = 0; i < (physmap_idx * 2); i += 2) {
 615                 pa = physmap[i] & ~L2_OFFSET;
 616                 va = pa - dmap_phys_base + DMAP_MIN_ADDRESS;
 617
 618                 /* Create L2 mappings at the start of the region */
 619                 if ((pa & L1_OFFSET) != 0) {
 620                         l1_slot = ((va - DMAP_MIN_ADDRESS) >> L1_SHIFT);
 621                         if (l1_slot != prev_l1_slot) {
 622                                 prev_l1_slot = l1_slot;
 623                                 l2 = (pt_entry_t *)freemempos;
 624                                 l2_pa = pmap_early_vtophys(kern_l1,
 625                                     (vm_offset_t)l2);
 626                                 freemempos += PAGE_SIZE;
 627
 628                                 pmap_load_store(&pagetable_dmap[l1_slot],
 629                                     (l2_pa & ~Ln_TABLE_MASK) | L1_TABLE);
 630
 631                                 memset(l2, 0, PAGE_SIZE);
 632                         }
 633                         KASSERT(l2 != NULL,
 634                             ("pmap_bootstrap_dmap: NULL l2 map"));
 635                         for (; va < DMAP_MAX_ADDRESS && pa < physmap[i + 1];
 636                             pa += L2_SIZE, va += L2_SIZE) {
 637                                 /*
 638                                  * We are on a boundary, stop to
 639                                  * create a level 1 block
 640                                  */
 641                                 if ((pa & L1_OFFSET) == 0)
 642                                         break;
 643
 644                                 l2_slot = pmap_l2_index(va);
 645                                 KASSERT(l2_slot != 0, ("..."));
 646                                 pmap_load_store(&l2[l2_slot],
 647                                     (pa & ~L2_OFFSET) | ATTR_DEFAULT | ATTR_XN |
 648                                     ATTR_IDX(CACHED_MEMORY) | L2_BLOCK);
 649                         }
 650                         KASSERT(va == (pa - dmap_phys_base + DMAP_MIN_ADDRESS),
 651                             ("..."));
 652                 }
 653
 654                 for (; va < DMAP_MAX_ADDRESS && pa < physmap[i + 1] &&
 655                     (physmap[i + 1] - pa) >= L1_SIZE;
 656                     pa += L1_SIZE, va += L1_SIZE) {
 657                         l1_slot = ((va - DMAP_MIN_ADDRESS) >> L1_SHIFT);
 658                         pmap_load_store(&pagetable_dmap[l1_slot],
 659                             (pa & ~L1_OFFSET) | ATTR_DEFAULT | ATTR_XN |
 660                             ATTR_IDX(CACHED_MEMORY) | L1_BLOCK);
 661                 }
 662
 663                 /* Create L2 mappings at the end of the region */
 664                 if (pa < physmap[i + 1]) {
 665                         l1_slot = ((va - DMAP_MIN_ADDRESS) >> L1_SHIFT);
 666                         if (l1_slot != prev_l1_slot) {
 667                                 prev_l1_slot = l1_slot;
 668                                 l2 = (pt_entry_t *)freemempos;
 669                                 l2_pa = pmap_early_vtophys(kern_l1,
 670                                     (vm_offset_t)l2);
 671                                 freemempos += PAGE_SIZE;
 672
 673                                 pmap_load_store(&pagetable_dmap[l1_slot],
 674                                     (l2_pa & ~Ln_TABLE_MASK) | L1_TABLE);
 675
 676                                 memset(l2, 0, PAGE_SIZE);
 677                         }
 678                         KASSERT(l2 != NULL,
 679                             ("pmap_bootstrap_dmap: NULL l2 map"));
 680                         for (; va < DMAP_MAX_ADDRESS && pa < physmap[i + 1];
 681                             pa += L2_SIZE, va += L2_SIZE) {
 682                                 l2_slot = pmap_l2_index(va);
 683                                 pmap_load_store(&l2[l2_slot],
 684                                     (pa & ~L2_OFFSET) | ATTR_DEFAULT | ATTR_XN |
 685                                     ATTR_IDX(CACHED_MEMORY) | L2_BLOCK);
 686                         }
 687                 }
 688
 689                 if (pa > dmap_phys_max) {
 690                         dmap_phys_max = pa;
 691                         dmap_max_addr = va;
 692                 }
 693         }
 694
 695         cpu_tlb_flushID();
 696
 697         return (freemempos);
 698 }
 699
 700 static vm_offset_t
 701 pmap_bootstrap_l2(vm_offset_t l1pt, vm_offset_t va, vm_offset_t l2_start)
 702 {
 703         vm_offset_t l2pt;
 704         vm_paddr_t pa;
 705         pd_entry_t *l1;
 706         u_int l1_slot;
 707
 708         KASSERT((va & L1_OFFSET) == 0, ("Invalid virtual address"));
 709
 710         l1 = (pd_entry_t *)l1pt;
 711         l1_slot = pmap_l1_index(va);
 712         l2pt = l2_start;
 713
 714         for (; va < VM_MAX_KERNEL_ADDRESS; l1_slot++, va += L1_SIZE) {
 715                 KASSERT(l1_slot < Ln_ENTRIES, ("Invalid L1 index"));
 716
 717                 pa = pmap_early_vtophys(l1pt, l2pt);
 718                 pmap_load_store(&l1[l1_slot],
 719                     (pa & ~Ln_TABLE_MASK) | L1_TABLE);
 720                 l2pt += PAGE_SIZE;
 721         }
 722
 723         /* Clean the L2 page table */
 724         memset((void *)l2_start, 0, l2pt - l2_start);
 725
 726         return l2pt;
 727 }
 728
 729 static vm_offset_t
 730 pmap_bootstrap_l3(vm_offset_t l1pt, vm_offset_t va, vm_offset_t l3_start)
 731 {
 732         vm_offset_t l3pt;
 733         vm_paddr_t pa;
 734         pd_entry_t *l2;
 735         u_int l2_slot;
 736
 737         KASSERT((va & L2_OFFSET) == 0, ("Invalid virtual address"));
 738
 739         l2 = pmap_l2(kernel_pmap, va);
 740         l2 = (pd_entry_t *)rounddown2((uintptr_t)l2, PAGE_SIZE);
 741         l2_slot = pmap_l2_index(va);
 742         l3pt = l3_start;
 743
 744         for (; va < VM_MAX_KERNEL_ADDRESS; l2_slot++, va += L2_SIZE) {
 745                 KASSERT(l2_slot < Ln_ENTRIES, ("Invalid L2 index"));
 746
 747                 pa = pmap_early_vtophys(l1pt, l3pt);
 748                 pmap_load_store(&l2[l2_slot],
 749                     (pa & ~Ln_TABLE_MASK) | L2_TABLE);
 750                 l3pt += PAGE_SIZE;
 751         }
 752
 753         /* Clean the L2 page table */
 754         memset((void *)l3_start, 0, l3pt - l3_start);
 755
 756         return l3pt;
 757 }
 758
 759 /*
 760  *      Bootstrap the system enough to run with virtual memory.
 761  */
 762 void
 763 pmap_bootstrap(vm_offset_t l0pt, vm_offset_t l1pt, vm_paddr_t kernstart,
 764     vm_size_t kernlen)
 765 {
 766         u_int l1_slot, l2_slot;
 767         uint64_t kern_delta;
 768         pt_entry_t *l2;
 769         vm_offset_t va, freemempos;
 770         vm_offset_t dpcpu, msgbufpv;
 771         vm_paddr_t start_pa, pa, min_pa;
 772         int i;
 773
 774         kern_delta = KERNBASE - kernstart;
 775
 776         printf("pmap_bootstrap %lx %lx %lx\n", l1pt, kernstart, kernlen);
 777         printf("%lx\n", l1pt);
 778         printf("%lx\n", (KERNBASE >> L1_SHIFT) & Ln_ADDR_MASK);
 779
 780         /* Set this early so we can use the pagetable walking functions */
 781         kernel_pmap_store.pm_l0 = (pd_entry_t *)l0pt;
 782         PMAP_LOCK_INIT(kernel_pmap);
 783
 784         /* Assume the address we were loaded to is a valid physical address */
 785         min_pa = KERNBASE - kern_delta;
 786
 787         physmap_idx = arm_physmem_avail(physmap, nitems(physmap));
 788         physmap_idx /= 2;
 789
 790         /*
 791          * Find the minimum physical address. physmap is sorted,
 792          * but may contain empty ranges.
 793          */
 794         for (i = 0; i < (physmap_idx * 2); i += 2) {
 795                 if (physmap[i] == physmap[i + 1])
 796                         continue;
 797                 if (physmap[i] <= min_pa)
 798                         min_pa = physmap[i];
 799         }
 800
 801         freemempos = KERNBASE + kernlen;
 802         freemempos = roundup2(freemempos, PAGE_SIZE);
 803
 804         /* Create a direct map region early so we can use it for pa -> va */
 805         freemempos = pmap_bootstrap_dmap(l1pt, min_pa, freemempos);
 806
 807         va = KERNBASE;
 808         start_pa = pa = KERNBASE - kern_delta;
 809
 810         /*
 811          * Read the page table to find out what is already mapped.
 812          * This assumes we have mapped a block of memory from KERNBASE
 813          * using a single L1 entry.
 814          */
 815         l2 = pmap_early_page_idx(l1pt, KERNBASE, &l1_slot, &l2_slot);
 816
 817         /* Sanity check the index, KERNBASE should be the first VA */
 818         KASSERT(l2_slot == 0, ("The L2 index is non-zero"));
 819
 820         /* Find how many pages we have mapped */
 821         for (; l2_slot < Ln_ENTRIES; l2_slot++) {
 822                 if ((l2[l2_slot] & ATTR_DESCR_MASK) == 0)
 823                         break;
 824
 825                 /* Check locore used L2 blocks */
 826                 KASSERT((l2[l2_slot] & ATTR_DESCR_MASK) == L2_BLOCK,
 827                     ("Invalid bootstrap L2 table"));
 828                 KASSERT((l2[l2_slot] & ~ATTR_MASK) == pa,
 829                     ("Incorrect PA in L2 table"));
 830
 831                 va += L2_SIZE;
 832                 pa += L2_SIZE;
 833         }
 834
 835         va = roundup2(va, L1_SIZE);
 836
 837         /* Create the l2 tables up to VM_MAX_KERNEL_ADDRESS */
 838         freemempos = pmap_bootstrap_l2(l1pt, va, freemempos);
 839         /* And the l3 tables for the early devmap */
 840         freemempos = pmap_bootstrap_l3(l1pt,
 841             VM_MAX_KERNEL_ADDRESS - (PMAP_MAPDEV_EARLY_SIZE), freemempos);
 842
 843         cpu_tlb_flushID();
 844
 845 #define alloc_pages(var, np)                                            \
 846         (var) = freemempos;                                             \
 847         freemempos += (np * PAGE_SIZE);                                 \
 848         memset((char *)(var), 0, ((np) * PAGE_SIZE));
 849
 850         /* Allocate dynamic per-cpu area. */
 851         alloc_pages(dpcpu, DPCPU_SIZE / PAGE_SIZE);
 852         dpcpu_init((void *)dpcpu, 0);
 853
 854         /* Allocate memory for the msgbuf, e.g. for /sbin/dmesg */
 855         alloc_pages(msgbufpv, round_page(msgbufsize) / PAGE_SIZE);
 856         msgbufp = (void *)msgbufpv;
 857
 858         /* Reserve some VA space for early BIOS/ACPI mapping */
 859         preinit_map_va = roundup2(freemempos, L2_SIZE);
 860
 861         virtual_avail = preinit_map_va + PMAP_PREINIT_MAPPING_SIZE;
 862         virtual_avail = roundup2(virtual_avail, L1_SIZE);
 863         virtual_end = VM_MAX_KERNEL_ADDRESS - (PMAP_MAPDEV_EARLY_SIZE);
 864         kernel_vm_end = virtual_avail;
 865
 866         pa = pmap_early_vtophys(l1pt, freemempos);
 867
 868         arm_physmem_exclude_region(start_pa, pa - start_pa, EXFLAG_NOALLOC);
 869
 870         cpu_tlb_flushID();
 871 }
 872
 873 /*
 874  *      Initialize a vm_page's machine-dependent fields.
 875  */
 876 void
 877 pmap_page_init(vm_page_t m)
 878 {
 879
 880         TAILQ_INIT(&m->md.pv_list);
 881         m->md.pv_memattr = VM_MEMATTR_WRITE_BACK;
 882 }
 883
 884 /*
 885  *      Initialize the pmap module.
 886  *      Called by vm_init, to initialize any structures that the pmap
 887  *      system needs to map virtual memory.
 888  */
 889 void
 890 pmap_init(void)
 891 {
 892         vm_size_t s;
 893         int i, pv_npg;
 894
 895         /*
 896          * Are large page mappings enabled?
 897          */
 898         TUNABLE_INT_FETCH("vm.pmap.superpages_enabled", &superpages_enabled);
 899         if (superpages_enabled) {
 900                 KASSERT(MAXPAGESIZES > 1 && pagesizes[1] == 0,
 901                     ("pmap_init: can't assign to pagesizes[1]"));
 902                 pagesizes[1] = L2_SIZE;
 903         }
 904
 905         /*
 906          * Initialize the pv chunk list mutex.
 907          */
 908         mtx_init(&pv_chunks_mutex, "pmap pv chunk list", NULL, MTX_DEF);
 909
 910         /*
 911          * Initialize the pool of pv list locks.
 912          */
 913         for (i = 0; i < NPV_LIST_LOCKS; i++)
 914                 rw_init(&pv_list_locks[i], "pmap pv list");
 915
 916         /*
 917          * Calculate the size of the pv head table for superpages.
 918          */
 919         pv_npg = howmany(vm_phys_segs[vm_phys_nsegs - 1].end, L2_SIZE);
 920
 921         /*
 922          * Allocate memory for the pv head table for superpages.
 923          */
 924         s = (vm_size_t)(pv_npg * sizeof(struct md_page));
 925         s = round_page(s);
 926         pv_table = (struct md_page *)kmem_malloc(kernel_arena, s,
 927             M_WAITOK | M_ZERO);
 928         for (i = 0; i < pv_npg; i++)
 929                 TAILQ_INIT(&pv_table[i].pv_list);
 930         TAILQ_INIT(&pv_dummy.pv_list);
 931
 932         vm_initialized = 1;
 933 }
 934
 935 static SYSCTL_NODE(_vm_pmap, OID_AUTO, l2, CTLFLAG_RD, 0,
 936     "2MB page mapping counters");
 937
 938 static u_long pmap_l2_demotions;
 939 SYSCTL_ULONG(_vm_pmap_l2, OID_AUTO, demotions, CTLFLAG_RD,
 940     &pmap_l2_demotions, 0, "2MB page demotions");
 941
 942 static u_long pmap_l2_mappings;
 943 SYSCTL_ULONG(_vm_pmap_l2, OID_AUTO, mappings, CTLFLAG_RD,
 944     &pmap_l2_mappings, 0, "2MB page mappings");
 945
 946 static u_long pmap_l2_p_failures;
 947 SYSCTL_ULONG(_vm_pmap_l2, OID_AUTO, p_failures, CTLFLAG_RD,
 948     &pmap_l2_p_failures, 0, "2MB page promotion failures");
 949
 950 static u_long pmap_l2_promotions;
 951 SYSCTL_ULONG(_vm_pmap_l2, OID_AUTO, promotions, CTLFLAG_RD,
 952     &pmap_l2_promotions, 0, "2MB page promotions");
 953
 954 /*
 955  * Invalidate a single TLB entry.
 956  */
 957 static __inline void
 958 pmap_invalidate_page(pmap_t pmap, vm_offset_t va)
 959 {
 960
 961         sched_pin();
 962         __asm __volatile(
 963             "dsb  ishst         \n"
 964             "tlbi vaae1is, %0   \n"
 965             "dsb  ish           \n"
 966             "isb                \n"
 967             : : "r"(va >> PAGE_SHIFT));
 968         sched_unpin();
 969 }
 970
 971 static __inline void
 972 pmap_invalidate_range_nopin(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
 973 {
 974         vm_offset_t addr;
 975
 976         dsb(ishst);
 977         for (addr = sva; addr < eva; addr += PAGE_SIZE) {
 978                 __asm __volatile(
 979                     "tlbi vaae1is, %0" : : "r"(addr >> PAGE_SHIFT));
 980         }
 981         __asm __volatile(
 982             "dsb  ish   \n"
 983             "isb        \n");
 984 }
 985
 986 static __inline void
 987 pmap_invalidate_range(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
 988 {
 989
 990         sched_pin();
 991         pmap_invalidate_range_nopin(pmap, sva, eva);
 992         sched_unpin();
 993 }
 994
 995 static __inline void
 996 pmap_invalidate_all(pmap_t pmap)
 997 {
 998
 999         sched_pin();
1000         __asm __volatile(
1001             "dsb  ishst         \n"
1002             "tlbi vmalle1is     \n"
1003             "dsb  ish           \n"
1004             "isb                \n");
1005         sched_unpin();
1006 }
1007
1008 /*
1009  *      Routine:        pmap_extract
1010  *      Function:
1011  *              Extract the physical page address associated
1012  *              with the given map/virtual_address pair.
1013  */
1014 vm_paddr_t
1015 pmap_extract(pmap_t pmap, vm_offset_t va)
1016 {
1017         pt_entry_t *pte, tpte;
1018         vm_paddr_t pa;
1019         int lvl;
1020
1021         pa = 0;
1022         PMAP_LOCK(pmap);
1023         /*
1024          * Find the block or page map for this virtual address. pmap_pte
1025          * will return either a valid block/page entry, or NULL.
1026          */
1027         pte = pmap_pte(pmap, va, &lvl);
1028         if (pte != NULL) {
1029                 tpte = pmap_load(pte);
1030                 pa = tpte & ~ATTR_MASK;
1031                 switch(lvl) {
1032                 case 1:
1033                         KASSERT((tpte & ATTR_DESCR_MASK) == L1_BLOCK,
1034                             ("pmap_extract: Invalid L1 pte found: %lx",
1035                             tpte & ATTR_DESCR_MASK));
1036                         pa |= (va & L1_OFFSET);
1037                         break;
1038                 case 2:
1039                         KASSERT((tpte & ATTR_DESCR_MASK) == L2_BLOCK,
1040                             ("pmap_extract: Invalid L2 pte found: %lx",
1041                             tpte & ATTR_DESCR_MASK));
1042                         pa |= (va & L2_OFFSET);
1043                         break;
1044                 case 3:
1045                         KASSERT((tpte & ATTR_DESCR_MASK) == L3_PAGE,
1046                             ("pmap_extract: Invalid L3 pte found: %lx",
1047                             tpte & ATTR_DESCR_MASK));
1048                         pa |= (va & L3_OFFSET);
1049                         break;
1050                 }
1051         }
1052         PMAP_UNLOCK(pmap);
1053         return (pa);
1054 }
1055
1056 /*
1057  *      Routine:        pmap_extract_and_hold
1058  *      Function:
1059  *              Atomically extract and hold the physical page
1060  *              with the given pmap and virtual address pair
1061  *              if that mapping permits the given protection.
1062  */
1063 vm_page_t
1064 pmap_extract_and_hold(pmap_t pmap, vm_offset_t va, vm_prot_t prot)
1065 {
1066         pt_entry_t *pte, tpte;
1067         vm_offset_t off;
1068         vm_paddr_t pa;
1069         vm_page_t m;
1070         int lvl;
1071
1072         pa = 0;
1073         m = NULL;
1074         PMAP_LOCK(pmap);
1075 retry:
1076         pte = pmap_pte(pmap, va, &lvl);
1077         if (pte != NULL) {
1078                 tpte = pmap_load(pte);
1079
1080                 KASSERT(lvl > 0 && lvl <= 3,
1081                     ("pmap_extract_and_hold: Invalid level %d", lvl));
1082                 CTASSERT(L1_BLOCK == L2_BLOCK);
1083                 KASSERT((lvl == 3 && (tpte & ATTR_DESCR_MASK) == L3_PAGE) ||
1084                     (lvl < 3 && (tpte & ATTR_DESCR_MASK) == L1_BLOCK),
1085                     ("pmap_extract_and_hold: Invalid pte at L%d: %lx", lvl,
1086                      tpte & ATTR_DESCR_MASK));
1087                 if (((tpte & ATTR_AP_RW_BIT) == ATTR_AP(ATTR_AP_RW)) ||
1088                     ((prot & VM_PROT_WRITE) == 0)) {
1089                         switch(lvl) {
1090                         case 1:
1091                                 off = va & L1_OFFSET;
1092                                 break;
1093                         case 2:
1094                                 off = va & L2_OFFSET;
1095                                 break;
1096                         case 3:
1097                         default:
1098                                 off = 0;
1099                         }
1100                         if (vm_page_pa_tryrelock(pmap,
1101                             (tpte & ~ATTR_MASK) | off, &pa))
1102                                 goto retry;
1103                         m = PHYS_TO_VM_PAGE((tpte & ~ATTR_MASK) | off);
1104                         vm_page_hold(m);
1105                 }
1106         }
1107         PA_UNLOCK_COND(pa);
1108         PMAP_UNLOCK(pmap);
1109         return (m);
1110 }
1111
1112 vm_paddr_t
1113 pmap_kextract(vm_offset_t va)
1114 {
1115         pt_entry_t *pte, tpte;
1116         vm_paddr_t pa;
1117         int lvl;
1118
1119         if (va >= DMAP_MIN_ADDRESS && va < DMAP_MAX_ADDRESS) {
1120                 pa = DMAP_TO_PHYS(va);
1121         } else {
1122                 pa = 0;
1123                 pte = pmap_pte(kernel_pmap, va, &lvl);
1124                 if (pte != NULL) {
1125                         tpte = pmap_load(pte);
1126                         pa = tpte & ~ATTR_MASK;
1127                         switch(lvl) {
1128                         case 1:
1129                                 KASSERT((tpte & ATTR_DESCR_MASK) == L1_BLOCK,
1130                                     ("pmap_kextract: Invalid L1 pte found: %lx",
1131                                     tpte & ATTR_DESCR_MASK));
1132                                 pa |= (va & L1_OFFSET);
1133                                 break;
1134                         case 2:
1135                                 KASSERT((tpte & ATTR_DESCR_MASK) == L2_BLOCK,
1136                                     ("pmap_kextract: Invalid L2 pte found: %lx",
1137                                     tpte & ATTR_DESCR_MASK));
1138                                 pa |= (va & L2_OFFSET);
1139                                 break;
1140                         case 3:
1141                                 KASSERT((tpte & ATTR_DESCR_MASK) == L3_PAGE,
1142                                     ("pmap_kextract: Invalid L3 pte found: %lx",
1143                                     tpte & ATTR_DESCR_MASK));
1144                                 pa |= (va & L3_OFFSET);
1145                                 break;
1146                         }
1147                 }
1148         }
1149         return (pa);
1150 }
1151
1152 /***************************************************
1153  * Low level mapping routines.....
1154  ***************************************************/
1155
1156 void
1157 pmap_kenter(vm_offset_t sva, vm_size_t size, vm_paddr_t pa, int mode)
1158 {
1159         pd_entry_t *pde;
1160         pt_entry_t *pte, attr;
1161         vm_offset_t va;
1162         int lvl;
1163
1164         KASSERT((pa & L3_OFFSET) == 0,
1165            ("pmap_kenter: Invalid physical address"));
1166         KASSERT((sva & L3_OFFSET) == 0,
1167            ("pmap_kenter: Invalid virtual address"));
1168         KASSERT((size & PAGE_MASK) == 0,
1169             ("pmap_kenter: Mapping is not page-sized"));
1170
1171         attr = ATTR_DEFAULT | ATTR_IDX(mode) | L3_PAGE;
1172         if (mode == DEVICE_MEMORY)
1173                 attr |= ATTR_XN;
1174
1175         va = sva;
1176         while (size != 0) {
1177                 pde = pmap_pde(kernel_pmap, va, &lvl);
1178                 KASSERT(pde != NULL,
1179                     ("pmap_kenter: Invalid page entry, va: 0x%lx", va));
1180                 KASSERT(lvl == 2, ("pmap_kenter: Invalid level %d", lvl));
1181
1182                 pte = pmap_l2_to_l3(pde, va);
1183                 pmap_load_store(pte, (pa & ~L3_OFFSET) | attr);
1184
1185                 va += PAGE_SIZE;
1186                 pa += PAGE_SIZE;
1187                 size -= PAGE_SIZE;
1188         }
1189         pmap_invalidate_range(kernel_pmap, sva, va);
1190 }
1191
1192 void
1193 pmap_kenter_device(vm_offset_t sva, vm_size_t size, vm_paddr_t pa)
1194 {
1195
1196         pmap_kenter(sva, size, pa, DEVICE_MEMORY);
1197 }
1198
1199 /*
1200  * Remove a page from the kernel pagetables.
1201  */
1202 PMAP_INLINE void
1203 pmap_kremove(vm_offset_t va)
1204 {
1205         pt_entry_t *pte;
1206         int lvl;
1207
1208         pte = pmap_pte(kernel_pmap, va, &lvl);
1209         KASSERT(pte != NULL, ("pmap_kremove: Invalid address"));
1210         KASSERT(lvl == 3, ("pmap_kremove: Invalid pte level %d", lvl));
1211
1212         pmap_load_clear(pte);
1213         pmap_invalidate_page(kernel_pmap, va);
1214 }
1215
1216 void
1217 pmap_kremove_device(vm_offset_t sva, vm_size_t size)
1218 {
1219         pt_entry_t *pte;
1220         vm_offset_t va;
1221         int lvl;
1222
1223         KASSERT((sva & L3_OFFSET) == 0,
1224            ("pmap_kremove_device: Invalid virtual address"));
1225         KASSERT((size & PAGE_MASK) == 0,
1226             ("pmap_kremove_device: Mapping is not page-sized"));
1227
1228         va = sva;
1229         while (size != 0) {
1230                 pte = pmap_pte(kernel_pmap, va, &lvl);
1231                 KASSERT(pte != NULL, ("Invalid page table, va: 0x%lx", va));
1232                 KASSERT(lvl == 3,
1233                     ("Invalid device pagetable level: %d != 3", lvl));
1234                 pmap_load_clear(pte);
1235
1236                 va += PAGE_SIZE;
1237                 size -= PAGE_SIZE;
1238         }
1239         pmap_invalidate_range(kernel_pmap, sva, va);
1240 }
1241
1242 /*
1243  *      Used to map a range of physical addresses into kernel
1244  *      virtual address space.
1245  *
1246  *      The value passed in '*virt' is a suggested virtual address for
1247  *      the mapping. Architectures which can support a direct-mapped
1248  *      physical to virtual region can return the appropriate address
1249  *      within that region, leaving '*virt' unchanged. Other
1250  *      architectures should map the pages starting at '*virt' and
1251  *      update '*virt' with the first usable address after the mapped
1252  *      region.
1253  */
1254 vm_offset_t
1255 pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
1256 {
1257         return PHYS_TO_DMAP(start);
1258 }
1259
1260
1261 /*
1262  * Add a list of wired pages to the kva
1263  * this routine is only used for temporary
1264  * kernel mappings that do not need to have
1265  * page modification or references recorded.
1266  * Note that old mappings are simply written
1267  * over.  The page *must* be wired.
1268  * Note: SMP coherent.  Uses a ranged shootdown IPI.
1269  */
1270 void
1271 pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
1272 {
1273         pd_entry_t *pde;
1274         pt_entry_t *pte, pa;
1275         vm_offset_t va;
1276         vm_page_t m;
1277         int i, lvl;
1278
1279         va = sva;
1280         for (i = 0; i < count; i++) {
1281                 pde = pmap_pde(kernel_pmap, va, &lvl);
1282                 KASSERT(pde != NULL,
1283                     ("pmap_qenter: Invalid page entry, va: 0x%lx", va));
1284                 KASSERT(lvl == 2,
1285                     ("pmap_qenter: Invalid level %d", lvl));
1286
1287                 m = ma[i];
1288                 pa = VM_PAGE_TO_PHYS(m) | ATTR_DEFAULT | ATTR_AP(ATTR_AP_RW) |
1289                     ATTR_IDX(m->md.pv_memattr) | L3_PAGE;
1290                 if (m->md.pv_memattr == DEVICE_MEMORY)
1291                         pa |= ATTR_XN;
1292                 pte = pmap_l2_to_l3(pde, va);
1293                 pmap_load_store(pte, pa);
1294
1295                 va += L3_SIZE;
1296         }
1297         pmap_invalidate_range(kernel_pmap, sva, va);
1298 }
1299
1300 /*
1301  * This routine tears out page mappings from the
1302  * kernel -- it is meant only for temporary mappings.
1303  */
1304 void
1305 pmap_qremove(vm_offset_t sva, int count)
1306 {
1307         pt_entry_t *pte;
1308         vm_offset_t va;
1309         int lvl;
1310
1311         KASSERT(sva >= VM_MIN_KERNEL_ADDRESS, ("usermode va %lx", sva));
1312
1313         va = sva;
1314         while (count-- > 0) {
1315                 pte = pmap_pte(kernel_pmap, va, &lvl);
1316                 KASSERT(lvl == 3,
1317                     ("Invalid device pagetable level: %d != 3", lvl));
1318                 if (pte != NULL) {
1319                         pmap_load_clear(pte);
1320                 }
1321
1322                 va += PAGE_SIZE;
1323         }
1324         pmap_invalidate_range(kernel_pmap, sva, va);
1325 }
1326
1327 /***************************************************
1328  * Page table page management routines.....
1329  ***************************************************/
1330 /*
1331  * Schedule the specified unused page table page to be freed.  Specifically,
1332  * add the page to the specified list of pages that will be released to the
1333  * physical memory manager after the TLB has been updated.
1334  */
1335 static __inline void
1336 pmap_add_delayed_free_list(vm_page_t m, struct spglist *free,
1337     boolean_t set_PG_ZERO)
1338 {
1339
1340         if (set_PG_ZERO)
1341                 m->flags |= PG_ZERO;
1342         else
1343                 m->flags &= ~PG_ZERO;
1344         SLIST_INSERT_HEAD(free, m, plinks.s.ss);
1345 }
1346
1347 /*
1348  * Decrements a page table page's wire count, which is used to record the
1349  * number of valid page table entries within the page.  If the wire count
1350  * drops to zero, then the page table page is unmapped.  Returns TRUE if the
1351  * page table page was unmapped and FALSE otherwise.
1352  */
1353 static inline boolean_t
1354 pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m, struct spglist *free)
1355 {
1356
1357         --m->wire_count;
1358         if (m->wire_count == 0) {
1359                 _pmap_unwire_l3(pmap, va, m, free);
1360                 return (TRUE);
1361         } else
1362                 return (FALSE);
1363 }
1364
1365 static void
1366 _pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m, struct spglist *free)
1367 {
1368
1369         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1370         /*
1371          * unmap the page table page
1372          */
1373         if (m->pindex >= (NUL2E + NUL1E)) {
1374                 /* l1 page */
1375                 pd_entry_t *l0;
1376
1377                 l0 = pmap_l0(pmap, va);
1378                 pmap_load_clear(l0);
1379         } else if (m->pindex >= NUL2E) {
1380                 /* l2 page */
1381                 pd_entry_t *l1;
1382
1383                 l1 = pmap_l1(pmap, va);
1384                 pmap_load_clear(l1);
1385         } else {
1386                 /* l3 page */
1387                 pd_entry_t *l2;
1388
1389                 l2 = pmap_l2(pmap, va);
1390                 pmap_load_clear(l2);
1391         }
1392         pmap_resident_count_dec(pmap, 1);
1393         if (m->pindex < NUL2E) {
1394                 /* We just released an l3, unhold the matching l2 */
1395                 pd_entry_t *l1, tl1;
1396                 vm_page_t l2pg;
1397
1398                 l1 = pmap_l1(pmap, va);
1399                 tl1 = pmap_load(l1);
1400                 l2pg = PHYS_TO_VM_PAGE(tl1 & ~ATTR_MASK);
1401                 pmap_unwire_l3(pmap, va, l2pg, free);
1402         } else if (m->pindex < (NUL2E + NUL1E)) {
1403                 /* We just released an l2, unhold the matching l1 */
1404                 pd_entry_t *l0, tl0;
1405                 vm_page_t l1pg;
1406
1407                 l0 = pmap_l0(pmap, va);
1408                 tl0 = pmap_load(l0);
1409                 l1pg = PHYS_TO_VM_PAGE(tl0 & ~ATTR_MASK);
1410                 pmap_unwire_l3(pmap, va, l1pg, free);
1411         }
1412         pmap_invalidate_page(pmap, va);
1413
1414         vm_wire_sub(1);
1415
1416         /*
1417          * Put page on a list so that it is released after
1418          * *ALL* TLB shootdown is done
1419          */
1420         pmap_add_delayed_free_list(m, free, TRUE);
1421 }
1422
1423 /*
1424  * After removing a page table entry, this routine is used to
1425  * conditionally free the page, and manage the hold/wire counts.
1426  */
1427 static int
1428 pmap_unuse_pt(pmap_t pmap, vm_offset_t va, pd_entry_t ptepde,
1429     struct spglist *free)
1430 {
1431         vm_page_t mpte;
1432
1433         if (va >= VM_MAXUSER_ADDRESS)
1434                 return (0);
1435         KASSERT(ptepde != 0, ("pmap_unuse_pt: ptepde != 0"));
1436         mpte = PHYS_TO_VM_PAGE(ptepde & ~ATTR_MASK);
1437         return (pmap_unwire_l3(pmap, va, mpte, free));
1438 }
1439
1440 void
1441 pmap_pinit0(pmap_t pmap)
1442 {
1443
1444         PMAP_LOCK_INIT(pmap);
1445         bzero(&pmap->pm_stats, sizeof(pmap->pm_stats));
1446         pmap->pm_l0 = kernel_pmap->pm_l0;
1447         pmap->pm_root.rt_root = 0;
1448 }
1449
1450 int
1451 pmap_pinit(pmap_t pmap)
1452 {
1453         vm_paddr_t l0phys;
1454         vm_page_t l0pt;
1455
1456         /*
1457          * allocate the l0 page
1458          */
1459         while ((l0pt = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
1460             VM_ALLOC_NOOBJ | VM_ALLOC_WIRED | VM_ALLOC_ZERO)) == NULL)
1461                 vm_wait(NULL);
1462
1463         l0phys = VM_PAGE_TO_PHYS(l0pt);
1464         pmap->pm_l0 = (pd_entry_t *)PHYS_TO_DMAP(l0phys);
1465
1466         if ((l0pt->flags & PG_ZERO) == 0)
1467                 pagezero(pmap->pm_l0);
1468
1469         pmap->pm_root.rt_root = 0;
1470         bzero(&pmap->pm_stats, sizeof(pmap->pm_stats));
1471
1472         return (1);
1473 }
1474
1475 /*
1476  * This routine is called if the desired page table page does not exist.
1477  *
1478  * If page table page allocation fails, this routine may sleep before
1479  * returning NULL.  It sleeps only if a lock pointer was given.
1480  *
1481  * Note: If a page allocation fails at page table level two or three,
1482  * one or two pages may be held during the wait, only to be released
1483  * afterwards.  This conservative approach is easily argued to avoid
1484  * race conditions.
1485  */
1486 static vm_page_t
1487 _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
1488 {
1489         vm_page_t m, l1pg, l2pg;
1490
1491         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1492
1493         /*
1494          * Allocate a page table page.
1495          */
1496         if ((m = vm_page_alloc(NULL, ptepindex, VM_ALLOC_NOOBJ |
1497             VM_ALLOC_WIRED | VM_ALLOC_ZERO)) == NULL) {
1498                 if (lockp != NULL) {
1499                         RELEASE_PV_LIST_LOCK(lockp);
1500                         PMAP_UNLOCK(pmap);
1501                         vm_wait(NULL);
1502                         PMAP_LOCK(pmap);
1503                 }
1504
1505                 /*
1506                  * Indicate the need to retry.  While waiting, the page table
1507                  * page may have been allocated.
1508                  */
1509                 return (NULL);
1510         }
1511         if ((m->flags & PG_ZERO) == 0)
1512                 pmap_zero_page(m);
1513
1514         /*
1515          * Map the pagetable page into the process address space, if
1516          * it isn't already there.
1517          */
1518
1519         if (ptepindex >= (NUL2E + NUL1E)) {
1520                 pd_entry_t *l0;
1521                 vm_pindex_t l0index;
1522
1523                 l0index = ptepindex - (NUL2E + NUL1E);
1524                 l0 = &pmap->pm_l0[l0index];
1525                 pmap_load_store(l0, VM_PAGE_TO_PHYS(m) | L0_TABLE);
1526         } else if (ptepindex >= NUL2E) {
1527                 vm_pindex_t l0index, l1index;
1528                 pd_entry_t *l0, *l1;
1529                 pd_entry_t tl0;
1530
1531                 l1index = ptepindex - NUL2E;
1532                 l0index = l1index >> L0_ENTRIES_SHIFT;
1533
1534                 l0 = &pmap->pm_l0[l0index];
1535                 tl0 = pmap_load(l0);
1536                 if (tl0 == 0) {
1537                         /* recurse for allocating page dir */
1538                         if (_pmap_alloc_l3(pmap, NUL2E + NUL1E + l0index,
1539                             lockp) == NULL) {
1540                                 vm_page_unwire_noq(m);
1541                                 vm_page_free_zero(m);
1542                                 return (NULL);
1543                         }
1544                 } else {
1545                         l1pg = PHYS_TO_VM_PAGE(tl0 & ~ATTR_MASK);
1546                         l1pg->wire_count++;
1547                 }
1548
1549                 l1 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l0) & ~ATTR_MASK);
1550                 l1 = &l1[ptepindex & Ln_ADDR_MASK];
1551                 pmap_load_store(l1, VM_PAGE_TO_PHYS(m) | L1_TABLE);
1552         } else {
1553                 vm_pindex_t l0index, l1index;
1554                 pd_entry_t *l0, *l1, *l2;
1555                 pd_entry_t tl0, tl1;
1556
1557                 l1index = ptepindex >> Ln_ENTRIES_SHIFT;
1558                 l0index = l1index >> L0_ENTRIES_SHIFT;
1559
1560                 l0 = &pmap->pm_l0[l0index];
1561                 tl0 = pmap_load(l0);
1562                 if (tl0 == 0) {
1563                         /* recurse for allocating page dir */
1564                         if (_pmap_alloc_l3(pmap, NUL2E + l1index,
1565                             lockp) == NULL) {
1566                                 vm_page_unwire_noq(m);
1567                                 vm_page_free_zero(m);
1568                                 return (NULL);
1569                         }
1570                         tl0 = pmap_load(l0);
1571                         l1 = (pd_entry_t *)PHYS_TO_DMAP(tl0 & ~ATTR_MASK);
1572                         l1 = &l1[l1index & Ln_ADDR_MASK];
1573                 } else {
1574                         l1 = (pd_entry_t *)PHYS_TO_DMAP(tl0 & ~ATTR_MASK);
1575                         l1 = &l1[l1index & Ln_ADDR_MASK];
1576                         tl1 = pmap_load(l1);
1577                         if (tl1 == 0) {
1578                                 /* recurse for allocating page dir */
1579                                 if (_pmap_alloc_l3(pmap, NUL2E + l1index,
1580                                     lockp) == NULL) {
1581                                         vm_page_unwire_noq(m);
1582                                         vm_page_free_zero(m);
1583                                         return (NULL);
1584                                 }
1585                         } else {
1586                                 l2pg = PHYS_TO_VM_PAGE(tl1 & ~ATTR_MASK);
1587                                 l2pg->wire_count++;
1588                         }
1589                 }
1590
1591                 l2 = (pd_entry_t *)PHYS_TO_DMAP(pmap_load(l1) & ~ATTR_MASK);
1592                 l2 = &l2[ptepindex & Ln_ADDR_MASK];
1593                 pmap_load_store(l2, VM_PAGE_TO_PHYS(m) | L2_TABLE);
1594         }
1595
1596         pmap_resident_count_inc(pmap, 1);
1597
1598         return (m);
1599 }
1600
1601 static vm_page_t
1602 pmap_alloc_l2(pmap_t pmap, vm_offset_t va, struct rwlock **lockp)
1603 {
1604         pd_entry_t *l1;
1605         vm_page_t l2pg;
1606         vm_pindex_t l2pindex;
1607
1608 retry:
1609         l1 = pmap_l1(pmap, va);
1610         if (l1 != NULL && (pmap_load(l1) & ATTR_DESCR_MASK) == L1_TABLE) {
1611                 /* Add a reference to the L2 page. */
1612                 l2pg = PHYS_TO_VM_PAGE(pmap_load(l1) & ~ATTR_MASK);
1613                 l2pg->wire_count++;
1614         } else {
1615                 /* Allocate a L2 page. */
1616                 l2pindex = pmap_l2_pindex(va) >> Ln_ENTRIES_SHIFT;
1617                 l2pg = _pmap_alloc_l3(pmap, NUL2E + l2pindex, lockp);
1618                 if (l2pg == NULL && lockp != NULL)
1619                         goto retry;
1620         }
1621         return (l2pg);
1622 }
1623
1624 static vm_page_t
1625 pmap_alloc_l3(pmap_t pmap, vm_offset_t va, struct rwlock **lockp)
1626 {
1627         vm_pindex_t ptepindex;
1628         pd_entry_t *pde, tpde;
1629 #ifdef INVARIANTS
1630         pt_entry_t *pte;
1631 #endif
1632         vm_page_t m;
1633         int lvl;
1634
1635         /*
1636          * Calculate pagetable page index
1637          */
1638         ptepindex = pmap_l2_pindex(va);
1639 retry:
1640         /*
1641          * Get the page directory entry
1642          */
1643         pde = pmap_pde(pmap, va, &lvl);
1644
1645         /*
1646          * If the page table page is mapped, we just increment the hold count,
1647          * and activate it. If we get a level 2 pde it will point to a level 3
1648          * table.
1649          */
1650         switch (lvl) {
1651         case -1:
1652                 break;
1653         case 0:
1654 #ifdef INVARIANTS
1655                 pte = pmap_l0_to_l1(pde, va);
1656                 KASSERT(pmap_load(pte) == 0,
1657                     ("pmap_alloc_l3: TODO: l0 superpages"));
1658 #endif
1659                 break;
1660         case 1:
1661 #ifdef INVARIANTS
1662                 pte = pmap_l1_to_l2(pde, va);
1663                 KASSERT(pmap_load(pte) == 0,
1664                     ("pmap_alloc_l3: TODO: l1 superpages"));
1665 #endif
1666                 break;
1667         case 2:
1668                 tpde = pmap_load(pde);
1669                 if (tpde != 0) {
1670                         m = PHYS_TO_VM_PAGE(tpde & ~ATTR_MASK);
1671                         m->wire_count++;
1672                         return (m);
1673                 }
1674                 break;
1675         default:
1676                 panic("pmap_alloc_l3: Invalid level %d", lvl);
1677         }
1678
1679         /*
1680          * Here if the pte page isn't mapped, or if it has been deallocated.
1681          */
1682         m = _pmap_alloc_l3(pmap, ptepindex, lockp);
1683         if (m == NULL && lockp != NULL)
1684                 goto retry;
1685
1686         return (m);
1687 }
1688
1689 /***************************************************
1690  * Pmap allocation/deallocation routines.
1691  ***************************************************/
1692
1693 /*
1694  * Release any resources held by the given physical map.
1695  * Called when a pmap initialized by pmap_pinit is being released.
1696  * Should only be called if the map contains no valid mappings.
1697  */
1698 void
1699 pmap_release(pmap_t pmap)
1700 {
1701         vm_page_t m;
1702
1703         KASSERT(pmap->pm_stats.resident_count == 0,
1704             ("pmap_release: pmap resident count %ld != 0",
1705             pmap->pm_stats.resident_count));
1706         KASSERT(vm_radix_is_empty(&pmap->pm_root),
1707             ("pmap_release: pmap has reserved page table page(s)"));
1708
1709         m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pmap->pm_l0));
1710
1711         vm_page_unwire_noq(m);
1712         vm_page_free_zero(m);
1713 }
1714
1715 static int
1716 kvm_size(SYSCTL_HANDLER_ARGS)
1717 {
1718         unsigned long ksize = VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS;
1719
1720         return sysctl_handle_long(oidp, &ksize, 0, req);
1721 }
1722 SYSCTL_PROC(_vm, OID_AUTO, kvm_size, CTLTYPE_LONG|CTLFLAG_RD,
1723     0, 0, kvm_size, "LU", "Size of KVM");
1724
1725 static int
1726 kvm_free(SYSCTL_HANDLER_ARGS)
1727 {
1728         unsigned long kfree = VM_MAX_KERNEL_ADDRESS - kernel_vm_end;
1729
1730         return sysctl_handle_long(oidp, &kfree, 0, req);
1731 }
1732 SYSCTL_PROC(_vm, OID_AUTO, kvm_free, CTLTYPE_LONG|CTLFLAG_RD,
1733     0, 0, kvm_free, "LU", "Amount of KVM free");
1734
1735 /*
1736  * grow the number of kernel page table entries, if needed
1737  */
1738 void
1739 pmap_growkernel(vm_offset_t addr)
1740 {
1741         vm_paddr_t paddr;
1742         vm_page_t nkpg;
1743         pd_entry_t *l0, *l1, *l2;
1744
1745         mtx_assert(&kernel_map->system_mtx, MA_OWNED);
1746
1747         addr = roundup2(addr, L2_SIZE);
1748         if (addr - 1 >= kernel_map->max_offset)
1749                 addr = kernel_map->max_offset;
1750         while (kernel_vm_end < addr) {
1751                 l0 = pmap_l0(kernel_pmap, kernel_vm_end);
1752                 KASSERT(pmap_load(l0) != 0,
1753                     ("pmap_growkernel: No level 0 kernel entry"));
1754
1755                 l1 = pmap_l0_to_l1(l0, kernel_vm_end);
1756                 if (pmap_load(l1) == 0) {
1757                         /* We need a new PDP entry */
1758                         nkpg = vm_page_alloc(NULL, kernel_vm_end >> L1_SHIFT,
1759                             VM_ALLOC_INTERRUPT | VM_ALLOC_NOOBJ |
1760                             VM_ALLOC_WIRED | VM_ALLOC_ZERO);
1761                         if (nkpg == NULL)
1762                                 panic("pmap_growkernel: no memory to grow kernel");
1763                         if ((nkpg->flags & PG_ZERO) == 0)
1764                                 pmap_zero_page(nkpg);
1765                         paddr = VM_PAGE_TO_PHYS(nkpg);
1766                         pmap_load_store(l1, paddr | L1_TABLE);
1767                         continue; /* try again */
1768                 }
1769                 l2 = pmap_l1_to_l2(l1, kernel_vm_end);
1770                 if ((pmap_load(l2) & ATTR_AF) != 0) {
1771                         kernel_vm_end = (kernel_vm_end + L2_SIZE) & ~L2_OFFSET;
1772                         if (kernel_vm_end - 1 >= kernel_map->max_offset) {
1773                                 kernel_vm_end = kernel_map->max_offset;
1774                                 break;
1775                         }
1776                         continue;
1777                 }
1778
1779                 nkpg = vm_page_alloc(NULL, kernel_vm_end >> L2_SHIFT,
1780                     VM_ALLOC_INTERRUPT | VM_ALLOC_NOOBJ | VM_ALLOC_WIRED |
1781                     VM_ALLOC_ZERO);
1782                 if (nkpg == NULL)
1783                         panic("pmap_growkernel: no memory to grow kernel");
1784                 if ((nkpg->flags & PG_ZERO) == 0)
1785                         pmap_zero_page(nkpg);
1786                 paddr = VM_PAGE_TO_PHYS(nkpg);
1787                 pmap_load_store(l2, paddr | L2_TABLE);
1788                 pmap_invalidate_page(kernel_pmap, kernel_vm_end);
1789
1790                 kernel_vm_end = (kernel_vm_end + L2_SIZE) & ~L2_OFFSET;
1791                 if (kernel_vm_end - 1 >= kernel_map->max_offset) {
1792                         kernel_vm_end = kernel_map->max_offset;
1793                         break;
1794                 }
1795         }
1796 }
1797
1798
1799 /***************************************************
1800  * page management routines.
1801  ***************************************************/
1802
1803 CTASSERT(sizeof(struct pv_chunk) == PAGE_SIZE);
1804 CTASSERT(_NPCM == 3);
1805 CTASSERT(_NPCPV == 168);
1806
1807 static __inline struct pv_chunk *
1808 pv_to_chunk(pv_entry_t pv)
1809 {
1810
1811         return ((struct pv_chunk *)((uintptr_t)pv & ~(uintptr_t)PAGE_MASK));
1812 }
1813
1814 #define PV_PMAP(pv) (pv_to_chunk(pv)->pc_pmap)
1815
1816 #define PC_FREE0        0xfffffffffffffffful
1817 #define PC_FREE1        0xfffffffffffffffful
1818 #define PC_FREE2        0x000000fffffffffful
1819
1820 static const uint64_t pc_freemask[_NPCM] = { PC_FREE0, PC_FREE1, PC_FREE2 };
1821
1822 #if 0
1823 #ifdef PV_STATS
1824 static int pc_chunk_count, pc_chunk_allocs, pc_chunk_frees, pc_chunk_tryfail;
1825
1826 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_count, CTLFLAG_RD, &pc_chunk_count, 0,
1827         "Current number of pv entry chunks");
1828 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_allocs, CTLFLAG_RD, &pc_chunk_allocs, 0,
1829         "Current number of pv entry chunks allocated");
1830 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_frees, CTLFLAG_RD, &pc_chunk_frees, 0,
1831         "Current number of pv entry chunks frees");
1832 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_tryfail, CTLFLAG_RD, &pc_chunk_tryfail, 0,
1833         "Number of times tried to get a chunk page but failed.");
1834
1835 static long pv_entry_frees, pv_entry_allocs, pv_entry_count;
1836 static int pv_entry_spare;
1837
1838 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_frees, CTLFLAG_RD, &pv_entry_frees, 0,
1839         "Current number of pv entry frees");
1840 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_allocs, CTLFLAG_RD, &pv_entry_allocs, 0,
1841         "Current number of pv entry allocs");
1842 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_count, CTLFLAG_RD, &pv_entry_count, 0,
1843         "Current number of pv entries");
1844 SYSCTL_INT(_vm_pmap, OID_AUTO, pv_entry_spare, CTLFLAG_RD, &pv_entry_spare, 0,
1845         "Current number of spare pv entries");
1846 #endif
1847 #endif /* 0 */
1848
1849 /*
1850  * We are in a serious low memory condition.  Resort to
1851  * drastic measures to free some pages so we can allocate
1852  * another pv entry chunk.
1853  *
1854  * Returns NULL if PV entries were reclaimed from the specified pmap.
1855  *
1856  * We do not, however, unmap 2mpages because subsequent accesses will
1857  * allocate per-page pv entries until repromotion occurs, thereby
1858  * exacerbating the shortage of free pv entries.
1859  */
1860 static vm_page_t
1861 reclaim_pv_chunk(pmap_t locked_pmap, struct rwlock **lockp)
1862 {
1863         struct pv_chunk *pc, *pc_marker, *pc_marker_end;
1864         struct pv_chunk_header pc_marker_b, pc_marker_end_b;
1865         struct md_page *pvh;
1866         pd_entry_t *pde;
1867         pmap_t next_pmap, pmap;
1868         pt_entry_t *pte, tpte;
1869         pv_entry_t pv;
1870         vm_offset_t va;
1871         vm_page_t m, m_pc;
1872         struct spglist free;
1873         uint64_t inuse;
1874         int bit, field, freed, lvl;
1875         static int active_reclaims = 0;
1876
1877         PMAP_LOCK_ASSERT(locked_pmap, MA_OWNED);
1878         KASSERT(lockp != NULL, ("reclaim_pv_chunk: lockp is NULL"));
1879
1880         pmap = NULL;
1881         m_pc = NULL;
1882         SLIST_INIT(&free);
1883         bzero(&pc_marker_b, sizeof(pc_marker_b));
1884         bzero(&pc_marker_end_b, sizeof(pc_marker_end_b));
1885         pc_marker = (struct pv_chunk *)&pc_marker_b;
1886         pc_marker_end = (struct pv_chunk *)&pc_marker_end_b;
1887
1888         mtx_lock(&pv_chunks_mutex);
1889         active_reclaims++;
1890         TAILQ_INSERT_HEAD(&pv_chunks, pc_marker, pc_lru);
1891         TAILQ_INSERT_TAIL(&pv_chunks, pc_marker_end, pc_lru);
1892         while ((pc = TAILQ_NEXT(pc_marker, pc_lru)) != pc_marker_end &&
1893             SLIST_EMPTY(&free)) {
1894                 next_pmap = pc->pc_pmap;
1895                 if (next_pmap == NULL) {
1896                         /*
1897                          * The next chunk is a marker.  However, it is
1898                          * not our marker, so active_reclaims must be
1899                          * > 1.  Consequently, the next_chunk code
1900                          * will not rotate the pv_chunks list.
1901                          */
1902                         goto next_chunk;
1903                 }
1904                 mtx_unlock(&pv_chunks_mutex);
1905
1906                 /*
1907                  * A pv_chunk can only be removed from the pc_lru list
1908                  * when both pv_chunks_mutex is owned and the
1909                  * corresponding pmap is locked.
1910                  */
1911                 if (pmap != next_pmap) {
1912                         if (pmap != NULL && pmap != locked_pmap)
1913                                 PMAP_UNLOCK(pmap);
1914                         pmap = next_pmap;
1915                         /* Avoid deadlock and lock recursion. */
1916                         if (pmap > locked_pmap) {
1917                                 RELEASE_PV_LIST_LOCK(lockp);
1918                                 PMAP_LOCK(pmap);
1919                                 mtx_lock(&pv_chunks_mutex);
1920                                 continue;
1921                         } else if (pmap != locked_pmap) {
1922                                 if (PMAP_TRYLOCK(pmap)) {
1923                                         mtx_lock(&pv_chunks_mutex);
1924                                         continue;
1925                                 } else {
1926                                         pmap = NULL; /* pmap is not locked */
1927                                         mtx_lock(&pv_chunks_mutex);
1928                                         pc = TAILQ_NEXT(pc_marker, pc_lru);
1929                                         if (pc == NULL ||
1930                                             pc->pc_pmap != next_pmap)
1931                                                 continue;
1932                                         goto next_chunk;
1933                                 }
1934                         }
1935                 }
1936
1937                 /*
1938                  * Destroy every non-wired, 4 KB page mapping in the chunk.
1939                  */
1940                 freed = 0;
1941                 for (field = 0; field < _NPCM; field++) {
1942                         for (inuse = ~pc->pc_map[field] & pc_freemask[field];
1943                             inuse != 0; inuse &= ~(1UL << bit)) {
1944                                 bit = ffsl(inuse) - 1;
1945                                 pv = &pc->pc_pventry[field * 64 + bit];
1946                                 va = pv->pv_va;
1947                                 pde = pmap_pde(pmap, va, &lvl);
1948                                 if (lvl != 2)
1949                                         continue;
1950                                 pte = pmap_l2_to_l3(pde, va);
1951                                 tpte = pmap_load(pte);
1952                                 if ((tpte & ATTR_SW_WIRED) != 0)
1953                                         continue;
1954                                 tpte = pmap_load_clear(pte);
1955                                 pmap_invalidate_page(pmap, va);
1956                                 m = PHYS_TO_VM_PAGE(tpte & ~ATTR_MASK);
1957                                 if (pmap_page_dirty(tpte))
1958                                         vm_page_dirty(m);
1959                                 if ((tpte & ATTR_AF) != 0)
1960                                         vm_page_aflag_set(m, PGA_REFERENCED);
1961                                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m);
1962                                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
1963                                 m->md.pv_gen++;
1964                                 if (TAILQ_EMPTY(&m->md.pv_list) &&
1965                                     (m->flags & PG_FICTITIOUS) == 0) {
1966                                         pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
1967                                         if (TAILQ_EMPTY(&pvh->pv_list)) {
1968                                                 vm_page_aflag_clear(m,
1969                                                     PGA_WRITEABLE);
1970                                         }
1971                                 }
1972                                 pc->pc_map[field] |= 1UL << bit;
1973                                 pmap_unuse_pt(pmap, va, pmap_load(pde), &free);
1974                                 freed++;
1975                         }
1976                 }
1977                 if (freed == 0) {
1978                         mtx_lock(&pv_chunks_mutex);
1979                         goto next_chunk;
1980                 }
1981                 /* Every freed mapping is for a 4 KB page. */
1982                 pmap_resident_count_dec(pmap, freed);
1983                 PV_STAT(atomic_add_long(&pv_entry_frees, freed));
1984                 PV_STAT(atomic_add_int(&pv_entry_spare, freed));
1985                 PV_STAT(atomic_subtract_long(&pv_entry_count, freed));
1986                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
1987                 if (pc->pc_map[0] == PC_FREE0 && pc->pc_map[1] == PC_FREE1 &&
1988                     pc->pc_map[2] == PC_FREE2) {
1989                         PV_STAT(atomic_subtract_int(&pv_entry_spare, _NPCPV));
1990                         PV_STAT(atomic_subtract_int(&pc_chunk_count, 1));
1991                         PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
1992                         /* Entire chunk is free; return it. */
1993                         m_pc = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
1994                         dump_drop_page(m_pc->phys_addr);
1995                         mtx_lock(&pv_chunks_mutex);
1996                         TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
1997                         break;
1998                 }
1999                 TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
2000                 mtx_lock(&pv_chunks_mutex);
2001                 /* One freed pv entry in locked_pmap is sufficient. */
2002                 if (pmap == locked_pmap)
2003                         break;
2004
2005 next_chunk:
2006                 TAILQ_REMOVE(&pv_chunks, pc_marker, pc_lru);
2007                 TAILQ_INSERT_AFTER(&pv_chunks, pc, pc_marker, pc_lru);
2008                 if (active_reclaims == 1 && pmap != NULL) {
2009                         /*
2010                          * Rotate the pv chunks list so that we do not
2011                          * scan the same pv chunks that could not be
2012                          * freed (because they contained a wired
2013                          * and/or superpage mapping) on every
2014                          * invocation of reclaim_pv_chunk().
2015                          */
2016                         while ((pc = TAILQ_FIRST(&pv_chunks)) != pc_marker) {
2017                                 MPASS(pc->pc_pmap != NULL);
2018                                 TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
2019                                 TAILQ_INSERT_TAIL(&pv_chunks, pc, pc_lru);
2020                         }
2021                 }
2022         }
2023         TAILQ_REMOVE(&pv_chunks, pc_marker, pc_lru);
2024         TAILQ_REMOVE(&pv_chunks, pc_marker_end, pc_lru);
2025         active_reclaims--;
2026         mtx_unlock(&pv_chunks_mutex);
2027         if (pmap != NULL && pmap != locked_pmap)
2028                 PMAP_UNLOCK(pmap);
2029         if (m_pc == NULL && !SLIST_EMPTY(&free)) {
2030                 m_pc = SLIST_FIRST(&free);
2031                 SLIST_REMOVE_HEAD(&free, plinks.s.ss);
2032                 /* Recycle a freed page table page. */
2033                 m_pc->wire_count = 1;
2034                 vm_wire_add(1);
2035         }
2036         vm_page_free_pages_toq(&free, false);
2037         return (m_pc);
2038 }
2039
2040 /*
2041  * free the pv_entry back to the free list
2042  */
2043 static void
2044 free_pv_entry(pmap_t pmap, pv_entry_t pv)
2045 {
2046         struct pv_chunk *pc;
2047         int idx, field, bit;
2048
2049         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2050         PV_STAT(atomic_add_long(&pv_entry_frees, 1));
2051         PV_STAT(atomic_add_int(&pv_entry_spare, 1));
2052         PV_STAT(atomic_subtract_long(&pv_entry_count, 1));
2053         pc = pv_to_chunk(pv);
2054         idx = pv - &pc->pc_pventry[0];
2055         field = idx / 64;
2056         bit = idx % 64;
2057         pc->pc_map[field] |= 1ul << bit;
2058         if (pc->pc_map[0] != PC_FREE0 || pc->pc_map[1] != PC_FREE1 ||
2059             pc->pc_map[2] != PC_FREE2) {
2060                 /* 98% of the time, pc is already at the head of the list. */
2061                 if (__predict_false(pc != TAILQ_FIRST(&pmap->pm_pvchunk))) {
2062                         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2063                         TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
2064                 }
2065                 return;
2066         }
2067         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2068         free_pv_chunk(pc);
2069 }
2070
2071 static void
2072 free_pv_chunk(struct pv_chunk *pc)
2073 {
2074         vm_page_t m;
2075
2076         mtx_lock(&pv_chunks_mutex);
2077         TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
2078         mtx_unlock(&pv_chunks_mutex);
2079         PV_STAT(atomic_subtract_int(&pv_entry_spare, _NPCPV));
2080         PV_STAT(atomic_subtract_int(&pc_chunk_count, 1));
2081         PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
2082         /* entire chunk is free, return it */
2083         m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
2084         dump_drop_page(m->phys_addr);
2085         vm_page_unwire_noq(m);
2086         vm_page_free(m);
2087 }
2088
2089 /*
2090  * Returns a new PV entry, allocating a new PV chunk from the system when
2091  * needed.  If this PV chunk allocation fails and a PV list lock pointer was
2092  * given, a PV chunk is reclaimed from an arbitrary pmap.  Otherwise, NULL is
2093  * returned.
2094  *
2095  * The given PV list lock may be released.
2096  */
2097 static pv_entry_t
2098 get_pv_entry(pmap_t pmap, struct rwlock **lockp)
2099 {
2100         int bit, field;
2101         pv_entry_t pv;
2102         struct pv_chunk *pc;
2103         vm_page_t m;
2104
2105         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2106         PV_STAT(atomic_add_long(&pv_entry_allocs, 1));
2107 retry:
2108         pc = TAILQ_FIRST(&pmap->pm_pvchunk);
2109         if (pc != NULL) {
2110                 for (field = 0; field < _NPCM; field++) {
2111                         if (pc->pc_map[field]) {
2112                                 bit = ffsl(pc->pc_map[field]) - 1;
2113                                 break;
2114                         }
2115                 }
2116                 if (field < _NPCM) {
2117                         pv = &pc->pc_pventry[field * 64 + bit];
2118                         pc->pc_map[field] &= ~(1ul << bit);
2119                         /* If this was the last item, move it to tail */
2120                         if (pc->pc_map[0] == 0 && pc->pc_map[1] == 0 &&
2121                             pc->pc_map[2] == 0) {
2122                                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2123                                 TAILQ_INSERT_TAIL(&pmap->pm_pvchunk, pc,
2124                                     pc_list);
2125                         }
2126                         PV_STAT(atomic_add_long(&pv_entry_count, 1));
2127                         PV_STAT(atomic_subtract_int(&pv_entry_spare, 1));
2128                         return (pv);
2129                 }
2130         }
2131         /* No free items, allocate another chunk */
2132         m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ |
2133             VM_ALLOC_WIRED);
2134         if (m == NULL) {
2135                 if (lockp == NULL) {
2136                         PV_STAT(pc_chunk_tryfail++);
2137                         return (NULL);
2138                 }
2139                 m = reclaim_pv_chunk(pmap, lockp);
2140                 if (m == NULL)
2141                         goto retry;
2142         }
2143         PV_STAT(atomic_add_int(&pc_chunk_count, 1));
2144         PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
2145         dump_add_page(m->phys_addr);
2146         pc = (void *)PHYS_TO_DMAP(m->phys_addr);
2147         pc->pc_pmap = pmap;
2148         pc->pc_map[0] = PC_FREE0 & ~1ul;        /* preallocated bit 0 */
2149         pc->pc_map[1] = PC_FREE1;
2150         pc->pc_map[2] = PC_FREE2;
2151         mtx_lock(&pv_chunks_mutex);
2152         TAILQ_INSERT_TAIL(&pv_chunks, pc, pc_lru);
2153         mtx_unlock(&pv_chunks_mutex);
2154         pv = &pc->pc_pventry[0];
2155         TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
2156         PV_STAT(atomic_add_long(&pv_entry_count, 1));
2157         PV_STAT(atomic_add_int(&pv_entry_spare, _NPCPV - 1));
2158         return (pv);
2159 }
2160
2161 /*
2162  * Ensure that the number of spare PV entries in the specified pmap meets or
2163  * exceeds the given count, "needed".
2164  *
2165  * The given PV list lock may be released.
2166  */
2167 static void
2168 reserve_pv_entries(pmap_t pmap, int needed, struct rwlock **lockp)
2169 {
2170         struct pch new_tail;
2171         struct pv_chunk *pc;
2172         vm_page_t m;
2173         int avail, free;
2174         bool reclaimed;
2175
2176         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2177         KASSERT(lockp != NULL, ("reserve_pv_entries: lockp is NULL"));
2178
2179         /*
2180          * Newly allocated PV chunks must be stored in a private list until
2181          * the required number of PV chunks have been allocated.  Otherwise,
2182          * reclaim_pv_chunk() could recycle one of these chunks.  In
2183          * contrast, these chunks must be added to the pmap upon allocation.
2184          */
2185         TAILQ_INIT(&new_tail);
2186 retry:
2187         avail = 0;
2188         TAILQ_FOREACH(pc, &pmap->pm_pvchunk, pc_list) {
2189                 bit_count((bitstr_t *)pc->pc_map, 0,
2190                     sizeof(pc->pc_map) * NBBY, &free);
2191                 if (free == 0)
2192                         break;
2193                 avail += free;
2194                 if (avail >= needed)
2195                         break;
2196         }
2197         for (reclaimed = false; avail < needed; avail += _NPCPV) {
2198                 m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ |
2199                     VM_ALLOC_WIRED);
2200                 if (m == NULL) {
2201                         m = reclaim_pv_chunk(pmap, lockp);
2202                         if (m == NULL)
2203                                 goto retry;
2204                         reclaimed = true;
2205                 }
2206                 PV_STAT(atomic_add_int(&pc_chunk_count, 1));
2207                 PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
2208                 dump_add_page(m->phys_addr);
2209                 pc = (void *)PHYS_TO_DMAP(m->phys_addr);
2210                 pc->pc_pmap = pmap;
2211                 pc->pc_map[0] = PC_FREE0;
2212                 pc->pc_map[1] = PC_FREE1;
2213                 pc->pc_map[2] = PC_FREE2;
2214                 TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
2215                 TAILQ_INSERT_TAIL(&new_tail, pc, pc_lru);
2216                 PV_STAT(atomic_add_int(&pv_entry_spare, _NPCPV));
2217
2218                 /*
2219                  * The reclaim might have freed a chunk from the current pmap.
2220                  * If that chunk contained available entries, we need to
2221                  * re-count the number of available entries.
2222                  */
2223                 if (reclaimed)
2224                         goto retry;
2225         }
2226         if (!TAILQ_EMPTY(&new_tail)) {
2227                 mtx_lock(&pv_chunks_mutex);
2228                 TAILQ_CONCAT(&pv_chunks, &new_tail, pc_lru);
2229                 mtx_unlock(&pv_chunks_mutex);
2230         }
2231 }
2232
2233 /*
2234  * First find and then remove the pv entry for the specified pmap and virtual
2235  * address from the specified pv list.  Returns the pv entry if found and NULL
2236  * otherwise.  This operation can be performed on pv lists for either 4KB or
2237  * 2MB page mappings.
2238  */
2239 static __inline pv_entry_t
2240 pmap_pvh_remove(struct md_page *pvh, pmap_t pmap, vm_offset_t va)
2241 {
2242         pv_entry_t pv;
2243
2244         TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
2245                 if (pmap == PV_PMAP(pv) && va == pv->pv_va) {
2246                         TAILQ_REMOVE(&pvh->pv_list, pv, pv_next);
2247                         pvh->pv_gen++;
2248                         break;
2249                 }
2250         }
2251         return (pv);
2252 }
2253
2254 /*
2255  * After demotion from a 2MB page mapping to 512 4KB page mappings,
2256  * destroy the pv entry for the 2MB page mapping and reinstantiate the pv
2257  * entries for each of the 4KB page mappings.
2258  */
2259 static void
2260 pmap_pv_demote_l2(pmap_t pmap, vm_offset_t va, vm_paddr_t pa,
2261     struct rwlock **lockp)
2262 {
2263         struct md_page *pvh;
2264         struct pv_chunk *pc;
2265         pv_entry_t pv;
2266         vm_offset_t va_last;
2267         vm_page_t m;
2268         int bit, field;
2269
2270         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2271         KASSERT((pa & L2_OFFSET) == 0,
2272             ("pmap_pv_demote_l2: pa is not 2mpage aligned"));
2273         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa);
2274
2275         /*
2276          * Transfer the 2mpage's pv entry for this mapping to the first
2277          * page's pv list.  Once this transfer begins, the pv list lock
2278          * must not be released until the last pv entry is reinstantiated.
2279          */
2280         pvh = pa_to_pvh(pa);
2281         va = va & ~L2_OFFSET;
2282         pv = pmap_pvh_remove(pvh, pmap, va);
2283         KASSERT(pv != NULL, ("pmap_pv_demote_l2: pv not found"));
2284         m = PHYS_TO_VM_PAGE(pa);
2285         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
2286         m->md.pv_gen++;
2287         /* Instantiate the remaining Ln_ENTRIES - 1 pv entries. */
2288         PV_STAT(atomic_add_long(&pv_entry_allocs, Ln_ENTRIES - 1));
2289         va_last = va + L2_SIZE - PAGE_SIZE;
2290         for (;;) {
2291                 pc = TAILQ_FIRST(&pmap->pm_pvchunk);
2292                 KASSERT(pc->pc_map[0] != 0 || pc->pc_map[1] != 0 ||
2293                     pc->pc_map[2] != 0, ("pmap_pv_demote_l2: missing spare"));
2294                 for (field = 0; field < _NPCM; field++) {
2295                         while (pc->pc_map[field]) {
2296                                 bit = ffsl(pc->pc_map[field]) - 1;
2297                                 pc->pc_map[field] &= ~(1ul << bit);
2298                                 pv = &pc->pc_pventry[field * 64 + bit];
2299                                 va += PAGE_SIZE;
2300                                 pv->pv_va = va;
2301                                 m++;
2302                                 KASSERT((m->oflags & VPO_UNMANAGED) == 0,
2303                             ("pmap_pv_demote_l2: page %p is not managed", m));
2304                                 TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
2305                                 m->md.pv_gen++;
2306                                 if (va == va_last)
2307                                         goto out;
2308                         }
2309                 }
2310                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2311                 TAILQ_INSERT_TAIL(&pmap->pm_pvchunk, pc, pc_list);
2312         }
2313 out:
2314         if (pc->pc_map[0] == 0 && pc->pc_map[1] == 0 && pc->pc_map[2] == 0) {
2315                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2316                 TAILQ_INSERT_TAIL(&pmap->pm_pvchunk, pc, pc_list);
2317         }
2318         PV_STAT(atomic_add_long(&pv_entry_count, Ln_ENTRIES - 1));
2319         PV_STAT(atomic_subtract_int(&pv_entry_spare, Ln_ENTRIES - 1));
2320 }
2321
2322 /*
2323  * First find and then destroy the pv entry for the specified pmap and virtual
2324  * address.  This operation can be performed on pv lists for either 4KB or 2MB
2325  * page mappings.
2326  */
2327 static void
2328 pmap_pvh_free(struct md_page *pvh, pmap_t pmap, vm_offset_t va)
2329 {
2330         pv_entry_t pv;
2331
2332         pv = pmap_pvh_remove(pvh, pmap, va);
2333         KASSERT(pv != NULL, ("pmap_pvh_free: pv not found"));
2334         free_pv_entry(pmap, pv);
2335 }
2336
2337 /*
2338  * Conditionally create the PV entry for a 4KB page mapping if the required
2339  * memory can be allocated without resorting to reclamation.
2340  */
2341 static boolean_t
2342 pmap_try_insert_pv_entry(pmap_t pmap, vm_offset_t va, vm_page_t m,
2343     struct rwlock **lockp)
2344 {
2345         pv_entry_t pv;
2346
2347         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2348         /* Pass NULL instead of the lock pointer to disable reclamation. */
2349         if ((pv = get_pv_entry(pmap, NULL)) != NULL) {
2350                 pv->pv_va = va;
2351                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m);
2352                 TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
2353                 m->md.pv_gen++;
2354                 return (TRUE);
2355         } else
2356                 return (FALSE);
2357 }
2358
2359 /*
2360  * Create the PV entry for a 2MB page mapping.  Always returns true unless the
2361  * flag PMAP_ENTER_NORECLAIM is specified.  If that flag is specified, returns
2362  * false if the PV entry cannot be allocated without resorting to reclamation.
2363  */
2364 static bool
2365 pmap_pv_insert_l2(pmap_t pmap, vm_offset_t va, pd_entry_t l2e, u_int flags,
2366     struct rwlock **lockp)
2367 {
2368         struct md_page *pvh;
2369         pv_entry_t pv;
2370         vm_paddr_t pa;
2371
2372         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2373         /* Pass NULL instead of the lock pointer to disable reclamation. */
2374         if ((pv = get_pv_entry(pmap, (flags & PMAP_ENTER_NORECLAIM) != 0 ?
2375             NULL : lockp)) == NULL)
2376                 return (false);
2377         pv->pv_va = va;
2378         pa = l2e & ~ATTR_MASK;
2379         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa);
2380         pvh = pa_to_pvh(pa);
2381         TAILQ_INSERT_TAIL(&pvh->pv_list, pv, pv_next);
2382         pvh->pv_gen++;
2383         return (true);
2384 }
2385
2386 /*
2387  * pmap_remove_l2: do the things to unmap a level 2 superpage in a process
2388  */
2389 static int
2390 pmap_remove_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t sva,
2391     pd_entry_t l1e, struct spglist *free, struct rwlock **lockp)
2392 {
2393         struct md_page *pvh;
2394         pt_entry_t old_l2;
2395         vm_offset_t eva, va;
2396         vm_page_t m, ml3;
2397
2398         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2399         KASSERT((sva & L2_OFFSET) == 0, ("pmap_remove_l2: sva is not aligned"));
2400         old_l2 = pmap_load_clear(l2);
2401         KASSERT((old_l2 & ATTR_DESCR_MASK) == L2_BLOCK,
2402             ("pmap_remove_l2: L2e %lx is not a block mapping", old_l2));
2403         pmap_invalidate_range(pmap, sva, sva + L2_SIZE);
2404         if (old_l2 & ATTR_SW_WIRED)
2405                 pmap->pm_stats.wired_count -= L2_SIZE / PAGE_SIZE;
2406         pmap_resident_count_dec(pmap, L2_SIZE / PAGE_SIZE);
2407         if (old_l2 & ATTR_SW_MANAGED) {
2408                 CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, old_l2 & ~ATTR_MASK);
2409                 pvh = pa_to_pvh(old_l2 & ~ATTR_MASK);
2410                 pmap_pvh_free(pvh, pmap, sva);
2411                 eva = sva + L2_SIZE;
2412                 for (va = sva, m = PHYS_TO_VM_PAGE(old_l2 & ~ATTR_MASK);
2413                     va < eva; va += PAGE_SIZE, m++) {
2414                         if (pmap_page_dirty(old_l2))
2415                                 vm_page_dirty(m);
2416                         if (old_l2 & ATTR_AF)
2417                                 vm_page_aflag_set(m, PGA_REFERENCED);
2418                         if (TAILQ_EMPTY(&m->md.pv_list) &&
2419                             TAILQ_EMPTY(&pvh->pv_list))
2420                                 vm_page_aflag_clear(m, PGA_WRITEABLE);
2421                 }
2422         }
2423         KASSERT(pmap != kernel_pmap,
2424             ("Attempting to remove an l2 kernel page"));
2425         ml3 = pmap_remove_pt_page(pmap, sva);
2426         if (ml3 != NULL) {
2427                 pmap_resident_count_dec(pmap, 1);
2428                 KASSERT(ml3->wire_count == NL3PG,
2429                     ("pmap_remove_l2: l3 page wire count error"));
2430                 ml3->wire_count = 1;
2431                 vm_page_unwire_noq(ml3);
2432                 pmap_add_delayed_free_list(ml3, free, FALSE);
2433         }
2434         return (pmap_unuse_pt(pmap, sva, l1e, free));
2435 }
2436
2437 /*
2438  * pmap_remove_l3: do the things to unmap a page in a process
2439  */
2440 static int
2441 pmap_remove_l3(pmap_t pmap, pt_entry_t *l3, vm_offset_t va,
2442     pd_entry_t l2e, struct spglist *free, struct rwlock **lockp)
2443 {
2444         struct md_page *pvh;
2445         pt_entry_t old_l3;
2446         vm_page_t m;
2447
2448         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2449         old_l3 = pmap_load_clear(l3);
2450         pmap_invalidate_page(pmap, va);
2451         if (old_l3 & ATTR_SW_WIRED)
2452                 pmap->pm_stats.wired_count -= 1;
2453         pmap_resident_count_dec(pmap, 1);
2454         if (old_l3 & ATTR_SW_MANAGED) {
2455                 m = PHYS_TO_VM_PAGE(old_l3 & ~ATTR_MASK);
2456                 if (pmap_page_dirty(old_l3))
2457                         vm_page_dirty(m);
2458                 if (old_l3 & ATTR_AF)
2459                         vm_page_aflag_set(m, PGA_REFERENCED);
2460                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m);
2461                 pmap_pvh_free(&m->md, pmap, va);
2462                 if (TAILQ_EMPTY(&m->md.pv_list) &&
2463                     (m->flags & PG_FICTITIOUS) == 0) {
2464                         pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
2465                         if (TAILQ_EMPTY(&pvh->pv_list))
2466                                 vm_page_aflag_clear(m, PGA_WRITEABLE);
2467                 }
2468         }
2469         return (pmap_unuse_pt(pmap, va, l2e, free));
2470 }
2471
2472 /*
2473  *      Remove the given range of addresses from the specified map.
2474  *
2475  *      It is assumed that the start and end are properly
2476  *      rounded to the page size.
2477  */
2478 void
2479 pmap_remove(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
2480 {
2481         struct rwlock *lock;
2482         vm_offset_t va, va_next;
2483         pd_entry_t *l0, *l1, *l2;
2484         pt_entry_t l3_paddr, *l3;
2485         struct spglist free;
2486
2487         /*
2488          * Perform an unsynchronized read.  This is, however, safe.
2489          */
2490         if (pmap->pm_stats.resident_count == 0)
2491                 return;
2492
2493         SLIST_INIT(&free);
2494
2495         PMAP_LOCK(pmap);
2496
2497         lock = NULL;
2498         for (; sva < eva; sva = va_next) {
2499
2500                 if (pmap->pm_stats.resident_count == 0)
2501                         break;
2502
2503                 l0 = pmap_l0(pmap, sva);
2504                 if (pmap_load(l0) == 0) {
2505                         va_next = (sva + L0_SIZE) & ~L0_OFFSET;
2506                         if (va_next < sva)
2507                                 va_next = eva;
2508                         continue;
2509                 }
2510
2511                 l1 = pmap_l0_to_l1(l0, sva);
2512                 if (pmap_load(l1) == 0) {
2513                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
2514                         if (va_next < sva)
2515                                 va_next = eva;
2516                         continue;
2517                 }
2518
2519                 /*
2520                  * Calculate index for next page table.
2521                  */
2522                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
2523                 if (va_next < sva)
2524                         va_next = eva;
2525
2526                 l2 = pmap_l1_to_l2(l1, sva);
2527                 if (l2 == NULL)
2528                         continue;
2529
2530                 l3_paddr = pmap_load(l2);
2531
2532                 if ((l3_paddr & ATTR_DESCR_MASK) == L2_BLOCK) {
2533                         if (sva + L2_SIZE == va_next && eva >= va_next) {
2534                                 pmap_remove_l2(pmap, l2, sva, pmap_load(l1),
2535                                     &free, &lock);
2536                                 continue;
2537                         } else if (pmap_demote_l2_locked(pmap, l2,
2538                             sva &~L2_OFFSET, &lock) == NULL)
2539                                 continue;
2540                         l3_paddr = pmap_load(l2);
2541                 }
2542
2543                 /*
2544                  * Weed out invalid mappings.
2545                  */
2546                 if ((l3_paddr & ATTR_DESCR_MASK) != L2_TABLE)
2547                         continue;
2548
2549                 /*
2550                  * Limit our scan to either the end of the va represented
2551                  * by the current page table page, or to the end of the
2552                  * range being removed.
2553                  */
2554                 if (va_next > eva)
2555                         va_next = eva;
2556
2557                 va = va_next;
2558                 for (l3 = pmap_l2_to_l3(l2, sva); sva != va_next; l3++,
2559                     sva += L3_SIZE) {
2560                         if (l3 == NULL)
2561                                 panic("l3 == NULL");
2562                         if (pmap_load(l3) == 0) {
2563                                 if (va != va_next) {
2564                                         pmap_invalidate_range(pmap, va, sva);
2565                                         va = va_next;
2566                                 }
2567                                 continue;
2568                         }
2569                         if (va == va_next)
2570                                 va = sva;
2571                         if (pmap_remove_l3(pmap, l3, sva, l3_paddr, &free,
2572                             &lock)) {
2573                                 sva += L3_SIZE;
2574                                 break;
2575                         }
2576                 }
2577                 if (va != va_next)
2578                         pmap_invalidate_range(pmap, va, sva);
2579         }
2580         if (lock != NULL)
2581                 rw_wunlock(lock);
2582         PMAP_UNLOCK(pmap);
2583         vm_page_free_pages_toq(&free, false);
2584 }
2585
2586 /*
2587  *      Routine:        pmap_remove_all
2588  *      Function:
2589  *              Removes this physical page from
2590  *              all physical maps in which it resides.
2591  *              Reflects back modify bits to the pager.
2592  *
2593  *      Notes:
2594  *              Original versions of this routine were very
2595  *              inefficient because they iteratively called
2596  *              pmap_remove (slow...)
2597  */
2598
2599 void
2600 pmap_remove_all(vm_page_t m)
2601 {
2602         struct md_page *pvh;
2603         pv_entry_t pv;
2604         pmap_t pmap;
2605         struct rwlock *lock;
2606         pd_entry_t *pde, tpde;
2607         pt_entry_t *pte, tpte;
2608         vm_offset_t va;
2609         struct spglist free;
2610         int lvl, pvh_gen, md_gen;
2611
2612         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
2613             ("pmap_remove_all: page %p is not managed", m));
2614         SLIST_INIT(&free);
2615         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
2616         pvh = (m->flags & PG_FICTITIOUS) != 0 ? &pv_dummy :
2617             pa_to_pvh(VM_PAGE_TO_PHYS(m));
2618 retry:
2619         rw_wlock(lock);
2620         while ((pv = TAILQ_FIRST(&pvh->pv_list)) != NULL) {
2621                 pmap = PV_PMAP(pv);
2622                 if (!PMAP_TRYLOCK(pmap)) {
2623                         pvh_gen = pvh->pv_gen;
2624                         rw_wunlock(lock);
2625                         PMAP_LOCK(pmap);
2626                         rw_wlock(lock);
2627                         if (pvh_gen != pvh->pv_gen) {
2628                                 rw_wunlock(lock);
2629                                 PMAP_UNLOCK(pmap);
2630                                 goto retry;
2631                         }
2632                 }
2633                 va = pv->pv_va;
2634                 pte = pmap_pte(pmap, va, &lvl);
2635                 KASSERT(pte != NULL,
2636                     ("pmap_remove_all: no page table entry found"));
2637                 KASSERT(lvl == 2,
2638                     ("pmap_remove_all: invalid pte level %d", lvl));
2639
2640                 pmap_demote_l2_locked(pmap, pte, va, &lock);
2641                 PMAP_UNLOCK(pmap);
2642         }
2643         while ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
2644                 pmap = PV_PMAP(pv);
2645                 if (!PMAP_TRYLOCK(pmap)) {
2646                         pvh_gen = pvh->pv_gen;
2647                         md_gen = m->md.pv_gen;
2648                         rw_wunlock(lock);
2649                         PMAP_LOCK(pmap);
2650                         rw_wlock(lock);
2651                         if (pvh_gen != pvh->pv_gen || md_gen != m->md.pv_gen) {
2652                                 rw_wunlock(lock);
2653                                 PMAP_UNLOCK(pmap);
2654                                 goto retry;
2655                         }
2656                 }
2657                 pmap_resident_count_dec(pmap, 1);
2658
2659                 pde = pmap_pde(pmap, pv->pv_va, &lvl);
2660                 KASSERT(pde != NULL,
2661                     ("pmap_remove_all: no page directory entry found"));
2662                 KASSERT(lvl == 2,
2663                     ("pmap_remove_all: invalid pde level %d", lvl));
2664                 tpde = pmap_load(pde);
2665
2666                 pte = pmap_l2_to_l3(pde, pv->pv_va);
2667                 tpte = pmap_load(pte);
2668                 pmap_load_clear(pte);
2669                 pmap_invalidate_page(pmap, pv->pv_va);
2670                 if (tpte & ATTR_SW_WIRED)
2671                         pmap->pm_stats.wired_count--;
2672                 if ((tpte & ATTR_AF) != 0)
2673                         vm_page_aflag_set(m, PGA_REFERENCED);
2674
2675                 /*
2676                  * Update the vm_page_t clean and reference bits.
2677                  */
2678                 if (pmap_page_dirty(tpte))
2679                         vm_page_dirty(m);
2680                 pmap_unuse_pt(pmap, pv->pv_va, tpde, &free);
2681                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
2682                 m->md.pv_gen++;
2683                 free_pv_entry(pmap, pv);
2684                 PMAP_UNLOCK(pmap);
2685         }
2686         vm_page_aflag_clear(m, PGA_WRITEABLE);
2687         rw_wunlock(lock);
2688         vm_page_free_pages_toq(&free, false);
2689 }
2690
2691 /*
2692  *      Set the physical protection on the
2693  *      specified range of this map as requested.
2694  */
2695 void
2696 pmap_protect(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, vm_prot_t prot)
2697 {
2698         vm_offset_t va, va_next;
2699         pd_entry_t *l0, *l1, *l2;
2700         pt_entry_t *l3p, l3, nbits;
2701
2702         KASSERT((prot & ~VM_PROT_ALL) == 0, ("invalid prot %x", prot));
2703         if (prot == VM_PROT_NONE) {
2704                 pmap_remove(pmap, sva, eva);
2705                 return;
2706         }
2707
2708         if ((prot & (VM_PROT_WRITE | VM_PROT_EXECUTE)) ==
2709             (VM_PROT_WRITE | VM_PROT_EXECUTE))
2710                 return;
2711
2712         PMAP_LOCK(pmap);
2713         for (; sva < eva; sva = va_next) {
2714
2715                 l0 = pmap_l0(pmap, sva);
2716                 if (pmap_load(l0) == 0) {
2717                         va_next = (sva + L0_SIZE) & ~L0_OFFSET;
2718                         if (va_next < sva)
2719                                 va_next = eva;
2720                         continue;
2721                 }
2722
2723                 l1 = pmap_l0_to_l1(l0, sva);
2724                 if (pmap_load(l1) == 0) {
2725                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
2726                         if (va_next < sva)
2727                                 va_next = eva;
2728                         continue;
2729                 }
2730
2731                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
2732                 if (va_next < sva)
2733                         va_next = eva;
2734
2735                 l2 = pmap_l1_to_l2(l1, sva);
2736                 if (pmap_load(l2) == 0)
2737                         continue;
2738
2739                 if ((pmap_load(l2) & ATTR_DESCR_MASK) == L2_BLOCK) {
2740                         l3p = pmap_demote_l2(pmap, l2, sva);
2741                         if (l3p == NULL)
2742                                 continue;
2743                 }
2744                 KASSERT((pmap_load(l2) & ATTR_DESCR_MASK) == L2_TABLE,
2745                     ("pmap_protect: Invalid L2 entry after demotion"));
2746
2747                 if (va_next > eva)
2748                         va_next = eva;
2749
2750                 va = va_next;
2751                 for (l3p = pmap_l2_to_l3(l2, sva); sva != va_next; l3p++,
2752                     sva += L3_SIZE) {
2753                         l3 = pmap_load(l3p);
2754                         if (!pmap_l3_valid(l3))
2755                                 continue;
2756
2757                         nbits = 0;
2758                         if ((prot & VM_PROT_WRITE) == 0) {
2759                                 if ((l3 & ATTR_SW_MANAGED) &&
2760                                     pmap_page_dirty(l3)) {
2761                                         vm_page_dirty(PHYS_TO_VM_PAGE(l3 &
2762                                             ~ATTR_MASK));
2763                                 }
2764                                 nbits |= ATTR_AP(ATTR_AP_RO);
2765                         }
2766                         if ((prot & VM_PROT_EXECUTE) == 0)
2767                                 nbits |= ATTR_XN;
2768
2769                         pmap_set(l3p, nbits);
2770                         /* XXX: Use pmap_invalidate_range */
2771                         pmap_invalidate_page(pmap, sva);
2772                 }
2773         }
2774         PMAP_UNLOCK(pmap);
2775 }
2776
2777 /*
2778  * Inserts the specified page table page into the specified pmap's collection
2779  * of idle page table pages.  Each of a pmap's page table pages is responsible
2780  * for mapping a distinct range of virtual addresses.  The pmap's collection is
2781  * ordered by this virtual address range.
2782  */
2783 static __inline int
2784 pmap_insert_pt_page(pmap_t pmap, vm_page_t mpte)
2785 {
2786
2787         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2788         return (vm_radix_insert(&pmap->pm_root, mpte));
2789 }
2790
2791 /*
2792  * Removes the page table page mapping the specified virtual address from the
2793  * specified pmap's collection of idle page table pages, and returns it.
2794  * Otherwise, returns NULL if there is no page table page corresponding to the
2795  * specified virtual address.
2796  */
2797 static __inline vm_page_t
2798 pmap_remove_pt_page(pmap_t pmap, vm_offset_t va)
2799 {
2800
2801         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2802         return (vm_radix_remove(&pmap->pm_root, pmap_l2_pindex(va)));
2803 }
2804
2805 /*
2806  * Performs a break-before-make update of a pmap entry. This is needed when
2807  * either promoting or demoting pages to ensure the TLB doesn't get into an
2808  * inconsistent state.
2809  */
2810 static void
2811 pmap_update_entry(pmap_t pmap, pd_entry_t *pte, pd_entry_t newpte,
2812     vm_offset_t va, vm_size_t size)
2813 {
2814         register_t intr;
2815
2816         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2817
2818         /*
2819          * Ensure we don't get switched out with the page table in an
2820          * inconsistent state. We also need to ensure no interrupts fire
2821          * as they may make use of an address we are about to invalidate.
2822          */
2823         intr = intr_disable();
2824         critical_enter();
2825
2826         /* Clear the old mapping */
2827         pmap_load_clear(pte);
2828         pmap_invalidate_range_nopin(pmap, va, va + size);
2829
2830         /* Create the new mapping */
2831         pmap_load_store(pte, newpte);
2832
2833         critical_exit();
2834         intr_restore(intr);
2835 }
2836
2837 #if VM_NRESERVLEVEL > 0
2838 /*
2839  * After promotion from 512 4KB page mappings to a single 2MB page mapping,
2840  * replace the many pv entries for the 4KB page mappings by a single pv entry
2841  * for the 2MB page mapping.
2842  */
2843 static void
2844 pmap_pv_promote_l2(pmap_t pmap, vm_offset_t va, vm_paddr_t pa,
2845     struct rwlock **lockp)
2846 {
2847         struct md_page *pvh;
2848         pv_entry_t pv;
2849         vm_offset_t va_last;
2850         vm_page_t m;
2851
2852         KASSERT((pa & L2_OFFSET) == 0,
2853             ("pmap_pv_promote_l2: pa is not 2mpage aligned"));
2854         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa);
2855
2856         /*
2857          * Transfer the first page's pv entry for this mapping to the 2mpage's
2858          * pv list.  Aside from avoiding the cost of a call to get_pv_entry(),
2859          * a transfer avoids the possibility that get_pv_entry() calls
2860          * reclaim_pv_chunk() and that reclaim_pv_chunk() removes one of the
2861          * mappings that is being promoted.
2862          */
2863         m = PHYS_TO_VM_PAGE(pa);
2864         va = va & ~L2_OFFSET;
2865         pv = pmap_pvh_remove(&m->md, pmap, va);
2866         KASSERT(pv != NULL, ("pmap_pv_promote_l2: pv not found"));
2867         pvh = pa_to_pvh(pa);
2868         TAILQ_INSERT_TAIL(&pvh->pv_list, pv, pv_next);
2869         pvh->pv_gen++;
2870         /* Free the remaining NPTEPG - 1 pv entries. */
2871         va_last = va + L2_SIZE - PAGE_SIZE;
2872         do {
2873                 m++;
2874                 va += PAGE_SIZE;
2875                 pmap_pvh_free(&m->md, pmap, va);
2876         } while (va < va_last);
2877 }
2878
2879 /*
2880  * Tries to promote the 512, contiguous 4KB page mappings that are within a
2881  * single level 2 table entry to a single 2MB page mapping.  For promotion
2882  * to occur, two conditions must be met: (1) the 4KB page mappings must map
2883  * aligned, contiguous physical memory and (2) the 4KB page mappings must have
2884  * identical characteristics.
2885  */
2886 static void
2887 pmap_promote_l2(pmap_t pmap, pd_entry_t *l2, vm_offset_t va,
2888     struct rwlock **lockp)
2889 {
2890         pt_entry_t *firstl3, *l3, newl2, oldl3, pa;
2891         vm_page_t mpte;
2892         vm_offset_t sva;
2893
2894         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2895
2896         sva = va & ~L2_OFFSET;
2897         firstl3 = pmap_l2_to_l3(l2, sva);
2898         newl2 = pmap_load(firstl3);
2899
2900         /* Check the alingment is valid */
2901         if (((newl2 & ~ATTR_MASK) & L2_OFFSET) != 0) {
2902                 atomic_add_long(&pmap_l2_p_failures, 1);
2903                 CTR2(KTR_PMAP, "pmap_promote_l2: failure for va %#lx"
2904                     " in pmap %p", va, pmap);
2905                 return;
2906         }
2907
2908         pa = newl2 + L2_SIZE - PAGE_SIZE;
2909         for (l3 = firstl3 + NL3PG - 1; l3 > firstl3; l3--) {
2910                 oldl3 = pmap_load(l3);
2911                 if (oldl3 != pa) {
2912                         atomic_add_long(&pmap_l2_p_failures, 1);
2913                         CTR2(KTR_PMAP, "pmap_promote_l2: failure for va %#lx"
2914                             " in pmap %p", va, pmap);
2915                         return;
2916                 }
2917                 pa -= PAGE_SIZE;
2918         }
2919
2920         /*
2921          * Save the page table page in its current state until the L2
2922          * mapping the superpage is demoted by pmap_demote_l2() or
2923          * destroyed by pmap_remove_l3().
2924          */
2925         mpte = PHYS_TO_VM_PAGE(pmap_load(l2) & ~ATTR_MASK);
2926         KASSERT(mpte >= vm_page_array &&
2927             mpte < &vm_page_array[vm_page_array_size],
2928             ("pmap_promote_l2: page table page is out of range"));
2929         KASSERT(mpte->pindex == pmap_l2_pindex(va),
2930             ("pmap_promote_l2: page table page's pindex is wrong"));
2931         if (pmap_insert_pt_page(pmap, mpte)) {
2932                 atomic_add_long(&pmap_l2_p_failures, 1);
2933                 CTR2(KTR_PMAP,
2934                     "pmap_promote_l2: failure for va %#lx in pmap %p", va,
2935                     pmap);
2936                 return;
2937         }
2938
2939         if ((newl2 & ATTR_SW_MANAGED) != 0)
2940                 pmap_pv_promote_l2(pmap, va, newl2 & ~ATTR_MASK, lockp);
2941
2942         newl2 &= ~ATTR_DESCR_MASK;
2943         newl2 |= L2_BLOCK;
2944
2945         pmap_update_entry(pmap, l2, newl2, sva, L2_SIZE);
2946
2947         atomic_add_long(&pmap_l2_promotions, 1);
2948         CTR2(KTR_PMAP, "pmap_promote_l2: success for va %#lx in pmap %p", va,
2949                     pmap);
2950 }
2951 #endif /* VM_NRESERVLEVEL > 0 */
2952
2953 /*
2954  *      Insert the given physical page (p) at
2955  *      the specified virtual address (v) in the
2956  *      target physical map with the protection requested.
2957  *
2958  *      If specified, the page will be wired down, meaning
2959  *      that the related pte can not be reclaimed.
2960  *
2961  *      NB:  This is the only routine which MAY NOT lazy-evaluate
2962  *      or lose information.  That is, this routine must actually
2963  *      insert this page into the given map NOW.
2964  */
2965 int
2966 pmap_enter(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
2967     u_int flags, int8_t psind)
2968 {
2969         struct rwlock *lock;
2970         pd_entry_t *pde;
2971         pt_entry_t new_l3, orig_l3;
2972         pt_entry_t *l2, *l3;
2973         pv_entry_t pv;
2974         vm_paddr_t opa, pa, l1_pa, l2_pa, l3_pa;
2975         vm_page_t mpte, om, l1_m, l2_m, l3_m;
2976         boolean_t nosleep;
2977         int lvl, rv;
2978
2979         va = trunc_page(va);
2980         if ((m->oflags & VPO_UNMANAGED) == 0 && !vm_page_xbusied(m))
2981                 VM_OBJECT_ASSERT_LOCKED(m->object);
2982         pa = VM_PAGE_TO_PHYS(m);
2983         new_l3 = (pt_entry_t)(pa | ATTR_DEFAULT | ATTR_IDX(m->md.pv_memattr) |
2984             L3_PAGE);
2985         if ((prot & VM_PROT_WRITE) == 0)
2986                 new_l3 |= ATTR_AP(ATTR_AP_RO);
2987         if ((prot & VM_PROT_EXECUTE) == 0 || m->md.pv_memattr == DEVICE_MEMORY)
2988                 new_l3 |= ATTR_XN;
2989         if ((flags & PMAP_ENTER_WIRED) != 0)
2990                 new_l3 |= ATTR_SW_WIRED;
2991         if (va < VM_MAXUSER_ADDRESS)
2992                 new_l3 |= ATTR_AP(ATTR_AP_USER) | ATTR_PXN;
2993         if ((m->oflags & VPO_UNMANAGED) == 0)
2994                 new_l3 |= ATTR_SW_MANAGED;
2995
2996         CTR2(KTR_PMAP, "pmap_enter: %.16lx -> %.16lx", va, pa);
2997
2998         lock = NULL;
2999         mpte = NULL;
3000         PMAP_LOCK(pmap);
3001         if (psind == 1) {
3002                 /* Assert the required virtual and physical alignment. */
3003                 KASSERT((va & L2_OFFSET) == 0, ("pmap_enter: va unaligned"));
3004                 KASSERT(m->psind > 0, ("pmap_enter: m->psind < psind"));
3005                 rv = pmap_enter_l2(pmap, va, (new_l3 & ~L3_PAGE) | L2_BLOCK,
3006                     flags, m, &lock);
3007                 goto out;
3008         }
3009
3010         pde = pmap_pde(pmap, va, &lvl);
3011         if (pde != NULL && lvl == 1) {
3012                 l2 = pmap_l1_to_l2(pde, va);
3013                 if ((pmap_load(l2) & ATTR_DESCR_MASK) == L2_BLOCK &&
3014                     (l3 = pmap_demote_l2_locked(pmap, l2, va & ~L2_OFFSET,
3015                     &lock)) != NULL) {
3016                         l3 = &l3[pmap_l3_index(va)];
3017                         if (va < VM_MAXUSER_ADDRESS) {
3018                                 mpte = PHYS_TO_VM_PAGE(
3019                                     pmap_load(l2) & ~ATTR_MASK);
3020                                 mpte->wire_count++;
3021                         }
3022                         goto havel3;
3023                 }
3024         }
3025
3026         if (va < VM_MAXUSER_ADDRESS) {
3027                 nosleep = (flags & PMAP_ENTER_NOSLEEP) != 0;
3028                 mpte = pmap_alloc_l3(pmap, va, nosleep ? NULL : &lock);
3029                 if (mpte == NULL && nosleep) {
3030                         CTR0(KTR_PMAP, "pmap_enter: mpte == NULL");
3031                         if (lock != NULL)
3032                                 rw_wunlock(lock);
3033                         PMAP_UNLOCK(pmap);
3034                         return (KERN_RESOURCE_SHORTAGE);
3035                 }
3036                 pde = pmap_pde(pmap, va, &lvl);
3037                 KASSERT(pde != NULL,
3038                     ("pmap_enter: Invalid page entry, va: 0x%lx", va));
3039                 KASSERT(lvl == 2,
3040                     ("pmap_enter: Invalid level %d", lvl));
3041         } else {
3042                 /*
3043                  * If we get a level 2 pde it must point to a level 3 entry
3044                  * otherwise we will need to create the intermediate tables
3045                  */
3046                 if (lvl < 2) {
3047                         switch (lvl) {
3048                         default:
3049                         case -1:
3050                                 /* Get the l0 pde to update */
3051                                 pde = pmap_l0(pmap, va);
3052                                 KASSERT(pde != NULL, ("..."));
3053
3054                                 l1_m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
3055                                     VM_ALLOC_NOOBJ | VM_ALLOC_WIRED |
3056                                     VM_ALLOC_ZERO);
3057                                 if (l1_m == NULL)
3058                                         panic("pmap_enter: l1 pte_m == NULL");
3059                                 if ((l1_m->flags & PG_ZERO) == 0)
3060                                         pmap_zero_page(l1_m);
3061
3062                                 l1_pa = VM_PAGE_TO_PHYS(l1_m);
3063                                 pmap_load_store(pde, l1_pa | L0_TABLE);
3064                                 /* FALLTHROUGH */
3065                         case 0:
3066                                 /* Get the l1 pde to update */
3067                                 pde = pmap_l1_to_l2(pde, va);
3068                                 KASSERT(pde != NULL, ("..."));
3069
3070                                 l2_m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
3071                                     VM_ALLOC_NOOBJ | VM_ALLOC_WIRED |
3072                                     VM_ALLOC_ZERO);
3073                                 if (l2_m == NULL)
3074                                         panic("pmap_enter: l2 pte_m == NULL");
3075                                 if ((l2_m->flags & PG_ZERO) == 0)
3076                                         pmap_zero_page(l2_m);
3077
3078                                 l2_pa = VM_PAGE_TO_PHYS(l2_m);
3079                                 pmap_load_store(pde, l2_pa | L1_TABLE);
3080                                 /* FALLTHROUGH */
3081                         case 1:
3082                                 /* Get the l2 pde to update */
3083                                 pde = pmap_l1_to_l2(pde, va);
3084                                 KASSERT(pde != NULL, ("..."));
3085
3086                                 l3_m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
3087                                     VM_ALLOC_NOOBJ | VM_ALLOC_WIRED |
3088                                     VM_ALLOC_ZERO);
3089                                 if (l3_m == NULL)
3090                                         panic("pmap_enter: l3 pte_m == NULL");
3091                                 if ((l3_m->flags & PG_ZERO) == 0)
3092                                         pmap_zero_page(l3_m);
3093
3094                                 l3_pa = VM_PAGE_TO_PHYS(l3_m);
3095                                 pmap_load_store(pde, l3_pa | L2_TABLE);
3096                                 break;
3097                         }
3098                 }
3099         }
3100         l3 = pmap_l2_to_l3(pde, va);
3101
3102 havel3:
3103         orig_l3 = pmap_load(l3);
3104         opa = orig_l3 & ~ATTR_MASK;
3105         pv = NULL;
3106
3107         /*
3108          * Is the specified virtual address already mapped?
3109          */
3110         if (pmap_l3_valid(orig_l3)) {
3111                 /*
3112                  * Wiring change, just update stats. We don't worry about
3113                  * wiring PT pages as they remain resident as long as there
3114                  * are valid mappings in them. Hence, if a user page is wired,
3115                  * the PT page will be also.
3116                  */
3117                 if ((flags & PMAP_ENTER_WIRED) != 0 &&
3118                     (orig_l3 & ATTR_SW_WIRED) == 0)
3119                         pmap->pm_stats.wired_count++;
3120                 else if ((flags & PMAP_ENTER_WIRED) == 0 &&
3121                     (orig_l3 & ATTR_SW_WIRED) != 0)
3122                         pmap->pm_stats.wired_count--;
3123
3124                 /*
3125                  * Remove the extra PT page reference.
3126                  */
3127                 if (mpte != NULL) {
3128                         mpte->wire_count--;
3129                         KASSERT(mpte->wire_count > 0,
3130                             ("pmap_enter: missing reference to page table page,"
3131                              " va: 0x%lx", va));
3132                 }
3133
3134                 /*
3135                  * Has the physical page changed?
3136                  */
3137                 if (opa == pa) {
3138                         /*
3139                          * No, might be a protection or wiring change.
3140                          */
3141                         if ((orig_l3 & ATTR_SW_MANAGED) != 0) {
3142                                 if ((new_l3 & ATTR_AP(ATTR_AP_RW)) ==
3143                                     ATTR_AP(ATTR_AP_RW)) {
3144                                         vm_page_aflag_set(m, PGA_WRITEABLE);
3145                                 }
3146                         }
3147                         goto validate;
3148                 }
3149
3150                 /*
3151                  * The physical page has changed.
3152                  */
3153                 (void)pmap_load_clear(l3);
3154                 KASSERT((orig_l3 & ~ATTR_MASK) == opa,
3155                     ("pmap_enter: unexpected pa update for %#lx", va));
3156                 if ((orig_l3 & ATTR_SW_MANAGED) != 0) {
3157                         om = PHYS_TO_VM_PAGE(opa);
3158
3159                         /*
3160                          * The pmap lock is sufficient to synchronize with
3161                          * concurrent calls to pmap_page_test_mappings() and
3162                          * pmap_ts_referenced().
3163                          */
3164                         if (pmap_page_dirty(orig_l3))
3165                                 vm_page_dirty(om);
3166                         if ((orig_l3 & ATTR_AF) != 0)
3167                                 vm_page_aflag_set(om, PGA_REFERENCED);
3168                         CHANGE_PV_LIST_LOCK_TO_PHYS(&lock, opa);
3169                         pv = pmap_pvh_remove(&om->md, pmap, va);
3170                         if ((m->oflags & VPO_UNMANAGED) != 0)
3171                                 free_pv_entry(pmap, pv);
3172                         if ((om->aflags & PGA_WRITEABLE) != 0 &&
3173                             TAILQ_EMPTY(&om->md.pv_list) &&
3174                             ((om->flags & PG_FICTITIOUS) != 0 ||
3175                             TAILQ_EMPTY(&pa_to_pvh(opa)->pv_list)))
3176                                 vm_page_aflag_clear(om, PGA_WRITEABLE);
3177                 }
3178                 pmap_invalidate_page(pmap, va);
3179                 orig_l3 = 0;
3180         } else {
3181                 /*
3182                  * Increment the counters.
3183                  */
3184                 if ((new_l3 & ATTR_SW_WIRED) != 0)
3185                         pmap->pm_stats.wired_count++;
3186                 pmap_resident_count_inc(pmap, 1);
3187         }
3188         /*
3189          * Enter on the PV list if part of our managed memory.
3190          */
3191         if ((m->oflags & VPO_UNMANAGED) == 0) {
3192                 if (pv == NULL) {
3193                         pv = get_pv_entry(pmap, &lock);
3194                         pv->pv_va = va;
3195                 }
3196                 CHANGE_PV_LIST_LOCK_TO_PHYS(&lock, pa);
3197                 TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
3198                 m->md.pv_gen++;
3199                 if ((new_l3 & ATTR_AP_RW_BIT) == ATTR_AP(ATTR_AP_RW))
3200                         vm_page_aflag_set(m, PGA_WRITEABLE);
3201         }
3202
3203 validate:
3204         /*
3205          * Sync icache if exec permission and attribute VM_MEMATTR_WRITE_BACK
3206          * is set. Do it now, before the mapping is stored and made
3207          * valid for hardware table walk. If done later, then other can
3208          * access this page before caches are properly synced.
3209          * Don't do it for kernel memory which is mapped with exec
3210          * permission even if the memory isn't going to hold executable
3211          * code. The only time when icache sync is needed is after
3212          * kernel module is loaded and the relocation info is processed.
3213          * And it's done in elf_cpu_load_file().
3214         */
3215         if ((prot & VM_PROT_EXECUTE) &&  pmap != kernel_pmap &&
3216             m->md.pv_memattr == VM_MEMATTR_WRITE_BACK &&
3217             (opa != pa || (orig_l3 & ATTR_XN)))
3218                 cpu_icache_sync_range(PHYS_TO_DMAP(pa), PAGE_SIZE);
3219
3220         /*
3221          * Update the L3 entry
3222          */
3223         if (pmap_l3_valid(orig_l3)) {
3224                 KASSERT(opa == pa, ("pmap_enter: invalid update"));
3225                 if ((orig_l3 & ~ATTR_AF) != (new_l3 & ~ATTR_AF)) {
3226                         /* same PA, different attributes */
3227                         pmap_load_store(l3, new_l3);
3228                         pmap_invalidate_page(pmap, va);
3229                         if (pmap_page_dirty(orig_l3) &&
3230                             (orig_l3 & ATTR_SW_MANAGED) != 0)
3231                                 vm_page_dirty(m);
3232                 } else {
3233                         /*
3234                          * orig_l3 == new_l3
3235                          * This can happens if multiple threads simultaneously
3236                          * access not yet mapped page. This bad for performance
3237                          * since this can cause full demotion-NOP-promotion
3238                          * cycle.
3239                          * Another possible reasons are:
3240                          * - VM and pmap memory layout are diverged
3241                          * - tlb flush is missing somewhere and CPU doesn't see
3242                          *   actual mapping.
3243                          */
3244                         CTR4(KTR_PMAP, "%s: already mapped page - "
3245                             "pmap %p va 0x%#lx pte 0x%lx",
3246                             __func__, pmap, va, new_l3);
3247                 }
3248         } else {
3249                 /* New mappig */
3250                 pmap_load_store(l3, new_l3);
3251         }
3252
3253 #if VM_NRESERVLEVEL > 0
3254         if (pmap != pmap_kernel() &&
3255             (mpte == NULL || mpte->wire_count == NL3PG) &&
3256             pmap_ps_enabled(pmap) &&
3257             (m->flags & PG_FICTITIOUS) == 0 &&
3258             vm_reserv_level_iffullpop(m) == 0) {
3259                 pmap_promote_l2(pmap, pde, va, &lock);
3260         }
3261 #endif
3262
3263         rv = KERN_SUCCESS;
3264 out:
3265         if (lock != NULL)
3266                 rw_wunlock(lock);
3267         PMAP_UNLOCK(pmap);
3268         return (rv);
3269 }
3270
3271 /*
3272  * Tries to create a read- and/or execute-only 2MB page mapping.  Returns true
3273  * if successful.  Returns false if (1) a page table page cannot be allocated
3274  * without sleeping, (2) a mapping already exists at the specified virtual
3275  * address, or (3) a PV entry cannot be allocated without reclaiming another
3276  * PV entry.
3277  */
3278 static bool
3279 pmap_enter_2mpage(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
3280     struct rwlock **lockp)
3281 {
3282         pd_entry_t new_l2;
3283
3284         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3285
3286         new_l2 = (pd_entry_t)(VM_PAGE_TO_PHYS(m) | ATTR_DEFAULT |
3287             ATTR_IDX(m->md.pv_memattr) | ATTR_AP(ATTR_AP_RO) | L2_BLOCK);
3288         if ((m->oflags & VPO_UNMANAGED) == 0)
3289                 new_l2 |= ATTR_SW_MANAGED;
3290         if ((prot & VM_PROT_EXECUTE) == 0 || m->md.pv_memattr == DEVICE_MEMORY)
3291                 new_l2 |= ATTR_XN;
3292         if (va < VM_MAXUSER_ADDRESS)
3293                 new_l2 |= ATTR_AP(ATTR_AP_USER) | ATTR_PXN;
3294         return (pmap_enter_l2(pmap, va, new_l2, PMAP_ENTER_NOSLEEP |
3295             PMAP_ENTER_NOREPLACE | PMAP_ENTER_NORECLAIM, NULL, lockp) ==
3296             KERN_SUCCESS);
3297 }
3298
3299 /*
3300  * Tries to create the specified 2MB page mapping.  Returns KERN_SUCCESS if
3301  * the mapping was created, and either KERN_FAILURE or KERN_RESOURCE_SHORTAGE
3302  * otherwise.  Returns KERN_FAILURE if PMAP_ENTER_NOREPLACE was specified and
3303  * a mapping already exists at the specified virtual address.  Returns
3304  * KERN_RESOURCE_SHORTAGE if PMAP_ENTER_NOSLEEP was specified and a page table
3305  * page allocation failed.  Returns KERN_RESOURCE_SHORTAGE if
3306  * PMAP_ENTER_NORECLAIM was specified and a PV entry allocation failed.
3307  *
3308  * The parameter "m" is only used when creating a managed, writeable mapping.
3309  */
3310 static int
3311 pmap_enter_l2(pmap_t pmap, vm_offset_t va, pd_entry_t new_l2, u_int flags,
3312     vm_page_t m, struct rwlock **lockp)
3313 {
3314         struct spglist free;
3315         pd_entry_t *l2, *l3, old_l2;
3316         vm_offset_t sva;
3317         vm_page_t l2pg, mt;
3318
3319         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3320
3321         if ((l2pg = pmap_alloc_l2(pmap, va, (flags & PMAP_ENTER_NOSLEEP) != 0 ?
3322             NULL : lockp)) == NULL) {
3323                 CTR2(KTR_PMAP, "pmap_enter_l2: failure for va %#lx in pmap %p",
3324                     va, pmap);
3325                 return (KERN_RESOURCE_SHORTAGE);
3326         }
3327
3328         l2 = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(l2pg));
3329         l2 = &l2[pmap_l2_index(va)];
3330         if ((old_l2 = pmap_load(l2)) != 0) {
3331                 KASSERT(l2pg->wire_count > 1,
3332                     ("pmap_enter_l2: l2pg's wire count is too low"));
3333                 if ((flags & PMAP_ENTER_NOREPLACE) != 0) {
3334                         l2pg->wire_count--;
3335                         CTR2(KTR_PMAP,
3336                             "pmap_enter_l2: failure for va %#lx in pmap %p",
3337                             va, pmap);
3338                         return (KERN_FAILURE);
3339                 }
3340                 SLIST_INIT(&free);
3341                 if ((old_l2 & ATTR_DESCR_MASK) == L2_BLOCK)
3342                         (void)pmap_remove_l2(pmap, l2, va,
3343                             pmap_load(pmap_l1(pmap, va)), &free, lockp);
3344                 else
3345                         for (sva = va; sva < va + L2_SIZE; sva += PAGE_SIZE) {
3346                                 l3 = pmap_l2_to_l3(l2, sva);
3347                                 if (pmap_l3_valid(pmap_load(l3)) &&
3348                                     pmap_remove_l3(pmap, l3, sva, old_l2, &free,
3349                                     lockp) != 0)
3350                                         break;
3351                         }
3352                 vm_page_free_pages_toq(&free, true);
3353                 if (va >= VM_MAXUSER_ADDRESS) {
3354                         mt = PHYS_TO_VM_PAGE(pmap_load(l2) & ~ATTR_MASK);
3355                         if (pmap_insert_pt_page(pmap, mt)) {
3356                                 /*
3357                                  * XXX Currently, this can't happen bacuse
3358                                  * we do not perform pmap_enter(psind == 1)
3359                                  * on the kernel pmap.
3360                                  */
3361                                 panic("pmap_enter_l2: trie insert failed");
3362                         }
3363                 } else
3364                         KASSERT(pmap_load(l2) == 0,
3365                             ("pmap_enter_l2: non-zero L2 entry %p", l2));
3366         }
3367
3368         if ((new_l2 & ATTR_SW_MANAGED) != 0) {
3369                 /*
3370                  * Abort this mapping if its PV entry could not be created.
3371                  */
3372                 if (!pmap_pv_insert_l2(pmap, va, new_l2, flags, lockp)) {
3373                         SLIST_INIT(&free);
3374                         if (pmap_unwire_l3(pmap, va, l2pg, &free)) {
3375                                 /*
3376                                  * Although "va" is not mapped, paging-structure
3377                                  * caches could nonetheless have entries that
3378                                  * refer to the freed page table pages.
3379                                  * Invalidate those entries.
3380                                  */
3381                                 pmap_invalidate_page(pmap, va);
3382                                 vm_page_free_pages_toq(&free, true);
3383                         }
3384                         CTR2(KTR_PMAP,
3385                             "pmap_enter_l2: failure for va %#lx in pmap %p",
3386                             va, pmap);
3387                         return (KERN_RESOURCE_SHORTAGE);
3388                 }
3389                 if ((new_l2 & ATTR_AP_RW_BIT) == ATTR_AP(ATTR_AP_RW))
3390                         for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)
3391                                 vm_page_aflag_set(mt, PGA_WRITEABLE);
3392         }
3393
3394         /*
3395          * Increment counters.
3396          */
3397         if ((new_l2 & ATTR_SW_WIRED) != 0)
3398                 pmap->pm_stats.wired_count += L2_SIZE / PAGE_SIZE;
3399         pmap->pm_stats.resident_count += L2_SIZE / PAGE_SIZE;
3400
3401         /*
3402          * Map the superpage.
3403          */
3404         (void)pmap_load_store(l2, new_l2);
3405
3406         atomic_add_long(&pmap_l2_mappings, 1);
3407         CTR2(KTR_PMAP, "pmap_enter_l2: success for va %#lx in pmap %p",
3408             va, pmap);
3409
3410         return (KERN_SUCCESS);
3411 }
3412
3413 /*
3414  * Maps a sequence of resident pages belonging to the same object.
3415  * The sequence begins with the given page m_start.  This page is
3416  * mapped at the given virtual address start.  Each subsequent page is
3417  * mapped at a virtual address that is offset from start by the same
3418  * amount as the page is offset from m_start within the object.  The
3419  * last page in the sequence is the page with the largest offset from
3420  * m_start that can be mapped at a virtual address less than the given
3421  * virtual address end.  Not every virtual page between start and end
3422  * is mapped; only those for which a resident page exists with the
3423  * corresponding offset from m_start are mapped.
3424  */
3425 void
3426 pmap_enter_object(pmap_t pmap, vm_offset_t start, vm_offset_t end,
3427     vm_page_t m_start, vm_prot_t prot)
3428 {
3429         struct rwlock *lock;
3430         vm_offset_t va;
3431         vm_page_t m, mpte;
3432         vm_pindex_t diff, psize;
3433
3434         VM_OBJECT_ASSERT_LOCKED(m_start->object);
3435
3436         psize = atop(end - start);
3437         mpte = NULL;
3438         m = m_start;
3439         lock = NULL;
3440         PMAP_LOCK(pmap);
3441         while (m != NULL && (diff = m->pindex - m_start->pindex) < psize) {
3442                 va = start + ptoa(diff);
3443                 if ((va & L2_OFFSET) == 0 && va + L2_SIZE <= end &&
3444                     m->psind == 1 && pmap_ps_enabled(pmap) &&
3445                     pmap_enter_2mpage(pmap, va, m, prot, &lock))
3446                         m = &m[L2_SIZE / PAGE_SIZE - 1];
3447                 else
3448                         mpte = pmap_enter_quick_locked(pmap, va, m, prot, mpte,
3449                             &lock);
3450                 m = TAILQ_NEXT(m, listq);
3451         }
3452         if (lock != NULL)
3453                 rw_wunlock(lock);
3454         PMAP_UNLOCK(pmap);
3455 }
3456
3457 /*
3458  * this code makes some *MAJOR* assumptions:
3459  * 1. Current pmap & pmap exists.
3460  * 2. Not wired.
3461  * 3. Read access.
3462  * 4. No page table pages.
3463  * but is *MUCH* faster than pmap_enter...
3464  */
3465
3466 void
3467 pmap_enter_quick(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot)
3468 {
3469         struct rwlock *lock;
3470
3471         lock = NULL;
3472         PMAP_LOCK(pmap);
3473         (void)pmap_enter_quick_locked(pmap, va, m, prot, NULL, &lock);
3474         if (lock != NULL)
3475                 rw_wunlock(lock);
3476         PMAP_UNLOCK(pmap);
3477 }
3478
3479 static vm_page_t
3480 pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va, vm_page_t m,
3481     vm_prot_t prot, vm_page_t mpte, struct rwlock **lockp)
3482 {
3483         struct spglist free;
3484         pd_entry_t *pde;
3485         pt_entry_t *l2, *l3, l3_val;
3486         vm_paddr_t pa;
3487         int lvl;
3488
3489         KASSERT(va < kmi.clean_sva || va >= kmi.clean_eva ||
3490             (m->oflags & VPO_UNMANAGED) != 0,
3491             ("pmap_enter_quick_locked: managed mapping within the clean submap"));
3492         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
3493
3494         CTR2(KTR_PMAP, "pmap_enter_quick_locked: %p %lx", pmap, va);
3495         /*
3496          * In the case that a page table page is not
3497          * resident, we are creating it here.
3498          */
3499         if (va < VM_MAXUSER_ADDRESS) {
3500                 vm_pindex_t l2pindex;
3501
3502                 /*
3503                  * Calculate pagetable page index
3504                  */
3505                 l2pindex = pmap_l2_pindex(va);
3506                 if (mpte && (mpte->pindex == l2pindex)) {
3507                         mpte->wire_count++;
3508                 } else {
3509                         /*
3510                          * Get the l2 entry
3511                          */
3512                         pde = pmap_pde(pmap, va, &lvl);
3513
3514                         /*
3515                          * If the page table page is mapped, we just increment
3516                          * the hold count, and activate it.  Otherwise, we
3517                          * attempt to allocate a page table page.  If this
3518                          * attempt fails, we don't retry.  Instead, we give up.
3519                          */
3520                         if (lvl == 1) {
3521                                 l2 = pmap_l1_to_l2(pde, va);
3522                                 if ((pmap_load(l2) & ATTR_DESCR_MASK) ==
3523                                     L2_BLOCK)
3524                                         return (NULL);
3525                         }
3526                         if (lvl == 2 && pmap_load(pde) != 0) {
3527                                 mpte =
3528                                     PHYS_TO_VM_PAGE(pmap_load(pde) & ~ATTR_MASK);
3529                                 mpte->wire_count++;
3530                         } else {
3531                                 /*
3532                                  * Pass NULL instead of the PV list lock
3533                                  * pointer, because we don't intend to sleep.
3534                                  */
3535                                 mpte = _pmap_alloc_l3(pmap, l2pindex, NULL);
3536                                 if (mpte == NULL)
3537                                         return (mpte);
3538                         }
3539                 }
3540                 l3 = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
3541                 l3 = &l3[pmap_l3_index(va)];
3542         } else {
3543                 mpte = NULL;
3544                 pde = pmap_pde(kernel_pmap, va, &lvl);
3545                 KASSERT(pde != NULL,
3546                     ("pmap_enter_quick_locked: Invalid page entry, va: 0x%lx",
3547                      va));
3548                 KASSERT(lvl == 2,
3549                     ("pmap_enter_quick_locked: Invalid level %d", lvl));
3550                 l3 = pmap_l2_to_l3(pde, va);
3551         }
3552
3553         if (pmap_load(l3) != 0) {
3554                 if (mpte != NULL) {
3555                         mpte->wire_count--;
3556                         mpte = NULL;
3557                 }
3558                 return (mpte);
3559         }
3560
3561         /*
3562          * Enter on the PV list if part of our managed memory.
3563          */
3564         if ((m->oflags & VPO_UNMANAGED) == 0 &&
3565             !pmap_try_insert_pv_entry(pmap, va, m, lockp)) {
3566                 if (mpte != NULL) {
3567                         SLIST_INIT(&free);
3568                         if (pmap_unwire_l3(pmap, va, mpte, &free)) {
3569                                 pmap_invalidate_page(pmap, va);
3570                                 vm_page_free_pages_toq(&free, false);
3571                         }
3572                         mpte = NULL;
3573                 }
3574                 return (mpte);
3575         }
3576
3577         /*
3578          * Increment counters
3579          */
3580         pmap_resident_count_inc(pmap, 1);
3581
3582         pa = VM_PAGE_TO_PHYS(m);
3583         l3_val = pa | ATTR_DEFAULT | ATTR_IDX(m->md.pv_memattr) |
3584             ATTR_AP(ATTR_AP_RO) | L3_PAGE;
3585         if ((prot & VM_PROT_EXECUTE) == 0 || m->md.pv_memattr == DEVICE_MEMORY)
3586                 l3_val |= ATTR_XN;
3587         else if (va < VM_MAXUSER_ADDRESS)
3588                 l3_val |= ATTR_PXN;
3589
3590         /*
3591          * Now validate mapping with RO protection
3592          */
3593         if ((m->oflags & VPO_UNMANAGED) == 0)
3594                 l3_val |= ATTR_SW_MANAGED;
3595
3596         /* Sync icache before the mapping is stored to PTE */
3597         if ((prot & VM_PROT_EXECUTE) && pmap != kernel_pmap &&
3598             m->md.pv_memattr == VM_MEMATTR_WRITE_BACK)
3599                 cpu_icache_sync_range(PHYS_TO_DMAP(pa), PAGE_SIZE);
3600
3601         pmap_load_store(l3, l3_val);
3602         pmap_invalidate_page(pmap, va);
3603         return (mpte);
3604 }
3605
3606 /*
3607  * This code maps large physical mmap regions into the
3608  * processor address space.  Note that some shortcuts
3609  * are taken, but the code works.
3610  */
3611 void
3612 pmap_object_init_pt(pmap_t pmap, vm_offset_t addr, vm_object_t object,
3613     vm_pindex_t pindex, vm_size_t size)
3614 {
3615
3616         VM_OBJECT_ASSERT_WLOCKED(object);
3617         KASSERT(object->type == OBJT_DEVICE || object->type == OBJT_SG,
3618             ("pmap_object_init_pt: non-device object"));
3619 }
3620
3621 /*
3622  *      Clear the wired attribute from the mappings for the specified range of
3623  *      addresses in the given pmap.  Every valid mapping within that range
3624  *      must have the wired attribute set.  In contrast, invalid mappings
3625  *      cannot have the wired attribute set, so they are ignored.
3626  *
3627  *      The wired attribute of the page table entry is not a hardware feature,
3628  *      so there is no need to invalidate any TLB entries.
3629  */
3630 void
3631 pmap_unwire(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
3632 {
3633         vm_offset_t va_next;
3634         pd_entry_t *l0, *l1, *l2;
3635         pt_entry_t *l3;
3636
3637         PMAP_LOCK(pmap);
3638         for (; sva < eva; sva = va_next) {
3639                 l0 = pmap_l0(pmap, sva);
3640                 if (pmap_load(l0) == 0) {
3641                         va_next = (sva + L0_SIZE) & ~L0_OFFSET;
3642                         if (va_next < sva)
3643                                 va_next = eva;
3644                         continue;
3645                 }
3646
3647                 l1 = pmap_l0_to_l1(l0, sva);
3648                 if (pmap_load(l1) == 0) {
3649                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
3650                         if (va_next < sva)
3651                                 va_next = eva;
3652                         continue;
3653                 }
3654
3655                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
3656                 if (va_next < sva)
3657                         va_next = eva;
3658
3659                 l2 = pmap_l1_to_l2(l1, sva);
3660                 if (pmap_load(l2) == 0)
3661                         continue;
3662
3663                 if ((pmap_load(l2) & ATTR_DESCR_MASK) == L2_BLOCK) {
3664                         l3 = pmap_demote_l2(pmap, l2, sva);
3665                         if (l3 == NULL)
3666                                 continue;
3667                 }
3668                 KASSERT((pmap_load(l2) & ATTR_DESCR_MASK) == L2_TABLE,
3669                     ("pmap_unwire: Invalid l2 entry after demotion"));
3670
3671                 if (va_next > eva)
3672                         va_next = eva;
3673                 for (l3 = pmap_l2_to_l3(l2, sva); sva != va_next; l3++,
3674                     sva += L3_SIZE) {
3675                         if (pmap_load(l3) == 0)
3676                                 continue;
3677                         if ((pmap_load(l3) & ATTR_SW_WIRED) == 0)
3678                                 panic("pmap_unwire: l3 %#jx is missing "
3679                                     "ATTR_SW_WIRED", (uintmax_t)pmap_load(l3));
3680
3681                         /*
3682                          * PG_W must be cleared atomically.  Although the pmap
3683                          * lock synchronizes access to PG_W, another processor
3684                          * could be setting PG_M and/or PG_A concurrently.
3685                          */
3686                         atomic_clear_long(l3, ATTR_SW_WIRED);
3687                         pmap->pm_stats.wired_count--;
3688                 }
3689         }
3690         PMAP_UNLOCK(pmap);
3691 }
3692
3693 /*
3694  *      Copy the range specified by src_addr/len
3695  *      from the source map to the range dst_addr/len
3696  *      in the destination map.
3697  *
3698  *      This routine is only advisory and need not do anything.
3699  */
3700
3701 void
3702 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, vm_size_t len,
3703     vm_offset_t src_addr)
3704 {
3705 }
3706
3707 /*
3708  *      pmap_zero_page zeros the specified hardware page by mapping
3709  *      the page into KVM and using bzero to clear its contents.
3710  */
3711 void
3712 pmap_zero_page(vm_page_t m)
3713 {
3714         vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
3715
3716         pagezero((void *)va);
3717 }
3718
3719 /*
3720  *      pmap_zero_page_area zeros the specified hardware page by mapping
3721  *      the page into KVM and using bzero to clear its contents.
3722  *
3723  *      off and size may not cover an area beyond a single hardware page.
3724  */
3725 void
3726 pmap_zero_page_area(vm_page_t m, int off, int size)
3727 {
3728         vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
3729
3730         if (off == 0 && size == PAGE_SIZE)
3731                 pagezero((void *)va);
3732         else
3733                 bzero((char *)va + off, size);
3734 }
3735
3736 /*
3737  *      pmap_copy_page copies the specified (machine independent)
3738  *      page by mapping the page into virtual memory and using
3739  *      bcopy to copy the page, one machine dependent page at a
3740  *      time.
3741  */
3742 void
3743 pmap_copy_page(vm_page_t msrc, vm_page_t mdst)
3744 {
3745         vm_offset_t src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
3746         vm_offset_t dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
3747
3748         pagecopy((void *)src, (void *)dst);
3749 }
3750
3751 int unmapped_buf_allowed = 1;
3752
3753 void
3754 pmap_copy_pages(vm_page_t ma[], vm_offset_t a_offset, vm_page_t mb[],
3755     vm_offset_t b_offset, int xfersize)
3756 {
3757         void *a_cp, *b_cp;
3758         vm_page_t m_a, m_b;
3759         vm_paddr_t p_a, p_b;
3760         vm_offset_t a_pg_offset, b_pg_offset;
3761         int cnt;
3762
3763         while (xfersize > 0) {
3764                 a_pg_offset = a_offset & PAGE_MASK;
3765                 m_a = ma[a_offset >> PAGE_SHIFT];
3766                 p_a = m_a->phys_addr;
3767                 b_pg_offset = b_offset & PAGE_MASK;
3768                 m_b = mb[b_offset >> PAGE_SHIFT];
3769                 p_b = m_b->phys_addr;
3770                 cnt = min(xfersize, PAGE_SIZE - a_pg_offset);
3771                 cnt = min(cnt, PAGE_SIZE - b_pg_offset);
3772                 if (__predict_false(!PHYS_IN_DMAP(p_a))) {
3773                         panic("!DMAP a %lx", p_a);
3774                 } else {
3775                         a_cp = (char *)PHYS_TO_DMAP(p_a) + a_pg_offset;
3776                 }
3777                 if (__predict_false(!PHYS_IN_DMAP(p_b))) {
3778                         panic("!DMAP b %lx", p_b);
3779                 } else {
3780                         b_cp = (char *)PHYS_TO_DMAP(p_b) + b_pg_offset;
3781                 }
3782                 bcopy(a_cp, b_cp, cnt);
3783                 a_offset += cnt;
3784                 b_offset += cnt;
3785                 xfersize -= cnt;
3786         }
3787 }
3788
3789 vm_offset_t
3790 pmap_quick_enter_page(vm_page_t m)
3791 {
3792
3793         return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
3794 }
3795
3796 void
3797 pmap_quick_remove_page(vm_offset_t addr)
3798 {
3799 }
3800
3801 /*
3802  * Returns true if the pmap's pv is one of the first
3803  * 16 pvs linked to from this page.  This count may
3804  * be changed upwards or downwards in the future; it
3805  * is only necessary that true be returned for a small
3806  * subset of pmaps for proper page aging.
3807  */
3808 boolean_t
3809 pmap_page_exists_quick(pmap_t pmap, vm_page_t m)
3810 {
3811         struct md_page *pvh;
3812         struct rwlock *lock;
3813         pv_entry_t pv;
3814         int loops = 0;
3815         boolean_t rv;
3816
3817         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
3818             ("pmap_page_exists_quick: page %p is not managed", m));
3819         rv = FALSE;
3820         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
3821         rw_rlock(lock);
3822         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
3823                 if (PV_PMAP(pv) == pmap) {
3824                         rv = TRUE;
3825                         break;
3826                 }
3827                 loops++;
3828                 if (loops >= 16)
3829                         break;
3830         }
3831         if (!rv && loops < 16 && (m->flags & PG_FICTITIOUS) == 0) {
3832                 pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
3833                 TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
3834                         if (PV_PMAP(pv) == pmap) {
3835                                 rv = TRUE;
3836                                 break;
3837                         }
3838                         loops++;
3839                         if (loops >= 16)
3840                                 break;
3841                 }
3842         }
3843         rw_runlock(lock);
3844         return (rv);
3845 }
3846
3847 /*
3848  *      pmap_page_wired_mappings:
3849  *
3850  *      Return the number of managed mappings to the given physical page
3851  *      that are wired.
3852  */
3853 int
3854 pmap_page_wired_mappings(vm_page_t m)
3855 {
3856         struct rwlock *lock;
3857         struct md_page *pvh;
3858         pmap_t pmap;
3859         pt_entry_t *pte;
3860         pv_entry_t pv;
3861         int count, lvl, md_gen, pvh_gen;
3862
3863         if ((m->oflags & VPO_UNMANAGED) != 0)
3864                 return (0);
3865         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
3866         rw_rlock(lock);
3867 restart:
3868         count = 0;
3869         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
3870                 pmap = PV_PMAP(pv);
3871                 if (!PMAP_TRYLOCK(pmap)) {
3872                         md_gen = m->md.pv_gen;
3873                         rw_runlock(lock);
3874                         PMAP_LOCK(pmap);
3875                         rw_rlock(lock);
3876                         if (md_gen != m->md.pv_gen) {
3877                                 PMAP_UNLOCK(pmap);
3878                                 goto restart;
3879                         }
3880                 }
3881                 pte = pmap_pte(pmap, pv->pv_va, &lvl);
3882                 if (pte != NULL && (pmap_load(pte) & ATTR_SW_WIRED) != 0)
3883                         count++;
3884                 PMAP_UNLOCK(pmap);
3885         }
3886         if ((m->flags & PG_FICTITIOUS) == 0) {
3887                 pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
3888                 TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
3889                         pmap = PV_PMAP(pv);
3890                         if (!PMAP_TRYLOCK(pmap)) {
3891                                 md_gen = m->md.pv_gen;
3892                                 pvh_gen = pvh->pv_gen;
3893                                 rw_runlock(lock);
3894                                 PMAP_LOCK(pmap);
3895                                 rw_rlock(lock);
3896                                 if (md_gen != m->md.pv_gen ||
3897                                     pvh_gen != pvh->pv_gen) {
3898                                         PMAP_UNLOCK(pmap);
3899                                         goto restart;
3900                                 }
3901                         }
3902                         pte = pmap_pte(pmap, pv->pv_va, &lvl);
3903                         if (pte != NULL &&
3904                             (pmap_load(pte) & ATTR_SW_WIRED) != 0)
3905                                 count++;
3906                         PMAP_UNLOCK(pmap);
3907                 }
3908         }
3909         rw_runlock(lock);
3910         return (count);
3911 }
3912
3913 /*
3914  * Destroy all managed, non-wired mappings in the given user-space
3915  * pmap.  This pmap cannot be active on any processor besides the
3916  * caller.
3917  *
3918  * This function cannot be applied to the kernel pmap.  Moreover, it
3919  * is not intended for general use.  It is only to be used during
3920  * process termination.  Consequently, it can be implemented in ways
3921  * that make it faster than pmap_remove().  First, it can more quickly
3922  * destroy mappings by iterating over the pmap's collection of PV
3923  * entries, rather than searching the page table.  Second, it doesn't
3924  * have to test and clear the page table entries atomically, because
3925  * no processor is currently accessing the user address space.  In
3926  * particular, a page table entry's dirty bit won't change state once
3927  * this function starts.
3928  */
3929 void
3930 pmap_remove_pages(pmap_t pmap)
3931 {
3932         pd_entry_t *pde;
3933         pt_entry_t *pte, tpte;
3934         struct spglist free;
3935         vm_page_t m, ml3, mt;
3936         pv_entry_t pv;
3937         struct md_page *pvh;
3938         struct pv_chunk *pc, *npc;
3939         struct rwlock *lock;
3940         int64_t bit;
3941         uint64_t inuse, bitmask;
3942         int allfree, field, freed, idx, lvl;
3943         vm_paddr_t pa;
3944
3945         lock = NULL;
3946
3947         SLIST_INIT(&free);
3948         PMAP_LOCK(pmap);
3949         TAILQ_FOREACH_SAFE(pc, &pmap->pm_pvchunk, pc_list, npc) {
3950                 allfree = 1;
3951                 freed = 0;
3952                 for (field = 0; field < _NPCM; field++) {
3953                         inuse = ~pc->pc_map[field] & pc_freemask[field];
3954                         while (inuse != 0) {
3955                                 bit = ffsl(inuse) - 1;
3956                                 bitmask = 1UL << bit;
3957                                 idx = field * 64 + bit;
3958                                 pv = &pc->pc_pventry[idx];
3959                                 inuse &= ~bitmask;
3960
3961                                 pde = pmap_pde(pmap, pv->pv_va, &lvl);
3962                                 KASSERT(pde != NULL,
3963                                     ("Attempting to remove an unmapped page"));
3964
3965                                 switch(lvl) {
3966                                 case 1:
3967                                         pte = pmap_l1_to_l2(pde, pv->pv_va);
3968                                         tpte = pmap_load(pte);
3969                                         KASSERT((tpte & ATTR_DESCR_MASK) ==
3970                                             L2_BLOCK,
3971                                             ("Attempting to remove an invalid "
3972                                             "block: %lx", tpte));
3973                                         tpte = pmap_load(pte);
3974                                         break;
3975                                 case 2:
3976                                         pte = pmap_l2_to_l3(pde, pv->pv_va);
3977                                         tpte = pmap_load(pte);
3978                                         KASSERT((tpte & ATTR_DESCR_MASK) ==
3979                                             L3_PAGE,
3980                                             ("Attempting to remove an invalid "
3981                                              "page: %lx", tpte));
3982                                         break;
3983                                 default:
3984                                         panic(
3985                                             "Invalid page directory level: %d",
3986                                             lvl);
3987                                 }
3988
3989 /*
3990  * We cannot remove wired pages from a process' mapping at this time
3991  */
3992                                 if (tpte & ATTR_SW_WIRED) {
3993                                         allfree = 0;
3994                                         continue;
3995                                 }
3996
3997                                 pa = tpte & ~ATTR_MASK;
3998
3999                                 m = PHYS_TO_VM_PAGE(pa);
4000                                 KASSERT(m->phys_addr == pa,
4001                                     ("vm_page_t %p phys_addr mismatch %016jx %016jx",
4002                                     m, (uintmax_t)m->phys_addr,
4003                                     (uintmax_t)tpte));
4004
4005                                 KASSERT((m->flags & PG_FICTITIOUS) != 0 ||
4006                                     m < &vm_page_array[vm_page_array_size],
4007                                     ("pmap_remove_pages: bad pte %#jx",
4008                                     (uintmax_t)tpte));
4009
4010                                 pmap_load_clear(pte);
4011
4012                                 /*
4013                                  * Update the vm_page_t clean/reference bits.
4014                                  */
4015                                 if ((tpte & ATTR_AP_RW_BIT) ==
4016                                     ATTR_AP(ATTR_AP_RW)) {
4017                                         switch (lvl) {
4018                                         case 1:
4019                                                 for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)
4020                                                         vm_page_dirty(m);
4021                                                 break;
4022                                         case 2:
4023                                                 vm_page_dirty(m);
4024                                                 break;
4025                                         }
4026                                 }
4027
4028                                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(&lock, m);
4029
4030                                 /* Mark free */
4031                                 pc->pc_map[field] |= bitmask;
4032                                 switch (lvl) {
4033                                 case 1:
4034                                         pmap_resident_count_dec(pmap,
4035                                             L2_SIZE / PAGE_SIZE);
4036                                         pvh = pa_to_pvh(tpte & ~ATTR_MASK);
4037                                         TAILQ_REMOVE(&pvh->pv_list, pv,pv_next);
4038                                         pvh->pv_gen++;
4039                                         if (TAILQ_EMPTY(&pvh->pv_list)) {
4040                                                 for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)
4041                                                         if ((mt->aflags & PGA_WRITEABLE) != 0 &&
4042                                                             TAILQ_EMPTY(&mt->md.pv_list))
4043                                                                 vm_page_aflag_clear(mt, PGA_WRITEABLE);
4044                                         }
4045                                         ml3 = pmap_remove_pt_page(pmap,
4046                                             pv->pv_va);
4047                                         if (ml3 != NULL) {
4048                                                 pmap_resident_count_dec(pmap,1);
4049                                                 KASSERT(ml3->wire_count == NL3PG,
4050                                                     ("pmap_remove_pages: l3 page wire count error"));
4051                                                 ml3->wire_count = 1;
4052                                                 vm_page_unwire_noq(ml3);
4053                                                 pmap_add_delayed_free_list(ml3,
4054                                                     &free, FALSE);
4055                                         }
4056                                         break;
4057                                 case 2:
4058                                         pmap_resident_count_dec(pmap, 1);
4059                                         TAILQ_REMOVE(&m->md.pv_list, pv,
4060                                             pv_next);
4061                                         m->md.pv_gen++;
4062                                         if ((m->aflags & PGA_WRITEABLE) != 0 &&
4063                                             TAILQ_EMPTY(&m->md.pv_list) &&
4064                                             (m->flags & PG_FICTITIOUS) == 0) {
4065                                                 pvh = pa_to_pvh(
4066                                                     VM_PAGE_TO_PHYS(m));
4067                                                 if (TAILQ_EMPTY(&pvh->pv_list))
4068                                                         vm_page_aflag_clear(m,
4069                                                             PGA_WRITEABLE);
4070                                         }
4071                                         break;
4072                                 }
4073                                 pmap_unuse_pt(pmap, pv->pv_va, pmap_load(pde),
4074                                     &free);
4075                                 freed++;
4076                         }
4077                 }
4078                 PV_STAT(atomic_add_long(&pv_entry_frees, freed));
4079                 PV_STAT(atomic_add_int(&pv_entry_spare, freed));
4080                 PV_STAT(atomic_subtract_long(&pv_entry_count, freed));
4081                 if (allfree) {
4082                         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
4083                         free_pv_chunk(pc);
4084                 }
4085         }
4086         pmap_invalidate_all(pmap);
4087         if (lock != NULL)
4088                 rw_wunlock(lock);
4089         PMAP_UNLOCK(pmap);
4090         vm_page_free_pages_toq(&free, false);
4091 }
4092
4093 /*
4094  * This is used to check if a page has been accessed or modified. As we
4095  * don't have a bit to see if it has been modified we have to assume it
4096  * has been if the page is read/write.
4097  */
4098 static boolean_t
4099 pmap_page_test_mappings(vm_page_t m, boolean_t accessed, boolean_t modified)
4100 {
4101         struct rwlock *lock;
4102         pv_entry_t pv;
4103         struct md_page *pvh;
4104         pt_entry_t *pte, mask, value;
4105         pmap_t pmap;
4106         int lvl, md_gen, pvh_gen;
4107         boolean_t rv;
4108
4109         rv = FALSE;
4110         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
4111         rw_rlock(lock);
4112 restart:
4113         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
4114                 pmap = PV_PMAP(pv);
4115                 if (!PMAP_TRYLOCK(pmap)) {
4116                         md_gen = m->md.pv_gen;
4117                         rw_runlock(lock);
4118                         PMAP_LOCK(pmap);
4119                         rw_rlock(lock);
4120                         if (md_gen != m->md.pv_gen) {
4121                                 PMAP_UNLOCK(pmap);
4122                                 goto restart;
4123                         }
4124                 }
4125                 pte = pmap_pte(pmap, pv->pv_va, &lvl);
4126                 KASSERT(lvl == 3,
4127                     ("pmap_page_test_mappings: Invalid level %d", lvl));
4128                 mask = 0;
4129                 value = 0;
4130                 if (modified) {
4131                         mask |= ATTR_AP_RW_BIT;
4132                         value |= ATTR_AP(ATTR_AP_RW);
4133                 }
4134                 if (accessed) {
4135                         mask |= ATTR_AF | ATTR_DESCR_MASK;
4136                         value |= ATTR_AF | L3_PAGE;
4137                 }
4138                 rv = (pmap_load(pte) & mask) == value;
4139                 PMAP_UNLOCK(pmap);
4140                 if (rv)
4141                         goto out;
4142         }
4143         if ((m->flags & PG_FICTITIOUS) == 0) {
4144                 pvh = pa_to_pvh(VM_PAGE_TO_PHYS(m));
4145                 TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
4146                         pmap = PV_PMAP(pv);
4147                         if (!PMAP_TRYLOCK(pmap)) {
4148                                 md_gen = m->md.pv_gen;
4149                                 pvh_gen = pvh->pv_gen;
4150                                 rw_runlock(lock);
4151                                 PMAP_LOCK(pmap);
4152                                 rw_rlock(lock);
4153                                 if (md_gen != m->md.pv_gen ||
4154                                     pvh_gen != pvh->pv_gen) {
4155                                         PMAP_UNLOCK(pmap);
4156                                         goto restart;
4157                                 }
4158                         }
4159                         pte = pmap_pte(pmap, pv->pv_va, &lvl);
4160                         KASSERT(lvl == 2,
4161                             ("pmap_page_test_mappings: Invalid level %d", lvl));
4162                         mask = 0;
4163                         value = 0;
4164                         if (modified) {
4165                                 mask |= ATTR_AP_RW_BIT;
4166                                 value |= ATTR_AP(ATTR_AP_RW);
4167                         }
4168                         if (accessed) {
4169                                 mask |= ATTR_AF | ATTR_DESCR_MASK;
4170                                 value |= ATTR_AF | L2_BLOCK;
4171                         }
4172                         rv = (pmap_load(pte) & mask) == value;
4173                         PMAP_UNLOCK(pmap);
4174                         if (rv)
4175                                 goto out;
4176                 }
4177         }
4178 out:
4179         rw_runlock(lock);
4180         return (rv);
4181 }
4182
4183 /*
4184  *      pmap_is_modified:
4185  *
4186  *      Return whether or not the specified physical page was modified
4187  *      in any physical maps.
4188  */
4189 boolean_t
4190 pmap_is_modified(vm_page_t m)
4191 {
4192
4193         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4194             ("pmap_is_modified: page %p is not managed", m));
4195
4196         /*
4197          * If the page is not exclusive busied, then PGA_WRITEABLE cannot be
4198          * concurrently set while the object is locked.  Thus, if PGA_WRITEABLE
4199          * is clear, no PTEs can have PG_M set.
4200          */
4201         VM_OBJECT_ASSERT_WLOCKED(m->object);
4202         if (!vm_page_xbusied(m) && (m->aflags & PGA_WRITEABLE) == 0)
4203                 return (FALSE);
4204         return (pmap_page_test_mappings(m, FALSE, TRUE));
4205 }
4206
4207 /*
4208  *      pmap_is_prefaultable:
4209  *
4210  *      Return whether or not the specified virtual address is eligible
4211  *      for prefault.
4212  */
4213 boolean_t
4214 pmap_is_prefaultable(pmap_t pmap, vm_offset_t addr)
4215 {
4216         pt_entry_t *pte;
4217         boolean_t rv;
4218         int lvl;
4219
4220         rv = FALSE;
4221         PMAP_LOCK(pmap);
4222         pte = pmap_pte(pmap, addr, &lvl);
4223         if (pte != NULL && pmap_load(pte) != 0) {
4224                 rv = TRUE;
4225         }
4226         PMAP_UNLOCK(pmap);
4227         return (rv);
4228 }
4229
4230 /*
4231  *      pmap_is_referenced:
4232  *
4233  *      Return whether or not the specified physical page was referenced
4234  *      in any physical maps.
4235  */
4236 boolean_t
4237 pmap_is_referenced(vm_page_t m)
4238 {
4239
4240         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4241             ("pmap_is_referenced: page %p is not managed", m));
4242         return (pmap_page_test_mappings(m, TRUE, FALSE));
4243 }
4244
4245 /*
4246  * Clear the write and modified bits in each of the given page's mappings.
4247  */
4248 void
4249 pmap_remove_write(vm_page_t m)
4250 {
4251         struct md_page *pvh;
4252         pmap_t pmap;
4253         struct rwlock *lock;
4254         pv_entry_t next_pv, pv;
4255         pt_entry_t oldpte, *pte;
4256         vm_offset_t va;
4257         int lvl, md_gen, pvh_gen;
4258
4259         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4260             ("pmap_remove_write: page %p is not managed", m));
4261
4262         /*
4263          * If the page is not exclusive busied, then PGA_WRITEABLE cannot be
4264          * set by another thread while the object is locked.  Thus,
4265          * if PGA_WRITEABLE is clear, no page table entries need updating.
4266          */
4267         VM_OBJECT_ASSERT_WLOCKED(m->object);
4268         if (!vm_page_xbusied(m) && (m->aflags & PGA_WRITEABLE) == 0)
4269                 return;
4270         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
4271         pvh = (m->flags & PG_FICTITIOUS) != 0 ? &pv_dummy :
4272             pa_to_pvh(VM_PAGE_TO_PHYS(m));
4273 retry_pv_loop:
4274         rw_wlock(lock);
4275         TAILQ_FOREACH_SAFE(pv, &pvh->pv_list, pv_next, next_pv) {
4276                 pmap = PV_PMAP(pv);
4277                 if (!PMAP_TRYLOCK(pmap)) {
4278                         pvh_gen = pvh->pv_gen;
4279                         rw_wunlock(lock);
4280                         PMAP_LOCK(pmap);
4281                         rw_wlock(lock);
4282                         if (pvh_gen != pvh->pv_gen) {
4283                                 PMAP_UNLOCK(pmap);
4284                                 rw_wunlock(lock);
4285                                 goto retry_pv_loop;
4286                         }
4287                 }
4288                 va = pv->pv_va;
4289                 pte = pmap_pte(pmap, pv->pv_va, &lvl);
4290                 if ((pmap_load(pte) & ATTR_AP_RW_BIT) == ATTR_AP(ATTR_AP_RW))
4291                         pmap_demote_l2_locked(pmap, pte, va & ~L2_OFFSET,
4292                             &lock);
4293                 KASSERT(lock == VM_PAGE_TO_PV_LIST_LOCK(m),
4294                     ("inconsistent pv lock %p %p for page %p",
4295                     lock, VM_PAGE_TO_PV_LIST_LOCK(m), m));
4296                 PMAP_UNLOCK(pmap);
4297         }
4298         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
4299                 pmap = PV_PMAP(pv);
4300                 if (!PMAP_TRYLOCK(pmap)) {
4301                         pvh_gen = pvh->pv_gen;
4302                         md_gen = m->md.pv_gen;
4303                         rw_wunlock(lock);
4304                         PMAP_LOCK(pmap);
4305                         rw_wlock(lock);
4306                         if (pvh_gen != pvh->pv_gen ||
4307                             md_gen != m->md.pv_gen) {
4308                                 PMAP_UNLOCK(pmap);
4309                                 rw_wunlock(lock);
4310                                 goto retry_pv_loop;
4311                         }
4312                 }
4313                 pte = pmap_pte(pmap, pv->pv_va, &lvl);
4314 retry:
4315                 oldpte = pmap_load(pte);
4316                 if ((oldpte & ATTR_AP_RW_BIT) == ATTR_AP(ATTR_AP_RW)) {
4317                         if (!atomic_cmpset_long(pte, oldpte,
4318                             oldpte | ATTR_AP(ATTR_AP_RO)))
4319                                 goto retry;
4320                         if ((oldpte & ATTR_AF) != 0)
4321                                 vm_page_dirty(m);
4322                         pmap_invalidate_page(pmap, pv->pv_va);
4323                 }
4324                 PMAP_UNLOCK(pmap);
4325         }
4326         rw_wunlock(lock);
4327         vm_page_aflag_clear(m, PGA_WRITEABLE);
4328 }
4329
4330 static __inline boolean_t
4331 safe_to_clear_referenced(pmap_t pmap, pt_entry_t pte)
4332 {
4333
4334         return (FALSE);
4335 }
4336
4337 /*
4338  *      pmap_ts_referenced:
4339  *
4340  *      Return a count of reference bits for a page, clearing those bits.
4341  *      It is not necessary for every reference bit to be cleared, but it
4342  *      is necessary that 0 only be returned when there are truly no
4343  *      reference bits set.
4344  *
4345  *      As an optimization, update the page's dirty field if a modified bit is
4346  *      found while counting reference bits.  This opportunistic update can be
4347  *      performed at low cost and can eliminate the need for some future calls
4348  *      to pmap_is_modified().  However, since this function stops after
4349  *      finding PMAP_TS_REFERENCED_MAX reference bits, it may not detect some
4350  *      dirty pages.  Those dirty pages will only be detected by a future call
4351  *      to pmap_is_modified().
4352  */
4353 int
4354 pmap_ts_referenced(vm_page_t m)
4355 {
4356         struct md_page *pvh;
4357         pv_entry_t pv, pvf;
4358         pmap_t pmap;
4359         struct rwlock *lock;
4360         pd_entry_t *pde, tpde;
4361         pt_entry_t *pte, tpte;
4362         pt_entry_t *l3;
4363         vm_offset_t va;
4364         vm_paddr_t pa;
4365         int cleared, md_gen, not_cleared, lvl, pvh_gen;
4366         struct spglist free;
4367         bool demoted;
4368
4369         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4370             ("pmap_ts_referenced: page %p is not managed", m));
4371         SLIST_INIT(&free);
4372         cleared = 0;
4373         pa = VM_PAGE_TO_PHYS(m);
4374         lock = PHYS_TO_PV_LIST_LOCK(pa);
4375         pvh = (m->flags & PG_FICTITIOUS) != 0 ? &pv_dummy : pa_to_pvh(pa);
4376         rw_wlock(lock);
4377 retry:
4378         not_cleared = 0;
4379         if ((pvf = TAILQ_FIRST(&pvh->pv_list)) == NULL)
4380                 goto small_mappings;
4381         pv = pvf;
4382         do {
4383                 if (pvf == NULL)
4384                         pvf = pv;
4385                 pmap = PV_PMAP(pv);
4386                 if (!PMAP_TRYLOCK(pmap)) {
4387                         pvh_gen = pvh->pv_gen;
4388                         rw_wunlock(lock);
4389                         PMAP_LOCK(pmap);
4390                         rw_wlock(lock);
4391                         if (pvh_gen != pvh->pv_gen) {
4392                                 PMAP_UNLOCK(pmap);
4393                                 goto retry;
4394                         }
4395                 }
4396                 va = pv->pv_va;
4397                 pde = pmap_pde(pmap, pv->pv_va, &lvl);
4398                 KASSERT(pde != NULL, ("pmap_ts_referenced: no l1 table found"));
4399                 KASSERT(lvl == 1,
4400                     ("pmap_ts_referenced: invalid pde level %d", lvl));
4401                 tpde = pmap_load(pde);
4402                 KASSERT((tpde & ATTR_DESCR_MASK) == L1_TABLE,
4403                     ("pmap_ts_referenced: found an invalid l1 table"));
4404                 pte = pmap_l1_to_l2(pde, pv->pv_va);
4405                 tpte = pmap_load(pte);
4406                 if (pmap_page_dirty(tpte)) {
4407                         /*
4408                          * Although "tpte" is mapping a 2MB page, because
4409                          * this function is called at a 4KB page granularity,
4410                          * we only update the 4KB page under test.
4411                          */
4412                         vm_page_dirty(m);
4413                 }
4414                 if ((tpte & ATTR_AF) != 0) {
4415                         /*
4416                          * Since this reference bit is shared by 512 4KB
4417                          * pages, it should not be cleared every time it is
4418                          * tested.  Apply a simple "hash" function on the
4419                          * physical page number, the virtual superpage number,
4420                          * and the pmap address to select one 4KB page out of
4421                          * the 512 on which testing the reference bit will
4422                          * result in clearing that reference bit.  This
4423                          * function is designed to avoid the selection of the
4424                          * same 4KB page for every 2MB page mapping.
4425                          *
4426                          * On demotion, a mapping that hasn't been referenced
4427                          * is simply destroyed.  To avoid the possibility of a
4428                          * subsequent page fault on a demoted wired mapping,
4429                          * always leave its reference bit set.  Moreover,
4430                          * since the superpage is wired, the current state of
4431                          * its reference bit won't affect page replacement.
4432                          */
4433                         if ((((pa >> PAGE_SHIFT) ^ (pv->pv_va >> L2_SHIFT) ^
4434                             (uintptr_t)pmap) & (Ln_ENTRIES - 1)) == 0 &&
4435                             (tpte & ATTR_SW_WIRED) == 0) {
4436                                 if (safe_to_clear_referenced(pmap, tpte)) {
4437                                         /*
4438                                          * TODO: We don't handle the access
4439                                          * flag at all. We need to be able
4440                                          * to set it in  the exception handler.
4441                                          */
4442                                         panic("ARM64TODO: "
4443                                             "safe_to_clear_referenced\n");
4444                                 } else if (pmap_demote_l2_locked(pmap, pte,
4445                                     pv->pv_va, &lock) != NULL) {
4446                                         demoted = true;
4447                                         va += VM_PAGE_TO_PHYS(m) -
4448                                             (tpte & ~ATTR_MASK);
4449                                         l3 = pmap_l2_to_l3(pte, va);
4450                                         pmap_remove_l3(pmap, l3, va,
4451                                             pmap_load(pte), NULL, &lock);
4452                                 } else
4453                                         demoted = true;
4454
4455                                 if (demoted) {
4456                                         /*
4457                                          * The superpage mapping was removed
4458                                          * entirely and therefore 'pv' is no
4459                                          * longer valid.
4460                                          */
4461                                         if (pvf == pv)
4462                                                 pvf = NULL;
4463                                         pv = NULL;
4464                                 }
4465                                 cleared++;
4466                                 KASSERT(lock == VM_PAGE_TO_PV_LIST_LOCK(m),
4467                                     ("inconsistent pv lock %p %p for page %p",
4468                                     lock, VM_PAGE_TO_PV_LIST_LOCK(m), m));
4469                         } else
4470                                 not_cleared++;
4471                 }
4472                 PMAP_UNLOCK(pmap);
4473                 /* Rotate the PV list if it has more than one entry. */
4474                 if (pv != NULL && TAILQ_NEXT(pv, pv_next) != NULL) {
4475                         TAILQ_REMOVE(&pvh->pv_list, pv, pv_next);
4476                         TAILQ_INSERT_TAIL(&pvh->pv_list, pv, pv_next);
4477                         pvh->pv_gen++;
4478                 }
4479                 if (cleared + not_cleared >= PMAP_TS_REFERENCED_MAX)
4480                         goto out;
4481         } while ((pv = TAILQ_FIRST(&pvh->pv_list)) != pvf);
4482 small_mappings:
4483         if ((pvf = TAILQ_FIRST(&m->md.pv_list)) == NULL)
4484                 goto out;
4485         pv = pvf;
4486         do {
4487                 if (pvf == NULL)
4488                         pvf = pv;
4489                 pmap = PV_PMAP(pv);
4490                 if (!PMAP_TRYLOCK(pmap)) {
4491                         pvh_gen = pvh->pv_gen;
4492                         md_gen = m->md.pv_gen;
4493                         rw_wunlock(lock);
4494                         PMAP_LOCK(pmap);
4495                         rw_wlock(lock);
4496                         if (pvh_gen != pvh->pv_gen || md_gen != m->md.pv_gen) {
4497                                 PMAP_UNLOCK(pmap);
4498                                 goto retry;
4499                         }
4500                 }
4501                 pde = pmap_pde(pmap, pv->pv_va, &lvl);
4502                 KASSERT(pde != NULL, ("pmap_ts_referenced: no l2 table found"));
4503                 KASSERT(lvl == 2,
4504                     ("pmap_ts_referenced: invalid pde level %d", lvl));
4505                 tpde = pmap_load(pde);
4506                 KASSERT((tpde & ATTR_DESCR_MASK) == L2_TABLE,
4507                     ("pmap_ts_referenced: found an invalid l2 table"));
4508                 pte = pmap_l2_to_l3(pde, pv->pv_va);
4509                 tpte = pmap_load(pte);
4510                 if (pmap_page_dirty(tpte))
4511                         vm_page_dirty(m);
4512                 if ((tpte & ATTR_AF) != 0) {
4513                         if (safe_to_clear_referenced(pmap, tpte)) {
4514                                 /*
4515                                  * TODO: We don't handle the access flag
4516                                  * at all. We need to be able to set it in
4517                                  * the exception handler.
4518                                  */
4519                                 panic("ARM64TODO: safe_to_clear_referenced\n");
4520                         } else if ((tpte & ATTR_SW_WIRED) == 0) {
4521                                 /*
4522                                  * Wired pages cannot be paged out so
4523                                  * doing accessed bit emulation for
4524                                  * them is wasted effort. We do the
4525                                  * hard work for unwired pages only.
4526                                  */
4527                                 pmap_remove_l3(pmap, pte, pv->pv_va, tpde,
4528                                     &free, &lock);
4529                                 pmap_invalidate_page(pmap, pv->pv_va);
4530                                 cleared++;
4531                                 if (pvf == pv)
4532                                         pvf = NULL;
4533                                 pv = NULL;
4534                                 KASSERT(lock == VM_PAGE_TO_PV_LIST_LOCK(m),
4535                                     ("inconsistent pv lock %p %p for page %p",
4536                                     lock, VM_PAGE_TO_PV_LIST_LOCK(m), m));
4537                         } else
4538                                 not_cleared++;
4539                 }
4540                 PMAP_UNLOCK(pmap);
4541                 /* Rotate the PV list if it has more than one entry. */
4542                 if (pv != NULL && TAILQ_NEXT(pv, pv_next) != NULL) {
4543                         TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
4544                         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
4545                         m->md.pv_gen++;
4546                 }
4547         } while ((pv = TAILQ_FIRST(&m->md.pv_list)) != pvf && cleared +
4548             not_cleared < PMAP_TS_REFERENCED_MAX);
4549 out:
4550         rw_wunlock(lock);
4551         vm_page_free_pages_toq(&free, false);
4552         return (cleared + not_cleared);
4553 }
4554
4555 /*
4556  *      Apply the given advice to the specified range of addresses within the
4557  *      given pmap.  Depending on the advice, clear the referenced and/or
4558  *      modified flags in each mapping and set the mapped page's dirty field.
4559  */
4560 void
4561 pmap_advise(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, int advice)
4562 {
4563 }
4564
4565 /*
4566  *      Clear the modify bits on the specified physical page.
4567  */
4568 void
4569 pmap_clear_modify(vm_page_t m)
4570 {
4571
4572         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
4573             ("pmap_clear_modify: page %p is not managed", m));
4574         VM_OBJECT_ASSERT_WLOCKED(m->object);
4575         KASSERT(!vm_page_xbusied(m),
4576             ("pmap_clear_modify: page %p is exclusive busied", m));
4577
4578         /*
4579          * If the page is not PGA_WRITEABLE, then no PTEs can have PG_M set.
4580          * If the object containing the page is locked and the page is not
4581          * exclusive busied, then PGA_WRITEABLE cannot be concurrently set.
4582          */
4583         if ((m->aflags & PGA_WRITEABLE) == 0)
4584                 return;
4585
4586         /* ARM64TODO: We lack support for tracking if a page is modified */
4587 }
4588
4589 void *
4590 pmap_mapbios(vm_paddr_t pa, vm_size_t size)
4591 {
4592         struct pmap_preinit_mapping *ppim;
4593         vm_offset_t va, offset;
4594         pd_entry_t *pde;
4595         pt_entry_t *l2;
4596         int i, lvl, l2_blocks, free_l2_count, start_idx;
4597
4598         if (!vm_initialized) {
4599                 /*
4600                  * No L3 ptables so map entire L2 blocks where start VA is:
4601                  *      preinit_map_va + start_idx * L2_SIZE
4602                  * There may be duplicate mappings (multiple VA -> same PA) but
4603                  * ARM64 dcache is always PIPT so that's acceptable.
4604                  */
4605                  if (size == 0)
4606                          return (NULL);
4607
4608                  /* Calculate how many full L2 blocks are needed for the mapping */
4609                 l2_blocks = (roundup2(pa + size, L2_SIZE) - rounddown2(pa, L2_SIZE)) >> L2_SHIFT;
4610
4611                 offset = pa & L2_OFFSET;
4612
4613                 if (preinit_map_va == 0)
4614                         return (NULL);
4615
4616                 /* Map 2MiB L2 blocks from reserved VA space */
4617
4618                 free_l2_count = 0;
4619                 start_idx = -1;
4620                 /* Find enough free contiguous VA space */
4621                 for (i = 0; i < PMAP_PREINIT_MAPPING_COUNT; i++) {
4622                         ppim = pmap_preinit_mapping + i;
4623                         if (free_l2_count > 0 && ppim->pa != 0) {
4624                                 /* Not enough space here */
4625                                 free_l2_count = 0;
4626                                 start_idx = -1;
4627                                 continue;
4628                         }
4629
4630                         if (ppim->pa == 0) {
4631                                 /* Free L2 block */
4632                                 if (start_idx == -1)
4633                                         start_idx = i;
4634                                 free_l2_count++;
4635                                 if (free_l2_count == l2_blocks)
4636                                         break;
4637                         }
4638                 }
4639                 if (free_l2_count != l2_blocks)
4640                         panic("%s: too many preinit mappings", __func__);
4641
4642                 va = preinit_map_va + (start_idx * L2_SIZE);
4643                 for (i = start_idx; i < start_idx + l2_blocks; i++) {
4644                         /* Mark entries as allocated */
4645                         ppim = pmap_preinit_mapping + i;
4646                         ppim->pa = pa;
4647                         ppim->va = va + offset;
4648                         ppim->size = size;
4649                 }
4650
4651                 /* Map L2 blocks */
4652                 pa = rounddown2(pa, L2_SIZE);
4653                 for (i = 0; i < l2_blocks; i++) {
4654                         pde = pmap_pde(kernel_pmap, va, &lvl);
4655                         KASSERT(pde != NULL,
4656                             ("pmap_mapbios: Invalid page entry, va: 0x%lx", va));
4657                         KASSERT(lvl == 1, ("pmap_mapbios: Invalid level %d", lvl));
4658
4659                         /* Insert L2_BLOCK */
4660                         l2 = pmap_l1_to_l2(pde, va);
4661                         pmap_load_store(l2,
4662                             pa | ATTR_DEFAULT | ATTR_XN |
4663                             ATTR_IDX(CACHED_MEMORY) | L2_BLOCK);
4664                         pmap_invalidate_range(kernel_pmap, va, va + L2_SIZE);
4665
4666                         va += L2_SIZE;
4667                         pa += L2_SIZE;
4668                 }
4669
4670                 va = preinit_map_va + (start_idx * L2_SIZE);
4671
4672         } else {
4673                 /* kva_alloc may be used to map the pages */
4674                 offset = pa & PAGE_MASK;
4675                 size = round_page(offset + size);
4676
4677                 va = kva_alloc(size);
4678                 if (va == 0)
4679                         panic("%s: Couldn't allocate KVA", __func__);
4680
4681                 pde = pmap_pde(kernel_pmap, va, &lvl);
4682                 KASSERT(lvl == 2, ("pmap_mapbios: Invalid level %d", lvl));
4683
4684                 /* L3 table is linked */
4685                 va = trunc_page(va);
4686                 pa = trunc_page(pa);
4687                 pmap_kenter(va, size, pa, CACHED_MEMORY);
4688         }
4689
4690         return ((void *)(va + offset));
4691 }
4692
4693 void
4694 pmap_unmapbios(vm_offset_t va, vm_size_t size)
4695 {
4696         struct pmap_preinit_mapping *ppim;
4697         vm_offset_t offset, tmpsize, va_trunc;
4698         pd_entry_t *pde;
4699         pt_entry_t *l2;
4700         int i, lvl, l2_blocks, block;
4701
4702         l2_blocks = (roundup2(va + size, L2_SIZE) - rounddown2(va, L2_SIZE)) >> L2_SHIFT;
4703         KASSERT(l2_blocks > 0, ("pmap_unmapbios: invalid size %lx", size));
4704
4705         /* Remove preinit mapping */
4706         block = 0;
4707         for (i = 0; i < PMAP_PREINIT_MAPPING_COUNT; i++) {
4708                 ppim = pmap_preinit_mapping + i;
4709                 if (ppim->va == va) {
4710                         KASSERT(ppim->size == size, ("pmap_unmapbios: size mismatch"));
4711                         ppim->va = 0;
4712                         ppim->pa = 0;
4713                         ppim->size = 0;
4714                         offset = block * L2_SIZE;
4715                         va_trunc = rounddown2(va, L2_SIZE) + offset;
4716
4717                         /* Remove L2_BLOCK */
4718                         pde = pmap_pde(kernel_pmap, va_trunc, &lvl);
4719                         KASSERT(pde != NULL,
4720                             ("pmap_unmapbios: Invalid page entry, va: 0x%lx", va_trunc));
4721                         l2 = pmap_l1_to_l2(pde, va_trunc);
4722                         pmap_load_clear(l2);
4723                         pmap_invalidate_range(kernel_pmap, va_trunc, va_trunc + L2_SIZE);
4724
4725                         if (block == (l2_blocks - 1))
4726                                 return;
4727                         block++;
4728                 }
4729         }
4730
4731         /* Unmap the pages reserved with kva_alloc. */
4732         if (vm_initialized) {
4733                 offset = va & PAGE_MASK;
4734                 size = round_page(offset + size);
4735                 va = trunc_page(va);
4736
4737                 pde = pmap_pde(kernel_pmap, va, &lvl);
4738                 KASSERT(pde != NULL,
4739                     ("pmap_unmapbios: Invalid page entry, va: 0x%lx", va));
4740                 KASSERT(lvl == 2, ("pmap_unmapbios: Invalid level %d", lvl));
4741
4742                 /* Unmap and invalidate the pages */
4743                 for (tmpsize = 0; tmpsize < size; tmpsize += PAGE_SIZE)
4744                         pmap_kremove(va + tmpsize);
4745
4746                 kva_free(va, size);
4747         }
4748 }
4749
4750 /*
4751  * Sets the memory attribute for the specified page.
4752  */
4753 void
4754 pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
4755 {
4756
4757         m->md.pv_memattr = ma;
4758
4759         /*
4760          * If "m" is a normal page, update its direct mapping.  This update
4761          * can be relied upon to perform any cache operations that are
4762          * required for data coherence.
4763          */
4764         if ((m->flags & PG_FICTITIOUS) == 0 &&
4765             pmap_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,
4766             m->md.pv_memattr) != 0)
4767                 panic("memory attribute change on the direct map failed");
4768 }
4769
4770 /*
4771  * Changes the specified virtual address range's memory type to that given by
4772  * the parameter "mode".  The specified virtual address range must be
4773  * completely contained within either the direct map or the kernel map.  If
4774  * the virtual address range is contained within the kernel map, then the
4775  * memory type for each of the corresponding ranges of the direct map is also
4776  * changed.  (The corresponding ranges of the direct map are those ranges that
4777  * map the same physical pages as the specified virtual address range.)  These
4778  * changes to the direct map are necessary because Intel describes the
4779  * behavior of their processors as "undefined" if two or more mappings to the
4780  * same physical page have different memory types.
4781  *
4782  * Returns zero if the change completed successfully, and either EINVAL or
4783  * ENOMEM if the change failed.  Specifically, EINVAL is returned if some part
4784  * of the virtual address range was not mapped, and ENOMEM is returned if
4785  * there was insufficient memory available to complete the change.  In the
4786  * latter case, the memory type may have been changed on some part of the
4787  * virtual address range or the direct map.
4788  */
4789 static int
4790 pmap_change_attr(vm_offset_t va, vm_size_t size, int mode)
4791 {
4792         int error;
4793
4794         PMAP_LOCK(kernel_pmap);
4795         error = pmap_change_attr_locked(va, size, mode);
4796         PMAP_UNLOCK(kernel_pmap);
4797         return (error);
4798 }
4799
4800 static int
4801 pmap_change_attr_locked(vm_offset_t va, vm_size_t size, int mode)
4802 {
4803         vm_offset_t base, offset, tmpva;
4804         pt_entry_t l3, *pte, *newpte;
4805         int lvl;
4806
4807         PMAP_LOCK_ASSERT(kernel_pmap, MA_OWNED);
4808         base = trunc_page(va);
4809         offset = va & PAGE_MASK;
4810         size = round_page(offset + size);
4811
4812         if (!VIRT_IN_DMAP(base))
4813                 return (EINVAL);
4814
4815         for (tmpva = base; tmpva < base + size; ) {
4816                 pte = pmap_pte(kernel_pmap, va, &lvl);
4817                 if (pte == NULL)
4818                         return (EINVAL);
4819
4820                 if ((pmap_load(pte) & ATTR_IDX_MASK) == ATTR_IDX(mode)) {
4821                         /*
4822                          * We already have the correct attribute,
4823                          * ignore this entry.
4824                          */
4825                         switch (lvl) {
4826                         default:
4827                                 panic("Invalid DMAP table level: %d\n", lvl);
4828                         case 1:
4829                                 tmpva = (tmpva & ~L1_OFFSET) + L1_SIZE;
4830                                 break;
4831                         case 2:
4832                                 tmpva = (tmpva & ~L2_OFFSET) + L2_SIZE;
4833                                 break;
4834                         case 3:
4835                                 tmpva += PAGE_SIZE;
4836                                 break;
4837                         }
4838                 } else {
4839                         /*
4840                          * Split the entry to an level 3 table, then
4841                          * set the new attribute.
4842                          */
4843                         switch (lvl) {
4844                         default:
4845                                 panic("Invalid DMAP table level: %d\n", lvl);
4846                         case 1:
4847                                 newpte = pmap_demote_l1(kernel_pmap, pte,
4848                                     tmpva & ~L1_OFFSET);
4849                                 if (newpte == NULL)
4850                                         return (EINVAL);
4851                                 pte = pmap_l1_to_l2(pte, tmpva);
4852                         case 2:
4853                                 newpte = pmap_demote_l2(kernel_pmap, pte,
4854                                     tmpva & ~L2_OFFSET);
4855                                 if (newpte == NULL)
4856                                         return (EINVAL);
4857                                 pte = pmap_l2_to_l3(pte, tmpva);
4858                         case 3:
4859                                 /* Update the entry */
4860                                 l3 = pmap_load(pte);
4861                                 l3 &= ~ATTR_IDX_MASK;
4862                                 l3 |= ATTR_IDX(mode);
4863                                 if (mode == DEVICE_MEMORY)
4864                                         l3 |= ATTR_XN;
4865
4866                                 pmap_update_entry(kernel_pmap, pte, l3, tmpva,
4867                                     PAGE_SIZE);
4868
4869                                 /*
4870                                  * If moving to a non-cacheable entry flush
4871                                  * the cache.
4872                                  */
4873                                 if (mode == VM_MEMATTR_UNCACHEABLE)
4874                                         cpu_dcache_wbinv_range(tmpva, L3_SIZE);
4875
4876                                 break;
4877                         }
4878                         tmpva += PAGE_SIZE;
4879                 }
4880         }
4881
4882         return (0);
4883 }
4884
4885 /*
4886  * Create an L2 table to map all addresses within an L1 mapping.
4887  */
4888 static pt_entry_t *
4889 pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va)
4890 {
4891         pt_entry_t *l2, newl2, oldl1;
4892         vm_offset_t tmpl1;
4893         vm_paddr_t l2phys, phys;
4894         vm_page_t ml2;
4895         int i;
4896
4897         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
4898         oldl1 = pmap_load(l1);
4899         KASSERT((oldl1 & ATTR_DESCR_MASK) == L1_BLOCK,
4900             ("pmap_demote_l1: Demoting a non-block entry"));
4901         KASSERT((va & L1_OFFSET) == 0,
4902             ("pmap_demote_l1: Invalid virtual address %#lx", va));
4903         KASSERT((oldl1 & ATTR_SW_MANAGED) == 0,
4904             ("pmap_demote_l1: Level 1 table shouldn't be managed"));
4905
4906         tmpl1 = 0;
4907         if (va <= (vm_offset_t)l1 && va + L1_SIZE > (vm_offset_t)l1) {
4908                 tmpl1 = kva_alloc(PAGE_SIZE);
4909                 if (tmpl1 == 0)
4910                         return (NULL);
4911         }
4912
4913         if ((ml2 = vm_page_alloc(NULL, 0, VM_ALLOC_INTERRUPT |
4914             VM_ALLOC_NOOBJ | VM_ALLOC_WIRED)) == NULL) {
4915                 CTR2(KTR_PMAP, "pmap_demote_l1: failure for va %#lx"
4916                     " in pmap %p", va, pmap);
4917                 return (NULL);
4918         }
4919
4920         l2phys = VM_PAGE_TO_PHYS(ml2);
4921         l2 = (pt_entry_t *)PHYS_TO_DMAP(l2phys);
4922
4923         /* Address the range points at */
4924         phys = oldl1 & ~ATTR_MASK;
4925         /* The attributed from the old l1 table to be copied */
4926         newl2 = oldl1 & ATTR_MASK;
4927
4928         /* Create the new entries */
4929         for (i = 0; i < Ln_ENTRIES; i++) {
4930                 l2[i] = newl2 | phys;
4931                 phys += L2_SIZE;
4932         }
4933         KASSERT(l2[0] == ((oldl1 & ~ATTR_DESCR_MASK) | L2_BLOCK),
4934             ("Invalid l2 page (%lx != %lx)", l2[0],
4935             (oldl1 & ~ATTR_DESCR_MASK) | L2_BLOCK));
4936
4937         if (tmpl1 != 0) {
4938                 pmap_kenter(tmpl1, PAGE_SIZE,
4939                     DMAP_TO_PHYS((vm_offset_t)l1) & ~L3_OFFSET, CACHED_MEMORY);
4940                 l1 = (pt_entry_t *)(tmpl1 + ((vm_offset_t)l1 & PAGE_MASK));
4941         }
4942
4943         pmap_update_entry(pmap, l1, l2phys | L1_TABLE, va, PAGE_SIZE);
4944
4945         if (tmpl1 != 0) {
4946                 pmap_kremove(tmpl1);
4947                 kva_free(tmpl1, PAGE_SIZE);
4948         }
4949
4950         return (l2);
4951 }
4952
4953 /*
4954  * Create an L3 table to map all addresses within an L2 mapping.
4955  */
4956 static pt_entry_t *
4957 pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2, vm_offset_t va,
4958     struct rwlock **lockp)
4959 {
4960         pt_entry_t *l3, newl3, oldl2;
4961         vm_offset_t tmpl2;
4962         vm_paddr_t l3phys, phys;
4963         vm_page_t ml3;
4964         int i;
4965
4966         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
4967         l3 = NULL;
4968         oldl2 = pmap_load(l2);
4969         KASSERT((oldl2 & ATTR_DESCR_MASK) == L2_BLOCK,
4970             ("pmap_demote_l2: Demoting a non-block entry"));
4971         KASSERT((va & L2_OFFSET) == 0,
4972             ("pmap_demote_l2: Invalid virtual address %#lx", va));
4973
4974         tmpl2 = 0;
4975         if (va <= (vm_offset_t)l2 && va + L2_SIZE > (vm_offset_t)l2) {
4976                 tmpl2 = kva_alloc(PAGE_SIZE);
4977                 if (tmpl2 == 0)
4978                         return (NULL);
4979         }
4980
4981         if ((ml3 = pmap_remove_pt_page(pmap, va)) == NULL) {
4982                 ml3 = vm_page_alloc(NULL, pmap_l2_pindex(va),
4983                     (VIRT_IN_DMAP(va) ? VM_ALLOC_INTERRUPT : VM_ALLOC_NORMAL) |
4984                     VM_ALLOC_NOOBJ | VM_ALLOC_WIRED);
4985                 if (ml3 == NULL) {
4986                         CTR2(KTR_PMAP, "pmap_demote_l2: failure for va %#lx"
4987                             " in pmap %p", va, pmap);
4988                         goto fail;
4989                 }
4990                 if (va < VM_MAXUSER_ADDRESS)
4991                         pmap_resident_count_inc(pmap, 1);
4992         }
4993
4994         l3phys = VM_PAGE_TO_PHYS(ml3);
4995         l3 = (pt_entry_t *)PHYS_TO_DMAP(l3phys);
4996
4997         /* Address the range points at */
4998         phys = oldl2 & ~ATTR_MASK;
4999         /* The attributed from the old l2 table to be copied */
5000         newl3 = (oldl2 & (ATTR_MASK & ~ATTR_DESCR_MASK)) | L3_PAGE;
5001
5002         /*
5003          * If the page table page is new, initialize it.
5004          */
5005         if (ml3->wire_count == 1) {
5006                 ml3->wire_count = NL3PG;
5007                 for (i = 0; i < Ln_ENTRIES; i++) {
5008                         l3[i] = newl3 | phys;
5009                         phys += L3_SIZE;
5010                 }
5011         }
5012         KASSERT(l3[0] == ((oldl2 & ~ATTR_DESCR_MASK) | L3_PAGE),
5013             ("Invalid l3 page (%lx != %lx)", l3[0],
5014             (oldl2 & ~ATTR_DESCR_MASK) | L3_PAGE));
5015
5016         /*
5017          * Map the temporary page so we don't lose access to the l2 table.
5018          */
5019         if (tmpl2 != 0) {
5020                 pmap_kenter(tmpl2, PAGE_SIZE,
5021                     DMAP_TO_PHYS((vm_offset_t)l2) & ~L3_OFFSET, CACHED_MEMORY);
5022                 l2 = (pt_entry_t *)(tmpl2 + ((vm_offset_t)l2 & PAGE_MASK));
5023         }
5024
5025         /*
5026          * The spare PV entries must be reserved prior to demoting the
5027          * mapping, that is, prior to changing the PDE.  Otherwise, the state
5028          * of the L2 and the PV lists will be inconsistent, which can result
5029          * in reclaim_pv_chunk() attempting to remove a PV entry from the
5030          * wrong PV list and pmap_pv_demote_l2() failing to find the expected
5031          * PV entry for the 2MB page mapping that is being demoted.
5032          */
5033         if ((oldl2 & ATTR_SW_MANAGED) != 0)
5034                 reserve_pv_entries(pmap, Ln_ENTRIES - 1, lockp);
5035
5036         pmap_update_entry(pmap, l2, l3phys | L2_TABLE, va, PAGE_SIZE);
5037
5038         /*
5039          * Demote the PV entry.
5040          */
5041         if ((oldl2 & ATTR_SW_MANAGED) != 0)
5042                 pmap_pv_demote_l2(pmap, va, oldl2 & ~ATTR_MASK, lockp);
5043
5044         atomic_add_long(&pmap_l2_demotions, 1);
5045         CTR3(KTR_PMAP, "pmap_demote_l2: success for va %#lx"
5046             " in pmap %p %lx", va, pmap, l3[0]);
5047
5048 fail:
5049         if (tmpl2 != 0) {
5050                 pmap_kremove(tmpl2);
5051                 kva_free(tmpl2, PAGE_SIZE);
5052         }
5053
5054         return (l3);
5055
5056 }
5057
5058 static pt_entry_t *
5059 pmap_demote_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t va)
5060 {
5061         struct rwlock *lock;
5062         pt_entry_t *l3;
5063
5064         lock = NULL;
5065         l3 = pmap_demote_l2_locked(pmap, l2, va, &lock);
5066         if (lock != NULL)
5067                 rw_wunlock(lock);
5068         return (l3);
5069 }
5070
5071 /*
5072  * perform the pmap work for mincore
5073  */
5074 int
5075 pmap_mincore(pmap_t pmap, vm_offset_t addr, vm_paddr_t *locked_pa)
5076 {
5077         pt_entry_t *pte, tpte;
5078         vm_paddr_t mask, pa;
5079         int lvl, val;
5080         bool managed;
5081
5082         PMAP_LOCK(pmap);
5083 retry:
5084         val = 0;
5085         pte = pmap_pte(pmap, addr, &lvl);
5086         if (pte != NULL) {
5087                 tpte = pmap_load(pte);
5088
5089                 switch (lvl) {
5090                 case 3:
5091                         mask = L3_OFFSET;
5092                         break;
5093                 case 2:
5094                         mask = L2_OFFSET;
5095                         break;
5096                 case 1:
5097                         mask = L1_OFFSET;
5098                         break;
5099                 default:
5100                         panic("pmap_mincore: invalid level %d", lvl);
5101                 }
5102
5103                 val = MINCORE_INCORE;
5104                 if (lvl != 3)
5105                         val |= MINCORE_SUPER;
5106                 if (pmap_page_dirty(tpte))
5107                         val |= MINCORE_MODIFIED | MINCORE_MODIFIED_OTHER;
5108                 if ((tpte & ATTR_AF) == ATTR_AF)
5109                         val |= MINCORE_REFERENCED | MINCORE_REFERENCED_OTHER;
5110
5111                 managed = (tpte & ATTR_SW_MANAGED) == ATTR_SW_MANAGED;
5112                 pa = (tpte & ~ATTR_MASK) | (addr & mask);
5113         } else
5114                 managed = false;
5115
5116         if ((val & (MINCORE_MODIFIED_OTHER | MINCORE_REFERENCED_OTHER)) !=
5117             (MINCORE_MODIFIED_OTHER | MINCORE_REFERENCED_OTHER) && managed) {
5118                 /* Ensure that "PHYS_TO_VM_PAGE(pa)->object" doesn't change. */
5119                 if (vm_page_pa_tryrelock(pmap, pa, locked_pa))
5120                         goto retry;
5121         } else
5122                 PA_UNLOCK_COND(*locked_pa);
5123         PMAP_UNLOCK(pmap);
5124
5125         return (val);
5126 }
5127
5128 void
5129 pmap_activate(struct thread *td)
5130 {
5131         pmap_t  pmap;
5132
5133         critical_enter();
5134         pmap = vmspace_pmap(td->td_proc->p_vmspace);
5135         td->td_proc->p_md.md_l0addr = vtophys(pmap->pm_l0);
5136         __asm __volatile("msr ttbr0_el1, %0" : :
5137             "r"(td->td_proc->p_md.md_l0addr));
5138         pmap_invalidate_all(pmap);
5139         critical_exit();
5140 }
5141
5142 struct pcb *
5143 pmap_switch(struct thread *old, struct thread *new)
5144 {
5145         pcpu_bp_harden bp_harden;
5146         struct pcb *pcb;
5147
5148         /* Store the new curthread */
5149         PCPU_SET(curthread, new);
5150
5151         /* And the new pcb */
5152         pcb = new->td_pcb;
5153         PCPU_SET(curpcb, pcb);
5154
5155         /*
5156          * TODO: We may need to flush the cache here if switching
5157          * to a user process.
5158          */
5159
5160         if (old == NULL ||
5161             old->td_proc->p_md.md_l0addr != new->td_proc->p_md.md_l0addr) {
5162                 __asm __volatile(
5163                     /* Switch to the new pmap */
5164                     "msr        ttbr0_el1, %0   \n"
5165                     "isb                        \n"
5166
5167                     /* Invalidate the TLB */
5168                     "dsb        ishst           \n"
5169                     "tlbi       vmalle1is       \n"
5170                     "dsb        ish             \n"
5171                     "isb                        \n"
5172                     : : "r"(new->td_proc->p_md.md_l0addr));
5173
5174                 /*
5175                  * Stop userspace from training the branch predictor against
5176                  * other processes. This will call into a CPU specific
5177                  * function that clears the branch predictor state.
5178                  */
5179                 bp_harden = PCPU_GET(bp_harden);
5180                 if (bp_harden != NULL)
5181                         bp_harden();
5182         }
5183
5184         return (pcb);
5185 }
5186
5187 void
5188 pmap_sync_icache(pmap_t pmap, vm_offset_t va, vm_size_t sz)
5189 {
5190
5191         if (va >= VM_MIN_KERNEL_ADDRESS) {
5192                 cpu_icache_sync_range(va, sz);
5193         } else {
5194                 u_int len, offset;
5195                 vm_paddr_t pa;
5196
5197                 /* Find the length of data in this page to flush */
5198                 offset = va & PAGE_MASK;
5199                 len = imin(PAGE_SIZE - offset, sz);
5200
5201                 while (sz != 0) {
5202                         /* Extract the physical address & find it in the DMAP */
5203                         pa = pmap_extract(pmap, va);
5204                         if (pa != 0)
5205                                 cpu_icache_sync_range(PHYS_TO_DMAP(pa), len);
5206
5207                         /* Move to the next page */
5208                         sz -= len;
5209                         va += len;
5210                         /* Set the length for the next iteration */
5211                         len = imin(PAGE_SIZE, sz);
5212                 }
5213         }
5214 }
5215
5216 int
5217 pmap_fault(pmap_t pmap, uint64_t esr, uint64_t far)
5218 {
5219 #ifdef SMP
5220         register_t intr;
5221         uint64_t par;
5222
5223         switch (ESR_ELx_EXCEPTION(esr)) {
5224         case EXCP_INSN_ABORT_L:
5225         case EXCP_INSN_ABORT:
5226         case EXCP_DATA_ABORT_L:
5227         case EXCP_DATA_ABORT:
5228                 break;
5229         default:
5230                 return (KERN_FAILURE);
5231         }
5232
5233         /* Data and insn aborts use same encoding for FCS field. */
5234         switch (esr & ISS_DATA_DFSC_MASK) {
5235         case ISS_DATA_DFSC_TF_L0:
5236         case ISS_DATA_DFSC_TF_L1:
5237         case ISS_DATA_DFSC_TF_L2:
5238         case ISS_DATA_DFSC_TF_L3:
5239                 PMAP_LOCK(pmap);
5240                 /* Ask the MMU to check the address */
5241                 intr = intr_disable();
5242                 if (pmap == kernel_pmap)
5243                         par = arm64_address_translate_s1e1r(far);
5244                 else
5245                         par = arm64_address_translate_s1e0r(far);
5246                 intr_restore(intr);
5247                 PMAP_UNLOCK(pmap);
5248
5249                 /*
5250                  * If the translation was successful the address was invalid
5251                  * due to a break-before-make sequence. We can unlock and
5252                  * return success to the trap handler.
5253                  */
5254                 if (PAR_SUCCESS(par))
5255                         return (KERN_SUCCESS);
5256                 break;
5257         default:
5258                 break;
5259         }
5260 #endif
5261
5262         return (KERN_FAILURE);
5263 }
5264
5265 /*
5266  *      Increase the starting virtual address of the given mapping if a
5267  *      different alignment might result in more superpage mappings.
5268  */
5269 void
5270 pmap_align_superpage(vm_object_t object, vm_ooffset_t offset,
5271     vm_offset_t *addr, vm_size_t size)
5272 {
5273         vm_offset_t superpage_offset;
5274
5275         if (size < L2_SIZE)
5276                 return;
5277         if (object != NULL && (object->flags & OBJ_COLORED) != 0)
5278                 offset += ptoa(object->pg_color);
5279         superpage_offset = offset & L2_OFFSET;
5280         if (size - ((L2_SIZE - superpage_offset) & L2_OFFSET) < L2_SIZE ||
5281             (*addr & L2_OFFSET) == superpage_offset)
5282                 return;
5283         if ((*addr & L2_OFFSET) < superpage_offset)
5284                 *addr = (*addr & ~L2_OFFSET) + superpage_offset;
5285         else
5286                 *addr = ((*addr + L2_OFFSET) & ~L2_OFFSET) + superpage_offset;
5287 }
5288
5289 /**
5290  * Get the kernel virtual address of a set of physical pages. If there are
5291  * physical addresses not covered by the DMAP perform a transient mapping
5292  * that will be removed when calling pmap_unmap_io_transient.
5293  *
5294  * \param page        The pages the caller wishes to obtain the virtual
5295  *                    address on the kernel memory map.
5296  * \param vaddr       On return contains the kernel virtual memory address
5297  *                    of the pages passed in the page parameter.
5298  * \param count       Number of pages passed in.
5299  * \param can_fault   TRUE if the thread using the mapped pages can take
5300  *                    page faults, FALSE otherwise.
5301  *
5302  * \returns TRUE if the caller must call pmap_unmap_io_transient when
5303  *          finished or FALSE otherwise.
5304  *
5305  */
5306 boolean_t
5307 pmap_map_io_transient(vm_page_t page[], vm_offset_t vaddr[], int count,
5308     boolean_t can_fault)
5309 {
5310         vm_paddr_t paddr;
5311         boolean_t needs_mapping;
5312         int error, i;
5313
5314         /*
5315          * Allocate any KVA space that we need, this is done in a separate
5316          * loop to prevent calling vmem_alloc while pinned.
5317          */
5318         needs_mapping = FALSE;
5319         for (i = 0; i < count; i++) {
5320                 paddr = VM_PAGE_TO_PHYS(page[i]);
5321                 if (__predict_false(!PHYS_IN_DMAP(paddr))) {
5322                         error = vmem_alloc(kernel_arena, PAGE_SIZE,
5323                             M_BESTFIT | M_WAITOK, &vaddr[i]);
5324                         KASSERT(error == 0, ("vmem_alloc failed: %d", error));
5325                         needs_mapping = TRUE;
5326                 } else {
5327                         vaddr[i] = PHYS_TO_DMAP(paddr);
5328                 }
5329         }
5330
5331         /* Exit early if everything is covered by the DMAP */
5332         if (!needs_mapping)
5333                 return (FALSE);
5334
5335         if (!can_fault)
5336                 sched_pin();
5337         for (i = 0; i < count; i++) {
5338                 paddr = VM_PAGE_TO_PHYS(page[i]);
5339                 if (!PHYS_IN_DMAP(paddr)) {
5340                         panic(
5341                            "pmap_map_io_transient: TODO: Map out of DMAP data");
5342                 }
5343         }
5344
5345         return (needs_mapping);
5346 }
5347
5348 void
5349 pmap_unmap_io_transient(vm_page_t page[], vm_offset_t vaddr[], int count,
5350     boolean_t can_fault)
5351 {
5352         vm_paddr_t paddr;
5353         int i;
5354
5355         if (!can_fault)
5356                 sched_unpin();
5357         for (i = 0; i < count; i++) {
5358                 paddr = VM_PAGE_TO_PHYS(page[i]);
5359                 if (!PHYS_IN_DMAP(paddr)) {
5360                         panic("ARM64TODO: pmap_unmap_io_transient: Unmap data");
5361                 }
5362         }
5363 }
5364
5365 boolean_t
5366 pmap_is_valid_memattr(pmap_t pmap __unused, vm_memattr_t mode)
5367 {
5368
5369         return (mode >= VM_MEMATTR_DEVICE && mode <= VM_MEMATTR_WRITE_THROUGH);
5370 }