sys/platform/vkernel64/platform/pmap.c

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