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