sys/arm64/arm64/pmap.c

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