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