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