sys/platform/vkernel64/platform/pmap.c

   1 /*
   2  * Copyright (c) 1991 Regents of the University of California.
   3  * Copyright (c) 1994 John S. Dyson
   4  * Copyright (c) 1994 David Greenman
   5  * Copyright (c) 2003 Peter Wemm
   6  * Copyright (c) 2005-2008 Alan L. Cox <alc@cs.rice.edu>
   7  * Copyright (c) 2008-2019 The DragonFly Project.
   8  * Copyright (c) 2008, 2009 Jordan Gordeev.
   9  * All rights reserved.
  10  *
  11  * This code is derived from software contributed to Berkeley by
  12  * the Systems Programming Group of the University of Utah Computer
  13  * Science Department and William Jolitz of UUNET Technologies Inc.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  * 3. All advertising materials mentioning features or use of this software
  24  *    must display the following acknowledgement:
  25  *      This product includes software developed by the University of
  26  *      California, Berkeley and its contributors.
  27  * 4. Neither the name of the University nor the names of its contributors
  28  *    may be used to endorse or promote products derived from this software
  29  *    without specific prior written permission.
  30  *
  31  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  32  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  35  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  39  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  40  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  41  * SUCH DAMAGE.
  42  *
  43  *      from:   @(#)pmap.c      7.7 (Berkeley)  5/12/91
  44  * $FreeBSD: src/sys/i386/i386/pmap.c,v 1.250.2.18 2002/03/06 22:48:53 silby Exp $
  45  */
  46
  47 /*
  48  * Manages physical address maps.
  49  */
  50
  51 #include "opt_msgbuf.h"
  52
  53 #include <sys/param.h>
  54 #include <sys/systm.h>
  55 #include <sys/kernel.h>
  56 #include <sys/proc.h>
  57 #include <sys/msgbuf.h>
  58 #include <sys/vmmeter.h>
  59 #include <sys/mman.h>
  60 #include <sys/vmspace.h>
  61
  62 #include <vm/vm.h>
  63 #include <vm/vm_param.h>
  64 #include <sys/sysctl.h>
  65 #include <sys/lock.h>
  66 #include <vm/vm_kern.h>
  67 #include <vm/vm_page.h>
  68 #include <vm/vm_map.h>
  69 #include <vm/vm_object.h>
  70 #include <vm/vm_extern.h>
  71 #include <vm/vm_pageout.h>
  72 #include <vm/vm_pager.h>
  73 #include <vm/vm_zone.h>
  74
  75 #include <sys/thread2.h>
  76 #include <sys/spinlock2.h>
  77 #include <vm/vm_page2.h>
  78
  79 #include <machine/cputypes.h>
  80 #include <machine/md_var.h>
  81 #include <machine/specialreg.h>
  82 #include <machine/smp.h>
  83 #include <machine/globaldata.h>
  84 #include <machine/pcb.h>
  85 #include <machine/pmap.h>
  86 #include <machine/pmap_inval.h>
  87
  88 #include <ddb/ddb.h>
  89
  90 #include <stdio.h>
  91 #include <assert.h>
  92 #include <stdlib.h>
  93 #include <pthread.h>
  94
  95 #define PMAP_KEEP_PDIRS
  96 #ifndef PMAP_SHPGPERPROC
  97 #define PMAP_SHPGPERPROC 1000
  98 #endif
  99
 100 #if defined(DIAGNOSTIC)
 101 #define PMAP_DIAGNOSTIC
 102 #endif
 103
 104 #define MINPV 2048
 105
 106 #if !defined(PMAP_DIAGNOSTIC)
 107 #define PMAP_INLINE __inline
 108 #else
 109 #define PMAP_INLINE
 110 #endif
 111
 112 /*
 113  * Get PDEs and PTEs for user/kernel address space
 114  */
 115 static pd_entry_t *pmap_pde(pmap_t pmap, vm_offset_t va);
 116 #define pdir_pde(m, v) (m[(vm_offset_t)(v) >> PDRSHIFT])
 117
 118 #define pmap_pde_v(pte)         ((*(pd_entry_t *)pte & VPTE_V) != 0)
 119 #define pmap_pte_w(pte)         ((*(pt_entry_t *)pte & VPTE_WIRED) != 0)
 120 #define pmap_pte_m(pte)         ((*(pt_entry_t *)pte & VPTE_M) != 0)
 121 #define pmap_pte_u(pte)         ((*(pt_entry_t *)pte & VPTE_A) != 0)
 122 #define pmap_pte_v(pte)         ((*(pt_entry_t *)pte & VPTE_V) != 0)
 123
 124 /*
 125  * Given a map and a machine independent protection code,
 126  * convert to a vax protection code.
 127  */
 128 #define pte_prot(m, p)          \
 129         (protection_codes[p & (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE)])
 130 static uint64_t protection_codes[8];
 131
 132 struct pmap kernel_pmap;
 133
 134 static boolean_t pmap_initialized = FALSE;      /* Has pmap_init completed? */
 135
 136 static struct vm_object kptobj;
 137 static int nkpt;
 138
 139 static uint64_t KPDphys;        /* phys addr of kernel level 2 */
 140 uint64_t                KPDPphys;       /* phys addr of kernel level 3 */
 141 uint64_t                KPML4phys;      /* phys addr of kernel level 4 */
 142
 143 extern int vmm_enabled;
 144 extern void *vkernel_stack;
 145
 146 /*
 147  * Data for the pv entry allocation mechanism
 148  */
 149 static vm_zone_t pvzone;
 150 static struct vm_zone pvzone_store;
 151 static vm_pindex_t pv_entry_count = 0;
 152 static vm_pindex_t pv_entry_max = 0;
 153 static vm_pindex_t pv_entry_high_water = 0;
 154 static int pmap_pagedaemon_waken = 0;
 155 static struct pv_entry *pvinit;
 156
 157 /*
 158  * All those kernel PT submaps that BSD is so fond of
 159  */
 160 pt_entry_t *CMAP1 = NULL, *ptmmap;
 161 caddr_t CADDR1 = NULL;
 162 static pt_entry_t *msgbufmap;
 163
 164 uint64_t KPTphys;
 165
 166 static PMAP_INLINE void free_pv_entry (pv_entry_t pv);
 167 static pv_entry_t get_pv_entry (void);
 168 static void     x86_64_protection_init (void);
 169 static __inline void    pmap_clearbit (vm_page_t m, int bit);
 170
 171 static void     pmap_remove_all (vm_page_t m);
 172 static int pmap_remove_pte (struct pmap *pmap, pt_entry_t *ptq,
 173                                 pt_entry_t oldpte, vm_offset_t sva);
 174 static void pmap_remove_page (struct pmap *pmap, vm_offset_t va);
 175 static int pmap_remove_entry (struct pmap *pmap, vm_page_t m,
 176                                 vm_offset_t va);
 177 static boolean_t pmap_testbit (vm_page_t m, int bit);
 178 static void pmap_insert_entry (pmap_t pmap, vm_offset_t va,
 179                                 vm_page_t mpte, vm_page_t m, pv_entry_t);
 180
 181 static vm_page_t pmap_allocpte (pmap_t pmap, vm_offset_t va);
 182
 183 static int pmap_release_free_page (pmap_t pmap, vm_page_t p);
 184 static vm_page_t _pmap_allocpte (pmap_t pmap, vm_pindex_t ptepindex);
 185 static vm_page_t pmap_page_lookup (vm_object_t object, vm_pindex_t pindex);
 186 static int pmap_unuse_pt (pmap_t, vm_offset_t, vm_page_t);
 187
 188 static int
 189 pv_entry_compare(pv_entry_t pv1, pv_entry_t pv2)
 190 {
 191         if (pv1->pv_va < pv2->pv_va)
 192                 return(-1);
 193         if (pv1->pv_va > pv2->pv_va)
 194                 return(1);
 195         return(0);
 196 }
 197
 198 RB_GENERATE2(pv_entry_rb_tree, pv_entry, pv_entry,
 199             pv_entry_compare, vm_offset_t, pv_va);
 200
 201 static __inline vm_pindex_t
 202 pmap_pt_pindex(vm_offset_t va)
 203 {
 204         return va >> PDRSHIFT;
 205 }
 206
 207 static __inline vm_pindex_t
 208 pmap_pte_index(vm_offset_t va)
 209 {
 210         return ((va >> PAGE_SHIFT) & ((1ul << NPTEPGSHIFT) - 1));
 211 }
 212
 213 static __inline vm_pindex_t
 214 pmap_pde_index(vm_offset_t va)
 215 {
 216         return ((va >> PDRSHIFT) & ((1ul << NPDEPGSHIFT) - 1));
 217 }
 218
 219 static __inline vm_pindex_t
 220 pmap_pdpe_index(vm_offset_t va)
 221 {
 222         return ((va >> PDPSHIFT) & ((1ul << NPDPEPGSHIFT) - 1));
 223 }
 224
 225 static __inline vm_pindex_t
 226 pmap_pml4e_index(vm_offset_t va)
 227 {
 228         return ((va >> PML4SHIFT) & ((1ul << NPML4EPGSHIFT) - 1));
 229 }
 230
 231 /* Return a pointer to the PML4 slot that corresponds to a VA */
 232 static __inline pml4_entry_t *
 233 pmap_pml4e(pmap_t pmap, vm_offset_t va)
 234 {
 235         return (&pmap->pm_pml4[pmap_pml4e_index(va)]);
 236 }
 237
 238 /* Return a pointer to the PDP slot that corresponds to a VA */
 239 static __inline pdp_entry_t *
 240 pmap_pml4e_to_pdpe(pml4_entry_t *pml4e, vm_offset_t va)
 241 {
 242         pdp_entry_t *pdpe;
 243
 244         pdpe = (pdp_entry_t *)PHYS_TO_DMAP(*pml4e & VPTE_FRAME);
 245         return (&pdpe[pmap_pdpe_index(va)]);
 246 }
 247
 248 /* Return a pointer to the PDP slot that corresponds to a VA */
 249 static __inline pdp_entry_t *
 250 pmap_pdpe(pmap_t pmap, vm_offset_t va)
 251 {
 252         pml4_entry_t *pml4e;
 253
 254         pml4e = pmap_pml4e(pmap, va);
 255         if ((*pml4e & VPTE_V) == 0)
 256                 return NULL;
 257         return (pmap_pml4e_to_pdpe(pml4e, va));
 258 }
 259
 260 /* Return a pointer to the PD slot that corresponds to a VA */
 261 static __inline pd_entry_t *
 262 pmap_pdpe_to_pde(pdp_entry_t *pdpe, vm_offset_t va)
 263 {
 264         pd_entry_t *pde;
 265
 266         pde = (pd_entry_t *)PHYS_TO_DMAP(*pdpe & VPTE_FRAME);
 267         return (&pde[pmap_pde_index(va)]);
 268 }
 269
 270 /* Return a pointer to the PD slot that corresponds to a VA */
 271 static __inline pd_entry_t *
 272 pmap_pde(pmap_t pmap, vm_offset_t va)
 273 {
 274         pdp_entry_t *pdpe;
 275
 276         pdpe = pmap_pdpe(pmap, va);
 277         if (pdpe == NULL || (*pdpe & VPTE_V) == 0)
 278                  return NULL;
 279         return (pmap_pdpe_to_pde(pdpe, va));
 280 }
 281
 282 /* Return a pointer to the PT slot that corresponds to a VA */
 283 static __inline pt_entry_t *
 284 pmap_pde_to_pte(pd_entry_t *pde, vm_offset_t va)
 285 {
 286         pt_entry_t *pte;
 287
 288         pte = (pt_entry_t *)PHYS_TO_DMAP(*pde & VPTE_FRAME);
 289         return (&pte[pmap_pte_index(va)]);
 290 }
 291
 292 /*
 293  * Hold pt_m for page table scans to prevent it from getting reused out
 294  * from under us across blocking conditions in the body of the loop.
 295  */
 296 static __inline
 297 vm_page_t
 298 pmap_hold_pt_page(pd_entry_t *pde, vm_offset_t va)
 299 {
 300         pt_entry_t pte;
 301         vm_page_t pt_m;
 302
 303         pte = (pt_entry_t)*pde;
 304         KKASSERT(pte != 0);
 305         pt_m = PHYS_TO_VM_PAGE(pte & VPTE_FRAME);
 306         vm_page_hold(pt_m);
 307
 308         return pt_m;
 309 }
 310
 311 /* Return a pointer to the PT slot that corresponds to a VA */
 312 static __inline pt_entry_t *
 313 pmap_pte(pmap_t pmap, vm_offset_t va)
 314 {
 315         pd_entry_t *pde;
 316
 317         pde = pmap_pde(pmap, va);
 318         if (pde == NULL || (*pde & VPTE_V) == 0)
 319                 return NULL;
 320         if ((*pde & VPTE_PS) != 0)      /* compat with x86 pmap_pte() */
 321                 return ((pt_entry_t *)pde);
 322         return (pmap_pde_to_pte(pde, va));
 323 }
 324
 325 static PMAP_INLINE pt_entry_t *
 326 vtopte(vm_offset_t va)
 327 {
 328         pt_entry_t *x;
 329         x = pmap_pte(&kernel_pmap, va);
 330         assert(x != NULL);
 331         return x;
 332 }
 333
 334 static __inline pd_entry_t *
 335 vtopde(vm_offset_t va)
 336 {
 337         pd_entry_t *x;
 338         x = pmap_pde(&kernel_pmap, va);
 339         assert(x != NULL);
 340         return x;
 341 }
 342
 343 /*
 344  * Returns the physical address translation from va for a user address.
 345  * (vm_paddr_t)-1 is returned on failure.
 346  */
 347 vm_paddr_t
 348 uservtophys(vm_offset_t va)
 349 {
 350         struct vmspace *vm = curproc->p_vmspace;
 351         vm_page_t m;
 352         vm_paddr_t pa;
 353         int error;
 354         int busy;
 355
 356         /* XXX No idea how to handle this case in a simple way, just abort */
 357         if (PAGE_SIZE - (va & PAGE_MASK) < sizeof(u_int))
 358                 return ((vm_paddr_t)-1);
 359
 360         m = vm_fault_page(&vm->vm_map, trunc_page(va),
 361                           VM_PROT_READ|VM_PROT_WRITE,
 362                           VM_FAULT_NORMAL,
 363                           &error, &busy);
 364         if (error)
 365                 return ((vm_paddr_t)-1);
 366
 367         pa = VM_PAGE_TO_PHYS(m) | (va & PAGE_MASK);
 368         if (busy)
 369                 vm_page_wakeup(m);
 370         else
 371                 vm_page_unhold(m);
 372
 373         return pa;
 374 }
 375
 376 static uint64_t
 377 allocpages(vm_paddr_t *firstaddr, int n)
 378 {
 379         uint64_t ret;
 380
 381         ret = *firstaddr;
 382         /*bzero((void *)ret, n * PAGE_SIZE); not mapped yet */
 383         *firstaddr += n * PAGE_SIZE;
 384         return (ret);
 385 }
 386
 387 static void
 388 create_dmap_vmm(vm_paddr_t *firstaddr)
 389 {
 390         void *stack_addr;
 391         int pml4_stack_index;
 392         int pdp_stack_index;
 393         int pd_stack_index;
 394         long i,j;
 395         int regs[4];
 396         int amd_feature;
 397
 398         uint64_t KPDP_DMAP_phys = allocpages(firstaddr, NDMPML4E);
 399         uint64_t KPDP_VSTACK_phys = allocpages(firstaddr, 1);
 400         uint64_t KPD_VSTACK_phys = allocpages(firstaddr, 1);
 401
 402         pml4_entry_t *KPML4virt = (pml4_entry_t *)PHYS_TO_DMAP(KPML4phys);
 403         pdp_entry_t *KPDP_DMAP_virt = (pdp_entry_t *)PHYS_TO_DMAP(KPDP_DMAP_phys);
 404         pdp_entry_t *KPDP_VSTACK_virt = (pdp_entry_t *)PHYS_TO_DMAP(KPDP_VSTACK_phys);
 405         pd_entry_t *KPD_VSTACK_virt = (pd_entry_t *)PHYS_TO_DMAP(KPD_VSTACK_phys);
 406
 407         bzero(KPDP_DMAP_virt, NDMPML4E * PAGE_SIZE);
 408         bzero(KPDP_VSTACK_virt, 1 * PAGE_SIZE);
 409         bzero(KPD_VSTACK_virt, 1 * PAGE_SIZE);
 410
 411         do_cpuid(0x80000001, regs);
 412         amd_feature = regs[3];
 413
 414         /* Build the mappings for the first 512GB */
 415         if (amd_feature & AMDID_PAGE1GB) {
 416                 /* In pages of 1 GB, if supported */
 417                 for (i = 0; i < NPDPEPG; i++) {
 418                         KPDP_DMAP_virt[i] = ((uint64_t)i << PDPSHIFT);
 419                         KPDP_DMAP_virt[i] |= VPTE_RW | VPTE_V | VPTE_PS | VPTE_U;
 420                 }
 421         } else {
 422                 /* In page of 2MB, otherwise */
 423                 for (i = 0; i < NPDPEPG; i++) {
 424                         uint64_t KPD_DMAP_phys;
 425                         pd_entry_t *KPD_DMAP_virt;
 426
 427                         KPD_DMAP_phys = allocpages(firstaddr, 1);
 428                         KPD_DMAP_virt =
 429                                 (pd_entry_t *)PHYS_TO_DMAP(KPD_DMAP_phys);
 430
 431                         bzero(KPD_DMAP_virt, PAGE_SIZE);
 432
 433                         KPDP_DMAP_virt[i] = KPD_DMAP_phys;
 434                         KPDP_DMAP_virt[i] |= VPTE_RW | VPTE_V | VPTE_U;
 435
 436                         /* For each PD, we have to allocate NPTEPG PT */
 437                         for (j = 0; j < NPTEPG; j++) {
 438                                 KPD_DMAP_virt[j] = (i << PDPSHIFT) |
 439                                                    (j << PDRSHIFT);
 440                                 KPD_DMAP_virt[j] |= VPTE_RW | VPTE_V |
 441                                                     VPTE_PS | VPTE_U;
 442                         }
 443                 }
 444         }
 445
 446         /* DMAP for the first 512G */
 447         KPML4virt[0] = KPDP_DMAP_phys;
 448         KPML4virt[0] |= VPTE_RW | VPTE_V | VPTE_U;
 449
 450         /* create a 2 MB map of the new stack */
 451         pml4_stack_index = (uint64_t)&stack_addr >> PML4SHIFT;
 452         KPML4virt[pml4_stack_index] = KPDP_VSTACK_phys;
 453         KPML4virt[pml4_stack_index] |= VPTE_RW | VPTE_V | VPTE_U;
 454
 455         pdp_stack_index = ((uint64_t)&stack_addr & PML4MASK) >> PDPSHIFT;
 456         KPDP_VSTACK_virt[pdp_stack_index] = KPD_VSTACK_phys;
 457         KPDP_VSTACK_virt[pdp_stack_index] |= VPTE_RW | VPTE_V | VPTE_U;
 458
 459         pd_stack_index = ((uint64_t)&stack_addr & PDPMASK) >> PDRSHIFT;
 460         KPD_VSTACK_virt[pd_stack_index] = (uint64_t) vkernel_stack;
 461         KPD_VSTACK_virt[pd_stack_index] |= VPTE_RW | VPTE_V | VPTE_U | VPTE_PS;
 462 }
 463
 464 static void
 465 create_pagetables(vm_paddr_t *firstaddr, int64_t ptov_offset)
 466 {
 467         int i;
 468         pml4_entry_t *KPML4virt;
 469         pdp_entry_t *KPDPvirt;
 470         pd_entry_t *KPDvirt;
 471         pt_entry_t *KPTvirt;
 472         int kpml4i = pmap_pml4e_index(ptov_offset);
 473         int kpdpi = pmap_pdpe_index(ptov_offset);
 474         int kpdi = pmap_pde_index(ptov_offset);
 475
 476         /*
 477          * Calculate NKPT - number of kernel page tables.  We have to
 478          * accomodoate prealloction of the vm_page_array, dump bitmap,
 479          * MSGBUF_SIZE, and other stuff.  Be generous.
 480          *
 481          * Maxmem is in pages.
 482          */
 483         nkpt = (Maxmem * (sizeof(struct vm_page) * 2) + MSGBUF_SIZE) / NBPDR;
 484         /*
 485          * Allocate pages
 486          */
 487         KPML4phys = allocpages(firstaddr, 1);
 488         KPDPphys = allocpages(firstaddr, NKPML4E);
 489         KPDphys = allocpages(firstaddr, NKPDPE);
 490         KPTphys = allocpages(firstaddr, nkpt);
 491
 492         KPML4virt = (pml4_entry_t *)PHYS_TO_DMAP(KPML4phys);
 493         KPDPvirt = (pdp_entry_t *)PHYS_TO_DMAP(KPDPphys);
 494         KPDvirt = (pd_entry_t *)PHYS_TO_DMAP(KPDphys);
 495         KPTvirt = (pt_entry_t *)PHYS_TO_DMAP(KPTphys);
 496
 497         bzero(KPML4virt, 1 * PAGE_SIZE);
 498         bzero(KPDPvirt, NKPML4E * PAGE_SIZE);
 499         bzero(KPDvirt, NKPDPE * PAGE_SIZE);
 500         bzero(KPTvirt, nkpt * PAGE_SIZE);
 501
 502         /* Now map the page tables at their location within PTmap */
 503         for (i = 0; i < nkpt; i++) {
 504                 KPDvirt[i + kpdi] = KPTphys + (i << PAGE_SHIFT);
 505                 KPDvirt[i + kpdi] |= VPTE_RW | VPTE_V | VPTE_U;
 506         }
 507
 508         /* And connect up the PD to the PDP */
 509         for (i = 0; i < NKPDPE; i++) {
 510                 KPDPvirt[i + kpdpi] = KPDphys + (i << PAGE_SHIFT);
 511                 KPDPvirt[i + kpdpi] |= VPTE_RW | VPTE_V | VPTE_U;
 512         }
 513
 514         /* And recursively map PML4 to itself in order to get PTmap */
 515         KPML4virt[PML4PML4I] = KPML4phys;
 516         KPML4virt[PML4PML4I] |= VPTE_RW | VPTE_V | VPTE_U;
 517
 518         /* Connect the KVA slot up to the PML4 */
 519         KPML4virt[kpml4i] = KPDPphys;
 520         KPML4virt[kpml4i] |= VPTE_RW | VPTE_V | VPTE_U;
 521 }
 522
 523 /*
 524  * Typically used to initialize a fictitious page by vm/device_pager.c
 525  */
 526 void
 527 pmap_page_init(struct vm_page *m)
 528 {
 529         vm_page_init(m);
 530         TAILQ_INIT(&m->md.pv_list);
 531 }
 532
 533 /*
 534  *      Bootstrap the system enough to run with virtual memory.
 535  *
 536  *      On x86_64 this is called after mapping has already been enabled
 537  *      and just syncs the pmap module with what has already been done.
 538  *      [We can't call it easily with mapping off since the kernel is not
 539  *      mapped with PA == VA, hence we would have to relocate every address
 540  *      from the linked base (virtual) address "KERNBASE" to the actual
 541  *      (physical) address starting relative to 0]
 542  */
 543 void
 544 pmap_bootstrap(vm_paddr_t *firstaddr, int64_t ptov_offset)
 545 {
 546         vm_offset_t va;
 547         pt_entry_t *pte;
 548
 549         /*
 550          * Create an initial set of page tables to run the kernel in.
 551          */
 552         create_pagetables(firstaddr, ptov_offset);
 553
 554         /* Create the DMAP for the VMM */
 555         if (vmm_enabled) {
 556                 create_dmap_vmm(firstaddr);
 557         }
 558
 559         virtual_start = KvaStart;
 560         virtual_end = KvaEnd;
 561
 562         /*
 563          * Initialize protection array.
 564          */
 565         x86_64_protection_init();
 566
 567         /*
 568          * The kernel's pmap is statically allocated so we don't have to use
 569          * pmap_create, which is unlikely to work correctly at this part of
 570          * the boot sequence (XXX and which no longer exists).
 571          *
 572          * The kernel_pmap's pm_pteobj is used only for locking and not
 573          * for mmu pages.
 574          */
 575         kernel_pmap.pm_pml4 = (pml4_entry_t *)PHYS_TO_DMAP(KPML4phys);
 576         kernel_pmap.pm_count = 1;
 577         /* don't allow deactivation */
 578         CPUMASK_ASSALLONES(kernel_pmap.pm_active);
 579         kernel_pmap.pm_pteobj = NULL;   /* see pmap_init */
 580         RB_INIT(&kernel_pmap.pm_pvroot);
 581         spin_init(&kernel_pmap.pm_spin, "pmapbootstrap");
 582
 583         /*
 584          * Reserve some special page table entries/VA space for temporary
 585          * mapping of pages.
 586          */
 587 #define SYSMAP(c, p, v, n)      \
 588         v = (c)va; va += ((n)*PAGE_SIZE); p = pte; pte += (n);
 589
 590         va = virtual_start;
 591         pte = pmap_pte(&kernel_pmap, va);
 592         /*
 593          * CMAP1/CMAP2 are used for zeroing and copying pages.
 594          */
 595         SYSMAP(caddr_t, CMAP1, CADDR1, 1)
 596
 597 #if 0 /* JGV */
 598         /*
 599          * Crashdump maps.
 600          */
 601         SYSMAP(caddr_t, pt_crashdumpmap, crashdumpmap, MAXDUMPPGS);
 602 #endif
 603
 604         /*
 605          * ptvmmap is used for reading arbitrary physical pages via
 606          * /dev/mem.
 607          */
 608         SYSMAP(caddr_t, ptmmap, ptvmmap, 1)
 609
 610         /*
 611          * msgbufp is used to map the system message buffer.
 612          * XXX msgbufmap is not used.
 613          */
 614         SYSMAP(struct msgbuf *, msgbufmap, msgbufp,
 615                atop(round_page(MSGBUF_SIZE)))
 616
 617         virtual_start = va;
 618
 619         *CMAP1 = 0;
 620         /* Not ready to do an invltlb yet for VMM*/
 621         if (!vmm_enabled)
 622                 cpu_invltlb();
 623
 624 }
 625
 626 /*
 627  *      Initialize the pmap module.
 628  *      Called by vm_init, to initialize any structures that the pmap
 629  *      system needs to map virtual memory.
 630  *      pmap_init has been enhanced to support in a fairly consistant
 631  *      way, discontiguous physical memory.
 632  */
 633 void
 634 pmap_init(void)
 635 {
 636         vm_pindex_t i;
 637         vm_pindex_t initial_pvs;
 638
 639         /*
 640          * object for kernel page table pages
 641          */
 642         /* JG I think the number can be arbitrary */
 643         vm_object_init(&kptobj, 5);
 644         kernel_pmap.pm_pteobj = &kptobj;
 645
 646         /*
 647          * Allocate memory for random pmap data structures.  Includes the
 648          * pv_head_table.
 649          */
 650         for (i = 0; i < vm_page_array_size; i++) {
 651                 vm_page_t m;
 652
 653                 m = &vm_page_array[i];
 654                 TAILQ_INIT(&m->md.pv_list);
 655                 m->md.pv_list_count = 0;
 656         }
 657
 658         /*
 659          * init the pv free list
 660          */
 661         initial_pvs = vm_page_array_size;
 662         if (initial_pvs < MINPV)
 663                 initial_pvs = MINPV;
 664         pvzone = &pvzone_store;
 665         pvinit = (struct pv_entry *)
 666                 kmem_alloc(&kernel_map,
 667                            initial_pvs * sizeof (struct pv_entry),
 668                            VM_SUBSYS_PVENTRY);
 669         zbootinit(pvzone, "PV ENTRY", sizeof (struct pv_entry), pvinit,
 670                 initial_pvs);
 671
 672         /*
 673          * Now it is safe to enable pv_table recording.
 674          */
 675         pmap_initialized = TRUE;
 676 }
 677
 678 /*
 679  * Initialize the address space (zone) for the pv_entries.  Set a
 680  * high water mark so that the system can recover from excessive
 681  * numbers of pv entries.
 682  */
 683 void
 684 pmap_init2(void)
 685 {
 686         vm_pindex_t shpgperproc = PMAP_SHPGPERPROC;
 687
 688         TUNABLE_LONG_FETCH("vm.pmap.shpgperproc", &shpgperproc);
 689         pv_entry_max = shpgperproc * maxproc + vm_page_array_size;
 690         TUNABLE_LONG_FETCH("vm.pmap.pv_entries", &pv_entry_max);
 691         pv_entry_high_water = 9 * (pv_entry_max / 10);
 692         zinitna(pvzone, NULL, 0, pv_entry_max, ZONE_INTERRUPT);
 693 }
 694
 695
 696 /***************************************************
 697  * Low level helper routines.....
 698  ***************************************************/
 699
 700 /*
 701  * The modification bit is not tracked for any pages in this range. XXX
 702  * such pages in this maps should always use pmap_k*() functions and not
 703  * be managed anyhow.
 704  *
 705  * XXX User and kernel address spaces are independant for virtual kernels,
 706  * this function only applies to the kernel pmap.
 707  */
 708 static void
 709 pmap_track_modified(pmap_t pmap, vm_offset_t va)
 710 {
 711         KKASSERT(pmap != &kernel_pmap ||
 712                  va < clean_sva || va >= clean_eva);
 713 }
 714
 715 /*
 716  * Extract the physical page address associated with the map/VA pair.
 717  *
 718  * No requirements.
 719  */
 720 vm_paddr_t
 721 pmap_extract(pmap_t pmap, vm_offset_t va, void **handlep)
 722 {
 723         vm_paddr_t rtval;
 724         pt_entry_t *pte;
 725         pd_entry_t pde, *pdep;
 726
 727         vm_object_hold(pmap->pm_pteobj);
 728         rtval = 0;
 729         pdep = pmap_pde(pmap, va);
 730         if (pdep != NULL) {
 731                 pde = *pdep;
 732                 if (pde) {
 733                         if ((pde & VPTE_PS) != 0) {
 734                                 /* JGV */
 735                                 rtval = (pde & PG_PS_FRAME) | (va & PDRMASK);
 736                         } else {
 737                                 pte = pmap_pde_to_pte(pdep, va);
 738                                 rtval = (*pte & VPTE_FRAME) | (va & PAGE_MASK);
 739                         }
 740                 }
 741         }
 742         if (handlep)
 743                 *handlep = NULL;        /* XXX */
 744         vm_object_drop(pmap->pm_pteobj);
 745
 746         return rtval;
 747 }
 748
 749 void
 750 pmap_extract_done(void *handle)
 751 {
 752         pmap_t pmap;
 753
 754         if (handle) {
 755                 pmap = handle;
 756                 vm_object_drop(pmap->pm_pteobj);
 757         }
 758 }
 759
 760 /*
 761  * Similar to extract but checks protections, SMP-friendly short-cut for
 762  * vm_fault_page[_quick]().
 763  *
 764  * WARNING! THE RETURNED PAGE IS ONLY HELD AND NEITHER IT NOR ITS TARGET
 765  *          DATA IS SUITABLE FOR WRITING.  Writing can interfere with
 766  *          pageouts flushes, msync, etc.  The hold_count is not enough
 767  *          to avoid races against pageouts and other flush code doesn't
 768  *          care about hold_count.
 769  */
 770 vm_page_t
 771 pmap_fault_page_quick(pmap_t pmap __unused, vm_offset_t vaddr __unused,
 772                       vm_prot_t prot __unused, int *busyp __unused)
 773 {
 774         return(NULL);
 775 }
 776
 777 /*
 778  *      Routine:        pmap_kextract
 779  *      Function:
 780  *              Extract the physical page address associated
 781  *              kernel virtual address.
 782  */
 783 vm_paddr_t
 784 pmap_kextract(vm_offset_t va)
 785 {
 786         pd_entry_t pde;
 787         vm_paddr_t pa;
 788
 789         KKASSERT(va >= KvaStart && va < KvaEnd);
 790
 791         /*
 792          * The DMAP region is not included in [KvaStart, KvaEnd)
 793          */
 794 #if 0
 795         if (va >= DMAP_MIN_ADDRESS && va < DMAP_MAX_ADDRESS) {
 796                 pa = DMAP_TO_PHYS(va);
 797         } else {
 798 #endif
 799                 pde = *vtopde(va);
 800                 if (pde & VPTE_PS) {
 801                         /* JGV */
 802                         pa = (pde & PG_PS_FRAME) | (va & PDRMASK);
 803                 } else {
 804                         /*
 805                          * Beware of a concurrent promotion that changes the
 806                          * PDE at this point!  For example, vtopte() must not
 807                          * be used to access the PTE because it would use the
 808                          * new PDE.  It is, however, safe to use the old PDE
 809                          * because the page table page is preserved by the
 810                          * promotion.
 811                          */
 812                         pa = *pmap_pde_to_pte(&pde, va);
 813                         pa = (pa & VPTE_FRAME) | (va & PAGE_MASK);
 814                 }
 815 #if 0
 816         }
 817 #endif
 818         return pa;
 819 }
 820
 821 /***************************************************
 822  * Low level mapping routines.....
 823  ***************************************************/
 824
 825 /*
 826  * Enter a mapping into kernel_pmap.  Mappings created in this fashion
 827  * are not managed.  Mappings must be immediately accessible on all cpus.
 828  *
 829  * Call pmap_inval_pte() to invalidate the virtual pte and clean out the
 830  * real pmap and handle related races before storing the new vpte.  The
 831  * new semantics for kenter require use to do an UNCONDITIONAL invalidation,
 832  * because the entry may have previously been cleared without an invalidation.
 833  */
 834 void
 835 pmap_kenter(vm_offset_t va, vm_paddr_t pa)
 836 {
 837         pt_entry_t *ptep;
 838         pt_entry_t npte;
 839
 840         KKASSERT(va >= KvaStart && va < KvaEnd);
 841         npte = pa | VPTE_RW | VPTE_V | VPTE_U;
 842         ptep = vtopte(va);
 843
 844 #if 1
 845         pmap_inval_pte(ptep, &kernel_pmap, va);
 846 #else
 847         if (*pte & VPTE_V)
 848                 pmap_inval_pte(ptep, &kernel_pmap, va);
 849 #endif
 850         atomic_swap_long(ptep, npte);
 851 }
 852
 853 /*
 854  * Enter an unmanaged KVA mapping for the private use of the current
 855  * cpu only.
 856  *
 857  * It is illegal for the mapping to be accessed by other cpus without
 858  * proper invalidation.
 859  */
 860 int
 861 pmap_kenter_quick(vm_offset_t va, vm_paddr_t pa)
 862 {
 863         pt_entry_t *ptep;
 864         pt_entry_t npte;
 865         int res;
 866
 867         KKASSERT(va >= KvaStart && va < KvaEnd);
 868
 869         npte = (vpte_t)pa | VPTE_RW | VPTE_V | VPTE_U;
 870         ptep = vtopte(va);
 871
 872 #if 1
 873         pmap_inval_pte_quick(ptep, &kernel_pmap, va);
 874         res = 1;
 875 #else
 876         /* FUTURE */
 877         res = (*ptep != 0);
 878         if (*pte & VPTE_V)
 879                 pmap_inval_pte(pte, &kernel_pmap, va);
 880 #endif
 881         atomic_swap_long(ptep, npte);
 882
 883         return res;
 884 }
 885
 886 /*
 887  * Invalidation will occur later, ok to be lazy here.
 888  */
 889 int
 890 pmap_kenter_noinval(vm_offset_t va, vm_paddr_t pa)
 891 {
 892         pt_entry_t *ptep;
 893         pt_entry_t npte;
 894         int res;
 895
 896         KKASSERT(va >= KvaStart && va < KvaEnd);
 897
 898         npte = (vpte_t)pa | VPTE_RW | VPTE_V | VPTE_U;
 899         ptep = vtopte(va);
 900 #if 1
 901         res = 1;
 902 #else
 903         /* FUTURE */
 904         res = (*ptep != 0);
 905 #endif
 906         atomic_swap_long(ptep, npte);
 907
 908         return res;
 909 }
 910
 911 /*
 912  * Remove an unmanaged mapping created with pmap_kenter*().
 913  */
 914 void
 915 pmap_kremove(vm_offset_t va)
 916 {
 917         pt_entry_t *ptep;
 918
 919         KKASSERT(va >= KvaStart && va < KvaEnd);
 920
 921         ptep = vtopte(va);
 922         atomic_swap_long(ptep, 0);
 923         pmap_inval_pte(ptep, &kernel_pmap, va);
 924 }
 925
 926 /*
 927  * Remove an unmanaged mapping created with pmap_kenter*() but synchronize
 928  * only with this cpu.
 929  *
 930  * Unfortunately because we optimize new entries by testing VPTE_V later
 931  * on, we actually still have to synchronize with all the cpus.  XXX maybe
 932  * store a junk value and test against 0 in the other places instead?
 933  */
 934 void
 935 pmap_kremove_quick(vm_offset_t va)
 936 {
 937         pt_entry_t *ptep;
 938
 939         KKASSERT(va >= KvaStart && va < KvaEnd);
 940
 941         ptep = vtopte(va);
 942         atomic_swap_long(ptep, 0);
 943         pmap_inval_pte(ptep, &kernel_pmap, va); /* NOT _quick */
 944 }
 945
 946 /*
 947  * Invalidation will occur later, ok to be lazy here.
 948  */
 949 void
 950 pmap_kremove_noinval(vm_offset_t va)
 951 {
 952         pt_entry_t *ptep;
 953
 954         KKASSERT(va >= KvaStart && va < KvaEnd);
 955
 956         ptep = vtopte(va);
 957         atomic_swap_long(ptep, 0);
 958 }
 959
 960 /*
 961  *      Used to map a range of physical addresses into kernel
 962  *      virtual address space.
 963  *
 964  *      For now, VM is already on, we only need to map the
 965  *      specified memory.
 966  */
 967 vm_offset_t
 968 pmap_map(vm_offset_t *virtp, vm_paddr_t start, vm_paddr_t end, int prot)
 969 {
 970         return PHYS_TO_DMAP(start);
 971 }
 972
 973 /*
 974  * Map a set of unmanaged VM pages into KVM.
 975  */
 976 static __inline void
 977 _pmap_qenter(vm_offset_t beg_va, vm_page_t *m, int count, int doinval)
 978 {
 979         vm_offset_t end_va;
 980         vm_offset_t va;
 981
 982         end_va = beg_va + count * PAGE_SIZE;
 983         KKASSERT(beg_va >= KvaStart && end_va <= KvaEnd);
 984
 985         for (va = beg_va; va < end_va; va += PAGE_SIZE) {
 986                 pt_entry_t *ptep;
 987
 988                 ptep = vtopte(va);
 989                 atomic_swap_long(ptep, VM_PAGE_TO_PHYS(*m) |
 990                                        VPTE_RW | VPTE_V | VPTE_U);
 991                 ++m;
 992         }
 993         if (doinval)
 994                 pmap_invalidate_range(&kernel_pmap, beg_va, end_va);
 995         /* pmap_inval_pte(pte, &kernel_pmap, va); */
 996 }
 997
 998 void
 999 pmap_qenter(vm_offset_t beg_va, vm_page_t *m, int count)
1000 {
1001         _pmap_qenter(beg_va, m, count, 1);
1002 }
1003
1004 void
1005 pmap_qenter_noinval(vm_offset_t beg_va, vm_page_t *m, int count)
1006 {
1007         _pmap_qenter(beg_va, m, count, 0);
1008 }
1009
1010 /*
1011  * Undo the effects of pmap_qenter*().
1012  */
1013 void
1014 pmap_qremove(vm_offset_t beg_va, int count)
1015 {
1016         vm_offset_t end_va;
1017         vm_offset_t va;
1018
1019         end_va = beg_va + count * PAGE_SIZE;
1020         KKASSERT(beg_va >= KvaStart && end_va < KvaEnd);
1021
1022         for (va = beg_va; va < end_va; va += PAGE_SIZE) {
1023                 pt_entry_t *ptep;
1024
1025                 ptep = vtopte(va);
1026                 atomic_swap_long(ptep, 0);
1027         }
1028         pmap_invalidate_range(&kernel_pmap, beg_va, end_va);
1029 }
1030
1031 /*
1032  * Unlike the real pmap code, we can't avoid calling the real-kernel.
1033  */
1034 void
1035 pmap_qremove_quick(vm_offset_t va, int count)
1036 {
1037         pmap_qremove(va, count);
1038 }
1039
1040 void
1041 pmap_qremove_noinval(vm_offset_t va, int count)
1042 {
1043         pmap_qremove(va, count);
1044 }
1045
1046 /*
1047  * This routine works like vm_page_lookup() but also blocks as long as the
1048  * page is busy.  This routine does not busy the page it returns.
1049  *
1050  * Unless the caller is managing objects whos pages are in a known state,
1051  * the call should be made with a critical section held so the page's object
1052  * association remains valid on return.
1053  */
1054 static vm_page_t
1055 pmap_page_lookup(vm_object_t object, vm_pindex_t pindex)
1056 {
1057         vm_page_t m;
1058
1059         ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
1060         m = vm_page_lookup_busy_wait(object, pindex, TRUE, "pplookp");
1061
1062         return(m);
1063 }
1064
1065 /*
1066  * Create a new thread and optionally associate it with a (new) process.
1067  * NOTE! the new thread's cpu may not equal the current cpu.
1068  */
1069 void
1070 pmap_init_thread(thread_t td)
1071 {
1072         /* enforce pcb placement */
1073         td->td_pcb = (struct pcb *)(td->td_kstack + td->td_kstack_size) - 1;
1074         td->td_savefpu = &td->td_pcb->pcb_save;
1075         td->td_sp = (char *)td->td_pcb - 16; /* JG is -16 needed on x86_64? */
1076 }
1077
1078 /*
1079  * This routine directly affects the fork perf for a process.
1080  */
1081 void
1082 pmap_init_proc(struct proc *p)
1083 {
1084 }
1085
1086 /*
1087  * Unwire a page table which has been removed from the pmap.  We own the
1088  * wire_count, so the page cannot go away.  The page representing the page
1089  * table is passed in unbusied and must be busied if we cannot trivially
1090  * unwire it.
1091  *
1092  * XXX NOTE!  This code is not usually run because we do not currently
1093  *            implement dynamic page table page removal.  The page in
1094  *            its parent assumes at least 1 wire count, so no call to this
1095  *            function ever sees a wire count less than 2.
1096  */
1097 static int
1098 pmap_unwire_pgtable(pmap_t pmap, vm_offset_t va, vm_page_t m)
1099 {
1100         /*
1101          * Try to unwire optimally.  If non-zero is returned the wire_count
1102          * is 1 and we must busy the page to unwire it.
1103          */
1104         if (vm_page_unwire_quick(m) == 0)
1105                 return 0;
1106
1107         vm_page_busy_wait(m, TRUE, "pmuwpt");
1108         KASSERT(m->queue == PQ_NONE,
1109                 ("_pmap_unwire_pgtable: %p->queue != PQ_NONE", m));
1110
1111         if (m->wire_count == 1) {
1112                 /*
1113                  * Unmap the page table page.
1114                  */
1115                 /* pmap_inval_add(info, pmap, -1); */
1116
1117                 if (m->pindex >= (NUPT_TOTAL + NUPD_TOTAL)) {
1118                         /* PDP page */
1119                         pml4_entry_t *pml4;
1120                         pml4 = pmap_pml4e(pmap, va);
1121                         *pml4 = 0;
1122                 } else if (m->pindex >= NUPT_TOTAL) {
1123                         /* PD page */
1124                         pdp_entry_t *pdp;
1125                         pdp = pmap_pdpe(pmap, va);
1126                         *pdp = 0;
1127                 } else {
1128                         /* PT page */
1129                         pd_entry_t *pd;
1130                         pd = pmap_pde(pmap, va);
1131                         *pd = 0;
1132                 }
1133
1134                 KKASSERT(pmap->pm_stats.resident_count > 0);
1135                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
1136
1137                 if (pmap->pm_ptphint == m)
1138                         pmap->pm_ptphint = NULL;
1139
1140                 if (m->pindex < NUPT_TOTAL) {
1141                         /* We just released a PT, unhold the matching PD */
1142                         vm_page_t pdpg;
1143
1144                         pdpg = PHYS_TO_VM_PAGE(*pmap_pdpe(pmap, va) &
1145                                                VPTE_FRAME);
1146                         pmap_unwire_pgtable(pmap, va, pdpg);
1147                 }
1148                 if (m->pindex >= NUPT_TOTAL &&
1149                     m->pindex < (NUPT_TOTAL + NUPD_TOTAL)) {
1150                         /* We just released a PD, unhold the matching PDP */
1151                         vm_page_t pdppg;
1152
1153                         pdppg = PHYS_TO_VM_PAGE(*pmap_pml4e(pmap, va) &
1154                                                 VPTE_FRAME);
1155                         pmap_unwire_pgtable(pmap, va, pdppg);
1156                 }
1157
1158                 /*
1159                  * This was our last wire, the page had better be unwired
1160                  * after we decrement wire_count.
1161                  *
1162                  * FUTURE NOTE: shared page directory page could result in
1163                  * multiple wire counts.
1164                  */
1165                 vm_page_unwire(m, 0);
1166                 KKASSERT(m->wire_count == 0);
1167                 vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
1168                 vm_page_flash(m);
1169                 vm_page_free(m);
1170                 return 1;
1171         } else {
1172                 /* XXX SMP race to 1 if not holding vmobj */
1173                 vm_page_unwire(m, 0);
1174                 vm_page_wakeup(m);
1175                 return 0;
1176         }
1177 }
1178
1179 /*
1180  * After removing a page table entry, this routine is used to
1181  * conditionally free the page, and manage the hold/wire counts.
1182  *
1183  * If not NULL the caller owns a wire_count on mpte, so it can't disappear.
1184  * If NULL the caller owns a wire_count on what would be the mpte, we must
1185  * look it up.
1186  */
1187 static int
1188 pmap_unuse_pt(pmap_t pmap, vm_offset_t va, vm_page_t mpte)
1189 {
1190         vm_pindex_t ptepindex;
1191
1192         ASSERT_LWKT_TOKEN_HELD(vm_object_token(pmap->pm_pteobj));
1193
1194         if (mpte == NULL) {
1195                 /*
1196                  * page table pages in the kernel_pmap are not managed.
1197                  */
1198                 if (pmap == &kernel_pmap)
1199                         return(0);
1200                 ptepindex = pmap_pt_pindex(va);
1201                 if (pmap->pm_ptphint &&
1202                     (pmap->pm_ptphint->pindex == ptepindex)) {
1203                         mpte = pmap->pm_ptphint;
1204                 } else {
1205                         mpte = pmap_page_lookup(pmap->pm_pteobj, ptepindex);
1206                         pmap->pm_ptphint = mpte;
1207                         vm_page_wakeup(mpte);
1208                 }
1209         }
1210         return pmap_unwire_pgtable(pmap, va, mpte);
1211 }
1212
1213 /*
1214  * Initialize pmap0/vmspace0 .  Since process 0 never enters user mode we
1215  * just dummy it up so it works well enough for fork().
1216  *
1217  * In DragonFly, process pmaps may only be used to manipulate user address
1218  * space, never kernel address space.
1219  */
1220 void
1221 pmap_pinit0(struct pmap *pmap)
1222 {
1223         pmap_pinit(pmap);
1224 }
1225
1226 /*
1227  * Initialize a preallocated and zeroed pmap structure,
1228  * such as one in a vmspace structure.
1229  */
1230 void
1231 pmap_pinit(struct pmap *pmap)
1232 {
1233         vm_page_t ptdpg;
1234
1235         /*
1236          * No need to allocate page table space yet but we do need a valid
1237          * page directory table.
1238          */
1239         if (pmap->pm_pml4 == NULL) {
1240                 pmap->pm_pml4 = (pml4_entry_t *)
1241                         kmem_alloc_pageable(&kernel_map, PAGE_SIZE,
1242                                             VM_SUBSYS_PML4);
1243         }
1244
1245         /*
1246          * Allocate an object for the ptes
1247          */
1248         if (pmap->pm_pteobj == NULL)
1249                 pmap->pm_pteobj = vm_object_allocate(OBJT_DEFAULT, NUPT_TOTAL + NUPD_TOTAL + NUPDP_TOTAL + 1);
1250
1251         /*
1252          * Allocate the page directory page, unless we already have
1253          * one cached.  If we used the cached page the wire_count will
1254          * already be set appropriately.
1255          */
1256         if ((ptdpg = pmap->pm_pdirm) == NULL) {
1257                 ptdpg = vm_page_grab(pmap->pm_pteobj,
1258                                      NUPT_TOTAL + NUPD_TOTAL + NUPDP_TOTAL,
1259                                      VM_ALLOC_NORMAL | VM_ALLOC_RETRY |
1260                                      VM_ALLOC_ZERO);
1261                 pmap->pm_pdirm = ptdpg;
1262                 vm_page_flag_clear(ptdpg, PG_MAPPED | PG_WRITEABLE);
1263                 vm_page_wire(ptdpg);
1264                 vm_page_wakeup(ptdpg);
1265                 pmap_kenter((vm_offset_t)pmap->pm_pml4, VM_PAGE_TO_PHYS(ptdpg));
1266         }
1267         pmap->pm_count = 1;
1268         CPUMASK_ASSZERO(pmap->pm_active);
1269         pmap->pm_ptphint = NULL;
1270         RB_INIT(&pmap->pm_pvroot);
1271         spin_init(&pmap->pm_spin, "pmapinit");
1272         bzero(&pmap->pm_stats, sizeof pmap->pm_stats);
1273         pmap->pm_stats.resident_count = 1;
1274         pmap->pm_stats.wired_count = 1;
1275 }
1276
1277 /*
1278  * Clean up a pmap structure so it can be physically freed.  This routine
1279  * is called by the vmspace dtor function.  A great deal of pmap data is
1280  * left passively mapped to improve vmspace management so we have a bit
1281  * of cleanup work to do here.
1282  *
1283  * No requirements.
1284  */
1285 void
1286 pmap_puninit(pmap_t pmap)
1287 {
1288         vm_page_t p;
1289
1290         KKASSERT(CPUMASK_TESTZERO(pmap->pm_active));
1291         if ((p = pmap->pm_pdirm) != NULL) {
1292                 KKASSERT(pmap->pm_pml4 != NULL);
1293                 pmap_kremove((vm_offset_t)pmap->pm_pml4);
1294                 vm_page_busy_wait(p, TRUE, "pgpun");
1295                 vm_page_unwire(p, 0);
1296                 vm_page_flag_clear(p, PG_MAPPED | PG_WRITEABLE);
1297                 vm_page_free(p);
1298                 pmap->pm_pdirm = NULL;
1299                 atomic_add_long(&pmap->pm_stats.wired_count, -1);
1300                 KKASSERT(pmap->pm_stats.wired_count == 0);
1301         }
1302         if (pmap->pm_pml4) {
1303                 kmem_free(&kernel_map, (vm_offset_t)pmap->pm_pml4, PAGE_SIZE);
1304                 pmap->pm_pml4 = NULL;
1305         }
1306         if (pmap->pm_pteobj) {
1307                 vm_object_deallocate(pmap->pm_pteobj);
1308                 pmap->pm_pteobj = NULL;
1309         }
1310 }
1311
1312 /*
1313  * This function is now unused (used to add the pmap to the pmap_list)
1314  */
1315 void
1316 pmap_pinit2(struct pmap *pmap)
1317 {
1318 }
1319
1320 /*
1321  * Attempt to release and free a vm_page in a pmap.  Returns 1 on success,
1322  * 0 on failure (if the procedure had to sleep).
1323  *
1324  * When asked to remove the page directory page itself, we actually just
1325  * leave it cached so we do not have to incur the SMP inval overhead of
1326  * removing the kernel mapping.  pmap_puninit() will take care of it.
1327  */
1328 static int
1329 pmap_release_free_page(struct pmap *pmap, vm_page_t p)
1330 {
1331         /*
1332          * This code optimizes the case of freeing non-busy
1333          * page-table pages.  Those pages are zero now, and
1334          * might as well be placed directly into the zero queue.
1335          */
1336         if (vm_page_busy_try(p, TRUE)) {
1337                 vm_page_sleep_busy(p, TRUE, "pmaprl");
1338                 return 1;
1339         }
1340
1341         /*
1342          * Remove the page table page from the processes address space.
1343          */
1344         if (p->pindex == NUPT_TOTAL + NUPD_TOTAL + NUPDP_TOTAL) {
1345                 /*
1346                  * We are the pml4 table itself.
1347                  */
1348                 /* XXX anything to do here? */
1349         } else if (p->pindex >= (NUPT_TOTAL + NUPD_TOTAL)) {
1350                 /*
1351                  * We are a PDP page.
1352                  * We look for the PML4 entry that points to us.
1353                  */
1354                 vm_page_t m4;
1355                 pml4_entry_t *pml4;
1356                 int idx;
1357
1358                 m4 = vm_page_lookup(pmap->pm_pteobj,
1359                                     NUPT_TOTAL + NUPD_TOTAL + NUPDP_TOTAL);
1360                 KKASSERT(m4 != NULL);
1361                 pml4 = (pml4_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m4));
1362                 idx = (p->pindex - (NUPT_TOTAL + NUPD_TOTAL)) % NPML4EPG;
1363                 KKASSERT(pml4[idx] != 0);
1364                 if (pml4[idx] == 0)
1365                         kprintf("pmap_release: Unmapped PML4\n");
1366                 pml4[idx] = 0;
1367                 vm_page_unwire_quick(m4);
1368         } else if (p->pindex >= NUPT_TOTAL) {
1369                 /*
1370                  * We are a PD page.
1371                  * We look for the PDP entry that points to us.
1372                  */
1373                 vm_page_t m3;
1374                 pdp_entry_t *pdp;
1375                 int idx;
1376
1377                 m3 = vm_page_lookup(pmap->pm_pteobj,
1378                                     NUPT_TOTAL + NUPD_TOTAL +
1379                                      (p->pindex - NUPT_TOTAL) / NPDPEPG);
1380                 KKASSERT(m3 != NULL);
1381                 pdp = (pdp_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m3));
1382                 idx = (p->pindex - NUPT_TOTAL) % NPDPEPG;
1383                 KKASSERT(pdp[idx] != 0);
1384                 if (pdp[idx] == 0)
1385                         kprintf("pmap_release: Unmapped PDP %d\n", idx);
1386                 pdp[idx] = 0;
1387                 vm_page_unwire_quick(m3);
1388         } else {
1389                 /* We are a PT page.
1390                  * We look for the PD entry that points to us.
1391                  */
1392                 vm_page_t m2;
1393                 pd_entry_t *pd;
1394                 int idx;
1395
1396                 m2 = vm_page_lookup(pmap->pm_pteobj,
1397                                     NUPT_TOTAL + p->pindex / NPDEPG);
1398                 KKASSERT(m2 != NULL);
1399                 pd = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m2));
1400                 idx = p->pindex % NPDEPG;
1401                 if (pd[idx] == 0)
1402                         kprintf("pmap_release: Unmapped PD %d\n", idx);
1403                 pd[idx] = 0;
1404                 vm_page_unwire_quick(m2);
1405         }
1406         KKASSERT(pmap->pm_stats.resident_count > 0);
1407         atomic_add_long(&pmap->pm_stats.resident_count, -1);
1408
1409         if (p->wire_count > 1)  {
1410                 panic("pmap_release: freeing held pt page "
1411                       "pmap=%p pg=%p dmap=%p pi=%ld {%ld,%ld,%ld}",
1412                       pmap, p, (void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(p)),
1413                       p->pindex, NUPT_TOTAL, NUPD_TOTAL, NUPDP_TOTAL);
1414         }
1415
1416         if (pmap->pm_ptphint == p)
1417                 pmap->pm_ptphint = NULL;
1418
1419         /*
1420          * We leave the top-level page table page cached, wired, and mapped in
1421          * the pmap until the dtor function (pmap_puninit()) gets called.
1422          * However, still clean it up.
1423          */
1424         if (p->pindex == NUPT_TOTAL + NUPD_TOTAL + NUPDP_TOTAL) {
1425                 bzero(pmap->pm_pml4, PAGE_SIZE);
1426                 vm_page_wakeup(p);
1427         } else {
1428                 vm_page_unwire(p, 0);
1429                 vm_page_flag_clear(p, PG_MAPPED | PG_WRITEABLE);
1430                 vm_page_free(p);
1431                 atomic_add_long(&pmap->pm_stats.wired_count, -1);
1432         }
1433         return 0;
1434 }
1435
1436 /*
1437  * Locate the requested PT, PD, or PDP page table page.
1438  *
1439  * Returns a busied page, caller must vm_page_wakeup() when done.
1440  */
1441 static vm_page_t
1442 _pmap_allocpte(pmap_t pmap, vm_pindex_t ptepindex)
1443 {
1444         vm_page_t m;
1445         vm_page_t pm;
1446         vm_pindex_t pindex;
1447         pt_entry_t *ptep;
1448         pt_entry_t data;
1449
1450         /*
1451          * Find or fabricate a new pagetable page.  A non-zero wire_count
1452          * indicates that the page has already been mapped into its parent.
1453          */
1454         m = vm_page_grab(pmap->pm_pteobj, ptepindex,
1455                          VM_ALLOC_NORMAL | VM_ALLOC_ZERO | VM_ALLOC_RETRY);
1456         if (m->wire_count != 0)
1457                 return m;
1458
1459         /*
1460          * Map the page table page into its parent, giving it 1 wire count.
1461          */
1462         vm_page_wire(m);
1463         vm_page_unqueue(m);
1464         atomic_add_long(&pmap->pm_stats.resident_count, 1);
1465         vm_page_flag_set(m, PG_MAPPED | PG_WRITEABLE);
1466
1467         data = VM_PAGE_TO_PHYS(m) |
1468                VPTE_RW | VPTE_V | VPTE_U | VPTE_A | VPTE_M | VPTE_WIRED;
1469         atomic_add_long(&pmap->pm_stats.wired_count, 1);
1470
1471         if (ptepindex >= (NUPT_TOTAL + NUPD_TOTAL)) {
1472                 /*
1473                  * Map PDP into the PML4
1474                  */
1475                 pindex = ptepindex - (NUPT_TOTAL + NUPD_TOTAL);
1476                 pindex &= (NUPDP_TOTAL - 1);
1477                 ptep = (pt_entry_t *)pmap->pm_pml4;
1478                 pm = NULL;
1479         } else if (ptepindex >= NUPT_TOTAL) {
1480                 /*
1481                  * Map PD into its PDP
1482                  */
1483                 pindex = (ptepindex - NUPT_TOTAL) >> NPDPEPGSHIFT;
1484                 pindex += NUPT_TOTAL + NUPD_TOTAL;
1485                 pm = _pmap_allocpte(pmap, pindex);
1486                 pindex = (ptepindex - NUPT_TOTAL) & (NPDPEPG - 1);
1487                 ptep = (void *)PHYS_TO_DMAP(pm->phys_addr);
1488         } else {
1489                 /*
1490                  * Map PT into its PD
1491                  */
1492                 pindex = ptepindex >> NPDPEPGSHIFT;
1493                 pindex += NUPT_TOTAL;
1494                 pm = _pmap_allocpte(pmap, pindex);
1495                 pindex = ptepindex & (NPTEPG - 1);
1496                 ptep = (void *)PHYS_TO_DMAP(pm->phys_addr);
1497         }
1498
1499         /*
1500          * Install the pte in (pm).  (m) prevents races.
1501          */
1502         ptep += pindex;
1503         data = atomic_swap_long(ptep, data);
1504         if (pm) {
1505                 vm_page_wire_quick(pm);
1506                 vm_page_wakeup(pm);
1507         }
1508         pmap->pm_ptphint = pm;
1509
1510         return m;
1511 }
1512
1513 /*
1514  * Determine the page table page required to access the VA in the pmap
1515  * and allocate it if necessary.  Return a held vm_page_t for the page.
1516  *
1517  * Only used with user pmaps.
1518  */
1519 static vm_page_t
1520 pmap_allocpte(pmap_t pmap, vm_offset_t va)
1521 {
1522         vm_pindex_t ptepindex;
1523         vm_page_t m;
1524
1525         ASSERT_LWKT_TOKEN_HELD(vm_object_token(pmap->pm_pteobj));
1526
1527         /*
1528          * Calculate pagetable page index, and return the PT page to
1529          * the caller.
1530          */
1531         ptepindex = pmap_pt_pindex(va);
1532         m = _pmap_allocpte(pmap, ptepindex);
1533
1534         return m;
1535 }
1536
1537 /***************************************************
1538  * Pmap allocation/deallocation routines.
1539  ***************************************************/
1540
1541 /*
1542  * Release any resources held by the given physical map.
1543  * Called when a pmap initialized by pmap_pinit is being released.
1544  * Should only be called if the map contains no valid mappings.
1545  */
1546 static int pmap_release_callback(struct vm_page *p, void *data);
1547
1548 void
1549 pmap_release(struct pmap *pmap)
1550 {
1551         vm_object_t object = pmap->pm_pteobj;
1552         struct rb_vm_page_scan_info info;
1553
1554         KKASSERT(pmap != &kernel_pmap);
1555
1556 #if defined(DIAGNOSTIC)
1557         if (object->ref_count != 1)
1558                 panic("pmap_release: pteobj reference count != 1");
1559 #endif
1560
1561         info.pmap = pmap;
1562         info.object = object;
1563
1564         KASSERT(CPUMASK_TESTZERO(pmap->pm_active),
1565                 ("pmap %p still active! %016jx",
1566                 pmap,
1567                 (uintmax_t)CPUMASK_LOWMASK(pmap->pm_active)));
1568
1569         vm_object_hold(object);
1570         do {
1571                 info.error = 0;
1572                 info.mpte = NULL;
1573                 info.limit = object->generation;
1574
1575                 vm_page_rb_tree_RB_SCAN(&object->rb_memq, NULL,
1576                                         pmap_release_callback, &info);
1577                 if (info.error == 0 && info.mpte) {
1578                         if (pmap_release_free_page(pmap, info.mpte))
1579                                 info.error = 1;
1580                 }
1581         } while (info.error);
1582
1583         pmap->pm_ptphint = NULL;
1584
1585         KASSERT((pmap->pm_stats.wired_count == (pmap->pm_pdirm != NULL)),
1586                 ("pmap_release: dangling count %p %ld",
1587                 pmap, pmap->pm_stats.wired_count));
1588
1589         vm_object_drop(object);
1590 }
1591
1592 static int
1593 pmap_release_callback(struct vm_page *p, void *data)
1594 {
1595         struct rb_vm_page_scan_info *info = data;
1596
1597         if (p->pindex == NUPT_TOTAL + NUPD_TOTAL + NUPDP_TOTAL) {
1598                 info->mpte = p;
1599                 return(0);
1600         }
1601         if (pmap_release_free_page(info->pmap, p)) {
1602                 info->error = 1;
1603                 return(-1);
1604         }
1605         if (info->object->generation != info->limit) {
1606                 info->error = 1;
1607                 return(-1);
1608         }
1609         return(0);
1610 }
1611
1612 /*
1613  * Grow the number of kernel page table entries, if needed.
1614  *
1615  * kernel_map must be locked exclusively by the caller.
1616  */
1617 void
1618 pmap_growkernel(vm_offset_t kstart, vm_offset_t kend)
1619 {
1620         vm_offset_t addr;
1621         vm_paddr_t paddr;
1622         vm_offset_t ptppaddr;
1623         vm_page_t nkpg;
1624         pd_entry_t *pde, newpdir;
1625         pdp_entry_t newpdp;
1626
1627         addr = kend;
1628
1629         vm_object_hold(&kptobj);
1630         if (kernel_vm_end == 0) {
1631                 kernel_vm_end = KvaStart;
1632                 nkpt = 0;
1633                 while ((*pmap_pde(&kernel_pmap, kernel_vm_end) & VPTE_V) != 0) {
1634                         kernel_vm_end =
1635                             rounddown2(kernel_vm_end + PAGE_SIZE * NPTEPG,
1636                                 PAGE_SIZE * NPTEPG);
1637                         nkpt++;
1638                         if (kernel_vm_end - 1 >= vm_map_max(&kernel_map)) {
1639                                 kernel_vm_end = vm_map_max(&kernel_map);
1640                                 break;
1641                         }
1642                 }
1643         }
1644         addr = roundup2(addr, PAGE_SIZE * NPTEPG);
1645         if (addr - 1 >= vm_map_max(&kernel_map))
1646                 addr = vm_map_max(&kernel_map);
1647         while (kernel_vm_end < addr) {
1648                 pde = pmap_pde(&kernel_pmap, kernel_vm_end);
1649                 if (pde == NULL) {
1650                         /* We need a new PDP entry */
1651                         nkpg = vm_page_alloc(&kptobj, nkpt,
1652                                              VM_ALLOC_NORMAL |
1653                                              VM_ALLOC_SYSTEM |
1654                                              VM_ALLOC_INTERRUPT);
1655                         if (nkpg == NULL) {
1656                                 panic("pmap_growkernel: no memory to "
1657                                       "grow kernel");
1658                         }
1659                         paddr = VM_PAGE_TO_PHYS(nkpg);
1660                         pmap_zero_page(paddr);
1661                         newpdp = (pdp_entry_t)(paddr |
1662                                                VPTE_V | VPTE_RW | VPTE_U |
1663                                                VPTE_A | VPTE_M | VPTE_WIRED);
1664                         *pmap_pdpe(&kernel_pmap, kernel_vm_end) = newpdp;
1665                         atomic_add_long(&kernel_pmap.pm_stats.wired_count, 1);
1666                         nkpt++;
1667                         continue; /* try again */
1668                 }
1669                 if ((*pde & VPTE_V) != 0) {
1670                         kernel_vm_end =
1671                             rounddown2(kernel_vm_end + PAGE_SIZE * NPTEPG,
1672                                 PAGE_SIZE * NPTEPG);
1673                         if (kernel_vm_end - 1 >= vm_map_max(&kernel_map)) {
1674                                 kernel_vm_end = vm_map_max(&kernel_map);
1675                                 break;
1676                         }
1677                         continue;
1678                 }
1679
1680                 /*
1681                  * This index is bogus, but out of the way
1682                  */
1683                 nkpg = vm_page_alloc(&kptobj, nkpt,
1684                                      VM_ALLOC_NORMAL |
1685                                      VM_ALLOC_SYSTEM |
1686                                      VM_ALLOC_INTERRUPT);
1687                 if (nkpg == NULL)
1688                         panic("pmap_growkernel: no memory to grow kernel");
1689
1690                 vm_page_wire(nkpg);
1691                 ptppaddr = VM_PAGE_TO_PHYS(nkpg);
1692                 pmap_zero_page(ptppaddr);
1693                 newpdir = (pd_entry_t)(ptppaddr |
1694                                        VPTE_V | VPTE_RW | VPTE_U |
1695                                        VPTE_A | VPTE_M | VPTE_WIRED);
1696                 *pmap_pde(&kernel_pmap, kernel_vm_end) = newpdir;
1697                 atomic_add_long(&kernel_pmap.pm_stats.wired_count, 1);
1698                 nkpt++;
1699
1700                 kernel_vm_end =
1701                     rounddown2(kernel_vm_end + PAGE_SIZE * NPTEPG,
1702                         PAGE_SIZE * NPTEPG);
1703                 if (kernel_vm_end - 1 >= vm_map_max(&kernel_map)) {
1704                         kernel_vm_end = vm_map_max(&kernel_map);
1705                         break;
1706                 }
1707         }
1708         vm_object_drop(&kptobj);
1709 }
1710
1711 /*
1712  * Add a reference to the specified pmap.
1713  *
1714  * No requirements.
1715  */
1716 void
1717 pmap_reference(pmap_t pmap)
1718 {
1719         if (pmap)
1720                 atomic_add_int(&pmap->pm_count, 1);
1721 }
1722
1723 /************************************************************************
1724  *                      VMSPACE MANAGEMENT                              *
1725  ************************************************************************
1726  *
1727  * The VMSPACE management we do in our virtual kernel must be reflected
1728  * in the real kernel.  This is accomplished by making vmspace system
1729  * calls to the real kernel.
1730  */
1731 void
1732 cpu_vmspace_alloc(struct vmspace *vm)
1733 {
1734         int r;
1735         void *rp;
1736         vpte_t vpte;
1737
1738         /*
1739          * If VMM enable, don't do nothing, we
1740          * are able to use real page tables
1741          */
1742         if (vmm_enabled)
1743                 return;
1744
1745 #define USER_SIZE       (VM_MAX_USER_ADDRESS - VM_MIN_USER_ADDRESS)
1746
1747         if (vmspace_create(&vm->vm_pmap, 0, NULL) < 0)
1748                 panic("vmspace_create() failed");
1749
1750         rp = vmspace_mmap(&vm->vm_pmap, VM_MIN_USER_ADDRESS, USER_SIZE,
1751                           PROT_READ|PROT_WRITE|PROT_EXEC,
1752                           MAP_FILE|MAP_SHARED|MAP_VPAGETABLE|MAP_FIXED,
1753                           MemImageFd, 0);
1754         if (rp == MAP_FAILED)
1755                 panic("vmspace_mmap: failed");
1756         vmspace_mcontrol(&vm->vm_pmap, VM_MIN_USER_ADDRESS, USER_SIZE,
1757                          MADV_NOSYNC, 0);
1758         vpte = VM_PAGE_TO_PHYS(vmspace_pmap(vm)->pm_pdirm) |
1759                                VPTE_RW | VPTE_V | VPTE_U;
1760         r = vmspace_mcontrol(&vm->vm_pmap, VM_MIN_USER_ADDRESS, USER_SIZE,
1761                              MADV_SETMAP, vpte);
1762         if (r < 0)
1763                 panic("vmspace_mcontrol: failed");
1764 }
1765
1766 void
1767 cpu_vmspace_free(struct vmspace *vm)
1768 {
1769         /*
1770          * If VMM enable, don't do nothing, we
1771          * are able to use real page tables
1772          */
1773         if (vmm_enabled)
1774                 return;
1775
1776         if (vmspace_destroy(&vm->vm_pmap) < 0)
1777                 panic("vmspace_destroy() failed");
1778 }
1779
1780 /***************************************************
1781 * page management routines.
1782  ***************************************************/
1783
1784 /*
1785  * free the pv_entry back to the free list.  This function may be
1786  * called from an interrupt.
1787  */
1788 static __inline void
1789 free_pv_entry(pv_entry_t pv)
1790 {
1791         atomic_add_long(&pv_entry_count, -1);
1792         zfree(pvzone, pv);
1793 }
1794
1795 /*
1796  * get a new pv_entry, allocating a block from the system
1797  * when needed.  This function may be called from an interrupt.
1798  */
1799 static pv_entry_t
1800 get_pv_entry(void)
1801 {
1802         atomic_add_long(&pv_entry_count, 1);
1803         if (pv_entry_high_water &&
1804             (pv_entry_count > pv_entry_high_water) &&
1805             atomic_swap_int(&pmap_pagedaemon_waken, 1) == 0) {
1806                 wakeup(&vm_pages_needed);
1807         }
1808         return zalloc(pvzone);
1809 }
1810
1811 /*
1812  * This routine is very drastic, but can save the system
1813  * in a pinch.
1814  *
1815  * No requirements.
1816  */
1817 void
1818 pmap_collect(void)
1819 {
1820         int i;
1821         vm_page_t m;
1822         static int warningdone=0;
1823
1824         if (pmap_pagedaemon_waken == 0)
1825                 return;
1826         pmap_pagedaemon_waken = 0;
1827
1828         if (warningdone < 5) {
1829                 kprintf("pmap_collect: collecting pv entries -- "
1830                         "suggest increasing PMAP_SHPGPERPROC\n");
1831                 warningdone++;
1832         }
1833
1834         for (i = 0; i < vm_page_array_size; i++) {
1835                 m = &vm_page_array[i];
1836                 if (m->wire_count || m->hold_count)
1837                         continue;
1838                 if (vm_page_busy_try(m, TRUE) == 0) {
1839                         if (m->wire_count == 0 && m->hold_count == 0) {
1840                                 pmap_remove_all(m);
1841                         }
1842                         vm_page_wakeup(m);
1843                 }
1844         }
1845 }
1846
1847
1848 /*
1849  * If it is the first entry on the list, it is actually
1850  * in the header and we must copy the following entry up
1851  * to the header.  Otherwise we must search the list for
1852  * the entry.  In either case we free the now unused entry.
1853  *
1854  * pmap->pm_pteobj must be held and (m) must be spin-locked by the caller.
1855  */
1856 static int
1857 pmap_remove_entry(struct pmap *pmap, vm_page_t m, vm_offset_t va)
1858 {
1859         pv_entry_t pv;
1860         int rtval;
1861
1862         vm_page_spin_lock(m);
1863         pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot, va);
1864
1865         /*
1866          * Note that pv_ptem is NULL if the page table page itself is not
1867          * managed, even if the page being removed IS managed.
1868          */
1869         rtval = 0;
1870         if (pv) {
1871                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
1872                 if (TAILQ_EMPTY(&m->md.pv_list))
1873                         vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
1874                 m->md.pv_list_count--;
1875                 KKASSERT(m->md.pv_list_count >= 0);
1876                 pv_entry_rb_tree_RB_REMOVE(&pmap->pm_pvroot, pv);
1877                 atomic_add_int(&pmap->pm_generation, 1);
1878                 vm_page_spin_unlock(m);
1879                 rtval = pmap_unuse_pt(pmap, va, pv->pv_ptem);
1880                 free_pv_entry(pv);
1881         } else {
1882                 vm_page_spin_unlock(m);
1883                 kprintf("pmap_remove_entry: could not find "
1884                         "pmap=%p m=%p va=%016jx\n",
1885                         pmap, m, va);
1886         }
1887         return rtval;
1888 }
1889
1890 /*
1891  * Create a pv entry for page at pa for (pmap, va).  If the page table page
1892  * holding the VA is managed, mpte will be non-NULL.
1893  *
1894  * pmap->pm_pteobj must be held and (m) must be spin-locked by the caller.
1895  */
1896 static void
1897 pmap_insert_entry(pmap_t pmap, vm_offset_t va, vm_page_t mpte, vm_page_t m,
1898                   pv_entry_t pv)
1899 {
1900         pv->pv_va = va;
1901         pv->pv_pmap = pmap;
1902         pv->pv_ptem = mpte;
1903
1904         m->md.pv_list_count++;
1905         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_list);
1906         pv = pv_entry_rb_tree_RB_INSERT(&pmap->pm_pvroot, pv);
1907         vm_page_flag_set(m, PG_MAPPED);
1908         KKASSERT(pv == NULL);
1909 }
1910
1911 /*
1912  * pmap_remove_pte: do the things to unmap a page in a process
1913  *
1914  * Caller holds pmap->pm_pteobj and holds the associated page table
1915  * page busy to prevent races.
1916  */
1917 static int
1918 pmap_remove_pte(struct pmap *pmap, pt_entry_t *ptq, pt_entry_t oldpte,
1919                 vm_offset_t va)
1920 {
1921         vm_page_t m;
1922         int error;
1923
1924         if (ptq)
1925                 oldpte = pmap_inval_loadandclear(ptq, pmap, va);
1926
1927         if (oldpte & VPTE_WIRED)
1928                 atomic_add_long(&pmap->pm_stats.wired_count, -1);
1929         KKASSERT(pmap->pm_stats.wired_count >= 0);
1930
1931 #if 0
1932         /*
1933          * Machines that don't support invlpg, also don't support
1934          * PG_G.  XXX PG_G is disabled for SMP so don't worry about
1935          * the SMP case.
1936          */
1937         if (oldpte & PG_G)
1938                 cpu_invlpg((void *)va);
1939 #endif
1940         KKASSERT(pmap->pm_stats.resident_count > 0);
1941         atomic_add_long(&pmap->pm_stats.resident_count, -1);
1942         if (oldpte & VPTE_MANAGED) {
1943                 m = PHYS_TO_VM_PAGE(oldpte);
1944
1945                 /*
1946                  * NOTE: pmap_remove_entry() will spin-lock the page
1947                  */
1948                 if (oldpte & VPTE_M) {
1949 #if defined(PMAP_DIAGNOSTIC)
1950                         if (pmap_nw_modified(oldpte)) {
1951                                 kprintf("pmap_remove: modified page not "
1952                                         "writable: va: 0x%lx, pte: 0x%lx\n",
1953                                         va, oldpte);
1954                         }
1955 #endif
1956                         pmap_track_modified(pmap, va);
1957                         vm_page_dirty(m);
1958                 }
1959                 if (oldpte & VPTE_A)
1960                         vm_page_flag_set(m, PG_REFERENCED);
1961                 error = pmap_remove_entry(pmap, m, va);
1962         } else {
1963                 error = pmap_unuse_pt(pmap, va, NULL);
1964         }
1965         return error;
1966 }
1967
1968 /*
1969  * pmap_remove_page:
1970  *
1971  * Remove a single page from a process address space.
1972  *
1973  * This function may not be called from an interrupt if the pmap is
1974  * not kernel_pmap.
1975  *
1976  * Caller holds pmap->pm_pteobj
1977  */
1978 static void
1979 pmap_remove_page(struct pmap *pmap, vm_offset_t va)
1980 {
1981         pt_entry_t *pte;
1982
1983         pte = pmap_pte(pmap, va);
1984         if (pte == NULL)
1985                 return;
1986         if ((*pte & VPTE_V) == 0)
1987                 return;
1988         pmap_remove_pte(pmap, pte, 0, va);
1989 }
1990
1991 /*
1992  * Remove the given range of addresses from the specified map.
1993  *
1994  * It is assumed that the start and end are properly rounded to
1995  * the page size.
1996  *
1997  * This function may not be called from an interrupt if the pmap is
1998  * not kernel_pmap.
1999  *
2000  * No requirements.
2001  */
2002 void
2003 pmap_remove(struct pmap *pmap, vm_offset_t sva, vm_offset_t eva)
2004 {
2005         vm_offset_t va_next;
2006         pml4_entry_t *pml4e;
2007         pdp_entry_t *pdpe;
2008         pd_entry_t ptpaddr, *pde;
2009         pt_entry_t *pte;
2010         vm_page_t pt_m;
2011
2012         if (pmap == NULL)
2013                 return;
2014
2015         vm_object_hold(pmap->pm_pteobj);
2016         KKASSERT(pmap->pm_stats.resident_count >= 0);
2017         if (pmap->pm_stats.resident_count == 0) {
2018                 vm_object_drop(pmap->pm_pteobj);
2019                 return;
2020         }
2021
2022         /*
2023          * special handling of removing one page.  a very
2024          * common operation and easy to short circuit some
2025          * code.
2026          */
2027         if (sva + PAGE_SIZE == eva) {
2028                 pde = pmap_pde(pmap, sva);
2029                 if (pde && (*pde & VPTE_PS) == 0) {
2030                         pmap_remove_page(pmap, sva);
2031                         vm_object_drop(pmap->pm_pteobj);
2032                         return;
2033                 }
2034         }
2035
2036         for (; sva < eva; sva = va_next) {
2037                 pml4e = pmap_pml4e(pmap, sva);
2038                 if ((*pml4e & VPTE_V) == 0) {
2039                         va_next = (sva + NBPML4) & ~PML4MASK;
2040                         if (va_next < sva)
2041                                 va_next = eva;
2042                         continue;
2043                 }
2044
2045                 pdpe = pmap_pml4e_to_pdpe(pml4e, sva);
2046                 if ((*pdpe & VPTE_V) == 0) {
2047                         va_next = (sva + NBPDP) & ~PDPMASK;
2048                         if (va_next < sva)
2049                                 va_next = eva;
2050                         continue;
2051                 }
2052
2053                 /*
2054                  * Calculate index for next page table.
2055                  */
2056                 va_next = (sva + NBPDR) & ~PDRMASK;
2057                 if (va_next < sva)
2058                         va_next = eva;
2059
2060                 pde = pmap_pdpe_to_pde(pdpe, sva);
2061                 ptpaddr = *pde;
2062
2063                 /*
2064                  * Weed out invalid mappings.
2065                  */
2066                 if (ptpaddr == 0)
2067                         continue;
2068
2069                 /*
2070                  * Check for large page.
2071                  */
2072                 if ((ptpaddr & VPTE_PS) != 0) {
2073                         /* JG FreeBSD has more complex treatment here */
2074                         KKASSERT(*pde != 0);
2075                         pmap_inval_pde(pde, pmap, sva);
2076                         atomic_add_long(&pmap->pm_stats.resident_count,
2077                                        -NBPDR / PAGE_SIZE);
2078                         continue;
2079                 }
2080
2081                 /*
2082                  * Limit our scan to either the end of the va represented
2083                  * by the current page table page, or to the end of the
2084                  * range being removed.
2085                  */
2086                 if (va_next > eva)
2087                         va_next = eva;
2088
2089                 /*
2090                  * NOTE: pmap_remove_pte() can block.
2091                  */
2092                 pt_m = pmap_hold_pt_page(pde, sva);
2093                 for (pte = pmap_pde_to_pte(pde, sva); sva != va_next; pte++,
2094                      sva += PAGE_SIZE) {
2095                         if (*pte) {
2096                                 if (pmap_remove_pte(pmap, pte, 0, sva))
2097                                         break;
2098                         }
2099                 }
2100                 vm_page_unhold(pt_m);
2101         }
2102         vm_object_drop(pmap->pm_pteobj);
2103 }
2104
2105 /*
2106  * Removes this physical page from all physical maps in which it resides.
2107  * Reflects back modify bits to the pager.
2108  *
2109  * This routine may not be called from an interrupt.
2110  *
2111  * No requirements.
2112  */
2113 static void
2114 pmap_remove_all(vm_page_t m)
2115 {
2116         pt_entry_t *pte, tpte;
2117         pv_entry_t pv;
2118         vm_object_t pmobj;
2119         pmap_t pmap;
2120
2121 #if defined(PMAP_DIAGNOSTIC)
2122         /*
2123          * XXX this makes pmap_page_protect(NONE) illegal for non-managed
2124          * pages!
2125          */
2126         if (!pmap_initialized || (m->flags & PG_FICTITIOUS)) {
2127                 panic("pmap_page_protect: illegal for unmanaged page, va: 0x%08llx", (long long)VM_PAGE_TO_PHYS(m));
2128         }
2129 #endif
2130
2131 restart:
2132         vm_page_spin_lock(m);
2133         while ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
2134                 pmap = pv->pv_pmap;
2135                 pmobj = pmap->pm_pteobj;
2136
2137                 /*
2138                  * Handle reversed lock ordering
2139                  */
2140                 if (vm_object_hold_try(pmobj) == 0) {
2141                         refcount_acquire(&pmobj->hold_count);
2142                         vm_page_spin_unlock(m);
2143                         vm_object_lock(pmobj);
2144                         vm_page_spin_lock(m);
2145                         if (pv != TAILQ_FIRST(&m->md.pv_list) ||
2146                             pmap != pv->pv_pmap ||
2147                             pmobj != pmap->pm_pteobj) {
2148                                 vm_page_spin_unlock(m);
2149                                 vm_object_drop(pmobj);
2150                                 goto restart;
2151                         }
2152                 }
2153
2154                 KKASSERT(pmap->pm_stats.resident_count > 0);
2155                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
2156
2157                 pte = pmap_pte(pmap, pv->pv_va);
2158                 KKASSERT(pte != NULL);
2159
2160                 tpte = pmap_inval_loadandclear(pte, pmap, pv->pv_va);
2161                 if (tpte & VPTE_WIRED)
2162                         atomic_add_long(&pmap->pm_stats.wired_count, -1);
2163                 KKASSERT(pmap->pm_stats.wired_count >= 0);
2164
2165                 if (tpte & VPTE_A)
2166                         vm_page_flag_set(m, PG_REFERENCED);
2167
2168                 /*
2169                  * Update the vm_page_t clean and reference bits.
2170                  */
2171                 if (tpte & VPTE_M) {
2172 #if defined(PMAP_DIAGNOSTIC)
2173                         if (pmap_nw_modified(tpte)) {
2174                                 kprintf(
2175         "pmap_remove_all: modified page not writable: va: 0x%lx, pte: 0x%lx\n",
2176                                     pv->pv_va, tpte);
2177                         }
2178 #endif
2179                         pmap_track_modified(pmap, pv->pv_va);
2180                         vm_page_dirty(m);
2181                 }
2182                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
2183                 if (TAILQ_EMPTY(&m->md.pv_list))
2184                         vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
2185                 m->md.pv_list_count--;
2186                 KKASSERT(m->md.pv_list_count >= 0);
2187                 pv_entry_rb_tree_RB_REMOVE(&pmap->pm_pvroot, pv);
2188                 atomic_add_int(&pmap->pm_generation, 1);
2189                 vm_page_spin_unlock(m);
2190                 pmap_unuse_pt(pmap, pv->pv_va, pv->pv_ptem);
2191                 free_pv_entry(pv);
2192
2193                 vm_object_drop(pmobj);
2194                 vm_page_spin_lock(m);
2195         }
2196         KKASSERT((m->flags & (PG_MAPPED|PG_WRITEABLE)) == 0);
2197         vm_page_spin_unlock(m);
2198 }
2199
2200 /*
2201  * Removes the page from a particular pmap
2202  */
2203 void
2204 pmap_remove_specific(pmap_t pmap, vm_page_t m)
2205 {
2206         pt_entry_t *pte, tpte;
2207         pv_entry_t pv;
2208
2209         vm_object_hold(pmap->pm_pteobj);
2210 again:
2211         vm_page_spin_lock(m);
2212         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
2213                 if (pv->pv_pmap != pmap)
2214                         continue;
2215
2216                 KKASSERT(pmap->pm_stats.resident_count > 0);
2217                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
2218
2219                 pte = pmap_pte(pmap, pv->pv_va);
2220                 KKASSERT(pte != NULL);
2221
2222                 tpte = pmap_inval_loadandclear(pte, pmap, pv->pv_va);
2223                 if (tpte & VPTE_WIRED)
2224                         atomic_add_long(&pmap->pm_stats.wired_count, -1);
2225                 KKASSERT(pmap->pm_stats.wired_count >= 0);
2226
2227                 if (tpte & VPTE_A)
2228                         vm_page_flag_set(m, PG_REFERENCED);
2229
2230                 /*
2231                  * Update the vm_page_t clean and reference bits.
2232                  */
2233                 if (tpte & VPTE_M) {
2234                         pmap_track_modified(pmap, pv->pv_va);
2235                         vm_page_dirty(m);
2236                 }
2237                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
2238                 pv_entry_rb_tree_RB_REMOVE(&pmap->pm_pvroot, pv);
2239                 atomic_add_int(&pmap->pm_generation, 1);
2240                 m->md.pv_list_count--;
2241                 KKASSERT(m->md.pv_list_count >= 0);
2242                 if (TAILQ_EMPTY(&m->md.pv_list))
2243                         vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
2244                 pmap_unuse_pt(pmap, pv->pv_va, pv->pv_ptem);
2245                 vm_page_spin_unlock(m);
2246                 free_pv_entry(pv);
2247                 goto again;
2248         }
2249         vm_page_spin_unlock(m);
2250         vm_object_drop(pmap->pm_pteobj);
2251 }
2252
2253 /*
2254  * Set the physical protection on the specified range of this map
2255  * as requested.
2256  *
2257  * This function may not be called from an interrupt if the map is
2258  * not the kernel_pmap.
2259  *
2260  * No requirements.
2261  */
2262 void
2263 pmap_protect(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, vm_prot_t prot)
2264 {
2265         vm_offset_t va_next;
2266         pml4_entry_t *pml4e;
2267         pdp_entry_t *pdpe;
2268         pd_entry_t ptpaddr, *pde;
2269         pt_entry_t *pte;
2270         vm_page_t pt_m;
2271
2272         if (pmap == NULL)
2273                 return;
2274
2275         if ((prot & (VM_PROT_READ | VM_PROT_EXECUTE)) == VM_PROT_NONE) {
2276                 pmap_remove(pmap, sva, eva);
2277                 return;
2278         }
2279
2280         if (prot & VM_PROT_WRITE)
2281                 return;
2282
2283         vm_object_hold(pmap->pm_pteobj);
2284
2285         for (; sva < eva; sva = va_next) {
2286                 pml4e = pmap_pml4e(pmap, sva);
2287                 if ((*pml4e & VPTE_V) == 0) {
2288                         va_next = (sva + NBPML4) & ~PML4MASK;
2289                         if (va_next < sva)
2290                                 va_next = eva;
2291                         continue;
2292                 }
2293
2294                 pdpe = pmap_pml4e_to_pdpe(pml4e, sva);
2295                 if ((*pdpe & VPTE_V) == 0) {
2296                         va_next = (sva + NBPDP) & ~PDPMASK;
2297                         if (va_next < sva)
2298                                 va_next = eva;
2299                         continue;
2300                 }
2301
2302                 va_next = (sva + NBPDR) & ~PDRMASK;
2303                 if (va_next < sva)
2304                         va_next = eva;
2305
2306                 pde = pmap_pdpe_to_pde(pdpe, sva);
2307                 ptpaddr = *pde;
2308
2309 #if 0
2310                 /*
2311                  * Check for large page.
2312                  */
2313                 if ((ptpaddr & VPTE_PS) != 0) {
2314                         /* JG correct? */
2315                         pmap_clean_pde(pde, pmap, sva);
2316                         atomic_add_long(&pmap->pm_stats.resident_count,
2317                                         -NBPDR / PAGE_SIZE);
2318                         continue;
2319                 }
2320 #endif
2321
2322                 /*
2323                  * Weed out invalid mappings. Note: we assume that the page
2324                  * directory table is always allocated, and in kernel virtual.
2325                  */
2326                 if (ptpaddr == 0)
2327                         continue;
2328
2329                 if (va_next > eva)
2330                         va_next = eva;
2331
2332                 pt_m = pmap_hold_pt_page(pde, sva);
2333                 for (pte = pmap_pde_to_pte(pde, sva); sva != va_next; pte++,
2334                     sva += PAGE_SIZE) {
2335                         /*
2336                          * Clean managed pages and also check the accessed
2337                          * bit.  Just remove write perms for unmanaged
2338                          * pages.  Be careful of races, turning off write
2339                          * access will force a fault rather then setting
2340                          * the modified bit at an unexpected time.
2341                          */
2342                         pmap_track_modified(pmap, sva);
2343                         pmap_clean_pte(pte, pmap, sva, NULL);
2344                 }
2345                 vm_page_unhold(pt_m);
2346         }
2347         vm_object_drop(pmap->pm_pteobj);
2348 }
2349
2350 /*
2351  * Enter a managed page into a pmap.  If the page is not wired related pmap
2352  * data can be destroyed at any time for later demand-operation.
2353  *
2354  * Insert the vm_page (m) at virtual address (v) in (pmap), with the
2355  * specified protection, and wire the mapping if requested.
2356  *
2357  * NOTE: This routine may not lazy-evaluate or lose information.  The
2358  *       page must actually be inserted into the given map NOW.
2359  *
2360  * NOTE: When entering a page at a KVA address, the pmap must be the
2361  *       kernel_pmap.
2362  *
2363  * No requirements.
2364  */
2365 void
2366 pmap_enter(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
2367            boolean_t wired, vm_map_entry_t entry __unused)
2368 {
2369         vm_paddr_t pa;
2370         pv_entry_t pv;
2371         pt_entry_t *pte;
2372         pt_entry_t origpte, newpte;
2373         vm_paddr_t opa;
2374         vm_page_t mpte;
2375
2376         if (pmap == NULL)
2377                 return;
2378
2379         va = trunc_page(va);
2380
2381         vm_object_hold(pmap->pm_pteobj);
2382
2383         /*
2384          * Get the page table page.   The kernel_pmap's page table pages
2385          * are preallocated and have no associated vm_page_t.
2386          *
2387          * If not NULL, mpte will be busied and we must vm_page_wakeup()
2388          * to cleanup.  There will already be at least one wire count from
2389          * it being mapped into its parent.
2390          */
2391         if (pmap == &kernel_pmap) {
2392                 mpte = NULL;
2393                 pte = vtopte(va);
2394         } else {
2395                 mpte = pmap_allocpte(pmap, va);
2396                 pte = (void *)PHYS_TO_DMAP(mpte->phys_addr);
2397                 pte += pmap_pte_index(va);
2398         }
2399
2400         /*
2401          * Deal with races against the kernel's real MMU by cleaning the
2402          * page, even if we are re-entering the same page.
2403          */
2404         pa = VM_PAGE_TO_PHYS(m);
2405         origpte = pmap_inval_loadandclear(pte, pmap, va);
2406         /*origpte = pmap_clean_pte(pte, pmap, va, NULL);*/
2407         opa = origpte & VPTE_FRAME;
2408
2409         if (origpte & VPTE_PS)
2410                 panic("pmap_enter: attempted pmap_enter on 2MB page");
2411
2412         if ((origpte & (VPTE_MANAGED|VPTE_M)) == (VPTE_MANAGED|VPTE_M)) {
2413                 vm_page_t om;
2414
2415                 pmap_track_modified(pmap, va);
2416                 om = PHYS_TO_VM_PAGE(opa);
2417                 vm_page_dirty(om);
2418         }
2419
2420         /*
2421          * Mapping has not changed, must be protection or wiring change.
2422          */
2423         if (origpte && (opa == pa)) {
2424                 /*
2425                  * Wiring change, just update stats. We don't worry about
2426                  * wiring PT pages as they remain resident as long as there
2427                  * are valid mappings in them. Hence, if a user page is wired,
2428                  * the PT page will be also.
2429                  */
2430                 if (wired && ((origpte & VPTE_WIRED) == 0))
2431                         atomic_add_long(&pmap->pm_stats.wired_count, 1);
2432                 else if (!wired && (origpte & VPTE_WIRED))
2433                         atomic_add_long(&pmap->pm_stats.wired_count, -1);
2434
2435                 if (origpte & VPTE_MANAGED) {
2436                         pa |= VPTE_MANAGED;
2437                         KKASSERT(m->flags & PG_MAPPED);
2438                         KKASSERT((m->flags & PG_FICTITIOUS) == 0);
2439                 } else {
2440                         KKASSERT((m->flags & PG_FICTITIOUS));
2441                 }
2442                 vm_page_spin_lock(m);
2443                 goto validate;
2444         }
2445
2446         /*
2447          * Bump the wire_count for the page table page.
2448          */
2449         if (mpte)
2450                 vm_page_wire_quick(mpte);
2451
2452         /*
2453          * Mapping has changed, invalidate old range and fall through to
2454          * handle validating new mapping.  Don't inherit anything from
2455          * oldpte.
2456          */
2457         if (opa) {
2458                 int err;
2459                 err = pmap_remove_pte(pmap, NULL, origpte, va);
2460                 origpte = 0;
2461                 if (err)
2462                         panic("pmap_enter: pte vanished, va: 0x%lx", va);
2463         }
2464
2465         /*
2466          * Enter on the PV list if part of our managed memory. Note that we
2467          * raise IPL while manipulating pv_table since pmap_enter can be
2468          * called at interrupt time.
2469          */
2470         if (pmap_initialized) {
2471                 if ((m->flags & PG_FICTITIOUS) == 0) {
2472                         /*
2473                          * WARNING!  We are using m's spin-lock as a
2474                          *           man's pte lock to interlock against
2475                          *           pmap_page_protect() operations.
2476                          *
2477                          *           This is a bad hack (obviously).
2478                          */
2479                         pv = get_pv_entry();
2480                         vm_page_spin_lock(m);
2481                         pmap_insert_entry(pmap, va, mpte, m, pv);
2482                         pa |= VPTE_MANAGED;
2483                         /* vm_page_spin_unlock(m); */
2484                 } else {
2485                         vm_page_spin_lock(m);
2486                 }
2487         } else {
2488                 vm_page_spin_lock(m);
2489         }
2490
2491         /*
2492          * Increment counters
2493          */
2494         atomic_add_long(&pmap->pm_stats.resident_count, 1);
2495         if (wired)
2496                 atomic_add_long(&pmap->pm_stats.wired_count, 1);
2497
2498 validate:
2499         /*
2500          * Now validate mapping with desired protection/wiring.
2501          */
2502         newpte = (pt_entry_t)(pa | pte_prot(pmap, prot) | VPTE_V | VPTE_U);
2503         newpte |= VPTE_A;
2504
2505         if (wired)
2506                 newpte |= VPTE_WIRED;
2507 //      if (pmap != &kernel_pmap)
2508                 newpte |= VPTE_U;
2509         if (newpte & VPTE_RW)
2510                 vm_page_flag_set(m, PG_WRITEABLE);
2511         KKASSERT((newpte & VPTE_MANAGED) == 0 || (m->flags & PG_MAPPED));
2512
2513         origpte = atomic_swap_long(pte, newpte);
2514         if (origpte & VPTE_M) {
2515                 kprintf("pmap [M] race @ %016jx\n", va);
2516                 atomic_set_long(pte, VPTE_M);
2517         }
2518         vm_page_spin_unlock(m);
2519
2520         if (mpte)
2521                 vm_page_wakeup(mpte);
2522         vm_object_drop(pmap->pm_pteobj);
2523 }
2524
2525 /*
2526  * Make a temporary mapping for a physical address.  This is only intended
2527  * to be used for panic dumps.
2528  *
2529  * The caller is responsible for calling smp_invltlb().
2530  */
2531 void *
2532 pmap_kenter_temporary(vm_paddr_t pa, long i)
2533 {
2534         pmap_kenter_quick(crashdumpmap + (i * PAGE_SIZE), pa);
2535         return ((void *)crashdumpmap);
2536 }
2537
2538 #define MAX_INIT_PT (96)
2539
2540 /*
2541  * This routine preloads the ptes for a given object into the specified pmap.
2542  * This eliminates the blast of soft faults on process startup and
2543  * immediately after an mmap.
2544  *
2545  * No requirements.
2546  */
2547 static int pmap_object_init_pt_callback(vm_page_t p, void *data);
2548
2549 void
2550 pmap_object_init_pt(pmap_t pmap, vm_map_entry_t entry,
2551                     vm_offset_t addr, vm_size_t size, int limit)
2552 {
2553         vm_prot_t prot = entry->protection;
2554         vm_object_t object = entry->ba.object;
2555         vm_pindex_t pindex = atop(entry->ba.offset + (addr - entry->ba.start));
2556         struct rb_vm_page_scan_info info;
2557         struct lwp *lp;
2558         vm_size_t psize;
2559
2560         /*
2561          * We can't preinit if read access isn't set or there is no pmap
2562          * or object.
2563          */
2564         if ((prot & VM_PROT_READ) == 0 || pmap == NULL || object == NULL)
2565                 return;
2566
2567         /*
2568          * We can't preinit if the pmap is not the current pmap
2569          */
2570         lp = curthread->td_lwp;
2571         if (lp == NULL || pmap != vmspace_pmap(lp->lwp_vmspace))
2572                 return;
2573
2574         /*
2575          * Misc additional checks
2576          */
2577         psize = x86_64_btop(size);
2578
2579         if ((object->type != OBJT_VNODE) ||
2580                 ((limit & MAP_PREFAULT_PARTIAL) && (psize > MAX_INIT_PT) &&
2581                         (object->resident_page_count > MAX_INIT_PT))) {
2582                 return;
2583         }
2584
2585         if (psize + pindex > object->size) {
2586                 if (object->size < pindex)
2587                         return;
2588                 psize = object->size - pindex;
2589         }
2590
2591         if (psize == 0)
2592                 return;
2593
2594         /*
2595          * Use a red-black scan to traverse the requested range and load
2596          * any valid pages found into the pmap.
2597          *
2598          * We cannot safely scan the object's memq unless we are in a
2599          * critical section since interrupts can remove pages from objects.
2600          */
2601         info.start_pindex = pindex;
2602         info.end_pindex = pindex + psize - 1;
2603         info.limit = limit;
2604         info.mpte = NULL;
2605         info.addr = addr;
2606         info.pmap = pmap;
2607         info.entry = entry;
2608
2609         vm_object_hold_shared(object);
2610         vm_page_rb_tree_RB_SCAN(&object->rb_memq, rb_vm_page_scancmp,
2611                                 pmap_object_init_pt_callback, &info);
2612         vm_object_drop(object);
2613 }
2614
2615 static
2616 int
2617 pmap_object_init_pt_callback(vm_page_t p, void *data)
2618 {
2619         struct rb_vm_page_scan_info *info = data;
2620         vm_pindex_t rel_index;
2621         /*
2622          * don't allow an madvise to blow away our really
2623          * free pages allocating pv entries.
2624          */
2625         if ((info->limit & MAP_PREFAULT_MADVISE) &&
2626                 vmstats.v_free_count < vmstats.v_free_reserved) {
2627                     return(-1);
2628         }
2629
2630         /*
2631          * Ignore list markers and ignore pages we cannot instantly
2632          * busy (while holding the object token).
2633          */
2634         if (p->flags & PG_MARKER)
2635                 return 0;
2636         if (vm_page_busy_try(p, TRUE))
2637                 return 0;
2638         if (((p->valid & VM_PAGE_BITS_ALL) == VM_PAGE_BITS_ALL) &&
2639             (p->flags & PG_FICTITIOUS) == 0) {
2640                 if ((p->queue - p->pc) == PQ_CACHE)
2641                         vm_page_deactivate(p);
2642                 rel_index = p->pindex - info->start_pindex;
2643                 pmap_enter(info->pmap, info->addr + x86_64_ptob(rel_index), p,
2644                            VM_PROT_READ, FALSE, info->entry);
2645         }
2646         vm_page_wakeup(p);
2647         return(0);
2648 }
2649
2650 /*
2651  * Return TRUE if the pmap is in shape to trivially
2652  * pre-fault the specified address.
2653  *
2654  * Returns FALSE if it would be non-trivial or if a
2655  * pte is already loaded into the slot.
2656  *
2657  * No requirements.
2658  */
2659 int
2660 pmap_prefault_ok(pmap_t pmap, vm_offset_t addr)
2661 {
2662         pt_entry_t *pte;
2663         pd_entry_t *pde;
2664         int ret;
2665
2666         vm_object_hold(pmap->pm_pteobj);
2667         pde = pmap_pde(pmap, addr);
2668         if (pde == NULL || *pde == 0) {
2669                 ret = 0;
2670         } else {
2671                 pte = pmap_pde_to_pte(pde, addr);
2672                 ret = (*pte) ? 0 : 1;
2673         }
2674         vm_object_drop(pmap->pm_pteobj);
2675
2676         return (ret);
2677 }
2678
2679 /*
2680  * Change the wiring attribute for a map/virtual-address pair.
2681  *
2682  * The mapping must already exist in the pmap.
2683  * No other requirements.
2684  */
2685 vm_page_t
2686 pmap_unwire(pmap_t pmap, vm_offset_t va)
2687 {
2688         pt_entry_t *pte;
2689         vm_paddr_t pa;
2690         vm_page_t m;
2691
2692         if (pmap == NULL)
2693                 return NULL;
2694
2695         vm_object_hold(pmap->pm_pteobj);
2696         pte = pmap_pte(pmap, va);
2697
2698         if (pte == NULL || (*pte & VPTE_V) == 0) {
2699                 vm_object_drop(pmap->pm_pteobj);
2700                 return NULL;
2701         }
2702
2703         /*
2704          * Wiring is not a hardware characteristic so there is no need to
2705          * invalidate TLB.  However, in an SMP environment we must use
2706          * a locked bus cycle to update the pte (if we are not using
2707          * the pmap_inval_*() API that is)... it's ok to do this for simple
2708          * wiring changes.
2709          */
2710         if (pmap_pte_w(pte))
2711                 atomic_add_long(&pmap->pm_stats.wired_count, -1);
2712         /* XXX else return NULL so caller doesn't unwire m ? */
2713         atomic_clear_long(pte, VPTE_WIRED);
2714
2715         pa = *pte & VPTE_FRAME;
2716         m = PHYS_TO_VM_PAGE(pa);        /* held by wired count */
2717
2718         vm_object_drop(pmap->pm_pteobj);
2719
2720         return m;
2721 }
2722
2723 /*
2724  *      Copy the range specified by src_addr/len
2725  *      from the source map to the range dst_addr/len
2726  *      in the destination map.
2727  *
2728  *      This routine is only advisory and need not do anything.
2729  */
2730 void
2731 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr,
2732         vm_size_t len, vm_offset_t src_addr)
2733 {
2734         /*
2735          * XXX BUGGY.  Amoung other things srcmpte is assumed to remain
2736          * valid through blocking calls, and that's just not going to
2737          * be the case.
2738          *
2739          * FIXME!
2740          */
2741         return;
2742 }
2743
2744 /*
2745  * pmap_zero_page:
2746  *
2747  *      Zero the specified physical page.
2748  *
2749  *      This function may be called from an interrupt and no locking is
2750  *      required.
2751  */
2752 void
2753 pmap_zero_page(vm_paddr_t phys)
2754 {
2755         vm_offset_t va = PHYS_TO_DMAP(phys);
2756
2757         bzero((void *)va, PAGE_SIZE);
2758 }
2759
2760 /*
2761  * pmap_zero_page:
2762  *
2763  *      Zero part of a physical page by mapping it into memory and clearing
2764  *      its contents with bzero.
2765  *
2766  *      off and size may not cover an area beyond a single hardware page.
2767  */
2768 void
2769 pmap_zero_page_area(vm_paddr_t phys, int off, int size)
2770 {
2771         vm_offset_t virt = PHYS_TO_DMAP(phys);
2772
2773         bzero((char *)virt + off, size);
2774 }
2775
2776 /*
2777  * pmap_copy_page:
2778  *
2779  *      Copy the physical page from the source PA to the target PA.
2780  *      This function may be called from an interrupt.  No locking
2781  *      is required.
2782  */
2783 void
2784 pmap_copy_page(vm_paddr_t src, vm_paddr_t dst)
2785 {
2786         vm_offset_t src_virt, dst_virt;
2787
2788         src_virt = PHYS_TO_DMAP(src);
2789         dst_virt = PHYS_TO_DMAP(dst);
2790         bcopy((void *)src_virt, (void *)dst_virt, PAGE_SIZE);
2791 }
2792
2793 /*
2794  * pmap_copy_page_frag:
2795  *
2796  *      Copy the physical page from the source PA to the target PA.
2797  *      This function may be called from an interrupt.  No locking
2798  *      is required.
2799  */
2800 void
2801 pmap_copy_page_frag(vm_paddr_t src, vm_paddr_t dst, size_t bytes)
2802 {
2803         vm_offset_t src_virt, dst_virt;
2804
2805         src_virt = PHYS_TO_DMAP(src);
2806         dst_virt = PHYS_TO_DMAP(dst);
2807         bcopy((char *)src_virt + (src & PAGE_MASK),
2808               (char *)dst_virt + (dst & PAGE_MASK),
2809               bytes);
2810 }
2811
2812 /*
2813  * Remove all pages from specified address space this aids process
2814  * exit speeds.  Also, this code is special cased for current
2815  * process only, but can have the more generic (and slightly slower)
2816  * mode enabled.  This is much faster than pmap_remove in the case
2817  * of running down an entire address space.
2818  *
2819  * No other requirements.
2820  */
2821 void
2822 pmap_remove_pages(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
2823 {
2824         pmap_remove(pmap, sva, eva);
2825 #if 0
2826         pt_entry_t *pte, tpte;
2827         pv_entry_t pv, npv;
2828         vm_page_t m;
2829         int save_generation;
2830
2831         if (pmap->pm_pteobj)
2832                 vm_object_hold(pmap->pm_pteobj);
2833
2834         pmap_invalidate_range(pmap, sva, eva);
2835
2836         for (pv = TAILQ_FIRST(&pmap->pm_pvlist); pv; pv = npv) {
2837                 if (pv->pv_va >= eva || pv->pv_va < sva) {
2838                         npv = TAILQ_NEXT(pv, pv_plist);
2839                         continue;
2840                 }
2841
2842                 KKASSERT(pmap == pv->pv_pmap);
2843
2844                 pte = pmap_pte(pmap, pv->pv_va);
2845
2846                 /*
2847                  * We cannot remove wired pages from a process' mapping
2848                  * at this time
2849                  */
2850                 if (*pte & VPTE_WIRED) {
2851                         npv = TAILQ_NEXT(pv, pv_plist);
2852                         continue;
2853                 }
2854                 tpte = pmap_inval_loadandclear(pte, pmap, pv->pv_va);
2855
2856                 m = PHYS_TO_VM_PAGE(tpte & VPTE_FRAME);
2857                 vm_page_spin_lock(m);
2858
2859                 KASSERT(m < &vm_page_array[vm_page_array_size],
2860                         ("pmap_remove_pages: bad tpte %lx", tpte));
2861
2862                 KKASSERT(pmap->pm_stats.resident_count > 0);
2863                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
2864
2865                 /*
2866                  * Update the vm_page_t clean and reference bits.
2867                  */
2868                 if (tpte & VPTE_M) {
2869                         vm_page_dirty(m);
2870                 }
2871
2872                 npv = TAILQ_NEXT(pv, pv_plist);
2873                 TAILQ_REMOVE(&pmap->pm_pvlist, pv, pv_plist);
2874                 atomic_add_int(&pmap->pm_generation, 1);
2875                 save_generation = pmap->pm_generation;
2876                 m->md.pv_list_count--;
2877                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
2878                 if (TAILQ_EMPTY(&m->md.pv_list))
2879                         vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
2880                 vm_page_spin_unlock(m);
2881
2882                 pmap_unuse_pt(pmap, pv->pv_va, pv->pv_ptem);
2883                 free_pv_entry(pv);
2884
2885                 /*
2886                  * Restart the scan if we blocked during the unuse or free
2887                  * calls and other removals were made.
2888                  */
2889                 if (save_generation != pmap->pm_generation) {
2890                         kprintf("Warning: pmap_remove_pages race-A avoided\n");
2891                         npv = TAILQ_FIRST(&pmap->pm_pvlist);
2892                 }
2893         }
2894         if (pmap->pm_pteobj)
2895                 vm_object_drop(pmap->pm_pteobj);
2896         pmap_remove(pmap, sva, eva);
2897 #endif
2898 }
2899
2900 /*
2901  * pmap_testbit tests bits in active mappings of a VM page.
2902  */
2903 static boolean_t
2904 pmap_testbit(vm_page_t m, int bit)
2905 {
2906         pv_entry_t pv;
2907         pt_entry_t *pte;
2908
2909         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
2910                 return FALSE;
2911
2912         if (TAILQ_FIRST(&m->md.pv_list) == NULL)
2913                 return FALSE;
2914
2915         vm_page_spin_lock(m);
2916         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
2917                 /*
2918                  * if the bit being tested is the modified bit, then
2919                  * mark clean_map and ptes as never
2920                  * modified.
2921                  */
2922                 if (bit & (VPTE_A|VPTE_M))
2923                         pmap_track_modified(pv->pv_pmap, pv->pv_va);
2924
2925 #if defined(PMAP_DIAGNOSTIC)
2926                 if (pv->pv_pmap == NULL) {
2927                         kprintf("Null pmap (tb) at va: 0x%lx\n", pv->pv_va);
2928                         continue;
2929                 }
2930 #endif
2931                 pte = pmap_pte(pv->pv_pmap, pv->pv_va);
2932                 if (*pte & bit) {
2933                         vm_page_spin_unlock(m);
2934                         return TRUE;
2935                 }
2936         }
2937         vm_page_spin_unlock(m);
2938         return (FALSE);
2939 }
2940
2941 /*
2942  * This routine is used to clear bits in ptes.  Certain bits require special
2943  * handling, in particular (on virtual kernels) the VPTE_M (modify) bit.
2944  *
2945  * This routine is only called with certain VPTE_* bit combinations.
2946  */
2947 static __inline void
2948 pmap_clearbit(vm_page_t m, int bit)
2949 {
2950         pv_entry_t pv;
2951         pt_entry_t *pte;
2952         pt_entry_t pbits;
2953         vm_object_t pmobj;
2954         pmap_t pmap;
2955
2956         if (!pmap_initialized || (m->flags & PG_FICTITIOUS)) {
2957                 if (bit == VPTE_RW)
2958                         vm_page_flag_clear(m, PG_WRITEABLE);
2959                 return;
2960         }
2961
2962         /*
2963          * Loop over all current mappings setting/clearing as appropos If
2964          * setting RO do we need to clear the VAC?
2965          */
2966 restart:
2967         vm_page_spin_lock(m);
2968         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
2969                 /*
2970                  * Need the pmap object lock(?)
2971                  */
2972                 pmap = pv->pv_pmap;
2973                 pmobj = pmap->pm_pteobj;
2974
2975                 if (vm_object_hold_try(pmobj) == 0) {
2976                         refcount_acquire(&pmobj->hold_count);
2977                         vm_page_spin_unlock(m);
2978                         vm_object_lock(pmobj);
2979                         vm_object_drop(pmobj);
2980                         goto restart;
2981                 }
2982
2983                 /*
2984                  * don't write protect pager mappings
2985                  */
2986                 if (bit == VPTE_RW) {
2987                         pmap_track_modified(pv->pv_pmap, pv->pv_va);
2988                 }
2989
2990 #if defined(PMAP_DIAGNOSTIC)
2991                 if (pv->pv_pmap == NULL) {
2992                         kprintf("Null pmap (cb) at va: 0x%lx\n", pv->pv_va);
2993                         vm_object_drop(pmobj);
2994                         continue;
2995                 }
2996 #endif
2997
2998                 /*
2999                  * Careful here.  We can use a locked bus instruction to
3000                  * clear VPTE_A or VPTE_M safely but we need to synchronize
3001                  * with the target cpus when we mess with VPTE_RW.
3002                  *
3003                  * On virtual kernels we must force a new fault-on-write
3004                  * in the real kernel if we clear the Modify bit ourselves,
3005                  * otherwise the real kernel will not get a new fault and
3006                  * will never set our Modify bit again.
3007                  */
3008                 pte = pmap_pte(pv->pv_pmap, pv->pv_va);
3009                 if (*pte & bit) {
3010                         if (bit == VPTE_RW) {
3011                                 /*
3012                                  * We must also clear VPTE_M when clearing
3013                                  * VPTE_RW and synchronize its state to
3014                                  * the page.
3015                                  */
3016                                 pmap_track_modified(pv->pv_pmap, pv->pv_va);
3017                                 pbits = pmap_clean_pte(pte, pv->pv_pmap,
3018                                                        pv->pv_va, m);
3019                         } else if (bit == VPTE_M) {
3020                                 /*
3021                                  * We must invalidate the real-kernel pte
3022                                  * when clearing VPTE_M bit to force the
3023                                  * real-kernel to take a new fault to re-set
3024                                  * VPTE_M.
3025                                  */
3026                                 atomic_clear_long(pte, VPTE_M);
3027                                 if (*pte & VPTE_RW) {
3028                                         pmap_invalidate_range(pv->pv_pmap,
3029                                                       pv->pv_va,
3030                                                       pv->pv_va + PAGE_SIZE);
3031                                 }
3032                         } else if ((bit & (VPTE_RW|VPTE_M)) ==
3033                                    (VPTE_RW|VPTE_M)) {
3034                                 /*
3035                                  * We've been asked to clear W & M, I guess
3036                                  * the caller doesn't want us to update
3037                                  * the dirty status of the VM page.
3038                                  */
3039                                 pmap_track_modified(pv->pv_pmap, pv->pv_va);
3040                                 pmap_clean_pte(pte, pv->pv_pmap, pv->pv_va, m);
3041                                 panic("shouldn't be called");
3042                         } else {
3043                                 /*
3044                                  * We've been asked to clear bits that do
3045                                  * not interact with hardware.
3046                                  */
3047                                 atomic_clear_long(pte, bit);
3048                         }
3049                 }
3050                 vm_object_drop(pmobj);
3051         }
3052         if (bit == VPTE_RW)
3053                 vm_page_flag_clear(m, PG_WRITEABLE);
3054         vm_page_spin_unlock(m);
3055 }
3056
3057 /*
3058  * Lower the permission for all mappings to a given page.
3059  *
3060  * No other requirements.
3061  */
3062 void
3063 pmap_page_protect(vm_page_t m, vm_prot_t prot)
3064 {
3065         if ((prot & VM_PROT_WRITE) == 0) {
3066                 if (prot & (VM_PROT_READ | VM_PROT_EXECUTE)) {
3067                         pmap_clearbit(m, VPTE_RW);
3068                 } else {
3069                         pmap_remove_all(m);
3070                 }
3071         }
3072 }
3073
3074 vm_paddr_t
3075 pmap_phys_address(vm_pindex_t ppn)
3076 {
3077         return (x86_64_ptob(ppn));
3078 }
3079
3080 /*
3081  * Return a count of reference bits for a page, clearing those bits.
3082  * It is not necessary for every reference bit to be cleared, but it
3083  * is necessary that 0 only be returned when there are truly no
3084  * reference bits set.
3085  *
3086  * XXX: The exact number of bits to check and clear is a matter that
3087  * should be tested and standardized at some point in the future for
3088  * optimal aging of shared pages.
3089  *
3090  * No other requirements.
3091  */
3092 int
3093 pmap_ts_referenced(vm_page_t m)
3094 {
3095         pv_entry_t pv, pvf, pvn;
3096         pt_entry_t *pte;
3097         int rtval = 0;
3098
3099         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
3100                 return (rtval);
3101
3102         vm_page_spin_lock(m);
3103         if ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
3104                 pvf = pv;
3105                 do {
3106                         pvn = TAILQ_NEXT(pv, pv_list);
3107                         TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
3108                         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_list);
3109
3110                         pmap_track_modified(pv->pv_pmap, pv->pv_va);
3111                         pte = pmap_pte(pv->pv_pmap, pv->pv_va);
3112
3113                         if (pte && (*pte & VPTE_A)) {
3114                                 atomic_clear_long(pte, VPTE_A);
3115                                 rtval++;
3116                                 if (rtval > 4) {
3117                                         break;
3118                                 }
3119                         }
3120                 } while ((pv = pvn) != NULL && pv != pvf);
3121         }
3122         vm_page_spin_unlock(m);
3123
3124         return (rtval);
3125 }
3126
3127 /*
3128  * Return whether or not the specified physical page was modified
3129  * in any physical maps.
3130  *
3131  * No other requirements.
3132  */
3133 boolean_t
3134 pmap_is_modified(vm_page_t m)
3135 {
3136         boolean_t res;
3137
3138         res = pmap_testbit(m, VPTE_M);
3139
3140         return (res);
3141 }
3142
3143 /*
3144  * Clear the modify bits on the specified physical page.  For the vkernel
3145  * we really need to clean the page, which clears VPTE_RW and VPTE_M, in
3146  * order to ensure that we take a fault on the next write to the page.
3147  * Otherwise the page may become dirty without us knowing it.
3148  *
3149  * No other requirements.
3150  */
3151 void
3152 pmap_clear_modify(vm_page_t m)
3153 {
3154         pmap_clearbit(m, VPTE_RW);
3155 }
3156
3157 /*
3158  * Clear the reference bit on the specified physical page.
3159  *
3160  * No other requirements.
3161  */
3162 void
3163 pmap_clear_reference(vm_page_t m)
3164 {
3165         pmap_clearbit(m, VPTE_A);
3166 }
3167
3168 /*
3169  * Miscellaneous support routines follow
3170  */
3171 static void
3172 x86_64_protection_init(void)
3173 {
3174         uint64_t *kp;
3175         int prot;
3176
3177         kp = protection_codes;
3178         for (prot = 0; prot < 8; prot++) {
3179                 if (prot & VM_PROT_READ)
3180                         *kp |= 0;                       /* R */
3181                 if (prot & VM_PROT_WRITE)
3182                         *kp |= VPTE_RW;                 /* R+W */
3183                 if (prot && (prot & VM_PROT_EXECUTE) == 0)
3184                         *kp |= VPTE_NX;                 /* NX - !executable */
3185                 ++kp;
3186         }
3187 }
3188
3189 /*
3190  * Sets the memory attribute for the specified page.
3191  */
3192 void
3193 pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
3194 {
3195         /* This is a vkernel, do nothing */
3196 }
3197
3198 /*
3199  * Change the PAT attribute on an existing kernel memory map.  Caller
3200  * must ensure that the virtual memory in question is not accessed
3201  * during the adjustment.
3202  */
3203 void
3204 pmap_change_attr(vm_offset_t va, vm_size_t count, int mode)
3205 {
3206         /* This is a vkernel, do nothing */
3207 }
3208
3209 /*
3210  * Perform the pmap work for mincore
3211  *
3212  * No other requirements.
3213  */
3214 int
3215 pmap_mincore(pmap_t pmap, vm_offset_t addr)
3216 {
3217         pt_entry_t *ptep, pte;
3218         vm_page_t m;
3219         int val = 0;
3220
3221         vm_object_hold(pmap->pm_pteobj);
3222         ptep = pmap_pte(pmap, addr);
3223
3224         if (ptep && (pte = *ptep) != 0) {
3225                 vm_paddr_t pa;
3226
3227                 val = MINCORE_INCORE;
3228                 if ((pte & VPTE_MANAGED) == 0)
3229                         goto done;
3230
3231                 pa = pte & VPTE_FRAME;
3232
3233                 m = PHYS_TO_VM_PAGE(pa);
3234
3235                 /*
3236                  * Modified by us
3237                  */
3238                 if (pte & VPTE_M)
3239                         val |= MINCORE_MODIFIED|MINCORE_MODIFIED_OTHER;
3240                 /*
3241                  * Modified by someone
3242                  */
3243                 else if (m->dirty || pmap_is_modified(m))
3244                         val |= MINCORE_MODIFIED_OTHER;
3245                 /*
3246                  * Referenced by us
3247                  */
3248                 if (pte & VPTE_A)
3249                         val |= MINCORE_REFERENCED|MINCORE_REFERENCED_OTHER;
3250
3251                 /*
3252                  * Referenced by someone
3253                  */
3254                 else if ((m->flags & PG_REFERENCED) || pmap_ts_referenced(m)) {
3255                         val |= MINCORE_REFERENCED_OTHER;
3256                         vm_page_flag_set(m, PG_REFERENCED);
3257                 }
3258         }
3259 done:
3260         vm_object_drop(pmap->pm_pteobj);
3261
3262         return val;
3263 }
3264
3265 /*
3266  * Replace p->p_vmspace with a new one.  If adjrefs is non-zero the new
3267  * vmspace will be ref'd and the old one will be deref'd.
3268  *
3269  * Caller must hold vmspace->vm_map.token for oldvm and newvm
3270  */
3271 void
3272 pmap_replacevm(struct proc *p, struct vmspace *newvm, int adjrefs)
3273 {
3274         struct vmspace *oldvm;
3275         struct lwp *lp;
3276
3277         oldvm = p->p_vmspace;
3278         if (oldvm != newvm) {
3279                 if (adjrefs)
3280                         vmspace_ref(newvm);
3281                 KKASSERT((newvm->vm_refcnt & VM_REF_DELETED) == 0);
3282                 p->p_vmspace = newvm;
3283                 KKASSERT(p->p_nthreads == 1);
3284                 lp = RB_ROOT(&p->p_lwp_tree);
3285                 pmap_setlwpvm(lp, newvm);
3286                 if (adjrefs)
3287                         vmspace_rel(oldvm);
3288         }
3289 }
3290
3291 /*
3292  * Set the vmspace for a LWP.  The vmspace is almost universally set the
3293  * same as the process vmspace, but virtual kernels need to swap out contexts
3294  * on a per-lwp basis.
3295  */
3296 void
3297 pmap_setlwpvm(struct lwp *lp, struct vmspace *newvm)
3298 {
3299         struct vmspace *oldvm;
3300         struct pmap *pmap;
3301
3302         oldvm = lp->lwp_vmspace;
3303         if (oldvm != newvm) {
3304                 crit_enter();
3305                 KKASSERT((newvm->vm_refcnt & VM_REF_DELETED) == 0);
3306                 lp->lwp_vmspace = newvm;
3307                 if (curthread->td_lwp == lp) {
3308                         pmap = vmspace_pmap(newvm);
3309                         ATOMIC_CPUMASK_ORBIT(pmap->pm_active, mycpu->gd_cpuid);
3310                         if (pmap->pm_active_lock & CPULOCK_EXCL)
3311                                 pmap_interlock_wait(newvm);
3312 #if defined(SWTCH_OPTIM_STATS)
3313                         tlb_flush_count++;
3314 #endif
3315                         pmap = vmspace_pmap(oldvm);
3316                         ATOMIC_CPUMASK_NANDBIT(pmap->pm_active,
3317                                                mycpu->gd_cpuid);
3318                 }
3319                 crit_exit();
3320         }
3321 }
3322
3323 /*
3324  * The swtch code tried to switch in a heavy weight process whos pmap
3325  * is locked by another cpu.  We have to wait for the lock to clear before
3326  * the pmap can be used.
3327  */
3328 void
3329 pmap_interlock_wait (struct vmspace *vm)
3330 {
3331         pmap_t pmap = vmspace_pmap(vm);
3332
3333         if (pmap->pm_active_lock & CPULOCK_EXCL) {
3334                 crit_enter();
3335                 while (pmap->pm_active_lock & CPULOCK_EXCL) {
3336                         cpu_ccfence();
3337                         pthread_yield();
3338                 }
3339                 crit_exit();
3340         }
3341 }
3342
3343 vm_offset_t
3344 pmap_addr_hint(vm_object_t obj, vm_offset_t addr, vm_size_t size)
3345 {
3346
3347         if ((obj == NULL) || (size < NBPDR) || (obj->type != OBJT_DEVICE)) {
3348                 return addr;
3349         }
3350
3351         addr = roundup2(addr, NBPDR);
3352         return addr;
3353 }
3354
3355 /*
3356  * Used by kmalloc/kfree, page already exists at va
3357  */
3358 vm_page_t
3359 pmap_kvtom(vm_offset_t va)
3360 {
3361         vpte_t *ptep;
3362
3363         KKASSERT(va >= KvaStart && va < KvaEnd);
3364         ptep = vtopte(va);
3365         return(PHYS_TO_VM_PAGE(*ptep & PG_FRAME));
3366 }
3367
3368 void
3369 pmap_object_init(vm_object_t object)
3370 {
3371         /* empty */
3372 }
3373
3374 void
3375 pmap_object_free(vm_object_t object)
3376 {
3377         /* empty */
3378 }
3379
3380 void
3381 pmap_pgscan(struct pmap_pgscan_info *pginfo)
3382 {
3383         pmap_t pmap = pginfo->pmap;
3384         vm_offset_t sva = pginfo->beg_addr;
3385         vm_offset_t eva = pginfo->end_addr;
3386         vm_offset_t va_next;
3387         pml4_entry_t *pml4e;
3388         pdp_entry_t *pdpe;
3389         pd_entry_t ptpaddr, *pde;
3390         pt_entry_t *pte;
3391         vm_page_t pt_m;
3392         int stop = 0;
3393
3394         vm_object_hold(pmap->pm_pteobj);
3395
3396         for (; sva < eva; sva = va_next) {
3397                 if (stop)
3398                         break;
3399
3400                 pml4e = pmap_pml4e(pmap, sva);
3401                 if ((*pml4e & VPTE_V) == 0) {
3402                         va_next = (sva + NBPML4) & ~PML4MASK;
3403                         if (va_next < sva)
3404                                 va_next = eva;
3405                         continue;
3406                 }
3407
3408                 pdpe = pmap_pml4e_to_pdpe(pml4e, sva);
3409                 if ((*pdpe & VPTE_V) == 0) {
3410                         va_next = (sva + NBPDP) & ~PDPMASK;
3411                         if (va_next < sva)
3412                                 va_next = eva;
3413                         continue;
3414                 }
3415
3416                 va_next = (sva + NBPDR) & ~PDRMASK;
3417                 if (va_next < sva)
3418                         va_next = eva;
3419
3420                 pde = pmap_pdpe_to_pde(pdpe, sva);
3421                 ptpaddr = *pde;
3422
3423 #if 0
3424                 /*
3425                  * Check for large page (ignore).
3426                  */
3427                 if ((ptpaddr & VPTE_PS) != 0) {
3428 #if 0
3429                         pmap_clean_pde(pde, pmap, sva);
3430                         pmap->pm_stats.resident_count -= NBPDR / PAGE_SIZE;
3431 #endif
3432                         continue;
3433                 }
3434 #endif
3435
3436                 /*
3437                  * Weed out invalid mappings. Note: we assume that the page
3438                  * directory table is always allocated, and in kernel virtual.
3439                  */
3440                 if (ptpaddr == 0)
3441                         continue;
3442
3443                 if (va_next > eva)
3444                         va_next = eva;
3445
3446                 pt_m = pmap_hold_pt_page(pde, sva);
3447                 for (pte = pmap_pde_to_pte(pde, sva); sva != va_next; pte++,
3448                     sva += PAGE_SIZE) {
3449                         vm_page_t m;
3450
3451                         if (stop)
3452                                 break;
3453                         if ((*pte & VPTE_MANAGED) == 0)
3454                                 continue;
3455
3456                         m = PHYS_TO_VM_PAGE(*pte & VPTE_FRAME);
3457                         if (vm_page_busy_try(m, TRUE) == 0) {
3458                                 if (pginfo->callback(pginfo, sva, m) < 0)
3459                                         stop = 1;
3460                         }
3461                 }
3462                 vm_page_unhold(pt_m);
3463         }
3464         vm_object_drop(pmap->pm_pteobj);
3465 }
3466
3467 void
3468 pmap_maybethreaded(pmap_t pmap)
3469 {
3470         /* nop */
3471 }
3472
3473 /*
3474  * Called while page is hard-busied to clear the PG_MAPPED and PG_WRITEABLE
3475  * flags if able.
3476  *
3477  * vkernel code is using the old pmap style so the flags should already
3478  * be properly set.
3479  */
3480 int
3481 pmap_mapped_sync(vm_page_t m)
3482 {
3483         return (m->flags);
3484 }