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