sys/riscv/riscv/pmap.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-4-Clause
   3  *
   4  * Copyright (c) 1991 Regents of the University of California.
   5  * All rights reserved.
   6  * Copyright (c) 1994 John S. Dyson
   7  * All rights reserved.
   8  * Copyright (c) 1994 David Greenman
   9  * All rights reserved.
  10  * Copyright (c) 2003 Peter Wemm
  11  * All rights reserved.
  12  * Copyright (c) 2005-2010 Alan L. Cox <alc@cs.rice.edu>
  13  * All rights reserved.
  14  * Copyright (c) 2014 Andrew Turner
  15  * All rights reserved.
  16  * Copyright (c) 2014 The FreeBSD Foundation
  17  * All rights reserved.
  18  * Copyright (c) 2015-2018 Ruslan Bukin <br@bsdpad.com>
  19  * All rights reserved.
  20  *
  21  * This code is derived from software contributed to Berkeley by
  22  * the Systems Programming Group of the University of Utah Computer
  23  * Science Department and William Jolitz of UUNET Technologies Inc.
  24  *
  25  * Portions of this software were developed by Andrew Turner under
  26  * sponsorship from The FreeBSD Foundation.
  27  *
  28  * Portions of this software were developed by SRI International and the
  29  * University of Cambridge Computer Laboratory under DARPA/AFRL contract
  30  * FA8750-10-C-0237 ("CTSRD"), as part of the DARPA CRASH research programme.
  31  *
  32  * Portions of this software were developed by the University of Cambridge
  33  * Computer Laboratory as part of the CTSRD Project, with support from the
  34  * UK Higher Education Innovation Fund (HEIF).
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  * 1. Redistributions of source code must retain the above copyright
  40  *    notice, this list of conditions and the following disclaimer.
  41  * 2. Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in the
  43  *    documentation and/or other materials provided with the distribution.
  44  * 3. All advertising materials mentioning features or use of this software
  45  *    must display the following acknowledgement:
  46  *      This product includes software developed by the University of
  47  *      California, Berkeley and its contributors.
  48  * 4. Neither the name of the University nor the names of its contributors
  49  *    may be used to endorse or promote products derived from this software
  50  *    without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  53  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  54  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  55  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  56  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  57  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  58  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  59  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  60  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  61  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  62  * SUCH DAMAGE.
  63  *
  64  *      from:   @(#)pmap.c      7.7 (Berkeley)  5/12/91
  65  */
  66 /*-
  67  * Copyright (c) 2003 Networks Associates Technology, Inc.
  68  * All rights reserved.
  69  *
  70  * This software was developed for the FreeBSD Project by Jake Burkholder,
  71  * Safeport Network Services, and Network Associates Laboratories, the
  72  * Security Research Division of Network Associates, Inc. under
  73  * DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA
  74  * CHATS research program.
  75  *
  76  * Redistribution and use in source and binary forms, with or without
  77  * modification, are permitted provided that the following conditions
  78  * are met:
  79  * 1. Redistributions of source code must retain the above copyright
  80  *    notice, this list of conditions and the following disclaimer.
  81  * 2. Redistributions in binary form must reproduce the above copyright
  82  *    notice, this list of conditions and the following disclaimer in the
  83  *    documentation and/or other materials provided with the distribution.
  84  *
  85  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  86  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  88  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  89  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  90  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  91  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  92  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  93  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  94  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  95  * SUCH DAMAGE.
  96  */
  97
  98 #include <sys/cdefs.h>
  99 __FBSDID("$FreeBSD$");
 100
 101 /*
 102  *      Manages physical address maps.
 103  *
 104  *      Since the information managed by this module is
 105  *      also stored by the logical address mapping module,
 106  *      this module may throw away valid virtual-to-physical
 107  *      mappings at almost any time.  However, invalidations
 108  *      of virtual-to-physical mappings must be done as
 109  *      requested.
 110  *
 111  *      In order to cope with hardware architectures which
 112  *      make virtual-to-physical map invalidates expensive,
 113  *      this module may delay invalidate or reduced protection
 114  *      operations until such time as they are actually
 115  *      necessary.  This module is given full information as
 116  *      to which processors are currently using which maps,
 117  *      and to when physical maps must be made correct.
 118  */
 119
 120 #include <sys/param.h>
 121 #include <sys/bus.h>
 122 #include <sys/systm.h>
 123 #include <sys/kernel.h>
 124 #include <sys/ktr.h>
 125 #include <sys/lock.h>
 126 #include <sys/malloc.h>
 127 #include <sys/mman.h>
 128 #include <sys/msgbuf.h>
 129 #include <sys/mutex.h>
 130 #include <sys/proc.h>
 131 #include <sys/rwlock.h>
 132 #include <sys/sx.h>
 133 #include <sys/vmem.h>
 134 #include <sys/vmmeter.h>
 135 #include <sys/sched.h>
 136 #include <sys/sysctl.h>
 137 #include <sys/smp.h>
 138
 139 #include <vm/vm.h>
 140 #include <vm/vm_param.h>
 141 #include <vm/vm_kern.h>
 142 #include <vm/vm_page.h>
 143 #include <vm/vm_map.h>
 144 #include <vm/vm_object.h>
 145 #include <vm/vm_extern.h>
 146 #include <vm/vm_pageout.h>
 147 #include <vm/vm_pager.h>
 148 #include <vm/vm_radix.h>
 149 #include <vm/vm_reserv.h>
 150 #include <vm/uma.h>
 151
 152 #include <machine/machdep.h>
 153 #include <machine/md_var.h>
 154 #include <machine/pcb.h>
 155 #include <machine/sbi.h>
 156
 157 #define NPDEPG          (PAGE_SIZE/(sizeof (pd_entry_t)))
 158 #define NUPDE                   (NPDEPG * NPDEPG)
 159 #define NUSERPGTBLS             (NUPDE + NPDEPG)
 160
 161 #if !defined(DIAGNOSTIC)
 162 #ifdef __GNUC_GNU_INLINE__
 163 #define PMAP_INLINE     __attribute__((__gnu_inline__)) inline
 164 #else
 165 #define PMAP_INLINE     extern inline
 166 #endif
 167 #else
 168 #define PMAP_INLINE
 169 #endif
 170
 171 #ifdef PV_STATS
 172 #define PV_STAT(x)      do { x ; } while (0)
 173 #else
 174 #define PV_STAT(x)      do { } while (0)
 175 #endif
 176
 177 #define pmap_l2_pindex(v)       ((v) >> L2_SHIFT)
 178
 179 #define NPV_LIST_LOCKS  MAXCPU
 180
 181 #define PHYS_TO_PV_LIST_LOCK(pa)        \
 182                         (&pv_list_locks[pa_index(pa) % NPV_LIST_LOCKS])
 183
 184 #define CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, pa)  do {    \
 185         struct rwlock **_lockp = (lockp);               \
 186         struct rwlock *_new_lock;                       \
 187                                                         \
 188         _new_lock = PHYS_TO_PV_LIST_LOCK(pa);           \
 189         if (_new_lock != *_lockp) {                     \
 190                 if (*_lockp != NULL)                    \
 191                         rw_wunlock(*_lockp);            \
 192                 *_lockp = _new_lock;                    \
 193                 rw_wlock(*_lockp);                      \
 194         }                                               \
 195 } while (0)
 196
 197 #define CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m)        \
 198                         CHANGE_PV_LIST_LOCK_TO_PHYS(lockp, VM_PAGE_TO_PHYS(m))
 199
 200 #define RELEASE_PV_LIST_LOCK(lockp)             do {    \
 201         struct rwlock **_lockp = (lockp);               \
 202                                                         \
 203         if (*_lockp != NULL) {                          \
 204                 rw_wunlock(*_lockp);                    \
 205                 *_lockp = NULL;                         \
 206         }                                               \
 207 } while (0)
 208
 209 #define VM_PAGE_TO_PV_LIST_LOCK(m)      \
 210                         PHYS_TO_PV_LIST_LOCK(VM_PAGE_TO_PHYS(m))
 211
 212 /* The list of all the user pmaps */
 213 LIST_HEAD(pmaplist, pmap);
 214 static struct pmaplist allpmaps;
 215
 216 static MALLOC_DEFINE(M_VMPMAP, "pmap", "PMAP L1");
 217
 218 struct pmap kernel_pmap_store;
 219
 220 vm_offset_t virtual_avail;      /* VA of first avail page (after kernel bss) */
 221 vm_offset_t virtual_end;        /* VA of last avail page (end of kernel AS) */
 222 vm_offset_t kernel_vm_end = 0;
 223
 224 vm_paddr_t dmap_phys_base;      /* The start of the dmap region */
 225 vm_paddr_t dmap_phys_max;       /* The limit of the dmap region */
 226 vm_offset_t dmap_max_addr;      /* The virtual address limit of the dmap */
 227
 228 /* This code assumes all L1 DMAP entries will be used */
 229 CTASSERT((DMAP_MIN_ADDRESS  & ~L1_OFFSET) == DMAP_MIN_ADDRESS);
 230 CTASSERT((DMAP_MAX_ADDRESS  & ~L1_OFFSET) == DMAP_MAX_ADDRESS);
 231
 232 static struct rwlock_padalign pvh_global_lock;
 233
 234 /*
 235  * Data for the pv entry allocation mechanism
 236  */
 237 static TAILQ_HEAD(pch, pv_chunk) pv_chunks = TAILQ_HEAD_INITIALIZER(pv_chunks);
 238 static struct mtx pv_chunks_mutex;
 239 static struct rwlock pv_list_locks[NPV_LIST_LOCKS];
 240
 241 static void     free_pv_chunk(struct pv_chunk *pc);
 242 static void     free_pv_entry(pmap_t pmap, pv_entry_t pv);
 243 static pv_entry_t get_pv_entry(pmap_t pmap, struct rwlock **lockp);
 244 static vm_page_t reclaim_pv_chunk(pmap_t locked_pmap, struct rwlock **lockp);
 245 static void     pmap_pvh_free(struct md_page *pvh, pmap_t pmap, vm_offset_t va);
 246 static pv_entry_t pmap_pvh_remove(struct md_page *pvh, pmap_t pmap,
 247                     vm_offset_t va);
 248 static vm_page_t pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va,
 249     vm_page_t m, vm_prot_t prot, vm_page_t mpte, struct rwlock **lockp);
 250 static int pmap_remove_l3(pmap_t pmap, pt_entry_t *l3, vm_offset_t sva,
 251     pd_entry_t ptepde, struct spglist *free, struct rwlock **lockp);
 252 static boolean_t pmap_try_insert_pv_entry(pmap_t pmap, vm_offset_t va,
 253     vm_page_t m, struct rwlock **lockp);
 254
 255 static vm_page_t _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex,
 256                 struct rwlock **lockp);
 257
 258 static void _pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m,
 259     struct spglist *free);
 260 static int pmap_unuse_l3(pmap_t, vm_offset_t, pd_entry_t, struct spglist *);
 261
 262 /*
 263  * These load the old table data and store the new value.
 264  * They need to be atomic as the System MMU may write to the table at
 265  * the same time as the CPU.
 266  */
 267 #define pmap_load_store(table, entry) atomic_swap_64(table, entry)
 268 #define pmap_set(table, mask) atomic_set_64(table, mask)
 269 #define pmap_load_clear(table) atomic_swap_64(table, 0)
 270 #define pmap_load(table) (*table)
 271
 272 /********************/
 273 /* Inline functions */
 274 /********************/
 275
 276 static __inline void
 277 pagecopy(void *s, void *d)
 278 {
 279
 280         memcpy(d, s, PAGE_SIZE);
 281 }
 282
 283 static __inline void
 284 pagezero(void *p)
 285 {
 286
 287         bzero(p, PAGE_SIZE);
 288 }
 289
 290 #define pmap_l1_index(va)       (((va) >> L1_SHIFT) & Ln_ADDR_MASK)
 291 #define pmap_l2_index(va)       (((va) >> L2_SHIFT) & Ln_ADDR_MASK)
 292 #define pmap_l3_index(va)       (((va) >> L3_SHIFT) & Ln_ADDR_MASK)
 293
 294 #define PTE_TO_PHYS(pte)        ((pte >> PTE_PPN0_S) * PAGE_SIZE)
 295
 296 static __inline pd_entry_t *
 297 pmap_l1(pmap_t pmap, vm_offset_t va)
 298 {
 299
 300         return (&pmap->pm_l1[pmap_l1_index(va)]);
 301 }
 302
 303 static __inline pd_entry_t *
 304 pmap_l1_to_l2(pd_entry_t *l1, vm_offset_t va)
 305 {
 306         vm_paddr_t phys;
 307         pd_entry_t *l2;
 308
 309         phys = PTE_TO_PHYS(pmap_load(l1));
 310         l2 = (pd_entry_t *)PHYS_TO_DMAP(phys);
 311
 312         return (&l2[pmap_l2_index(va)]);
 313 }
 314
 315 static __inline pd_entry_t *
 316 pmap_l2(pmap_t pmap, vm_offset_t va)
 317 {
 318         pd_entry_t *l1;
 319
 320         l1 = pmap_l1(pmap, va);
 321         if (l1 == NULL)
 322                 return (NULL);
 323         if ((pmap_load(l1) & PTE_V) == 0)
 324                 return (NULL);
 325         if ((pmap_load(l1) & PTE_RX) != 0)
 326                 return (NULL);
 327
 328         return (pmap_l1_to_l2(l1, va));
 329 }
 330
 331 static __inline pt_entry_t *
 332 pmap_l2_to_l3(pd_entry_t *l2, vm_offset_t va)
 333 {
 334         vm_paddr_t phys;
 335         pt_entry_t *l3;
 336
 337         phys = PTE_TO_PHYS(pmap_load(l2));
 338         l3 = (pd_entry_t *)PHYS_TO_DMAP(phys);
 339
 340         return (&l3[pmap_l3_index(va)]);
 341 }
 342
 343 static __inline pt_entry_t *
 344 pmap_l3(pmap_t pmap, vm_offset_t va)
 345 {
 346         pd_entry_t *l2;
 347
 348         l2 = pmap_l2(pmap, va);
 349         if (l2 == NULL)
 350                 return (NULL);
 351         if ((pmap_load(l2) & PTE_V) == 0)
 352                 return (NULL);
 353         if ((pmap_load(l2) & PTE_RX) != 0)
 354                 return (NULL);
 355
 356         return (pmap_l2_to_l3(l2, va));
 357 }
 358
 359
 360 static __inline int
 361 pmap_is_write(pt_entry_t entry)
 362 {
 363
 364         return (entry & PTE_W);
 365 }
 366
 367 static __inline int
 368 pmap_l3_valid(pt_entry_t l3)
 369 {
 370
 371         return (l3 & PTE_V);
 372 }
 373
 374 static inline int
 375 pmap_page_accessed(pt_entry_t pte)
 376 {
 377
 378         return (pte & PTE_A);
 379 }
 380
 381 /* Checks if the page is dirty. */
 382 static inline int
 383 pmap_page_dirty(pt_entry_t pte)
 384 {
 385
 386         return (pte & PTE_D);
 387 }
 388
 389 static __inline void
 390 pmap_resident_count_inc(pmap_t pmap, int count)
 391 {
 392
 393         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
 394         pmap->pm_stats.resident_count += count;
 395 }
 396
 397 static __inline void
 398 pmap_resident_count_dec(pmap_t pmap, int count)
 399 {
 400
 401         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
 402         KASSERT(pmap->pm_stats.resident_count >= count,
 403             ("pmap %p resident count underflow %ld %d", pmap,
 404             pmap->pm_stats.resident_count, count));
 405         pmap->pm_stats.resident_count -= count;
 406 }
 407
 408 static void
 409 pmap_distribute_l1(struct pmap *pmap, vm_pindex_t l1index,
 410     pt_entry_t entry)
 411 {
 412         struct pmap *user_pmap;
 413         pd_entry_t *l1;
 414
 415         /* Distribute new kernel L1 entry to all the user pmaps */
 416         if (pmap != kernel_pmap)
 417                 return;
 418
 419         LIST_FOREACH(user_pmap, &allpmaps, pm_list) {
 420                 l1 = &user_pmap->pm_l1[l1index];
 421                 if (entry)
 422                         pmap_load_store(l1, entry);
 423                 else
 424                         pmap_load_clear(l1);
 425         }
 426 }
 427
 428 static pt_entry_t *
 429 pmap_early_page_idx(vm_offset_t l1pt, vm_offset_t va, u_int *l1_slot,
 430     u_int *l2_slot)
 431 {
 432         pt_entry_t *l2;
 433         pd_entry_t *l1;
 434
 435         l1 = (pd_entry_t *)l1pt;
 436         *l1_slot = (va >> L1_SHIFT) & Ln_ADDR_MASK;
 437
 438         /* Check locore has used a table L1 map */
 439         KASSERT((l1[*l1_slot] & PTE_RX) == 0,
 440                 ("Invalid bootstrap L1 table"));
 441
 442         /* Find the address of the L2 table */
 443         l2 = (pt_entry_t *)init_pt_va;
 444         *l2_slot = pmap_l2_index(va);
 445
 446         return (l2);
 447 }
 448
 449 static vm_paddr_t
 450 pmap_early_vtophys(vm_offset_t l1pt, vm_offset_t va)
 451 {
 452         u_int l1_slot, l2_slot;
 453         pt_entry_t *l2;
 454         u_int ret;
 455
 456         l2 = pmap_early_page_idx(l1pt, va, &l1_slot, &l2_slot);
 457
 458         /* Check locore has used L2 superpages */
 459         KASSERT((l2[l2_slot] & PTE_RX) != 0,
 460                 ("Invalid bootstrap L2 table"));
 461
 462         /* L2 is superpages */
 463         ret = (l2[l2_slot] >> PTE_PPN1_S) << L2_SHIFT;
 464         ret += (va & L2_OFFSET);
 465
 466         return (ret);
 467 }
 468
 469 static void
 470 pmap_bootstrap_dmap(vm_offset_t kern_l1, vm_paddr_t min_pa, vm_paddr_t max_pa)
 471 {
 472         vm_offset_t va;
 473         vm_paddr_t pa;
 474         pd_entry_t *l1;
 475         u_int l1_slot;
 476         pt_entry_t entry;
 477         pn_t pn;
 478
 479         pa = dmap_phys_base = min_pa & ~L1_OFFSET;
 480         va = DMAP_MIN_ADDRESS;
 481         l1 = (pd_entry_t *)kern_l1;
 482         l1_slot = pmap_l1_index(DMAP_MIN_ADDRESS);
 483
 484         for (; va < DMAP_MAX_ADDRESS && pa < max_pa;
 485             pa += L1_SIZE, va += L1_SIZE, l1_slot++) {
 486                 KASSERT(l1_slot < Ln_ENTRIES, ("Invalid L1 index"));
 487
 488                 /* superpages */
 489                 pn = (pa / PAGE_SIZE);
 490                 entry = PTE_KERN;
 491                 entry |= (pn << PTE_PPN0_S);
 492                 pmap_load_store(&l1[l1_slot], entry);
 493         }
 494
 495         /* Set the upper limit of the DMAP region */
 496         dmap_phys_max = pa;
 497         dmap_max_addr = va;
 498
 499         sfence_vma();
 500 }
 501
 502 static vm_offset_t
 503 pmap_bootstrap_l3(vm_offset_t l1pt, vm_offset_t va, vm_offset_t l3_start)
 504 {
 505         vm_offset_t l3pt;
 506         pt_entry_t entry;
 507         pd_entry_t *l2;
 508         vm_paddr_t pa;
 509         u_int l2_slot;
 510         pn_t pn;
 511
 512         KASSERT((va & L2_OFFSET) == 0, ("Invalid virtual address"));
 513
 514         l2 = pmap_l2(kernel_pmap, va);
 515         l2 = (pd_entry_t *)((uintptr_t)l2 & ~(PAGE_SIZE - 1));
 516         l2_slot = pmap_l2_index(va);
 517         l3pt = l3_start;
 518
 519         for (; va < VM_MAX_KERNEL_ADDRESS; l2_slot++, va += L2_SIZE) {
 520                 KASSERT(l2_slot < Ln_ENTRIES, ("Invalid L2 index"));
 521
 522                 pa = pmap_early_vtophys(l1pt, l3pt);
 523                 pn = (pa / PAGE_SIZE);
 524                 entry = (PTE_V);
 525                 entry |= (pn << PTE_PPN0_S);
 526                 pmap_load_store(&l2[l2_slot], entry);
 527                 l3pt += PAGE_SIZE;
 528         }
 529
 530
 531         /* Clean the L2 page table */
 532         memset((void *)l3_start, 0, l3pt - l3_start);
 533
 534         return (l3pt);
 535 }
 536
 537 /*
 538  *      Bootstrap the system enough to run with virtual memory.
 539  */
 540 void
 541 pmap_bootstrap(vm_offset_t l1pt, vm_paddr_t kernstart, vm_size_t kernlen)
 542 {
 543         u_int l1_slot, l2_slot, avail_slot, map_slot, used_map_slot;
 544         uint64_t kern_delta;
 545         pt_entry_t *l2;
 546         vm_offset_t va, freemempos;
 547         vm_offset_t dpcpu, msgbufpv;
 548         vm_paddr_t pa, min_pa, max_pa;
 549         int i;
 550
 551         kern_delta = KERNBASE - kernstart;
 552         physmem = 0;
 553
 554         printf("pmap_bootstrap %lx %lx %lx\n", l1pt, kernstart, kernlen);
 555         printf("%lx\n", l1pt);
 556         printf("%lx\n", (KERNBASE >> L1_SHIFT) & Ln_ADDR_MASK);
 557
 558         /* Set this early so we can use the pagetable walking functions */
 559         kernel_pmap_store.pm_l1 = (pd_entry_t *)l1pt;
 560         PMAP_LOCK_INIT(kernel_pmap);
 561
 562         /*
 563          * Initialize the global pv list lock.
 564          */
 565         rw_init(&pvh_global_lock, "pmap pv global");
 566
 567         LIST_INIT(&allpmaps);
 568
 569         /* Assume the address we were loaded to is a valid physical address */
 570         min_pa = max_pa = KERNBASE - kern_delta;
 571
 572         /*
 573          * Find the minimum physical address. physmap is sorted,
 574          * but may contain empty ranges.
 575          */
 576         for (i = 0; i < (physmap_idx * 2); i += 2) {
 577                 if (physmap[i] == physmap[i + 1])
 578                         continue;
 579                 if (physmap[i] <= min_pa)
 580                         min_pa = physmap[i];
 581                 if (physmap[i + 1] > max_pa)
 582                         max_pa = physmap[i + 1];
 583         }
 584         printf("physmap_idx %lx\n", physmap_idx);
 585         printf("min_pa %lx\n", min_pa);
 586         printf("max_pa %lx\n", max_pa);
 587
 588         /* Create a direct map region early so we can use it for pa -> va */
 589         pmap_bootstrap_dmap(l1pt, min_pa, max_pa);
 590
 591         va = KERNBASE;
 592         pa = KERNBASE - kern_delta;
 593
 594         /*
 595          * Start to initialize phys_avail by copying from physmap
 596          * up to the physical address KERNBASE points at.
 597          */
 598         map_slot = avail_slot = 0;
 599         for (; map_slot < (physmap_idx * 2); map_slot += 2) {
 600                 if (physmap[map_slot] == physmap[map_slot + 1])
 601                         continue;
 602
 603                 if (physmap[map_slot] <= pa &&
 604                     physmap[map_slot + 1] > pa)
 605                         break;
 606
 607                 phys_avail[avail_slot] = physmap[map_slot];
 608                 phys_avail[avail_slot + 1] = physmap[map_slot + 1];
 609                 physmem += (phys_avail[avail_slot + 1] -
 610                     phys_avail[avail_slot]) >> PAGE_SHIFT;
 611                 avail_slot += 2;
 612         }
 613
 614         /* Add the memory before the kernel */
 615         if (physmap[avail_slot] < pa) {
 616                 phys_avail[avail_slot] = physmap[map_slot];
 617                 phys_avail[avail_slot + 1] = pa;
 618                 physmem += (phys_avail[avail_slot + 1] -
 619                     phys_avail[avail_slot]) >> PAGE_SHIFT;
 620                 avail_slot += 2;
 621         }
 622         used_map_slot = map_slot;
 623
 624         /*
 625          * Read the page table to find out what is already mapped.
 626          * This assumes we have mapped a block of memory from KERNBASE
 627          * using a single L1 entry.
 628          */
 629         l2 = pmap_early_page_idx(l1pt, KERNBASE, &l1_slot, &l2_slot);
 630
 631         /* Sanity check the index, KERNBASE should be the first VA */
 632         KASSERT(l2_slot == 0, ("The L2 index is non-zero"));
 633
 634         /* Find how many pages we have mapped */
 635         for (; l2_slot < Ln_ENTRIES; l2_slot++) {
 636                 if ((l2[l2_slot] & PTE_V) == 0)
 637                         break;
 638
 639                 /* Check locore used L2 superpages */
 640                 KASSERT((l2[l2_slot] & PTE_RX) != 0,
 641                     ("Invalid bootstrap L2 table"));
 642
 643                 va += L2_SIZE;
 644                 pa += L2_SIZE;
 645         }
 646
 647         va = roundup2(va, L2_SIZE);
 648
 649         freemempos = KERNBASE + kernlen;
 650         freemempos = roundup2(freemempos, PAGE_SIZE);
 651
 652         /* Create the l3 tables for the early devmap */
 653         freemempos = pmap_bootstrap_l3(l1pt,
 654             VM_MAX_KERNEL_ADDRESS - L2_SIZE, freemempos);
 655
 656         sfence_vma();
 657
 658 #define alloc_pages(var, np)                                            \
 659         (var) = freemempos;                                             \
 660         freemempos += (np * PAGE_SIZE);                                 \
 661         memset((char *)(var), 0, ((np) * PAGE_SIZE));
 662
 663         /* Allocate dynamic per-cpu area. */
 664         alloc_pages(dpcpu, DPCPU_SIZE / PAGE_SIZE);
 665         dpcpu_init((void *)dpcpu, 0);
 666
 667         /* Allocate memory for the msgbuf, e.g. for /sbin/dmesg */
 668         alloc_pages(msgbufpv, round_page(msgbufsize) / PAGE_SIZE);
 669         msgbufp = (void *)msgbufpv;
 670
 671         virtual_avail = roundup2(freemempos, L2_SIZE);
 672         virtual_end = VM_MAX_KERNEL_ADDRESS - L2_SIZE;
 673         kernel_vm_end = virtual_avail;
 674
 675         pa = pmap_early_vtophys(l1pt, freemempos);
 676
 677         /* Finish initialising physmap */
 678         map_slot = used_map_slot;
 679         for (; avail_slot < (PHYS_AVAIL_SIZE - 2) &&
 680             map_slot < (physmap_idx * 2); map_slot += 2) {
 681                 if (physmap[map_slot] == physmap[map_slot + 1]) {
 682                         continue;
 683                 }
 684
 685                 /* Have we used the current range? */
 686                 if (physmap[map_slot + 1] <= pa) {
 687                         continue;
 688                 }
 689
 690                 /* Do we need to split the entry? */
 691                 if (physmap[map_slot] < pa) {
 692                         phys_avail[avail_slot] = pa;
 693                         phys_avail[avail_slot + 1] = physmap[map_slot + 1];
 694                 } else {
 695                         phys_avail[avail_slot] = physmap[map_slot];
 696                         phys_avail[avail_slot + 1] = physmap[map_slot + 1];
 697                 }
 698                 physmem += (phys_avail[avail_slot + 1] -
 699                     phys_avail[avail_slot]) >> PAGE_SHIFT;
 700
 701                 avail_slot += 2;
 702         }
 703         phys_avail[avail_slot] = 0;
 704         phys_avail[avail_slot + 1] = 0;
 705
 706         /*
 707          * Maxmem isn't the "maximum memory", it's one larger than the
 708          * highest page of the physical address space.  It should be
 709          * called something like "Maxphyspage".
 710          */
 711         Maxmem = atop(phys_avail[avail_slot - 1]);
 712 }
 713
 714 /*
 715  *      Initialize a vm_page's machine-dependent fields.
 716  */
 717 void
 718 pmap_page_init(vm_page_t m)
 719 {
 720
 721         TAILQ_INIT(&m->md.pv_list);
 722         m->md.pv_memattr = VM_MEMATTR_WRITE_BACK;
 723 }
 724
 725 /*
 726  *      Initialize the pmap module.
 727  *      Called by vm_init, to initialize any structures that the pmap
 728  *      system needs to map virtual memory.
 729  */
 730 void
 731 pmap_init(void)
 732 {
 733         int i;
 734
 735         /*
 736          * Initialize the pv chunk list mutex.
 737          */
 738         mtx_init(&pv_chunks_mutex, "pmap pv chunk list", NULL, MTX_DEF);
 739
 740         /*
 741          * Initialize the pool of pv list locks.
 742          */
 743         for (i = 0; i < NPV_LIST_LOCKS; i++)
 744                 rw_init(&pv_list_locks[i], "pmap pv list");
 745 }
 746
 747 #ifdef SMP
 748 /*
 749  * For SMP, these functions have to use IPIs for coherence.
 750  *
 751  * In general, the calling thread uses a plain fence to order the
 752  * writes to the page tables before invoking an SBI callback to invoke
 753  * sfence_vma() on remote CPUs.
 754  *
 755  * Since the riscv pmap does not yet have a pm_active field, IPIs are
 756  * sent to all CPUs in the system.
 757  */
 758 static void
 759 pmap_invalidate_page(pmap_t pmap, vm_offset_t va)
 760 {
 761         cpuset_t mask;
 762
 763         sched_pin();
 764         mask = all_cpus;
 765         CPU_CLR(PCPU_GET(cpuid), &mask);
 766         fence();
 767         sbi_remote_sfence_vma(mask.__bits, va, 1);
 768         sfence_vma_page(va);
 769         sched_unpin();
 770 }
 771
 772 static void
 773 pmap_invalidate_range(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
 774 {
 775         cpuset_t mask;
 776
 777         sched_pin();
 778         mask = all_cpus;
 779         CPU_CLR(PCPU_GET(cpuid), &mask);
 780         fence();
 781         sbi_remote_sfence_vma(mask.__bits, sva, eva - sva + 1);
 782
 783         /*
 784          * Might consider a loop of sfence_vma_page() for a small
 785          * number of pages in the future.
 786          */
 787         sfence_vma();
 788         sched_unpin();
 789 }
 790
 791 static void
 792 pmap_invalidate_all(pmap_t pmap)
 793 {
 794         cpuset_t mask;
 795
 796         sched_pin();
 797         mask = all_cpus;
 798         CPU_CLR(PCPU_GET(cpuid), &mask);
 799         fence();
 800
 801         /*
 802          * XXX: The SBI doc doesn't detail how to specify x0 as the
 803          * address to perform a global fence.  BBL currently treats
 804          * all sfence_vma requests as global however.
 805          */
 806         sbi_remote_sfence_vma(mask.__bits, 0, 0);
 807         sfence_vma();
 808         sched_unpin();
 809 }
 810 #else
 811 /*
 812  * Normal, non-SMP, invalidation functions.
 813  * We inline these within pmap.c for speed.
 814  */
 815 static __inline void
 816 pmap_invalidate_page(pmap_t pmap, vm_offset_t va)
 817 {
 818
 819         sfence_vma_page(va);
 820 }
 821
 822 static __inline void
 823 pmap_invalidate_range(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
 824 {
 825
 826         /*
 827          * Might consider a loop of sfence_vma_page() for a small
 828          * number of pages in the future.
 829          */
 830         sfence_vma();
 831 }
 832
 833 static __inline void
 834 pmap_invalidate_all(pmap_t pmap)
 835 {
 836
 837         sfence_vma();
 838 }
 839 #endif
 840
 841 /*
 842  *      Routine:        pmap_extract
 843  *      Function:
 844  *              Extract the physical page address associated
 845  *              with the given map/virtual_address pair.
 846  */
 847 vm_paddr_t
 848 pmap_extract(pmap_t pmap, vm_offset_t va)
 849 {
 850         pd_entry_t *l2p, l2;
 851         pt_entry_t *l3p, l3;
 852         vm_paddr_t pa;
 853
 854         pa = 0;
 855         PMAP_LOCK(pmap);
 856         /*
 857          * Start with the l2 tabel. We are unable to allocate
 858          * pages in the l1 table.
 859          */
 860         l2p = pmap_l2(pmap, va);
 861         if (l2p != NULL) {
 862                 l2 = pmap_load(l2p);
 863                 if ((l2 & PTE_RX) == 0) {
 864                         l3p = pmap_l2_to_l3(l2p, va);
 865                         if (l3p != NULL) {
 866                                 l3 = pmap_load(l3p);
 867                                 pa = PTE_TO_PHYS(l3);
 868                                 pa |= (va & L3_OFFSET);
 869                         }
 870                 } else {
 871                         /* L2 is superpages */
 872                         pa = (l2 >> PTE_PPN1_S) << L2_SHIFT;
 873                         pa |= (va & L2_OFFSET);
 874                 }
 875         }
 876         PMAP_UNLOCK(pmap);
 877         return (pa);
 878 }
 879
 880 /*
 881  *      Routine:        pmap_extract_and_hold
 882  *      Function:
 883  *              Atomically extract and hold the physical page
 884  *              with the given pmap and virtual address pair
 885  *              if that mapping permits the given protection.
 886  */
 887 vm_page_t
 888 pmap_extract_and_hold(pmap_t pmap, vm_offset_t va, vm_prot_t prot)
 889 {
 890         pt_entry_t *l3p, l3;
 891         vm_paddr_t phys;
 892         vm_paddr_t pa;
 893         vm_page_t m;
 894
 895         pa = 0;
 896         m = NULL;
 897         PMAP_LOCK(pmap);
 898 retry:
 899         l3p = pmap_l3(pmap, va);
 900         if (l3p != NULL && (l3 = pmap_load(l3p)) != 0) {
 901                 if ((pmap_is_write(l3)) || ((prot & VM_PROT_WRITE) == 0)) {
 902                         phys = PTE_TO_PHYS(l3);
 903                         if (vm_page_pa_tryrelock(pmap, phys, &pa))
 904                                 goto retry;
 905                         m = PHYS_TO_VM_PAGE(phys);
 906                         vm_page_hold(m);
 907                 }
 908         }
 909         PA_UNLOCK_COND(pa);
 910         PMAP_UNLOCK(pmap);
 911         return (m);
 912 }
 913
 914 vm_paddr_t
 915 pmap_kextract(vm_offset_t va)
 916 {
 917         pd_entry_t *l2;
 918         pt_entry_t *l3;
 919         vm_paddr_t pa;
 920
 921         if (va >= DMAP_MIN_ADDRESS && va < DMAP_MAX_ADDRESS) {
 922                 pa = DMAP_TO_PHYS(va);
 923         } else {
 924                 l2 = pmap_l2(kernel_pmap, va);
 925                 if (l2 == NULL)
 926                         panic("pmap_kextract: No l2");
 927                 if ((pmap_load(l2) & PTE_RX) != 0) {
 928                         /* superpages */
 929                         pa = (pmap_load(l2) >> PTE_PPN1_S) << L2_SHIFT;
 930                         pa |= (va & L2_OFFSET);
 931                         return (pa);
 932                 }
 933
 934                 l3 = pmap_l2_to_l3(l2, va);
 935                 if (l3 == NULL)
 936                         panic("pmap_kextract: No l3...");
 937                 pa = PTE_TO_PHYS(pmap_load(l3));
 938                 pa |= (va & PAGE_MASK);
 939         }
 940         return (pa);
 941 }
 942
 943 /***************************************************
 944  * Low level mapping routines.....
 945  ***************************************************/
 946
 947 void
 948 pmap_kenter_device(vm_offset_t sva, vm_size_t size, vm_paddr_t pa)
 949 {
 950         pt_entry_t entry;
 951         pt_entry_t *l3;
 952         vm_offset_t va;
 953         pn_t pn;
 954
 955         KASSERT((pa & L3_OFFSET) == 0,
 956            ("pmap_kenter_device: Invalid physical address"));
 957         KASSERT((sva & L3_OFFSET) == 0,
 958            ("pmap_kenter_device: Invalid virtual address"));
 959         KASSERT((size & PAGE_MASK) == 0,
 960             ("pmap_kenter_device: Mapping is not page-sized"));
 961
 962         va = sva;
 963         while (size != 0) {
 964                 l3 = pmap_l3(kernel_pmap, va);
 965                 KASSERT(l3 != NULL, ("Invalid page table, va: 0x%lx", va));
 966
 967                 pn = (pa / PAGE_SIZE);
 968                 entry = PTE_KERN;
 969                 entry |= (pn << PTE_PPN0_S);
 970                 pmap_load_store(l3, entry);
 971
 972                 va += PAGE_SIZE;
 973                 pa += PAGE_SIZE;
 974                 size -= PAGE_SIZE;
 975         }
 976         pmap_invalidate_range(kernel_pmap, sva, va);
 977 }
 978
 979 /*
 980  * Remove a page from the kernel pagetables.
 981  * Note: not SMP coherent.
 982  */
 983 PMAP_INLINE void
 984 pmap_kremove(vm_offset_t va)
 985 {
 986         pt_entry_t *l3;
 987
 988         l3 = pmap_l3(kernel_pmap, va);
 989         KASSERT(l3 != NULL, ("pmap_kremove: Invalid address"));
 990
 991         pmap_load_clear(l3);
 992
 993         sfence_vma();
 994 }
 995
 996 void
 997 pmap_kremove_device(vm_offset_t sva, vm_size_t size)
 998 {
 999         pt_entry_t *l3;
1000         vm_offset_t va;
1001
1002         KASSERT((sva & L3_OFFSET) == 0,
1003            ("pmap_kremove_device: Invalid virtual address"));
1004         KASSERT((size & PAGE_MASK) == 0,
1005             ("pmap_kremove_device: Mapping is not page-sized"));
1006
1007         va = sva;
1008         while (size != 0) {
1009                 l3 = pmap_l3(kernel_pmap, va);
1010                 KASSERT(l3 != NULL, ("Invalid page table, va: 0x%lx", va));
1011                 pmap_load_clear(l3);
1012
1013                 va += PAGE_SIZE;
1014                 size -= PAGE_SIZE;
1015         }
1016
1017         pmap_invalidate_range(kernel_pmap, sva, va);
1018 }
1019
1020 /*
1021  *      Used to map a range of physical addresses into kernel
1022  *      virtual address space.
1023  *
1024  *      The value passed in '*virt' is a suggested virtual address for
1025  *      the mapping. Architectures which can support a direct-mapped
1026  *      physical to virtual region can return the appropriate address
1027  *      within that region, leaving '*virt' unchanged. Other
1028  *      architectures should map the pages starting at '*virt' and
1029  *      update '*virt' with the first usable address after the mapped
1030  *      region.
1031  */
1032 vm_offset_t
1033 pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
1034 {
1035
1036         return PHYS_TO_DMAP(start);
1037 }
1038
1039
1040 /*
1041  * Add a list of wired pages to the kva
1042  * this routine is only used for temporary
1043  * kernel mappings that do not need to have
1044  * page modification or references recorded.
1045  * Note that old mappings are simply written
1046  * over.  The page *must* be wired.
1047  * Note: SMP coherent.  Uses a ranged shootdown IPI.
1048  */
1049 void
1050 pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
1051 {
1052         pt_entry_t *l3, pa;
1053         vm_offset_t va;
1054         vm_page_t m;
1055         pt_entry_t entry;
1056         pn_t pn;
1057         int i;
1058
1059         va = sva;
1060         for (i = 0; i < count; i++) {
1061                 m = ma[i];
1062                 pa = VM_PAGE_TO_PHYS(m);
1063                 pn = (pa / PAGE_SIZE);
1064                 l3 = pmap_l3(kernel_pmap, va);
1065
1066                 entry = PTE_KERN;
1067                 entry |= (pn << PTE_PPN0_S);
1068                 pmap_load_store(l3, entry);
1069
1070                 va += L3_SIZE;
1071         }
1072         pmap_invalidate_range(kernel_pmap, sva, va);
1073 }
1074
1075 /*
1076  * This routine tears out page mappings from the
1077  * kernel -- it is meant only for temporary mappings.
1078  * Note: SMP coherent.  Uses a ranged shootdown IPI.
1079  */
1080 void
1081 pmap_qremove(vm_offset_t sva, int count)
1082 {
1083         pt_entry_t *l3;
1084         vm_offset_t va;
1085
1086         KASSERT(sva >= VM_MIN_KERNEL_ADDRESS, ("usermode va %lx", sva));
1087
1088         va = sva;
1089         while (count-- > 0) {
1090                 l3 = pmap_l3(kernel_pmap, va);
1091                 KASSERT(l3 != NULL, ("pmap_kremove: Invalid address"));
1092
1093                 pmap_load_clear(l3);
1094
1095                 va += PAGE_SIZE;
1096         }
1097         pmap_invalidate_range(kernel_pmap, sva, va);
1098 }
1099
1100 /***************************************************
1101  * Page table page management routines.....
1102  ***************************************************/
1103 /*
1104  * Schedule the specified unused page table page to be freed.  Specifically,
1105  * add the page to the specified list of pages that will be released to the
1106  * physical memory manager after the TLB has been updated.
1107  */
1108 static __inline void
1109 pmap_add_delayed_free_list(vm_page_t m, struct spglist *free,
1110     boolean_t set_PG_ZERO)
1111 {
1112
1113         if (set_PG_ZERO)
1114                 m->flags |= PG_ZERO;
1115         else
1116                 m->flags &= ~PG_ZERO;
1117         SLIST_INSERT_HEAD(free, m, plinks.s.ss);
1118 }
1119
1120 /*
1121  * Decrements a page table page's wire count, which is used to record the
1122  * number of valid page table entries within the page.  If the wire count
1123  * drops to zero, then the page table page is unmapped.  Returns TRUE if the
1124  * page table page was unmapped and FALSE otherwise.
1125  */
1126 static inline boolean_t
1127 pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m, struct spglist *free)
1128 {
1129
1130         --m->wire_count;
1131         if (m->wire_count == 0) {
1132                 _pmap_unwire_l3(pmap, va, m, free);
1133                 return (TRUE);
1134         } else {
1135                 return (FALSE);
1136         }
1137 }
1138
1139 static void
1140 _pmap_unwire_l3(pmap_t pmap, vm_offset_t va, vm_page_t m, struct spglist *free)
1141 {
1142         vm_paddr_t phys;
1143
1144         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1145         /*
1146          * unmap the page table page
1147          */
1148         if (m->pindex >= NUPDE) {
1149                 /* PD page */
1150                 pd_entry_t *l1;
1151                 l1 = pmap_l1(pmap, va);
1152                 pmap_load_clear(l1);
1153                 pmap_distribute_l1(pmap, pmap_l1_index(va), 0);
1154         } else {
1155                 /* PTE page */
1156                 pd_entry_t *l2;
1157                 l2 = pmap_l2(pmap, va);
1158                 pmap_load_clear(l2);
1159         }
1160         pmap_resident_count_dec(pmap, 1);
1161         if (m->pindex < NUPDE) {
1162                 pd_entry_t *l1;
1163                 /* We just released a PT, unhold the matching PD */
1164                 vm_page_t pdpg;
1165
1166                 l1 = pmap_l1(pmap, va);
1167                 phys = PTE_TO_PHYS(pmap_load(l1));
1168                 pdpg = PHYS_TO_VM_PAGE(phys);
1169                 pmap_unwire_l3(pmap, va, pdpg, free);
1170         }
1171         pmap_invalidate_page(pmap, va);
1172
1173         vm_wire_sub(1);
1174
1175         /*
1176          * Put page on a list so that it is released after
1177          * *ALL* TLB shootdown is done
1178          */
1179         pmap_add_delayed_free_list(m, free, TRUE);
1180 }
1181
1182 /*
1183  * After removing an l3 entry, this routine is used to
1184  * conditionally free the page, and manage the hold/wire counts.
1185  */
1186 static int
1187 pmap_unuse_l3(pmap_t pmap, vm_offset_t va, pd_entry_t ptepde,
1188     struct spglist *free)
1189 {
1190         vm_paddr_t phys;
1191         vm_page_t mpte;
1192
1193         if (va >= VM_MAXUSER_ADDRESS)
1194                 return (0);
1195         KASSERT(ptepde != 0, ("pmap_unuse_pt: ptepde != 0"));
1196
1197         phys = PTE_TO_PHYS(ptepde);
1198
1199         mpte = PHYS_TO_VM_PAGE(phys);
1200         return (pmap_unwire_l3(pmap, va, mpte, free));
1201 }
1202
1203 void
1204 pmap_pinit0(pmap_t pmap)
1205 {
1206
1207         PMAP_LOCK_INIT(pmap);
1208         bzero(&pmap->pm_stats, sizeof(pmap->pm_stats));
1209         pmap->pm_l1 = kernel_pmap->pm_l1;
1210 }
1211
1212 int
1213 pmap_pinit(pmap_t pmap)
1214 {
1215         vm_paddr_t l1phys;
1216         vm_page_t l1pt;
1217
1218         /*
1219          * allocate the l1 page
1220          */
1221         while ((l1pt = vm_page_alloc(NULL, 0xdeadbeef, VM_ALLOC_NORMAL |
1222             VM_ALLOC_NOOBJ | VM_ALLOC_WIRED | VM_ALLOC_ZERO)) == NULL)
1223                 vm_wait(NULL);
1224
1225         l1phys = VM_PAGE_TO_PHYS(l1pt);
1226         pmap->pm_l1 = (pd_entry_t *)PHYS_TO_DMAP(l1phys);
1227
1228         if ((l1pt->flags & PG_ZERO) == 0)
1229                 pagezero(pmap->pm_l1);
1230
1231         bzero(&pmap->pm_stats, sizeof(pmap->pm_stats));
1232
1233         /* Install kernel pagetables */
1234         memcpy(pmap->pm_l1, kernel_pmap->pm_l1, PAGE_SIZE);
1235
1236         /* Add to the list of all user pmaps */
1237         LIST_INSERT_HEAD(&allpmaps, pmap, pm_list);
1238
1239         return (1);
1240 }
1241
1242 /*
1243  * This routine is called if the desired page table page does not exist.
1244  *
1245  * If page table page allocation fails, this routine may sleep before
1246  * returning NULL.  It sleeps only if a lock pointer was given.
1247  *
1248  * Note: If a page allocation fails at page table level two or three,
1249  * one or two pages may be held during the wait, only to be released
1250  * afterwards.  This conservative approach is easily argued to avoid
1251  * race conditions.
1252  */
1253 static vm_page_t
1254 _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
1255 {
1256         vm_page_t m, /*pdppg, */pdpg;
1257         pt_entry_t entry;
1258         vm_paddr_t phys;
1259         pn_t pn;
1260
1261         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1262
1263         /*
1264          * Allocate a page table page.
1265          */
1266         if ((m = vm_page_alloc(NULL, ptepindex, VM_ALLOC_NOOBJ |
1267             VM_ALLOC_WIRED | VM_ALLOC_ZERO)) == NULL) {
1268                 if (lockp != NULL) {
1269                         RELEASE_PV_LIST_LOCK(lockp);
1270                         PMAP_UNLOCK(pmap);
1271                         rw_runlock(&pvh_global_lock);
1272                         vm_wait(NULL);
1273                         rw_rlock(&pvh_global_lock);
1274                         PMAP_LOCK(pmap);
1275                 }
1276
1277                 /*
1278                  * Indicate the need to retry.  While waiting, the page table
1279                  * page may have been allocated.
1280                  */
1281                 return (NULL);
1282         }
1283
1284         if ((m->flags & PG_ZERO) == 0)
1285                 pmap_zero_page(m);
1286
1287         /*
1288          * Map the pagetable page into the process address space, if
1289          * it isn't already there.
1290          */
1291
1292         if (ptepindex >= NUPDE) {
1293                 pd_entry_t *l1;
1294                 vm_pindex_t l1index;
1295
1296                 l1index = ptepindex - NUPDE;
1297                 l1 = &pmap->pm_l1[l1index];
1298
1299                 pn = (VM_PAGE_TO_PHYS(m) / PAGE_SIZE);
1300                 entry = (PTE_V);
1301                 entry |= (pn << PTE_PPN0_S);
1302                 pmap_load_store(l1, entry);
1303                 pmap_distribute_l1(pmap, l1index, entry);
1304         } else {
1305                 vm_pindex_t l1index;
1306                 pd_entry_t *l1, *l2;
1307
1308                 l1index = ptepindex >> (L1_SHIFT - L2_SHIFT);
1309                 l1 = &pmap->pm_l1[l1index];
1310                 if (pmap_load(l1) == 0) {
1311                         /* recurse for allocating page dir */
1312                         if (_pmap_alloc_l3(pmap, NUPDE + l1index,
1313                             lockp) == NULL) {
1314                                 vm_page_unwire_noq(m);
1315                                 vm_page_free_zero(m);
1316                                 return (NULL);
1317                         }
1318                 } else {
1319                         phys = PTE_TO_PHYS(pmap_load(l1));
1320                         pdpg = PHYS_TO_VM_PAGE(phys);
1321                         pdpg->wire_count++;
1322                 }
1323
1324                 phys = PTE_TO_PHYS(pmap_load(l1));
1325                 l2 = (pd_entry_t *)PHYS_TO_DMAP(phys);
1326                 l2 = &l2[ptepindex & Ln_ADDR_MASK];
1327
1328                 pn = (VM_PAGE_TO_PHYS(m) / PAGE_SIZE);
1329                 entry = (PTE_V);
1330                 entry |= (pn << PTE_PPN0_S);
1331                 pmap_load_store(l2, entry);
1332         }
1333
1334         pmap_resident_count_inc(pmap, 1);
1335
1336         return (m);
1337 }
1338
1339 static vm_page_t
1340 pmap_alloc_l3(pmap_t pmap, vm_offset_t va, struct rwlock **lockp)
1341 {
1342         vm_pindex_t ptepindex;
1343         pd_entry_t *l2;
1344         vm_paddr_t phys;
1345         vm_page_t m;
1346
1347         /*
1348          * Calculate pagetable page index
1349          */
1350         ptepindex = pmap_l2_pindex(va);
1351 retry:
1352         /*
1353          * Get the page directory entry
1354          */
1355         l2 = pmap_l2(pmap, va);
1356
1357         /*
1358          * If the page table page is mapped, we just increment the
1359          * hold count, and activate it.
1360          */
1361         if (l2 != NULL && pmap_load(l2) != 0) {
1362                 phys = PTE_TO_PHYS(pmap_load(l2));
1363                 m = PHYS_TO_VM_PAGE(phys);
1364                 m->wire_count++;
1365         } else {
1366                 /*
1367                  * Here if the pte page isn't mapped, or if it has been
1368                  * deallocated.
1369                  */
1370                 m = _pmap_alloc_l3(pmap, ptepindex, lockp);
1371                 if (m == NULL && lockp != NULL)
1372                         goto retry;
1373         }
1374         return (m);
1375 }
1376
1377
1378 /***************************************************
1379  * Pmap allocation/deallocation routines.
1380  ***************************************************/
1381
1382 /*
1383  * Release any resources held by the given physical map.
1384  * Called when a pmap initialized by pmap_pinit is being released.
1385  * Should only be called if the map contains no valid mappings.
1386  */
1387 void
1388 pmap_release(pmap_t pmap)
1389 {
1390         vm_page_t m;
1391
1392         KASSERT(pmap->pm_stats.resident_count == 0,
1393             ("pmap_release: pmap resident count %ld != 0",
1394             pmap->pm_stats.resident_count));
1395
1396         m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pmap->pm_l1));
1397         vm_page_unwire_noq(m);
1398         vm_page_free_zero(m);
1399
1400         /* Remove pmap from the allpmaps list */
1401         LIST_REMOVE(pmap, pm_list);
1402
1403         /* Remove kernel pagetables */
1404         bzero(pmap->pm_l1, PAGE_SIZE);
1405 }
1406
1407 #if 0
1408 static int
1409 kvm_size(SYSCTL_HANDLER_ARGS)
1410 {
1411         unsigned long ksize = VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS;
1412
1413         return sysctl_handle_long(oidp, &ksize, 0, req);
1414 }
1415 SYSCTL_PROC(_vm, OID_AUTO, kvm_size, CTLTYPE_LONG|CTLFLAG_RD,
1416     0, 0, kvm_size, "LU", "Size of KVM");
1417
1418 static int
1419 kvm_free(SYSCTL_HANDLER_ARGS)
1420 {
1421         unsigned long kfree = VM_MAX_KERNEL_ADDRESS - kernel_vm_end;
1422
1423         return sysctl_handle_long(oidp, &kfree, 0, req);
1424 }
1425 SYSCTL_PROC(_vm, OID_AUTO, kvm_free, CTLTYPE_LONG|CTLFLAG_RD,
1426     0, 0, kvm_free, "LU", "Amount of KVM free");
1427 #endif /* 0 */
1428
1429 /*
1430  * grow the number of kernel page table entries, if needed
1431  */
1432 void
1433 pmap_growkernel(vm_offset_t addr)
1434 {
1435         vm_paddr_t paddr;
1436         vm_page_t nkpg;
1437         pd_entry_t *l1, *l2;
1438         pt_entry_t entry;
1439         pn_t pn;
1440
1441         mtx_assert(&kernel_map->system_mtx, MA_OWNED);
1442
1443         addr = roundup2(addr, L2_SIZE);
1444         if (addr - 1 >= vm_map_max(kernel_map))
1445                 addr = vm_map_max(kernel_map);
1446         while (kernel_vm_end < addr) {
1447                 l1 = pmap_l1(kernel_pmap, kernel_vm_end);
1448                 if (pmap_load(l1) == 0) {
1449                         /* We need a new PDP entry */
1450                         nkpg = vm_page_alloc(NULL, kernel_vm_end >> L1_SHIFT,
1451                             VM_ALLOC_INTERRUPT | VM_ALLOC_NOOBJ |
1452                             VM_ALLOC_WIRED | VM_ALLOC_ZERO);
1453                         if (nkpg == NULL)
1454                                 panic("pmap_growkernel: no memory to grow kernel");
1455                         if ((nkpg->flags & PG_ZERO) == 0)
1456                                 pmap_zero_page(nkpg);
1457                         paddr = VM_PAGE_TO_PHYS(nkpg);
1458
1459                         pn = (paddr / PAGE_SIZE);
1460                         entry = (PTE_V);
1461                         entry |= (pn << PTE_PPN0_S);
1462                         pmap_load_store(l1, entry);
1463                         pmap_distribute_l1(kernel_pmap,
1464                             pmap_l1_index(kernel_vm_end), entry);
1465                         continue; /* try again */
1466                 }
1467                 l2 = pmap_l1_to_l2(l1, kernel_vm_end);
1468                 if ((pmap_load(l2) & PTE_V) != 0 &&
1469                     (pmap_load(l2) & PTE_RWX) == 0) {
1470                         kernel_vm_end = (kernel_vm_end + L2_SIZE) & ~L2_OFFSET;
1471                         if (kernel_vm_end - 1 >= vm_map_max(kernel_map)) {
1472                                 kernel_vm_end = vm_map_max(kernel_map);
1473                                 break;
1474                         }
1475                         continue;
1476                 }
1477
1478                 nkpg = vm_page_alloc(NULL, kernel_vm_end >> L2_SHIFT,
1479                     VM_ALLOC_INTERRUPT | VM_ALLOC_NOOBJ | VM_ALLOC_WIRED |
1480                     VM_ALLOC_ZERO);
1481                 if (nkpg == NULL)
1482                         panic("pmap_growkernel: no memory to grow kernel");
1483                 if ((nkpg->flags & PG_ZERO) == 0) {
1484                         pmap_zero_page(nkpg);
1485                 }
1486                 paddr = VM_PAGE_TO_PHYS(nkpg);
1487
1488                 pn = (paddr / PAGE_SIZE);
1489                 entry = (PTE_V);
1490                 entry |= (pn << PTE_PPN0_S);
1491                 pmap_load_store(l2, entry);
1492
1493                 pmap_invalidate_page(kernel_pmap, kernel_vm_end);
1494
1495                 kernel_vm_end = (kernel_vm_end + L2_SIZE) & ~L2_OFFSET;
1496                 if (kernel_vm_end - 1 >= vm_map_max(kernel_map)) {
1497                         kernel_vm_end = vm_map_max(kernel_map);
1498                         break;
1499                 }
1500         }
1501 }
1502
1503
1504 /***************************************************
1505  * page management routines.
1506  ***************************************************/
1507
1508 CTASSERT(sizeof(struct pv_chunk) == PAGE_SIZE);
1509 CTASSERT(_NPCM == 3);
1510 CTASSERT(_NPCPV == 168);
1511
1512 static __inline struct pv_chunk *
1513 pv_to_chunk(pv_entry_t pv)
1514 {
1515
1516         return ((struct pv_chunk *)((uintptr_t)pv & ~(uintptr_t)PAGE_MASK));
1517 }
1518
1519 #define PV_PMAP(pv) (pv_to_chunk(pv)->pc_pmap)
1520
1521 #define PC_FREE0        0xfffffffffffffffful
1522 #define PC_FREE1        0xfffffffffffffffful
1523 #define PC_FREE2        0x000000fffffffffful
1524
1525 static const uint64_t pc_freemask[_NPCM] = { PC_FREE0, PC_FREE1, PC_FREE2 };
1526
1527 #if 0
1528 #ifdef PV_STATS
1529 static int pc_chunk_count, pc_chunk_allocs, pc_chunk_frees, pc_chunk_tryfail;
1530
1531 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_count, CTLFLAG_RD, &pc_chunk_count, 0,
1532         "Current number of pv entry chunks");
1533 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_allocs, CTLFLAG_RD, &pc_chunk_allocs, 0,
1534         "Current number of pv entry chunks allocated");
1535 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_frees, CTLFLAG_RD, &pc_chunk_frees, 0,
1536         "Current number of pv entry chunks frees");
1537 SYSCTL_INT(_vm_pmap, OID_AUTO, pc_chunk_tryfail, CTLFLAG_RD, &pc_chunk_tryfail, 0,
1538         "Number of times tried to get a chunk page but failed.");
1539
1540 static long pv_entry_frees, pv_entry_allocs, pv_entry_count;
1541 static int pv_entry_spare;
1542
1543 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_frees, CTLFLAG_RD, &pv_entry_frees, 0,
1544         "Current number of pv entry frees");
1545 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_allocs, CTLFLAG_RD, &pv_entry_allocs, 0,
1546         "Current number of pv entry allocs");
1547 SYSCTL_LONG(_vm_pmap, OID_AUTO, pv_entry_count, CTLFLAG_RD, &pv_entry_count, 0,
1548         "Current number of pv entries");
1549 SYSCTL_INT(_vm_pmap, OID_AUTO, pv_entry_spare, CTLFLAG_RD, &pv_entry_spare, 0,
1550         "Current number of spare pv entries");
1551 #endif
1552 #endif /* 0 */
1553
1554 /*
1555  * We are in a serious low memory condition.  Resort to
1556  * drastic measures to free some pages so we can allocate
1557  * another pv entry chunk.
1558  *
1559  * Returns NULL if PV entries were reclaimed from the specified pmap.
1560  *
1561  * We do not, however, unmap 2mpages because subsequent accesses will
1562  * allocate per-page pv entries until repromotion occurs, thereby
1563  * exacerbating the shortage of free pv entries.
1564  */
1565 static vm_page_t
1566 reclaim_pv_chunk(pmap_t locked_pmap, struct rwlock **lockp)
1567 {
1568
1569         panic("RISCVTODO: reclaim_pv_chunk");
1570 }
1571
1572 /*
1573  * free the pv_entry back to the free list
1574  */
1575 static void
1576 free_pv_entry(pmap_t pmap, pv_entry_t pv)
1577 {
1578         struct pv_chunk *pc;
1579         int idx, field, bit;
1580
1581         rw_assert(&pvh_global_lock, RA_LOCKED);
1582         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1583         PV_STAT(atomic_add_long(&pv_entry_frees, 1));
1584         PV_STAT(atomic_add_int(&pv_entry_spare, 1));
1585         PV_STAT(atomic_subtract_long(&pv_entry_count, 1));
1586         pc = pv_to_chunk(pv);
1587         idx = pv - &pc->pc_pventry[0];
1588         field = idx / 64;
1589         bit = idx % 64;
1590         pc->pc_map[field] |= 1ul << bit;
1591         if (pc->pc_map[0] != PC_FREE0 || pc->pc_map[1] != PC_FREE1 ||
1592             pc->pc_map[2] != PC_FREE2) {
1593                 /* 98% of the time, pc is already at the head of the list. */
1594                 if (__predict_false(pc != TAILQ_FIRST(&pmap->pm_pvchunk))) {
1595                         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
1596                         TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
1597                 }
1598                 return;
1599         }
1600         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
1601         free_pv_chunk(pc);
1602 }
1603
1604 static void
1605 free_pv_chunk(struct pv_chunk *pc)
1606 {
1607         vm_page_t m;
1608
1609         mtx_lock(&pv_chunks_mutex);
1610         TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
1611         mtx_unlock(&pv_chunks_mutex);
1612         PV_STAT(atomic_subtract_int(&pv_entry_spare, _NPCPV));
1613         PV_STAT(atomic_subtract_int(&pc_chunk_count, 1));
1614         PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
1615         /* entire chunk is free, return it */
1616         m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
1617 #if 0 /* TODO: For minidump */
1618         dump_drop_page(m->phys_addr);
1619 #endif
1620         vm_page_unwire(m, PQ_NONE);
1621         vm_page_free(m);
1622 }
1623
1624 /*
1625  * Returns a new PV entry, allocating a new PV chunk from the system when
1626  * needed.  If this PV chunk allocation fails and a PV list lock pointer was
1627  * given, a PV chunk is reclaimed from an arbitrary pmap.  Otherwise, NULL is
1628  * returned.
1629  *
1630  * The given PV list lock may be released.
1631  */
1632 static pv_entry_t
1633 get_pv_entry(pmap_t pmap, struct rwlock **lockp)
1634 {
1635         int bit, field;
1636         pv_entry_t pv;
1637         struct pv_chunk *pc;
1638         vm_page_t m;
1639
1640         rw_assert(&pvh_global_lock, RA_LOCKED);
1641         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1642         PV_STAT(atomic_add_long(&pv_entry_allocs, 1));
1643 retry:
1644         pc = TAILQ_FIRST(&pmap->pm_pvchunk);
1645         if (pc != NULL) {
1646                 for (field = 0; field < _NPCM; field++) {
1647                         if (pc->pc_map[field]) {
1648                                 bit = ffsl(pc->pc_map[field]) - 1;
1649                                 break;
1650                         }
1651                 }
1652                 if (field < _NPCM) {
1653                         pv = &pc->pc_pventry[field * 64 + bit];
1654                         pc->pc_map[field] &= ~(1ul << bit);
1655                         /* If this was the last item, move it to tail */
1656                         if (pc->pc_map[0] == 0 && pc->pc_map[1] == 0 &&
1657                             pc->pc_map[2] == 0) {
1658                                 TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
1659                                 TAILQ_INSERT_TAIL(&pmap->pm_pvchunk, pc,
1660                                     pc_list);
1661                         }
1662                         PV_STAT(atomic_add_long(&pv_entry_count, 1));
1663                         PV_STAT(atomic_subtract_int(&pv_entry_spare, 1));
1664                         return (pv);
1665                 }
1666         }
1667         /* No free items, allocate another chunk */
1668         m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ |
1669             VM_ALLOC_WIRED);
1670         if (m == NULL) {
1671                 if (lockp == NULL) {
1672                         PV_STAT(pc_chunk_tryfail++);
1673                         return (NULL);
1674                 }
1675                 m = reclaim_pv_chunk(pmap, lockp);
1676                 if (m == NULL)
1677                         goto retry;
1678         }
1679         PV_STAT(atomic_add_int(&pc_chunk_count, 1));
1680         PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
1681 #if 0 /* TODO: This is for minidump */
1682         dump_add_page(m->phys_addr);
1683 #endif
1684         pc = (void *)PHYS_TO_DMAP(m->phys_addr);
1685         pc->pc_pmap = pmap;
1686         pc->pc_map[0] = PC_FREE0 & ~1ul;        /* preallocated bit 0 */
1687         pc->pc_map[1] = PC_FREE1;
1688         pc->pc_map[2] = PC_FREE2;
1689         mtx_lock(&pv_chunks_mutex);
1690         TAILQ_INSERT_TAIL(&pv_chunks, pc, pc_lru);
1691         mtx_unlock(&pv_chunks_mutex);
1692         pv = &pc->pc_pventry[0];
1693         TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
1694         PV_STAT(atomic_add_long(&pv_entry_count, 1));
1695         PV_STAT(atomic_add_int(&pv_entry_spare, _NPCPV - 1));
1696         return (pv);
1697 }
1698
1699 /*
1700  * First find and then remove the pv entry for the specified pmap and virtual
1701  * address from the specified pv list.  Returns the pv entry if found and NULL
1702  * otherwise.  This operation can be performed on pv lists for either 4KB or
1703  * 2MB page mappings.
1704  */
1705 static __inline pv_entry_t
1706 pmap_pvh_remove(struct md_page *pvh, pmap_t pmap, vm_offset_t va)
1707 {
1708         pv_entry_t pv;
1709
1710         rw_assert(&pvh_global_lock, RA_LOCKED);
1711         TAILQ_FOREACH(pv, &pvh->pv_list, pv_next) {
1712                 if (pmap == PV_PMAP(pv) && va == pv->pv_va) {
1713                         TAILQ_REMOVE(&pvh->pv_list, pv, pv_next);
1714                         pvh->pv_gen++;
1715                         break;
1716                 }
1717         }
1718         return (pv);
1719 }
1720
1721 /*
1722  * First find and then destroy the pv entry for the specified pmap and virtual
1723  * address.  This operation can be performed on pv lists for either 4KB or 2MB
1724  * page mappings.
1725  */
1726 static void
1727 pmap_pvh_free(struct md_page *pvh, pmap_t pmap, vm_offset_t va)
1728 {
1729         pv_entry_t pv;
1730
1731         pv = pmap_pvh_remove(pvh, pmap, va);
1732
1733         KASSERT(pv != NULL, ("pmap_pvh_free: pv not found"));
1734         free_pv_entry(pmap, pv);
1735 }
1736
1737 /*
1738  * Conditionally create the PV entry for a 4KB page mapping if the required
1739  * memory can be allocated without resorting to reclamation.
1740  */
1741 static boolean_t
1742 pmap_try_insert_pv_entry(pmap_t pmap, vm_offset_t va, vm_page_t m,
1743     struct rwlock **lockp)
1744 {
1745         pv_entry_t pv;
1746
1747         rw_assert(&pvh_global_lock, RA_LOCKED);
1748         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1749         /* Pass NULL instead of the lock pointer to disable reclamation. */
1750         if ((pv = get_pv_entry(pmap, NULL)) != NULL) {
1751                 pv->pv_va = va;
1752                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m);
1753                 TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
1754                 m->md.pv_gen++;
1755                 return (TRUE);
1756         } else
1757                 return (FALSE);
1758 }
1759
1760 /*
1761  * pmap_remove_l3: do the things to unmap a page in a process
1762  */
1763 static int
1764 pmap_remove_l3(pmap_t pmap, pt_entry_t *l3, vm_offset_t va,
1765     pd_entry_t l2e, struct spglist *free, struct rwlock **lockp)
1766 {
1767         pt_entry_t old_l3;
1768         vm_paddr_t phys;
1769         vm_page_t m;
1770
1771         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1772         old_l3 = pmap_load_clear(l3);
1773         pmap_invalidate_page(pmap, va);
1774         if (old_l3 & PTE_SW_WIRED)
1775                 pmap->pm_stats.wired_count -= 1;
1776         pmap_resident_count_dec(pmap, 1);
1777         if (old_l3 & PTE_SW_MANAGED) {
1778                 phys = PTE_TO_PHYS(old_l3);
1779                 m = PHYS_TO_VM_PAGE(phys);
1780                 if (pmap_page_dirty(old_l3))
1781                         vm_page_dirty(m);
1782                 if (old_l3 & PTE_A)
1783                         vm_page_aflag_set(m, PGA_REFERENCED);
1784                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(lockp, m);
1785                 pmap_pvh_free(&m->md, pmap, va);
1786         }
1787
1788         return (pmap_unuse_l3(pmap, va, l2e, free));
1789 }
1790
1791 /*
1792  *      Remove the given range of addresses from the specified map.
1793  *
1794  *      It is assumed that the start and end are properly
1795  *      rounded to the page size.
1796  */
1797 void
1798 pmap_remove(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
1799 {
1800         struct rwlock *lock;
1801         vm_offset_t va, va_next;
1802         pd_entry_t *l1, *l2;
1803         pt_entry_t l3_pte, *l3;
1804         struct spglist free;
1805
1806         /*
1807          * Perform an unsynchronized read.  This is, however, safe.
1808          */
1809         if (pmap->pm_stats.resident_count == 0)
1810                 return;
1811
1812         SLIST_INIT(&free);
1813
1814         rw_rlock(&pvh_global_lock);
1815         PMAP_LOCK(pmap);
1816
1817         lock = NULL;
1818         for (; sva < eva; sva = va_next) {
1819                 if (pmap->pm_stats.resident_count == 0)
1820                         break;
1821
1822                 l1 = pmap_l1(pmap, sva);
1823                 if (pmap_load(l1) == 0) {
1824                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
1825                         if (va_next < sva)
1826                                 va_next = eva;
1827                         continue;
1828                 }
1829
1830                 /*
1831                  * Calculate index for next page table.
1832                  */
1833                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
1834                 if (va_next < sva)
1835                         va_next = eva;
1836
1837                 l2 = pmap_l1_to_l2(l1, sva);
1838                 if (l2 == NULL)
1839                         continue;
1840
1841                 l3_pte = pmap_load(l2);
1842
1843                 /*
1844                  * Weed out invalid mappings.
1845                  */
1846                 if (l3_pte == 0)
1847                         continue;
1848                 if ((pmap_load(l2) & PTE_RX) != 0)
1849                         continue;
1850
1851                 /*
1852                  * Limit our scan to either the end of the va represented
1853                  * by the current page table page, or to the end of the
1854                  * range being removed.
1855                  */
1856                 if (va_next > eva)
1857                         va_next = eva;
1858
1859                 va = va_next;
1860                 for (l3 = pmap_l2_to_l3(l2, sva); sva != va_next; l3++,
1861                     sva += L3_SIZE) {
1862                         if (l3 == NULL)
1863                                 panic("l3 == NULL");
1864                         if (pmap_load(l3) == 0) {
1865                                 if (va != va_next) {
1866                                         pmap_invalidate_range(pmap, va, sva);
1867                                         va = va_next;
1868                                 }
1869                                 continue;
1870                         }
1871                         if (va == va_next)
1872                                 va = sva;
1873                         if (pmap_remove_l3(pmap, l3, sva, l3_pte, &free,
1874                             &lock)) {
1875                                 sva += L3_SIZE;
1876                                 break;
1877                         }
1878                 }
1879                 if (va != va_next)
1880                         pmap_invalidate_range(pmap, va, sva);
1881         }
1882         if (lock != NULL)
1883                 rw_wunlock(lock);
1884         rw_runlock(&pvh_global_lock);
1885         PMAP_UNLOCK(pmap);
1886         vm_page_free_pages_toq(&free, false);
1887 }
1888
1889 /*
1890  *      Routine:        pmap_remove_all
1891  *      Function:
1892  *              Removes this physical page from
1893  *              all physical maps in which it resides.
1894  *              Reflects back modify bits to the pager.
1895  *
1896  *      Notes:
1897  *              Original versions of this routine were very
1898  *              inefficient because they iteratively called
1899  *              pmap_remove (slow...)
1900  */
1901
1902 void
1903 pmap_remove_all(vm_page_t m)
1904 {
1905         pv_entry_t pv;
1906         pmap_t pmap;
1907         pt_entry_t *l3, tl3;
1908         pd_entry_t *l2, tl2;
1909         struct spglist free;
1910
1911         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
1912             ("pmap_remove_all: page %p is not managed", m));
1913         SLIST_INIT(&free);
1914         rw_wlock(&pvh_global_lock);
1915         while ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
1916                 pmap = PV_PMAP(pv);
1917                 PMAP_LOCK(pmap);
1918                 pmap_resident_count_dec(pmap, 1);
1919                 l2 = pmap_l2(pmap, pv->pv_va);
1920                 KASSERT(l2 != NULL, ("pmap_remove_all: no l2 table found"));
1921                 tl2 = pmap_load(l2);
1922
1923                 KASSERT((tl2 & PTE_RX) == 0,
1924                     ("pmap_remove_all: found a table when expecting "
1925                     "a block in %p's pv list", m));
1926
1927                 l3 = pmap_l2_to_l3(l2, pv->pv_va);
1928                 tl3 = pmap_load_clear(l3);
1929                 pmap_invalidate_page(pmap, pv->pv_va);
1930                 if (tl3 & PTE_SW_WIRED)
1931                         pmap->pm_stats.wired_count--;
1932                 if ((tl3 & PTE_A) != 0)
1933                         vm_page_aflag_set(m, PGA_REFERENCED);
1934
1935                 /*
1936                  * Update the vm_page_t clean and reference bits.
1937                  */
1938                 if (pmap_page_dirty(tl3))
1939                         vm_page_dirty(m);
1940                 pmap_unuse_l3(pmap, pv->pv_va, pmap_load(l2), &free);
1941                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
1942                 m->md.pv_gen++;
1943                 free_pv_entry(pmap, pv);
1944                 PMAP_UNLOCK(pmap);
1945         }
1946         vm_page_aflag_clear(m, PGA_WRITEABLE);
1947         rw_wunlock(&pvh_global_lock);
1948         vm_page_free_pages_toq(&free, false);
1949 }
1950
1951 /*
1952  *      Set the physical protection on the
1953  *      specified range of this map as requested.
1954  */
1955 void
1956 pmap_protect(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, vm_prot_t prot)
1957 {
1958         vm_offset_t va_next;
1959         pd_entry_t *l1, *l2;
1960         pt_entry_t *l3p, l3;
1961         pt_entry_t entry;
1962
1963         if ((prot & VM_PROT_READ) == VM_PROT_NONE) {
1964                 pmap_remove(pmap, sva, eva);
1965                 return;
1966         }
1967
1968         if ((prot & VM_PROT_WRITE) == VM_PROT_WRITE)
1969                 return;
1970
1971         PMAP_LOCK(pmap);
1972         for (; sva < eva; sva = va_next) {
1973
1974                 l1 = pmap_l1(pmap, sva);
1975                 if (pmap_load(l1) == 0) {
1976                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
1977                         if (va_next < sva)
1978                                 va_next = eva;
1979                         continue;
1980                 }
1981
1982                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
1983                 if (va_next < sva)
1984                         va_next = eva;
1985
1986                 l2 = pmap_l1_to_l2(l1, sva);
1987                 if (l2 == NULL)
1988                         continue;
1989                 if (pmap_load(l2) == 0)
1990                         continue;
1991                 if ((pmap_load(l2) & PTE_RX) != 0)
1992                         continue;
1993
1994                 if (va_next > eva)
1995                         va_next = eva;
1996
1997                 for (l3p = pmap_l2_to_l3(l2, sva); sva != va_next; l3p++,
1998                     sva += L3_SIZE) {
1999                         l3 = pmap_load(l3p);
2000                         if (pmap_l3_valid(l3)) {
2001                                 entry = pmap_load(l3p);
2002                                 entry &= ~(PTE_W);
2003                                 pmap_load_store(l3p, entry);
2004                                 /* XXX: Use pmap_invalidate_range */
2005                                 pmap_invalidate_page(pmap, sva);
2006                         }
2007                 }
2008         }
2009         PMAP_UNLOCK(pmap);
2010 }
2011
2012 int
2013 pmap_fault_fixup(pmap_t pmap, vm_offset_t va, vm_prot_t prot)
2014 {
2015         pt_entry_t orig_l3;
2016         pt_entry_t new_l3;
2017         pt_entry_t *l3;
2018
2019         l3 = pmap_l3(pmap, va);
2020         if (l3 == NULL)
2021                 return (0);
2022
2023         orig_l3 = pmap_load(l3);
2024         if ((orig_l3 & PTE_V) == 0 ||
2025             ((prot & VM_PROT_WRITE) != 0 && (orig_l3 & PTE_W) == 0) ||
2026             ((prot & VM_PROT_READ) != 0 && (orig_l3 & PTE_R) == 0))
2027                 return (0);
2028
2029         new_l3 = orig_l3 | PTE_A;
2030         if ((prot & VM_PROT_WRITE) != 0)
2031                 new_l3 |= PTE_D;
2032
2033         if (orig_l3 != new_l3) {
2034                 pmap_load_store(l3, new_l3);
2035                 pmap_invalidate_page(pmap, va);
2036                 return (1);
2037         }
2038
2039         /*
2040          * XXX: This case should never happen since it means
2041          * the PTE shouldn't have resulted in a fault.
2042          */
2043
2044         return (0);
2045 }
2046
2047 /*
2048  *      Insert the given physical page (p) at
2049  *      the specified virtual address (v) in the
2050  *      target physical map with the protection requested.
2051  *
2052  *      If specified, the page will be wired down, meaning
2053  *      that the related pte can not be reclaimed.
2054  *
2055  *      NB:  This is the only routine which MAY NOT lazy-evaluate
2056  *      or lose information.  That is, this routine must actually
2057  *      insert this page into the given map NOW.
2058  */
2059 int
2060 pmap_enter(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
2061     u_int flags, int8_t psind __unused)
2062 {
2063         struct rwlock *lock;
2064         pd_entry_t *l1, *l2;
2065         pt_entry_t new_l3, orig_l3;
2066         pt_entry_t *l3;
2067         pv_entry_t pv;
2068         vm_paddr_t opa, pa, l2_pa, l3_pa;
2069         vm_page_t mpte, om, l2_m, l3_m;
2070         boolean_t nosleep;
2071         pt_entry_t entry;
2072         pn_t l2_pn;
2073         pn_t l3_pn;
2074         pn_t pn;
2075
2076         va = trunc_page(va);
2077         if ((m->oflags & VPO_UNMANAGED) == 0 && !vm_page_xbusied(m))
2078                 VM_OBJECT_ASSERT_LOCKED(m->object);
2079         pa = VM_PAGE_TO_PHYS(m);
2080         pn = (pa / PAGE_SIZE);
2081
2082         new_l3 = PTE_V | PTE_R | PTE_X;
2083         if (prot & VM_PROT_WRITE)
2084                 new_l3 |= PTE_W;
2085         if ((va >> 63) == 0)
2086                 new_l3 |= PTE_U;
2087
2088         new_l3 |= (pn << PTE_PPN0_S);
2089         if ((flags & PMAP_ENTER_WIRED) != 0)
2090                 new_l3 |= PTE_SW_WIRED;
2091         if ((m->oflags & VPO_UNMANAGED) == 0)
2092                 new_l3 |= PTE_SW_MANAGED;
2093
2094         CTR2(KTR_PMAP, "pmap_enter: %.16lx -> %.16lx", va, pa);
2095
2096         mpte = NULL;
2097
2098         lock = NULL;
2099         rw_rlock(&pvh_global_lock);
2100         PMAP_LOCK(pmap);
2101
2102         if (va < VM_MAXUSER_ADDRESS) {
2103                 nosleep = (flags & PMAP_ENTER_NOSLEEP) != 0;
2104                 mpte = pmap_alloc_l3(pmap, va, nosleep ? NULL : &lock);
2105                 if (mpte == NULL && nosleep) {
2106                         CTR0(KTR_PMAP, "pmap_enter: mpte == NULL");
2107                         if (lock != NULL)
2108                                 rw_wunlock(lock);
2109                         rw_runlock(&pvh_global_lock);
2110                         PMAP_UNLOCK(pmap);
2111                         return (KERN_RESOURCE_SHORTAGE);
2112                 }
2113                 l3 = pmap_l3(pmap, va);
2114         } else {
2115                 l3 = pmap_l3(pmap, va);
2116                 /* TODO: This is not optimal, but should mostly work */
2117                 if (l3 == NULL) {
2118                         l2 = pmap_l2(pmap, va);
2119                         if (l2 == NULL) {
2120                                 l2_m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
2121                                     VM_ALLOC_NOOBJ | VM_ALLOC_WIRED |
2122                                     VM_ALLOC_ZERO);
2123                                 if (l2_m == NULL)
2124                                         panic("pmap_enter: l2 pte_m == NULL");
2125                                 if ((l2_m->flags & PG_ZERO) == 0)
2126                                         pmap_zero_page(l2_m);
2127
2128                                 l2_pa = VM_PAGE_TO_PHYS(l2_m);
2129                                 l2_pn = (l2_pa / PAGE_SIZE);
2130
2131                                 l1 = pmap_l1(pmap, va);
2132                                 entry = (PTE_V);
2133                                 entry |= (l2_pn << PTE_PPN0_S);
2134                                 pmap_load_store(l1, entry);
2135                                 pmap_distribute_l1(pmap, pmap_l1_index(va), entry);
2136                                 l2 = pmap_l1_to_l2(l1, va);
2137                         }
2138
2139                         KASSERT(l2 != NULL,
2140                             ("No l2 table after allocating one"));
2141
2142                         l3_m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
2143                             VM_ALLOC_NOOBJ | VM_ALLOC_WIRED | VM_ALLOC_ZERO);
2144                         if (l3_m == NULL)
2145                                 panic("pmap_enter: l3 pte_m == NULL");
2146                         if ((l3_m->flags & PG_ZERO) == 0)
2147                                 pmap_zero_page(l3_m);
2148
2149                         l3_pa = VM_PAGE_TO_PHYS(l3_m);
2150                         l3_pn = (l3_pa / PAGE_SIZE);
2151                         entry = (PTE_V);
2152                         entry |= (l3_pn << PTE_PPN0_S);
2153                         pmap_load_store(l2, entry);
2154                         l3 = pmap_l2_to_l3(l2, va);
2155                 }
2156                 pmap_invalidate_page(pmap, va);
2157         }
2158
2159         orig_l3 = pmap_load(l3);
2160         opa = PTE_TO_PHYS(orig_l3);
2161         pv = NULL;
2162
2163         /*
2164          * Is the specified virtual address already mapped?
2165          */
2166         if (pmap_l3_valid(orig_l3)) {
2167                 /*
2168                  * Wiring change, just update stats. We don't worry about
2169                  * wiring PT pages as they remain resident as long as there
2170                  * are valid mappings in them. Hence, if a user page is wired,
2171                  * the PT page will be also.
2172                  */
2173                 if ((flags & PMAP_ENTER_WIRED) != 0 &&
2174                     (orig_l3 & PTE_SW_WIRED) == 0)
2175                         pmap->pm_stats.wired_count++;
2176                 else if ((flags & PMAP_ENTER_WIRED) == 0 &&
2177                     (orig_l3 & PTE_SW_WIRED) != 0)
2178                         pmap->pm_stats.wired_count--;
2179
2180                 /*
2181                  * Remove the extra PT page reference.
2182                  */
2183                 if (mpte != NULL) {
2184                         mpte->wire_count--;
2185                         KASSERT(mpte->wire_count > 0,
2186                             ("pmap_enter: missing reference to page table page,"
2187                              " va: 0x%lx", va));
2188                 }
2189
2190                 /*
2191                  * Has the physical page changed?
2192                  */
2193                 if (opa == pa) {
2194                         /*
2195                          * No, might be a protection or wiring change.
2196                          */
2197                         if ((orig_l3 & PTE_SW_MANAGED) != 0) {
2198                                 if (pmap_is_write(new_l3))
2199                                         vm_page_aflag_set(m, PGA_WRITEABLE);
2200                         }
2201                         goto validate;
2202                 }
2203
2204                 /*
2205                  * The physical page has changed.  Temporarily invalidate
2206                  * the mapping.  This ensures that all threads sharing the
2207                  * pmap keep a consistent view of the mapping, which is
2208                  * necessary for the correct handling of COW faults.  It
2209                  * also permits reuse of the old mapping's PV entry,
2210                  * avoiding an allocation.
2211                  *
2212                  * For consistency, handle unmanaged mappings the same way.
2213                  */
2214                 orig_l3 = pmap_load_clear(l3);
2215                 KASSERT(PTE_TO_PHYS(orig_l3) == opa,
2216                     ("pmap_enter: unexpected pa update for %#lx", va));
2217                 if ((orig_l3 & PTE_SW_MANAGED) != 0) {
2218                         om = PHYS_TO_VM_PAGE(opa);
2219
2220                         /*
2221                          * The pmap lock is sufficient to synchronize with
2222                          * concurrent calls to pmap_page_test_mappings() and
2223                          * pmap_ts_referenced().
2224                          */
2225                         if (pmap_page_dirty(orig_l3))
2226                                 vm_page_dirty(om);
2227                         if ((orig_l3 & PTE_A) != 0)
2228                                 vm_page_aflag_set(om, PGA_REFERENCED);
2229                         CHANGE_PV_LIST_LOCK_TO_PHYS(&lock, opa);
2230                         pv = pmap_pvh_remove(&om->md, pmap, va);
2231                         if ((new_l3 & PTE_SW_MANAGED) == 0)
2232                                 free_pv_entry(pmap, pv);
2233                         if ((om->aflags & PGA_WRITEABLE) != 0 &&
2234                             TAILQ_EMPTY(&om->md.pv_list))
2235                                 vm_page_aflag_clear(om, PGA_WRITEABLE);
2236                 }
2237                 pmap_invalidate_page(pmap, va);
2238                 orig_l3 = 0;
2239         } else {
2240                 /*
2241                  * Increment the counters.
2242                  */
2243                 if ((new_l3 & PTE_SW_WIRED) != 0)
2244                         pmap->pm_stats.wired_count++;
2245                 pmap_resident_count_inc(pmap, 1);
2246         }
2247         /*
2248          * Enter on the PV list if part of our managed memory.
2249          */
2250         if ((new_l3 & PTE_SW_MANAGED) != 0) {
2251                 if (pv == NULL) {
2252                         pv = get_pv_entry(pmap, &lock);
2253                         pv->pv_va = va;
2254                 }
2255                 CHANGE_PV_LIST_LOCK_TO_PHYS(&lock, pa);
2256                 TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
2257                 m->md.pv_gen++;
2258                 if (pmap_is_write(new_l3))
2259                         vm_page_aflag_set(m, PGA_WRITEABLE);
2260         }
2261
2262 validate:
2263         /*
2264          * Sync the i-cache on all harts before updating the PTE
2265          * if the new PTE is executable.
2266          */
2267         if (prot & VM_PROT_EXECUTE)
2268                 pmap_sync_icache(pmap, va, PAGE_SIZE);
2269
2270         /*
2271          * Update the L3 entry.
2272          */
2273         if (orig_l3 != 0) {
2274                 orig_l3 = pmap_load_store(l3, new_l3);
2275                 pmap_invalidate_page(pmap, va);
2276                 KASSERT(PTE_TO_PHYS(orig_l3) == pa,
2277                     ("pmap_enter: invalid update"));
2278                 if (pmap_page_dirty(orig_l3) &&
2279                     (orig_l3 & PTE_SW_MANAGED) != 0)
2280                         vm_page_dirty(m);
2281         } else {
2282                 pmap_load_store(l3, new_l3);
2283         }
2284
2285         if (lock != NULL)
2286                 rw_wunlock(lock);
2287         rw_runlock(&pvh_global_lock);
2288         PMAP_UNLOCK(pmap);
2289         return (KERN_SUCCESS);
2290 }
2291
2292 /*
2293  * Maps a sequence of resident pages belonging to the same object.
2294  * The sequence begins with the given page m_start.  This page is
2295  * mapped at the given virtual address start.  Each subsequent page is
2296  * mapped at a virtual address that is offset from start by the same
2297  * amount as the page is offset from m_start within the object.  The
2298  * last page in the sequence is the page with the largest offset from
2299  * m_start that can be mapped at a virtual address less than the given
2300  * virtual address end.  Not every virtual page between start and end
2301  * is mapped; only those for which a resident page exists with the
2302  * corresponding offset from m_start are mapped.
2303  */
2304 void
2305 pmap_enter_object(pmap_t pmap, vm_offset_t start, vm_offset_t end,
2306     vm_page_t m_start, vm_prot_t prot)
2307 {
2308         struct rwlock *lock;
2309         vm_offset_t va;
2310         vm_page_t m, mpte;
2311         vm_pindex_t diff, psize;
2312
2313         VM_OBJECT_ASSERT_LOCKED(m_start->object);
2314
2315         psize = atop(end - start);
2316         mpte = NULL;
2317         m = m_start;
2318         lock = NULL;
2319         rw_rlock(&pvh_global_lock);
2320         PMAP_LOCK(pmap);
2321         while (m != NULL && (diff = m->pindex - m_start->pindex) < psize) {
2322                 va = start + ptoa(diff);
2323                 mpte = pmap_enter_quick_locked(pmap, va, m, prot, mpte, &lock);
2324                 m = TAILQ_NEXT(m, listq);
2325         }
2326         if (lock != NULL)
2327                 rw_wunlock(lock);
2328         rw_runlock(&pvh_global_lock);
2329         PMAP_UNLOCK(pmap);
2330 }
2331
2332 /*
2333  * this code makes some *MAJOR* assumptions:
2334  * 1. Current pmap & pmap exists.
2335  * 2. Not wired.
2336  * 3. Read access.
2337  * 4. No page table pages.
2338  * but is *MUCH* faster than pmap_enter...
2339  */
2340
2341 void
2342 pmap_enter_quick(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot)
2343 {
2344         struct rwlock *lock;
2345
2346         lock = NULL;
2347         rw_rlock(&pvh_global_lock);
2348         PMAP_LOCK(pmap);
2349         (void)pmap_enter_quick_locked(pmap, va, m, prot, NULL, &lock);
2350         if (lock != NULL)
2351                 rw_wunlock(lock);
2352         rw_runlock(&pvh_global_lock);
2353         PMAP_UNLOCK(pmap);
2354 }
2355
2356 static vm_page_t
2357 pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va, vm_page_t m,
2358     vm_prot_t prot, vm_page_t mpte, struct rwlock **lockp)
2359 {
2360         struct spglist free;
2361         vm_paddr_t phys;
2362         pd_entry_t *l2;
2363         pt_entry_t *l3;
2364         vm_paddr_t pa;
2365         pt_entry_t entry;
2366         pn_t pn;
2367
2368         KASSERT(va < kmi.clean_sva || va >= kmi.clean_eva ||
2369             (m->oflags & VPO_UNMANAGED) != 0,
2370             ("pmap_enter_quick_locked: managed mapping within the clean submap"));
2371         rw_assert(&pvh_global_lock, RA_LOCKED);
2372         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2373
2374         CTR2(KTR_PMAP, "pmap_enter_quick_locked: %p %lx", pmap, va);
2375         /*
2376          * In the case that a page table page is not
2377          * resident, we are creating it here.
2378          */
2379         if (va < VM_MAXUSER_ADDRESS) {
2380                 vm_pindex_t l2pindex;
2381
2382                 /*
2383                  * Calculate pagetable page index
2384                  */
2385                 l2pindex = pmap_l2_pindex(va);
2386                 if (mpte && (mpte->pindex == l2pindex)) {
2387                         mpte->wire_count++;
2388                 } else {
2389                         /*
2390                          * Get the l2 entry
2391                          */
2392                         l2 = pmap_l2(pmap, va);
2393
2394                         /*
2395                          * If the page table page is mapped, we just increment
2396                          * the hold count, and activate it.  Otherwise, we
2397                          * attempt to allocate a page table page.  If this
2398                          * attempt fails, we don't retry.  Instead, we give up.
2399                          */
2400                         if (l2 != NULL && pmap_load(l2) != 0) {
2401                                 phys = PTE_TO_PHYS(pmap_load(l2));
2402                                 mpte = PHYS_TO_VM_PAGE(phys);
2403                                 mpte->wire_count++;
2404                         } else {
2405                                 /*
2406                                  * Pass NULL instead of the PV list lock
2407                                  * pointer, because we don't intend to sleep.
2408                                  */
2409                                 mpte = _pmap_alloc_l3(pmap, l2pindex, NULL);
2410                                 if (mpte == NULL)
2411                                         return (mpte);
2412                         }
2413                 }
2414                 l3 = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
2415                 l3 = &l3[pmap_l3_index(va)];
2416         } else {
2417                 mpte = NULL;
2418                 l3 = pmap_l3(kernel_pmap, va);
2419         }
2420         if (l3 == NULL)
2421                 panic("pmap_enter_quick_locked: No l3");
2422         if (pmap_load(l3) != 0) {
2423                 if (mpte != NULL) {
2424                         mpte->wire_count--;
2425                         mpte = NULL;
2426                 }
2427                 return (mpte);
2428         }
2429
2430         /*
2431          * Enter on the PV list if part of our managed memory.
2432          */
2433         if ((m->oflags & VPO_UNMANAGED) == 0 &&
2434             !pmap_try_insert_pv_entry(pmap, va, m, lockp)) {
2435                 if (mpte != NULL) {
2436                         SLIST_INIT(&free);
2437                         if (pmap_unwire_l3(pmap, va, mpte, &free)) {
2438                                 pmap_invalidate_page(pmap, va);
2439                                 vm_page_free_pages_toq(&free, false);
2440                         }
2441                         mpte = NULL;
2442                 }
2443                 return (mpte);
2444         }
2445
2446         /*
2447          * Increment counters
2448          */
2449         pmap_resident_count_inc(pmap, 1);
2450
2451         pa = VM_PAGE_TO_PHYS(m);
2452         pn = (pa / PAGE_SIZE);
2453
2454         entry = (PTE_V | PTE_R | PTE_X);
2455         entry |= (pn << PTE_PPN0_S);
2456
2457         /*
2458          * Now validate mapping with RO protection
2459          */
2460         if ((m->oflags & VPO_UNMANAGED) == 0)
2461                 entry |= PTE_SW_MANAGED;
2462
2463         /*
2464          * Sync the i-cache on all harts before updating the PTE
2465          * if the new PTE is executable.
2466          */
2467         if (prot & VM_PROT_EXECUTE)
2468                 pmap_sync_icache(pmap, va, PAGE_SIZE);
2469
2470         pmap_load_store(l3, entry);
2471
2472         pmap_invalidate_page(pmap, va);
2473         return (mpte);
2474 }
2475
2476 /*
2477  * This code maps large physical mmap regions into the
2478  * processor address space.  Note that some shortcuts
2479  * are taken, but the code works.
2480  */
2481 void
2482 pmap_object_init_pt(pmap_t pmap, vm_offset_t addr, vm_object_t object,
2483     vm_pindex_t pindex, vm_size_t size)
2484 {
2485
2486         VM_OBJECT_ASSERT_WLOCKED(object);
2487         KASSERT(object->type == OBJT_DEVICE || object->type == OBJT_SG,
2488             ("pmap_object_init_pt: non-device object"));
2489 }
2490
2491 /*
2492  *      Clear the wired attribute from the mappings for the specified range of
2493  *      addresses in the given pmap.  Every valid mapping within that range
2494  *      must have the wired attribute set.  In contrast, invalid mappings
2495  *      cannot have the wired attribute set, so they are ignored.
2496  *
2497  *      The wired attribute of the page table entry is not a hardware feature,
2498  *      so there is no need to invalidate any TLB entries.
2499  */
2500 void
2501 pmap_unwire(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
2502 {
2503         vm_offset_t va_next;
2504         pd_entry_t *l1, *l2;
2505         pt_entry_t *l3;
2506         boolean_t pv_lists_locked;
2507
2508         pv_lists_locked = FALSE;
2509         PMAP_LOCK(pmap);
2510         for (; sva < eva; sva = va_next) {
2511                 l1 = pmap_l1(pmap, sva);
2512                 if (pmap_load(l1) == 0) {
2513                         va_next = (sva + L1_SIZE) & ~L1_OFFSET;
2514                         if (va_next < sva)
2515                                 va_next = eva;
2516                         continue;
2517                 }
2518
2519                 va_next = (sva + L2_SIZE) & ~L2_OFFSET;
2520                 if (va_next < sva)
2521                         va_next = eva;
2522
2523                 l2 = pmap_l1_to_l2(l1, sva);
2524                 if (pmap_load(l2) == 0)
2525                         continue;
2526
2527                 if (va_next > eva)
2528                         va_next = eva;
2529                 for (l3 = pmap_l2_to_l3(l2, sva); sva != va_next; l3++,
2530                     sva += L3_SIZE) {
2531                         if (pmap_load(l3) == 0)
2532                                 continue;
2533                         if ((pmap_load(l3) & PTE_SW_WIRED) == 0)
2534                                 panic("pmap_unwire: l3 %#jx is missing "
2535                                     "PTE_SW_WIRED", (uintmax_t)*l3);
2536
2537                         /*
2538                          * PG_W must be cleared atomically.  Although the pmap
2539                          * lock synchronizes access to PG_W, another processor
2540                          * could be setting PG_M and/or PG_A concurrently.
2541                          */
2542                         atomic_clear_long(l3, PTE_SW_WIRED);
2543                         pmap->pm_stats.wired_count--;
2544                 }
2545         }
2546         if (pv_lists_locked)
2547                 rw_runlock(&pvh_global_lock);
2548         PMAP_UNLOCK(pmap);
2549 }
2550
2551 /*
2552  *      Copy the range specified by src_addr/len
2553  *      from the source map to the range dst_addr/len
2554  *      in the destination map.
2555  *
2556  *      This routine is only advisory and need not do anything.
2557  */
2558
2559 void
2560 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, vm_size_t len,
2561     vm_offset_t src_addr)
2562 {
2563
2564 }
2565
2566 /*
2567  *      pmap_zero_page zeros the specified hardware page by mapping
2568  *      the page into KVM and using bzero to clear its contents.
2569  */
2570 void
2571 pmap_zero_page(vm_page_t m)
2572 {
2573         vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
2574
2575         pagezero((void *)va);
2576 }
2577
2578 /*
2579  *      pmap_zero_page_area zeros the specified hardware page by mapping
2580  *      the page into KVM and using bzero to clear its contents.
2581  *
2582  *      off and size may not cover an area beyond a single hardware page.
2583  */
2584 void
2585 pmap_zero_page_area(vm_page_t m, int off, int size)
2586 {
2587         vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
2588
2589         if (off == 0 && size == PAGE_SIZE)
2590                 pagezero((void *)va);
2591         else
2592                 bzero((char *)va + off, size);
2593 }
2594
2595 /*
2596  *      pmap_copy_page copies the specified (machine independent)
2597  *      page by mapping the page into virtual memory and using
2598  *      bcopy to copy the page, one machine dependent page at a
2599  *      time.
2600  */
2601 void
2602 pmap_copy_page(vm_page_t msrc, vm_page_t mdst)
2603 {
2604         vm_offset_t src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
2605         vm_offset_t dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
2606
2607         pagecopy((void *)src, (void *)dst);
2608 }
2609
2610 int unmapped_buf_allowed = 1;
2611
2612 void
2613 pmap_copy_pages(vm_page_t ma[], vm_offset_t a_offset, vm_page_t mb[],
2614     vm_offset_t b_offset, int xfersize)
2615 {
2616         void *a_cp, *b_cp;
2617         vm_page_t m_a, m_b;
2618         vm_paddr_t p_a, p_b;
2619         vm_offset_t a_pg_offset, b_pg_offset;
2620         int cnt;
2621
2622         while (xfersize > 0) {
2623                 a_pg_offset = a_offset & PAGE_MASK;
2624                 m_a = ma[a_offset >> PAGE_SHIFT];
2625                 p_a = m_a->phys_addr;
2626                 b_pg_offset = b_offset & PAGE_MASK;
2627                 m_b = mb[b_offset >> PAGE_SHIFT];
2628                 p_b = m_b->phys_addr;
2629                 cnt = min(xfersize, PAGE_SIZE - a_pg_offset);
2630                 cnt = min(cnt, PAGE_SIZE - b_pg_offset);
2631                 if (__predict_false(!PHYS_IN_DMAP(p_a))) {
2632                         panic("!DMAP a %lx", p_a);
2633                 } else {
2634                         a_cp = (char *)PHYS_TO_DMAP(p_a) + a_pg_offset;
2635                 }
2636                 if (__predict_false(!PHYS_IN_DMAP(p_b))) {
2637                         panic("!DMAP b %lx", p_b);
2638                 } else {
2639                         b_cp = (char *)PHYS_TO_DMAP(p_b) + b_pg_offset;
2640                 }
2641                 bcopy(a_cp, b_cp, cnt);
2642                 a_offset += cnt;
2643                 b_offset += cnt;
2644                 xfersize -= cnt;
2645         }
2646 }
2647
2648 vm_offset_t
2649 pmap_quick_enter_page(vm_page_t m)
2650 {
2651
2652         return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
2653 }
2654
2655 void
2656 pmap_quick_remove_page(vm_offset_t addr)
2657 {
2658 }
2659
2660 /*
2661  * Returns true if the pmap's pv is one of the first
2662  * 16 pvs linked to from this page.  This count may
2663  * be changed upwards or downwards in the future; it
2664  * is only necessary that true be returned for a small
2665  * subset of pmaps for proper page aging.
2666  */
2667 boolean_t
2668 pmap_page_exists_quick(pmap_t pmap, vm_page_t m)
2669 {
2670         struct rwlock *lock;
2671         pv_entry_t pv;
2672         int loops = 0;
2673         boolean_t rv;
2674
2675         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
2676             ("pmap_page_exists_quick: page %p is not managed", m));
2677         rv = FALSE;
2678         rw_rlock(&pvh_global_lock);
2679         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
2680         rw_rlock(lock);
2681         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
2682                 if (PV_PMAP(pv) == pmap) {
2683                         rv = TRUE;
2684                         break;
2685                 }
2686                 loops++;
2687                 if (loops >= 16)
2688                         break;
2689         }
2690         rw_runlock(lock);
2691         rw_runlock(&pvh_global_lock);
2692         return (rv);
2693 }
2694
2695 /*
2696  *      pmap_page_wired_mappings:
2697  *
2698  *      Return the number of managed mappings to the given physical page
2699  *      that are wired.
2700  */
2701 int
2702 pmap_page_wired_mappings(vm_page_t m)
2703 {
2704         struct rwlock *lock;
2705         pmap_t pmap;
2706         pt_entry_t *l3;
2707         pv_entry_t pv;
2708         int count, md_gen;
2709
2710         if ((m->oflags & VPO_UNMANAGED) != 0)
2711                 return (0);
2712         rw_rlock(&pvh_global_lock);
2713         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
2714         rw_rlock(lock);
2715 restart:
2716         count = 0;
2717         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
2718                 pmap = PV_PMAP(pv);
2719                 if (!PMAP_TRYLOCK(pmap)) {
2720                         md_gen = m->md.pv_gen;
2721                         rw_runlock(lock);
2722                         PMAP_LOCK(pmap);
2723                         rw_rlock(lock);
2724                         if (md_gen != m->md.pv_gen) {
2725                                 PMAP_UNLOCK(pmap);
2726                                 goto restart;
2727                         }
2728                 }
2729                 l3 = pmap_l3(pmap, pv->pv_va);
2730                 if (l3 != NULL && (pmap_load(l3) & PTE_SW_WIRED) != 0)
2731                         count++;
2732                 PMAP_UNLOCK(pmap);
2733         }
2734         rw_runlock(lock);
2735         rw_runlock(&pvh_global_lock);
2736         return (count);
2737 }
2738
2739 /*
2740  * Destroy all managed, non-wired mappings in the given user-space
2741  * pmap.  This pmap cannot be active on any processor besides the
2742  * caller.
2743  *
2744  * This function cannot be applied to the kernel pmap.  Moreover, it
2745  * is not intended for general use.  It is only to be used during
2746  * process termination.  Consequently, it can be implemented in ways
2747  * that make it faster than pmap_remove().  First, it can more quickly
2748  * destroy mappings by iterating over the pmap's collection of PV
2749  * entries, rather than searching the page table.  Second, it doesn't
2750  * have to test and clear the page table entries atomically, because
2751  * no processor is currently accessing the user address space.  In
2752  * particular, a page table entry's dirty bit won't change state once
2753  * this function starts.
2754  */
2755 void
2756 pmap_remove_pages(pmap_t pmap)
2757 {
2758         pd_entry_t ptepde, *l2;
2759         pt_entry_t *l3, tl3;
2760         struct spglist free;
2761         vm_page_t m;
2762         pv_entry_t pv;
2763         struct pv_chunk *pc, *npc;
2764         struct rwlock *lock;
2765         int64_t bit;
2766         uint64_t inuse, bitmask;
2767         int allfree, field, freed, idx;
2768         vm_paddr_t pa;
2769
2770         lock = NULL;
2771
2772         SLIST_INIT(&free);
2773         rw_rlock(&pvh_global_lock);
2774         PMAP_LOCK(pmap);
2775         TAILQ_FOREACH_SAFE(pc, &pmap->pm_pvchunk, pc_list, npc) {
2776                 allfree = 1;
2777                 freed = 0;
2778                 for (field = 0; field < _NPCM; field++) {
2779                         inuse = ~pc->pc_map[field] & pc_freemask[field];
2780                         while (inuse != 0) {
2781                                 bit = ffsl(inuse) - 1;
2782                                 bitmask = 1UL << bit;
2783                                 idx = field * 64 + bit;
2784                                 pv = &pc->pc_pventry[idx];
2785                                 inuse &= ~bitmask;
2786
2787                                 l2 = pmap_l2(pmap, pv->pv_va);
2788                                 ptepde = pmap_load(l2);
2789                                 l3 = pmap_l2_to_l3(l2, pv->pv_va);
2790                                 tl3 = pmap_load(l3);
2791
2792 /*
2793  * We cannot remove wired pages from a process' mapping at this time
2794  */
2795                                 if (tl3 & PTE_SW_WIRED) {
2796                                         allfree = 0;
2797                                         continue;
2798                                 }
2799
2800                                 pa = PTE_TO_PHYS(tl3);
2801                                 m = PHYS_TO_VM_PAGE(pa);
2802                                 KASSERT(m->phys_addr == pa,
2803                                     ("vm_page_t %p phys_addr mismatch %016jx %016jx",
2804                                     m, (uintmax_t)m->phys_addr,
2805                                     (uintmax_t)tl3));
2806
2807                                 KASSERT((m->flags & PG_FICTITIOUS) != 0 ||
2808                                     m < &vm_page_array[vm_page_array_size],
2809                                     ("pmap_remove_pages: bad l3 %#jx",
2810                                     (uintmax_t)tl3));
2811
2812                                 pmap_load_clear(l3);
2813                                 pmap_invalidate_page(pmap, pv->pv_va);
2814
2815                                 /*
2816                                  * Update the vm_page_t clean/reference bits.
2817                                  */
2818                                 if (pmap_page_dirty(tl3))
2819                                         vm_page_dirty(m);
2820
2821                                 CHANGE_PV_LIST_LOCK_TO_VM_PAGE(&lock, m);
2822
2823                                 /* Mark free */
2824                                 pc->pc_map[field] |= bitmask;
2825
2826                                 pmap_resident_count_dec(pmap, 1);
2827                                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
2828                                 m->md.pv_gen++;
2829
2830                                 pmap_unuse_l3(pmap, pv->pv_va, ptepde, &free);
2831                                 freed++;
2832                         }
2833                 }
2834                 PV_STAT(atomic_add_long(&pv_entry_frees, freed));
2835                 PV_STAT(atomic_add_int(&pv_entry_spare, freed));
2836                 PV_STAT(atomic_subtract_long(&pv_entry_count, freed));
2837                 if (allfree) {
2838                         TAILQ_REMOVE(&pmap->pm_pvchunk, pc, pc_list);
2839                         free_pv_chunk(pc);
2840                 }
2841         }
2842         pmap_invalidate_all(pmap);
2843         if (lock != NULL)
2844                 rw_wunlock(lock);
2845         rw_runlock(&pvh_global_lock);
2846         PMAP_UNLOCK(pmap);
2847         vm_page_free_pages_toq(&free, false);
2848 }
2849
2850 /*
2851  * This is used to check if a page has been accessed or modified. As we
2852  * don't have a bit to see if it has been modified we have to assume it
2853  * has been if the page is read/write.
2854  */
2855 static boolean_t
2856 pmap_page_test_mappings(vm_page_t m, boolean_t accessed, boolean_t modified)
2857 {
2858         struct rwlock *lock;
2859         pv_entry_t pv;
2860         pt_entry_t *l3, mask, value;
2861         pmap_t pmap;
2862         int md_gen;
2863         boolean_t rv;
2864
2865         rv = FALSE;
2866         rw_rlock(&pvh_global_lock);
2867         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
2868         rw_rlock(lock);
2869 restart:
2870         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
2871                 pmap = PV_PMAP(pv);
2872                 if (!PMAP_TRYLOCK(pmap)) {
2873                         md_gen = m->md.pv_gen;
2874                         rw_runlock(lock);
2875                         PMAP_LOCK(pmap);
2876                         rw_rlock(lock);
2877                         if (md_gen != m->md.pv_gen) {
2878                                 PMAP_UNLOCK(pmap);
2879                                 goto restart;
2880                         }
2881                 }
2882                 l3 = pmap_l3(pmap, pv->pv_va);
2883                 mask = 0;
2884                 value = 0;
2885                 if (modified) {
2886                         mask |= PTE_D;
2887                         value |= PTE_D;
2888                 }
2889                 if (accessed) {
2890                         mask |= PTE_A;
2891                         value |= PTE_A;
2892                 }
2893
2894 #if 0
2895                 if (modified) {
2896                         mask |= ATTR_AP_RW_BIT;
2897                         value |= ATTR_AP(ATTR_AP_RW);
2898                 }
2899                 if (accessed) {
2900                         mask |= ATTR_AF | ATTR_DESCR_MASK;
2901                         value |= ATTR_AF | L3_PAGE;
2902                 }
2903 #endif
2904
2905                 rv = (pmap_load(l3) & mask) == value;
2906                 PMAP_UNLOCK(pmap);
2907                 if (rv)
2908                         goto out;
2909         }
2910 out:
2911         rw_runlock(lock);
2912         rw_runlock(&pvh_global_lock);
2913         return (rv);
2914 }
2915
2916 /*
2917  *      pmap_is_modified:
2918  *
2919  *      Return whether or not the specified physical page was modified
2920  *      in any physical maps.
2921  */
2922 boolean_t
2923 pmap_is_modified(vm_page_t m)
2924 {
2925
2926         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
2927             ("pmap_is_modified: page %p is not managed", m));
2928
2929         /*
2930          * If the page is not exclusive busied, then PGA_WRITEABLE cannot be
2931          * concurrently set while the object is locked.  Thus, if PGA_WRITEABLE
2932          * is clear, no PTEs can have PG_M set.
2933          */
2934         VM_OBJECT_ASSERT_WLOCKED(m->object);
2935         if (!vm_page_xbusied(m) && (m->aflags & PGA_WRITEABLE) == 0)
2936                 return (FALSE);
2937         return (pmap_page_test_mappings(m, FALSE, TRUE));
2938 }
2939
2940 /*
2941  *      pmap_is_prefaultable:
2942  *
2943  *      Return whether or not the specified virtual address is eligible
2944  *      for prefault.
2945  */
2946 boolean_t
2947 pmap_is_prefaultable(pmap_t pmap, vm_offset_t addr)
2948 {
2949         pt_entry_t *l3;
2950         boolean_t rv;
2951
2952         rv = FALSE;
2953         PMAP_LOCK(pmap);
2954         l3 = pmap_l3(pmap, addr);
2955         if (l3 != NULL && pmap_load(l3) != 0) {
2956                 rv = TRUE;
2957         }
2958         PMAP_UNLOCK(pmap);
2959         return (rv);
2960 }
2961
2962 /*
2963  *      pmap_is_referenced:
2964  *
2965  *      Return whether or not the specified physical page was referenced
2966  *      in any physical maps.
2967  */
2968 boolean_t
2969 pmap_is_referenced(vm_page_t m)
2970 {
2971
2972         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
2973             ("pmap_is_referenced: page %p is not managed", m));
2974         return (pmap_page_test_mappings(m, TRUE, FALSE));
2975 }
2976
2977 /*
2978  * Clear the write and modified bits in each of the given page's mappings.
2979  */
2980 void
2981 pmap_remove_write(vm_page_t m)
2982 {
2983         pmap_t pmap;
2984         struct rwlock *lock;
2985         pv_entry_t pv;
2986         pt_entry_t *l3, oldl3;
2987         pt_entry_t newl3;
2988         int md_gen;
2989
2990         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
2991             ("pmap_remove_write: page %p is not managed", m));
2992
2993         /*
2994          * If the page is not exclusive busied, then PGA_WRITEABLE cannot be
2995          * set by another thread while the object is locked.  Thus,
2996          * if PGA_WRITEABLE is clear, no page table entries need updating.
2997          */
2998         VM_OBJECT_ASSERT_WLOCKED(m->object);
2999         if (!vm_page_xbusied(m) && (m->aflags & PGA_WRITEABLE) == 0)
3000                 return;
3001         rw_rlock(&pvh_global_lock);
3002         lock = VM_PAGE_TO_PV_LIST_LOCK(m);
3003 retry_pv_loop:
3004         rw_wlock(lock);
3005         TAILQ_FOREACH(pv, &m->md.pv_list, pv_next) {
3006                 pmap = PV_PMAP(pv);
3007                 if (!PMAP_TRYLOCK(pmap)) {
3008                         md_gen = m->md.pv_gen;
3009                         rw_wunlock(lock);
3010                         PMAP_LOCK(pmap);
3011                         rw_wlock(lock);
3012                         if (md_gen != m->md.pv_gen) {
3013                                 PMAP_UNLOCK(pmap);
3014                                 rw_wunlock(lock);
3015                                 goto retry_pv_loop;
3016                         }
3017                 }
3018                 l3 = pmap_l3(pmap, pv->pv_va);
3019 retry:
3020                 oldl3 = pmap_load(l3);
3021
3022                 if (pmap_is_write(oldl3)) {
3023                         newl3 = oldl3 & ~(PTE_W);
3024                         if (!atomic_cmpset_long(l3, oldl3, newl3))
3025                                 goto retry;
3026                         /* TODO: use pmap_page_dirty(oldl3) ? */
3027                         if ((oldl3 & PTE_A) != 0)
3028                                 vm_page_dirty(m);
3029                         pmap_invalidate_page(pmap, pv->pv_va);
3030                 }
3031                 PMAP_UNLOCK(pmap);
3032         }
3033         rw_wunlock(lock);
3034         vm_page_aflag_clear(m, PGA_WRITEABLE);
3035         rw_runlock(&pvh_global_lock);
3036 }
3037
3038 static __inline boolean_t
3039 safe_to_clear_referenced(pmap_t pmap, pt_entry_t pte)
3040 {
3041
3042         return (FALSE);
3043 }
3044
3045 /*
3046  *      pmap_ts_referenced:
3047  *
3048  *      Return a count of reference bits for a page, clearing those bits.
3049  *      It is not necessary for every reference bit to be cleared, but it
3050  *      is necessary that 0 only be returned when there are truly no
3051  *      reference bits set.
3052  *
3053  *      As an optimization, update the page's dirty field if a modified bit is
3054  *      found while counting reference bits.  This opportunistic update can be
3055  *      performed at low cost and can eliminate the need for some future calls
3056  *      to pmap_is_modified().  However, since this function stops after
3057  *      finding PMAP_TS_REFERENCED_MAX reference bits, it may not detect some
3058  *      dirty pages.  Those dirty pages will only be detected by a future call
3059  *      to pmap_is_modified().
3060  */
3061 int
3062 pmap_ts_referenced(vm_page_t m)
3063 {
3064         pv_entry_t pv, pvf;
3065         pmap_t pmap;
3066         struct rwlock *lock;
3067         pd_entry_t *l2;
3068         pt_entry_t *l3, old_l3;
3069         vm_paddr_t pa;
3070         int cleared, md_gen, not_cleared;
3071         struct spglist free;
3072
3073         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
3074             ("pmap_ts_referenced: page %p is not managed", m));
3075         SLIST_INIT(&free);
3076         cleared = 0;
3077         pa = VM_PAGE_TO_PHYS(m);
3078         lock = PHYS_TO_PV_LIST_LOCK(pa);
3079         rw_rlock(&pvh_global_lock);
3080         rw_wlock(lock);
3081 retry:
3082         not_cleared = 0;
3083         if ((pvf = TAILQ_FIRST(&m->md.pv_list)) == NULL)
3084                 goto out;
3085         pv = pvf;
3086         do {
3087                 if (pvf == NULL)
3088                         pvf = pv;
3089                 pmap = PV_PMAP(pv);
3090                 if (!PMAP_TRYLOCK(pmap)) {
3091                         md_gen = m->md.pv_gen;
3092                         rw_wunlock(lock);
3093                         PMAP_LOCK(pmap);
3094                         rw_wlock(lock);
3095                         if (md_gen != m->md.pv_gen) {
3096                                 PMAP_UNLOCK(pmap);
3097                                 goto retry;
3098                         }
3099                 }
3100                 l2 = pmap_l2(pmap, pv->pv_va);
3101
3102                 KASSERT((pmap_load(l2) & PTE_RX) == 0,
3103                     ("pmap_ts_referenced: found an invalid l2 table"));
3104
3105                 l3 = pmap_l2_to_l3(l2, pv->pv_va);
3106                 old_l3 = pmap_load(l3);
3107                 if (pmap_page_dirty(old_l3))
3108                         vm_page_dirty(m);
3109                 if ((old_l3 & PTE_A) != 0) {
3110                         if (safe_to_clear_referenced(pmap, old_l3)) {
3111                                 /*
3112                                  * TODO: We don't handle the access flag
3113                                  * at all. We need to be able to set it in
3114                                  * the exception handler.
3115                                  */
3116                                 panic("RISCVTODO: safe_to_clear_referenced\n");
3117                         } else if ((old_l3 & PTE_SW_WIRED) == 0) {
3118                                 /*
3119                                  * Wired pages cannot be paged out so
3120                                  * doing accessed bit emulation for
3121                                  * them is wasted effort. We do the
3122                                  * hard work for unwired pages only.
3123                                  */
3124                                 pmap_remove_l3(pmap, l3, pv->pv_va,
3125                                     pmap_load(l2), &free, &lock);
3126                                 pmap_invalidate_page(pmap, pv->pv_va);
3127                                 cleared++;
3128                                 if (pvf == pv)
3129                                         pvf = NULL;
3130                                 pv = NULL;
3131                                 KASSERT(lock == VM_PAGE_TO_PV_LIST_LOCK(m),
3132                                     ("inconsistent pv lock %p %p for page %p",
3133                                     lock, VM_PAGE_TO_PV_LIST_LOCK(m), m));
3134                         } else
3135                                 not_cleared++;
3136                 }
3137                 PMAP_UNLOCK(pmap);
3138                 /* Rotate the PV list if it has more than one entry. */
3139                 if (pv != NULL && TAILQ_NEXT(pv, pv_next) != NULL) {
3140                         TAILQ_REMOVE(&m->md.pv_list, pv, pv_next);
3141                         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_next);
3142                         m->md.pv_gen++;
3143                 }
3144         } while ((pv = TAILQ_FIRST(&m->md.pv_list)) != pvf && cleared +
3145             not_cleared < PMAP_TS_REFERENCED_MAX);
3146 out:
3147         rw_wunlock(lock);
3148         rw_runlock(&pvh_global_lock);
3149         vm_page_free_pages_toq(&free, false);
3150         return (cleared + not_cleared);
3151 }
3152
3153 /*
3154  *      Apply the given advice to the specified range of addresses within the
3155  *      given pmap.  Depending on the advice, clear the referenced and/or
3156  *      modified flags in each mapping and set the mapped page's dirty field.
3157  */
3158 void
3159 pmap_advise(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, int advice)
3160 {
3161 }
3162
3163 /*
3164  *      Clear the modify bits on the specified physical page.
3165  */
3166 void
3167 pmap_clear_modify(vm_page_t m)
3168 {
3169
3170         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
3171             ("pmap_clear_modify: page %p is not managed", m));
3172         VM_OBJECT_ASSERT_WLOCKED(m->object);
3173         KASSERT(!vm_page_xbusied(m),
3174             ("pmap_clear_modify: page %p is exclusive busied", m));
3175
3176         /*
3177          * If the page is not PGA_WRITEABLE, then no PTEs can have PG_M set.
3178          * If the object containing the page is locked and the page is not
3179          * exclusive busied, then PGA_WRITEABLE cannot be concurrently set.
3180          */
3181         if ((m->aflags & PGA_WRITEABLE) == 0)
3182                 return;
3183
3184         /* RISCVTODO: We lack support for tracking if a page is modified */
3185 }
3186
3187 void *
3188 pmap_mapbios(vm_paddr_t pa, vm_size_t size)
3189 {
3190
3191         return ((void *)PHYS_TO_DMAP(pa));
3192 }
3193
3194 void
3195 pmap_unmapbios(vm_paddr_t pa, vm_size_t size)
3196 {
3197 }
3198
3199 /*
3200  * Sets the memory attribute for the specified page.
3201  */
3202 void
3203 pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
3204 {
3205
3206         m->md.pv_memattr = ma;
3207
3208         /*
3209          * RISCVTODO: Implement the below (from the amd64 pmap)
3210          * If "m" is a normal page, update its direct mapping.  This update
3211          * can be relied upon to perform any cache operations that are
3212          * required for data coherence.
3213          */
3214         if ((m->flags & PG_FICTITIOUS) == 0 &&
3215             PHYS_IN_DMAP(VM_PAGE_TO_PHYS(m)))
3216                 panic("RISCVTODO: pmap_page_set_memattr");
3217 }
3218
3219 /*
3220  * perform the pmap work for mincore
3221  */
3222 int
3223 pmap_mincore(pmap_t pmap, vm_offset_t addr, vm_paddr_t *locked_pa)
3224 {
3225         pt_entry_t *l2, *l3, tpte;
3226         vm_paddr_t pa;
3227         int val;
3228         bool managed;
3229
3230         PMAP_LOCK(pmap);
3231 retry:
3232         managed = false;
3233         val = 0;
3234
3235         l2 = pmap_l2(pmap, addr);
3236         if (l2 != NULL && ((tpte = pmap_load(l2)) & PTE_V) != 0) {
3237                 if ((tpte & (PTE_R | PTE_W | PTE_X)) != 0) {
3238                         pa = PTE_TO_PHYS(tpte) | (addr & L2_OFFSET);
3239                         val = MINCORE_INCORE | MINCORE_SUPER;
3240                 } else {
3241                         l3 = pmap_l2_to_l3(l2, addr);
3242                         tpte = pmap_load(l3);
3243                         if ((tpte & PTE_V) == 0)
3244                                 goto done;
3245                         pa = PTE_TO_PHYS(tpte) | (addr & L3_OFFSET);
3246                         val = MINCORE_INCORE;
3247                 }
3248
3249                 if (pmap_page_dirty(tpte))
3250                         val |= MINCORE_MODIFIED | MINCORE_MODIFIED_OTHER;
3251                 if (pmap_page_accessed(tpte))
3252                         val |= MINCORE_REFERENCED | MINCORE_REFERENCED_OTHER;
3253                 managed = (tpte & PTE_SW_MANAGED) == PTE_SW_MANAGED;
3254         }
3255
3256 done:
3257         if ((val & (MINCORE_MODIFIED_OTHER | MINCORE_REFERENCED_OTHER)) !=
3258             (MINCORE_MODIFIED_OTHER | MINCORE_REFERENCED_OTHER) && managed) {
3259                 /* Ensure that "PHYS_TO_VM_PAGE(pa)->object" doesn't change. */
3260                 if (vm_page_pa_tryrelock(pmap, pa, locked_pa))
3261                         goto retry;
3262         } else
3263                 PA_UNLOCK_COND(*locked_pa);
3264         PMAP_UNLOCK(pmap);
3265         return (val);
3266 }
3267
3268 void
3269 pmap_activate(struct thread *td)
3270 {
3271         pmap_t pmap;
3272         uint64_t reg;
3273
3274         critical_enter();
3275         pmap = vmspace_pmap(td->td_proc->p_vmspace);
3276         td->td_pcb->pcb_l1addr = vtophys(pmap->pm_l1);
3277
3278         reg = SATP_MODE_SV39;
3279         reg |= (td->td_pcb->pcb_l1addr >> PAGE_SHIFT);
3280         __asm __volatile("csrw sptbr, %0" :: "r"(reg));
3281
3282         pmap_invalidate_all(pmap);
3283         critical_exit();
3284 }
3285
3286 void
3287 pmap_sync_icache(pmap_t pm, vm_offset_t va, vm_size_t sz)
3288 {
3289         cpuset_t mask;
3290
3291         /*
3292          * From the RISC-V User-Level ISA V2.2:
3293          *
3294          * "To make a store to instruction memory visible to all
3295          * RISC-V harts, the writing hart has to execute a data FENCE
3296          * before requesting that all remote RISC-V harts execute a
3297          * FENCE.I."
3298          */
3299         sched_pin();
3300         mask = all_cpus;
3301         CPU_CLR(PCPU_GET(cpuid), &mask);
3302         fence();
3303         sbi_remote_fence_i(mask.__bits);
3304         sched_unpin();
3305 }
3306
3307 /*
3308  *      Increase the starting virtual address of the given mapping if a
3309  *      different alignment might result in more superpage mappings.
3310  */
3311 void
3312 pmap_align_superpage(vm_object_t object, vm_ooffset_t offset,
3313     vm_offset_t *addr, vm_size_t size)
3314 {
3315 }
3316
3317 /**
3318  * Get the kernel virtual address of a set of physical pages. If there are
3319  * physical addresses not covered by the DMAP perform a transient mapping
3320  * that will be removed when calling pmap_unmap_io_transient.
3321  *
3322  * \param page        The pages the caller wishes to obtain the virtual
3323  *                    address on the kernel memory map.
3324  * \param vaddr       On return contains the kernel virtual memory address
3325  *                    of the pages passed in the page parameter.
3326  * \param count       Number of pages passed in.
3327  * \param can_fault   TRUE if the thread using the mapped pages can take
3328  *                    page faults, FALSE otherwise.
3329  *
3330  * \returns TRUE if the caller must call pmap_unmap_io_transient when
3331  *          finished or FALSE otherwise.
3332  *
3333  */
3334 boolean_t
3335 pmap_map_io_transient(vm_page_t page[], vm_offset_t vaddr[], int count,
3336     boolean_t can_fault)
3337 {
3338         vm_paddr_t paddr;
3339         boolean_t needs_mapping;
3340         int error, i;
3341
3342         /*
3343          * Allocate any KVA space that we need, this is done in a separate
3344          * loop to prevent calling vmem_alloc while pinned.
3345          */
3346         needs_mapping = FALSE;
3347         for (i = 0; i < count; i++) {
3348                 paddr = VM_PAGE_TO_PHYS(page[i]);
3349                 if (__predict_false(paddr >= DMAP_MAX_PHYSADDR)) {
3350                         error = vmem_alloc(kernel_arena, PAGE_SIZE,
3351                             M_BESTFIT | M_WAITOK, &vaddr[i]);
3352                         KASSERT(error == 0, ("vmem_alloc failed: %d", error));
3353                         needs_mapping = TRUE;
3354                 } else {
3355                         vaddr[i] = PHYS_TO_DMAP(paddr);
3356                 }
3357         }
3358
3359         /* Exit early if everything is covered by the DMAP */
3360         if (!needs_mapping)
3361                 return (FALSE);
3362
3363         if (!can_fault)
3364                 sched_pin();
3365         for (i = 0; i < count; i++) {
3366                 paddr = VM_PAGE_TO_PHYS(page[i]);
3367                 if (paddr >= DMAP_MAX_PHYSADDR) {
3368                         panic(
3369                            "pmap_map_io_transient: TODO: Map out of DMAP data");
3370                 }
3371         }
3372
3373         return (needs_mapping);
3374 }
3375
3376 void
3377 pmap_unmap_io_transient(vm_page_t page[], vm_offset_t vaddr[], int count,
3378     boolean_t can_fault)
3379 {
3380         vm_paddr_t paddr;
3381         int i;
3382
3383         if (!can_fault)
3384                 sched_unpin();
3385         for (i = 0; i < count; i++) {
3386                 paddr = VM_PAGE_TO_PHYS(page[i]);
3387                 if (paddr >= DMAP_MAX_PHYSADDR) {
3388                         panic("RISCVTODO: pmap_unmap_io_transient: Unmap data");
3389                 }
3390         }
3391 }
3392
3393 boolean_t
3394 pmap_is_valid_memattr(pmap_t pmap __unused, vm_memattr_t mode)
3395 {
3396
3397         return (mode >= VM_MEMATTR_DEVICE && mode <= VM_MEMATTR_WRITE_BACK);
3398 }