sys/platform/pc64/x86_64/pmap.c

   1 /*
   2  * Copyright (c) 1991 Regents of the University of California.
   3  * Copyright (c) 1994 John S. Dyson
   4  * Copyright (c) 1994 David Greenman
   5  * Copyright (c) 2003 Peter Wemm
   6  * Copyright (c) 2005-2008 Alan L. Cox <alc@cs.rice.edu>
   7  * Copyright (c) 2008, 2009 The DragonFly Project.
   8  * Copyright (c) 2008, 2009 Jordan Gordeev.
   9  * Copyright (c) 2011-2012 Matthew Dillon
  10  * All rights reserved.
  11  *
  12  * This code is derived from software contributed to Berkeley by
  13  * the Systems Programming Group of the University of Utah Computer
  14  * Science Department and William Jolitz of UUNET Technologies Inc.
  15  *
  16  * Redistribution and use in source and binary forms, with or without
  17  * modification, are permitted provided that the following conditions
  18  * are met:
  19  * 1. Redistributions of source code must retain the above copyright
  20  *    notice, this list of conditions and the following disclaimer.
  21  * 2. Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in the
  23  *    documentation and/or other materials provided with the distribution.
  24  * 3. All advertising materials mentioning features or use of this software
  25  *    must display the following acknowledgement:
  26  *      This product includes software developed by the University of
  27  *      California, Berkeley and its contributors.
  28  * 4. Neither the name of the University nor the names of its contributors
  29  *    may be used to endorse or promote products derived from this software
  30  *    without specific prior written permission.
  31  *
  32  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  33  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  34  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  35  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  36  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  40  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  41  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  42  * SUCH DAMAGE.
  43  */
  44 /*
  45  * Manage physical address maps for x86-64 systems.
  46  */
  47
  48 #if JG
  49 #include "opt_disable_pse.h"
  50 #include "opt_pmap.h"
  51 #endif
  52 #include "opt_msgbuf.h"
  53
  54 #include <sys/param.h>
  55 #include <sys/systm.h>
  56 #include <sys/kernel.h>
  57 #include <sys/proc.h>
  58 #include <sys/msgbuf.h>
  59 #include <sys/vmmeter.h>
  60 #include <sys/mman.h>
  61
  62 #include <vm/vm.h>
  63 #include <vm/vm_param.h>
  64 #include <sys/sysctl.h>
  65 #include <sys/lock.h>
  66 #include <vm/vm_kern.h>
  67 #include <vm/vm_page.h>
  68 #include <vm/vm_map.h>
  69 #include <vm/vm_object.h>
  70 #include <vm/vm_extern.h>
  71 #include <vm/vm_pageout.h>
  72 #include <vm/vm_pager.h>
  73 #include <vm/vm_zone.h>
  74
  75 #include <sys/user.h>
  76 #include <sys/thread2.h>
  77 #include <sys/sysref2.h>
  78 #include <sys/spinlock2.h>
  79 #include <vm/vm_page2.h>
  80
  81 #include <machine/cputypes.h>
  82 #include <machine/md_var.h>
  83 #include <machine/specialreg.h>
  84 #include <machine/smp.h>
  85 #include <machine_base/apic/apicreg.h>
  86 #include <machine/globaldata.h>
  87 #include <machine/pmap.h>
  88 #include <machine/pmap_inval.h>
  89 #include <machine/inttypes.h>
  90
  91 #include <ddb/ddb.h>
  92
  93 #define PMAP_KEEP_PDIRS
  94 #ifndef PMAP_SHPGPERPROC
  95 #define PMAP_SHPGPERPROC 2000
  96 #endif
  97
  98 #if defined(DIAGNOSTIC)
  99 #define PMAP_DIAGNOSTIC
 100 #endif
 101
 102 #define MINPV 2048
 103
 104 /*
 105  * pmap debugging will report who owns a pv lock when blocking.
 106  */
 107 #ifdef PMAP_DEBUG
 108
 109 #define PMAP_DEBUG_DECL         ,const char *func, int lineno
 110 #define PMAP_DEBUG_ARGS         , __func__, __LINE__
 111 #define PMAP_DEBUG_COPY         , func, lineno
 112
 113 #define pv_get(pmap, pindex)            _pv_get(pmap, pindex            \
 114                                                         PMAP_DEBUG_ARGS)
 115 #define pv_lock(pv)                     _pv_lock(pv                     \
 116                                                         PMAP_DEBUG_ARGS)
 117 #define pv_hold_try(pv)                 _pv_hold_try(pv                 \
 118                                                         PMAP_DEBUG_ARGS)
 119 #define pv_alloc(pmap, pindex, isnewp)  _pv_alloc(pmap, pindex, isnewp  \
 120                                                         PMAP_DEBUG_ARGS)
 121
 122 #else
 123
 124 #define PMAP_DEBUG_DECL
 125 #define PMAP_DEBUG_ARGS
 126 #define PMAP_DEBUG_COPY
 127
 128 #define pv_get(pmap, pindex)            _pv_get(pmap, pindex)
 129 #define pv_lock(pv)                     _pv_lock(pv)
 130 #define pv_hold_try(pv)                 _pv_hold_try(pv)
 131 #define pv_alloc(pmap, pindex, isnewp)  _pv_alloc(pmap, pindex, isnewp)
 132
 133 #endif
 134
 135 /*
 136  * Get PDEs and PTEs for user/kernel address space
 137  */
 138 #define pdir_pde(m, v) (m[(vm_offset_t)(v) >> PDRSHIFT])
 139
 140 #define pmap_pde_v(pte)         ((*(pd_entry_t *)pte & PG_V) != 0)
 141 #define pmap_pte_w(pte)         ((*(pt_entry_t *)pte & PG_W) != 0)
 142 #define pmap_pte_m(pte)         ((*(pt_entry_t *)pte & PG_M) != 0)
 143 #define pmap_pte_u(pte)         ((*(pt_entry_t *)pte & PG_A) != 0)
 144 #define pmap_pte_v(pte)         ((*(pt_entry_t *)pte & PG_V) != 0)
 145
 146 /*
 147  * Given a map and a machine independent protection code,
 148  * convert to a vax protection code.
 149  */
 150 #define pte_prot(m, p)          \
 151         (protection_codes[p & (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE)])
 152 static int protection_codes[8];
 153
 154 struct pmap kernel_pmap;
 155 static TAILQ_HEAD(,pmap)        pmap_list = TAILQ_HEAD_INITIALIZER(pmap_list);
 156
 157 MALLOC_DEFINE(M_OBJPMAP, "objpmap", "pmaps associated with VM objects");
 158
 159 vm_paddr_t avail_start;         /* PA of first available physical page */
 160 vm_paddr_t avail_end;           /* PA of last available physical page */
 161 vm_offset_t virtual2_start;     /* cutout free area prior to kernel start */
 162 vm_offset_t virtual2_end;
 163 vm_offset_t virtual_start;      /* VA of first avail page (after kernel bss) */
 164 vm_offset_t virtual_end;        /* VA of last avail page (end of kernel AS) */
 165 vm_offset_t KvaStart;           /* VA start of KVA space */
 166 vm_offset_t KvaEnd;             /* VA end of KVA space (non-inclusive) */
 167 vm_offset_t KvaSize;            /* max size of kernel virtual address space */
 168 static boolean_t pmap_initialized = FALSE;      /* Has pmap_init completed? */
 169 static int pgeflag;             /* PG_G or-in */
 170 static int pseflag;             /* PG_PS or-in */
 171
 172 static int ndmpdp;
 173 static vm_paddr_t dmaplimit;
 174 static int nkpt;
 175 vm_offset_t kernel_vm_end = VM_MIN_KERNEL_ADDRESS;
 176
 177 static uint64_t KPTbase;
 178 static uint64_t KPTphys;
 179 static uint64_t KPDphys;        /* phys addr of kernel level 2 */
 180 static uint64_t KPDbase;        /* phys addr of kernel level 2 @ KERNBASE */
 181 uint64_t KPDPphys;      /* phys addr of kernel level 3 */
 182 uint64_t KPML4phys;     /* phys addr of kernel level 4 */
 183
 184 static uint64_t DMPDphys;       /* phys addr of direct mapped level 2 */
 185 static uint64_t DMPDPphys;      /* phys addr of direct mapped level 3 */
 186
 187 /*
 188  * Data for the pv entry allocation mechanism
 189  */
 190 static vm_zone_t pvzone;
 191 static struct vm_zone pvzone_store;
 192 static struct vm_object pvzone_obj;
 193 static int pv_entry_max=0, pv_entry_high_water=0;
 194 static int pmap_pagedaemon_waken = 0;
 195 static struct pv_entry *pvinit;
 196
 197 /*
 198  * All those kernel PT submaps that BSD is so fond of
 199  */
 200 pt_entry_t *CMAP1 = NULL, *ptmmap;
 201 caddr_t CADDR1 = NULL, ptvmmap = NULL;
 202 static pt_entry_t *msgbufmap;
 203 struct msgbuf *msgbufp=NULL;
 204
 205 /*
 206  * Crashdump maps.
 207  */
 208 static pt_entry_t *pt_crashdumpmap;
 209 static caddr_t crashdumpmap;
 210
 211 static int pmap_yield_count = 64;
 212 SYSCTL_INT(_machdep, OID_AUTO, pmap_yield_count, CTLFLAG_RW,
 213     &pmap_yield_count, 0, "Yield during init_pt/release");
 214 static int pmap_mmu_optimize = 0;
 215 SYSCTL_INT(_machdep, OID_AUTO, pmap_mmu_optimize, CTLFLAG_RW,
 216     &pmap_mmu_optimize, 0, "Share page table pages when possible");
 217
 218 #define DISABLE_PSE
 219
 220 static void pv_hold(pv_entry_t pv);
 221 static int _pv_hold_try(pv_entry_t pv
 222                                 PMAP_DEBUG_DECL);
 223 static void pv_drop(pv_entry_t pv);
 224 static void _pv_lock(pv_entry_t pv
 225                                 PMAP_DEBUG_DECL);
 226 static void pv_unlock(pv_entry_t pv);
 227 static pv_entry_t _pv_alloc(pmap_t pmap, vm_pindex_t pindex, int *isnew
 228                                 PMAP_DEBUG_DECL);
 229 static pv_entry_t _pv_get(pmap_t pmap, vm_pindex_t pindex
 230                                 PMAP_DEBUG_DECL);
 231 static pv_entry_t pv_get_try(pmap_t pmap, vm_pindex_t pindex, int *errorp);
 232 static pv_entry_t pv_find(pmap_t pmap, vm_pindex_t pindex);
 233 static void pv_put(pv_entry_t pv);
 234 static void pv_free(pv_entry_t pv);
 235 static void *pv_pte_lookup(pv_entry_t pv, vm_pindex_t pindex);
 236 static pv_entry_t pmap_allocpte(pmap_t pmap, vm_pindex_t ptepindex,
 237                       pv_entry_t *pvpp);
 238 static pv_entry_t pmap_allocpte_seg(pmap_t pmap, vm_pindex_t ptepindex,
 239                       pv_entry_t *pvpp, vm_map_entry_t entry, vm_offset_t va);
 240 static void pmap_remove_pv_pte(pv_entry_t pv, pv_entry_t pvp,
 241                       struct pmap_inval_info *info);
 242 static vm_page_t pmap_remove_pv_page(pv_entry_t pv);
 243 static int pmap_release_pv(pv_entry_t pv);
 244
 245 static void pmap_remove_callback(pmap_t pmap, struct pmap_inval_info *info,
 246                       pv_entry_t pte_pv, pv_entry_t pt_pv, int sharept,
 247                       vm_offset_t va, pt_entry_t *ptep, void *arg __unused);
 248 static void pmap_protect_callback(pmap_t pmap, struct pmap_inval_info *info,
 249                       pv_entry_t pte_pv, pv_entry_t pt_pv, int sharept,
 250                       vm_offset_t va, pt_entry_t *ptep, void *arg __unused);
 251
 252 static void i386_protection_init (void);
 253 static void create_pagetables(vm_paddr_t *firstaddr);
 254 static void pmap_remove_all (vm_page_t m);
 255 static boolean_t pmap_testbit (vm_page_t m, int bit);
 256
 257 static pt_entry_t * pmap_pte_quick (pmap_t pmap, vm_offset_t va);
 258 static vm_offset_t pmap_kmem_choose(vm_offset_t addr);
 259
 260 static unsigned pdir4mb;
 261
 262 static int
 263 pv_entry_compare(pv_entry_t pv1, pv_entry_t pv2)
 264 {
 265         if (pv1->pv_pindex < pv2->pv_pindex)
 266                 return(-1);
 267         if (pv1->pv_pindex > pv2->pv_pindex)
 268                 return(1);
 269         return(0);
 270 }
 271
 272 RB_GENERATE2(pv_entry_rb_tree, pv_entry, pv_entry,
 273              pv_entry_compare, vm_pindex_t, pv_pindex);
 274
 275 /*
 276  * Move the kernel virtual free pointer to the next
 277  * 2MB.  This is used to help improve performance
 278  * by using a large (2MB) page for much of the kernel
 279  * (.text, .data, .bss)
 280  */
 281 static
 282 vm_offset_t
 283 pmap_kmem_choose(vm_offset_t addr)
 284 {
 285         vm_offset_t newaddr = addr;
 286
 287         newaddr = (addr + (NBPDR - 1)) & ~(NBPDR - 1);
 288         return newaddr;
 289 }
 290
 291 /*
 292  * pmap_pte_quick:
 293  *
 294  *      Super fast pmap_pte routine best used when scanning the pv lists.
 295  *      This eliminates many course-grained invltlb calls.  Note that many of
 296  *      the pv list scans are across different pmaps and it is very wasteful
 297  *      to do an entire invltlb when checking a single mapping.
 298  */
 299 static __inline pt_entry_t *pmap_pte(pmap_t pmap, vm_offset_t va);
 300
 301 static
 302 pt_entry_t *
 303 pmap_pte_quick(pmap_t pmap, vm_offset_t va)
 304 {
 305         return pmap_pte(pmap, va);
 306 }
 307
 308 /*
 309  * Returns the pindex of a page table entry (representing a terminal page).
 310  * There are NUPTE_TOTAL page table entries possible (a huge number)
 311  *
 312  * x86-64 has a 48-bit address space, where bit 47 is sign-extended out.
 313  * We want to properly translate negative KVAs.
 314  */
 315 static __inline
 316 vm_pindex_t
 317 pmap_pte_pindex(vm_offset_t va)
 318 {
 319         return ((va >> PAGE_SHIFT) & (NUPTE_TOTAL - 1));
 320 }
 321
 322 /*
 323  * Returns the pindex of a page table.
 324  */
 325 static __inline
 326 vm_pindex_t
 327 pmap_pt_pindex(vm_offset_t va)
 328 {
 329         return (NUPTE_TOTAL + ((va >> PDRSHIFT) & (NUPT_TOTAL - 1)));
 330 }
 331
 332 /*
 333  * Returns the pindex of a page directory.
 334  */
 335 static __inline
 336 vm_pindex_t
 337 pmap_pd_pindex(vm_offset_t va)
 338 {
 339         return (NUPTE_TOTAL + NUPT_TOTAL +
 340                 ((va >> PDPSHIFT) & (NUPD_TOTAL - 1)));
 341 }
 342
 343 static __inline
 344 vm_pindex_t
 345 pmap_pdp_pindex(vm_offset_t va)
 346 {
 347         return (NUPTE_TOTAL + NUPT_TOTAL + NUPD_TOTAL +
 348                 ((va >> PML4SHIFT) & (NUPDP_TOTAL - 1)));
 349 }
 350
 351 static __inline
 352 vm_pindex_t
 353 pmap_pml4_pindex(void)
 354 {
 355         return (NUPTE_TOTAL + NUPT_TOTAL + NUPD_TOTAL + NUPDP_TOTAL);
 356 }
 357
 358 /*
 359  * Return various clipped indexes for a given VA
 360  *
 361  * Returns the index of a pte in a page table, representing a terminal
 362  * page.
 363  */
 364 static __inline
 365 vm_pindex_t
 366 pmap_pte_index(vm_offset_t va)
 367 {
 368         return ((va >> PAGE_SHIFT) & ((1ul << NPTEPGSHIFT) - 1));
 369 }
 370
 371 /*
 372  * Returns the index of a pt in a page directory, representing a page
 373  * table.
 374  */
 375 static __inline
 376 vm_pindex_t
 377 pmap_pt_index(vm_offset_t va)
 378 {
 379         return ((va >> PDRSHIFT) & ((1ul << NPDEPGSHIFT) - 1));
 380 }
 381
 382 /*
 383  * Returns the index of a pd in a page directory page, representing a page
 384  * directory.
 385  */
 386 static __inline
 387 vm_pindex_t
 388 pmap_pd_index(vm_offset_t va)
 389 {
 390         return ((va >> PDPSHIFT) & ((1ul << NPDPEPGSHIFT) - 1));
 391 }
 392
 393 /*
 394  * Returns the index of a pdp in the pml4 table, representing a page
 395  * directory page.
 396  */
 397 static __inline
 398 vm_pindex_t
 399 pmap_pdp_index(vm_offset_t va)
 400 {
 401         return ((va >> PML4SHIFT) & ((1ul << NPML4EPGSHIFT) - 1));
 402 }
 403
 404 /*
 405  * Generic procedure to index a pte from a pt, pd, or pdp.
 406  *
 407  * NOTE: Normally passed pindex as pmap_xx_index().  pmap_xx_pindex() is NOT
 408  *       a page table page index but is instead of PV lookup index.
 409  */
 410 static
 411 void *
 412 pv_pte_lookup(pv_entry_t pv, vm_pindex_t pindex)
 413 {
 414         pt_entry_t *pte;
 415
 416         pte = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pv->pv_m));
 417         return(&pte[pindex]);
 418 }
 419
 420 /*
 421  * Return pointer to PDP slot in the PML4
 422  */
 423 static __inline
 424 pml4_entry_t *
 425 pmap_pdp(pmap_t pmap, vm_offset_t va)
 426 {
 427         return (&pmap->pm_pml4[pmap_pdp_index(va)]);
 428 }
 429
 430 /*
 431  * Return pointer to PD slot in the PDP given a pointer to the PDP
 432  */
 433 static __inline
 434 pdp_entry_t *
 435 pmap_pdp_to_pd(pml4_entry_t pdp_pte, vm_offset_t va)
 436 {
 437         pdp_entry_t *pd;
 438
 439         pd = (pdp_entry_t *)PHYS_TO_DMAP(pdp_pte & PG_FRAME);
 440         return (&pd[pmap_pd_index(va)]);
 441 }
 442
 443 /*
 444  * Return pointer to PD slot in the PDP.
 445  */
 446 static __inline
 447 pdp_entry_t *
 448 pmap_pd(pmap_t pmap, vm_offset_t va)
 449 {
 450         pml4_entry_t *pdp;
 451
 452         pdp = pmap_pdp(pmap, va);
 453         if ((*pdp & PG_V) == 0)
 454                 return NULL;
 455         return (pmap_pdp_to_pd(*pdp, va));
 456 }
 457
 458 /*
 459  * Return pointer to PT slot in the PD given a pointer to the PD
 460  */
 461 static __inline
 462 pd_entry_t *
 463 pmap_pd_to_pt(pdp_entry_t pd_pte, vm_offset_t va)
 464 {
 465         pd_entry_t *pt;
 466
 467         pt = (pd_entry_t *)PHYS_TO_DMAP(pd_pte & PG_FRAME);
 468         return (&pt[pmap_pt_index(va)]);
 469 }
 470
 471 /*
 472  * Return pointer to PT slot in the PD
 473  *
 474  * SIMPLE PMAP NOTE: Simple pmaps (embedded in objects) do not have PDPs,
 475  *                   so we cannot lookup the PD via the PDP.  Instead we
 476  *                   must look it up via the pmap.
 477  */
 478 static __inline
 479 pd_entry_t *
 480 pmap_pt(pmap_t pmap, vm_offset_t va)
 481 {
 482         pdp_entry_t *pd;
 483         pv_entry_t pv;
 484         vm_pindex_t pd_pindex;
 485
 486         if (pmap->pm_flags & PMAP_FLAG_SIMPLE) {
 487                 pd_pindex = pmap_pd_pindex(va);
 488                 spin_lock(&pmap->pm_spin);
 489                 pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot, pd_pindex);
 490                 spin_unlock(&pmap->pm_spin);
 491                 if (pv == NULL || pv->pv_m == NULL)
 492                         return NULL;
 493                 return (pmap_pd_to_pt(VM_PAGE_TO_PHYS(pv->pv_m), va));
 494         } else {
 495                 pd = pmap_pd(pmap, va);
 496                 if (pd == NULL || (*pd & PG_V) == 0)
 497                          return NULL;
 498                 return (pmap_pd_to_pt(*pd, va));
 499         }
 500 }
 501
 502 /*
 503  * Return pointer to PTE slot in the PT given a pointer to the PT
 504  */
 505 static __inline
 506 pt_entry_t *
 507 pmap_pt_to_pte(pd_entry_t pt_pte, vm_offset_t va)
 508 {
 509         pt_entry_t *pte;
 510
 511         pte = (pt_entry_t *)PHYS_TO_DMAP(pt_pte & PG_FRAME);
 512         return (&pte[pmap_pte_index(va)]);
 513 }
 514
 515 /*
 516  * Return pointer to PTE slot in the PT
 517  */
 518 static __inline
 519 pt_entry_t *
 520 pmap_pte(pmap_t pmap, vm_offset_t va)
 521 {
 522         pd_entry_t *pt;
 523
 524         pt = pmap_pt(pmap, va);
 525         if (pt == NULL || (*pt & PG_V) == 0)
 526                  return NULL;
 527         if ((*pt & PG_PS) != 0)
 528                 return ((pt_entry_t *)pt);
 529         return (pmap_pt_to_pte(*pt, va));
 530 }
 531
 532 /*
 533  * Of all the layers (PTE, PT, PD, PDP, PML4) the best one to cache is
 534  * the PT layer.  This will speed up core pmap operations considerably.
 535  */
 536 static __inline
 537 void
 538 pv_cache(pv_entry_t pv, vm_pindex_t pindex)
 539 {
 540         if (pindex >= pmap_pt_pindex(0) && pindex <= pmap_pd_pindex(0))
 541                 pv->pv_pmap->pm_pvhint = pv;
 542 }
 543
 544
 545 /*
 546  * KVM - return address of PT slot in PD
 547  */
 548 static __inline
 549 pd_entry_t *
 550 vtopt(vm_offset_t va)
 551 {
 552         uint64_t mask = ((1ul << (NPDEPGSHIFT + NPDPEPGSHIFT +
 553                                   NPML4EPGSHIFT)) - 1);
 554
 555         return (PDmap + ((va >> PDRSHIFT) & mask));
 556 }
 557
 558 /*
 559  * KVM - return address of PTE slot in PT
 560  */
 561 static __inline
 562 pt_entry_t *
 563 vtopte(vm_offset_t va)
 564 {
 565         uint64_t mask = ((1ul << (NPTEPGSHIFT + NPDEPGSHIFT +
 566                                   NPDPEPGSHIFT + NPML4EPGSHIFT)) - 1);
 567
 568         return (PTmap + ((va >> PAGE_SHIFT) & mask));
 569 }
 570
 571 static uint64_t
 572 allocpages(vm_paddr_t *firstaddr, long n)
 573 {
 574         uint64_t ret;
 575
 576         ret = *firstaddr;
 577         bzero((void *)ret, n * PAGE_SIZE);
 578         *firstaddr += n * PAGE_SIZE;
 579         return (ret);
 580 }
 581
 582 static
 583 void
 584 create_pagetables(vm_paddr_t *firstaddr)
 585 {
 586         long i;         /* must be 64 bits */
 587         long nkpt_base;
 588         long nkpt_phys;
 589         int j;
 590
 591         /*
 592          * We are running (mostly) V=P at this point
 593          *
 594          * Calculate NKPT - number of kernel page tables.  We have to
 595          * accomodoate prealloction of the vm_page_array, dump bitmap,
 596          * MSGBUF_SIZE, and other stuff.  Be generous.
 597          *
 598          * Maxmem is in pages.
 599          *
 600          * ndmpdp is the number of 1GB pages we wish to map.
 601          */
 602         ndmpdp = (ptoa(Maxmem) + NBPDP - 1) >> PDPSHIFT;
 603         if (ndmpdp < 4)         /* Minimum 4GB of dirmap */
 604                 ndmpdp = 4;
 605         KKASSERT(ndmpdp <= NKPDPE * NPDEPG);
 606
 607         /*
 608          * Starting at the beginning of kvm (not KERNBASE).
 609          */
 610         nkpt_phys = (Maxmem * sizeof(struct vm_page) + NBPDR - 1) / NBPDR;
 611         nkpt_phys += (Maxmem * sizeof(struct pv_entry) + NBPDR - 1) / NBPDR;
 612         nkpt_phys += ((nkpt + nkpt + 1 + NKPML4E + NKPDPE + NDMPML4E +
 613                        ndmpdp) + 511) / 512;
 614         nkpt_phys += 128;
 615
 616         /*
 617          * Starting at KERNBASE - map 2G worth of page table pages.
 618          * KERNBASE is offset -2G from the end of kvm.
 619          */
 620         nkpt_base = (NPDPEPG - KPDPI) * NPTEPG; /* typically 2 x 512 */
 621
 622         /*
 623          * Allocate pages
 624          */
 625         KPTbase = allocpages(firstaddr, nkpt_base);
 626         KPTphys = allocpages(firstaddr, nkpt_phys);
 627         KPML4phys = allocpages(firstaddr, 1);
 628         KPDPphys = allocpages(firstaddr, NKPML4E);
 629         KPDphys = allocpages(firstaddr, NKPDPE);
 630
 631         /*
 632          * Calculate the page directory base for KERNBASE,
 633          * that is where we start populating the page table pages.
 634          * Basically this is the end - 2.
 635          */
 636         KPDbase = KPDphys + ((NKPDPE - (NPDPEPG - KPDPI)) << PAGE_SHIFT);
 637
 638         DMPDPphys = allocpages(firstaddr, NDMPML4E);
 639         if ((amd_feature & AMDID_PAGE1GB) == 0)
 640                 DMPDphys = allocpages(firstaddr, ndmpdp);
 641         dmaplimit = (vm_paddr_t)ndmpdp << PDPSHIFT;
 642
 643         /*
 644          * Fill in the underlying page table pages for the area around
 645          * KERNBASE.  This remaps low physical memory to KERNBASE.
 646          *
 647          * Read-only from zero to physfree
 648          * XXX not fully used, underneath 2M pages
 649          */
 650         for (i = 0; (i << PAGE_SHIFT) < *firstaddr; i++) {
 651                 ((pt_entry_t *)KPTbase)[i] = i << PAGE_SHIFT;
 652                 ((pt_entry_t *)KPTbase)[i] |= PG_RW | PG_V | PG_G;
 653         }
 654
 655         /*
 656          * Now map the initial kernel page tables.  One block of page
 657          * tables is placed at the beginning of kernel virtual memory,
 658          * and another block is placed at KERNBASE to map the kernel binary,
 659          * data, bss, and initial pre-allocations.
 660          */
 661         for (i = 0; i < nkpt_base; i++) {
 662                 ((pd_entry_t *)KPDbase)[i] = KPTbase + (i << PAGE_SHIFT);
 663                 ((pd_entry_t *)KPDbase)[i] |= PG_RW | PG_V;
 664         }
 665         for (i = 0; i < nkpt_phys; i++) {
 666                 ((pd_entry_t *)KPDphys)[i] = KPTphys + (i << PAGE_SHIFT);
 667                 ((pd_entry_t *)KPDphys)[i] |= PG_RW | PG_V;
 668         }
 669
 670         /*
 671          * Map from zero to end of allocations using 2M pages as an
 672          * optimization.  This will bypass some of the KPTBase pages
 673          * above in the KERNBASE area.
 674          */
 675         for (i = 0; (i << PDRSHIFT) < *firstaddr; i++) {
 676                 ((pd_entry_t *)KPDbase)[i] = i << PDRSHIFT;
 677                 ((pd_entry_t *)KPDbase)[i] |= PG_RW | PG_V | PG_PS | PG_G;
 678         }
 679
 680         /*
 681          * And connect up the PD to the PDP.  The kernel pmap is expected
 682          * to pre-populate all of its PDs.  See NKPDPE in vmparam.h.
 683          */
 684         for (i = 0; i < NKPDPE; i++) {
 685                 ((pdp_entry_t *)KPDPphys)[NPDPEPG - NKPDPE + i] =
 686                                 KPDphys + (i << PAGE_SHIFT);
 687                 ((pdp_entry_t *)KPDPphys)[NPDPEPG - NKPDPE + i] |=
 688                                 PG_RW | PG_V | PG_U;
 689         }
 690
 691         /*
 692          * Now set up the direct map space using either 2MB or 1GB pages
 693          * Preset PG_M and PG_A because demotion expects it.
 694          *
 695          * When filling in entries in the PD pages make sure any excess
 696          * entries are set to zero as we allocated enough PD pages
 697          */
 698         if ((amd_feature & AMDID_PAGE1GB) == 0) {
 699                 for (i = 0; i < NPDEPG * ndmpdp; i++) {
 700                         ((pd_entry_t *)DMPDphys)[i] = i << PDRSHIFT;
 701                         ((pd_entry_t *)DMPDphys)[i] |= PG_RW | PG_V | PG_PS |
 702                                                        PG_G | PG_M | PG_A;
 703                 }
 704
 705                 /*
 706                  * And the direct map space's PDP
 707                  */
 708                 for (i = 0; i < ndmpdp; i++) {
 709                         ((pdp_entry_t *)DMPDPphys)[i] = DMPDphys +
 710                                                         (i << PAGE_SHIFT);
 711                         ((pdp_entry_t *)DMPDPphys)[i] |= PG_RW | PG_V | PG_U;
 712                 }
 713         } else {
 714                 for (i = 0; i < ndmpdp; i++) {
 715                         ((pdp_entry_t *)DMPDPphys)[i] =
 716                                                 (vm_paddr_t)i << PDPSHIFT;
 717                         ((pdp_entry_t *)DMPDPphys)[i] |= PG_RW | PG_V | PG_PS |
 718                                                          PG_G | PG_M | PG_A;
 719                 }
 720         }
 721
 722         /* And recursively map PML4 to itself in order to get PTmap */
 723         ((pdp_entry_t *)KPML4phys)[PML4PML4I] = KPML4phys;
 724         ((pdp_entry_t *)KPML4phys)[PML4PML4I] |= PG_RW | PG_V | PG_U;
 725
 726         /*
 727          * Connect the Direct Map slots up to the PML4
 728          */
 729         for (j = 0; j < NDMPML4E; ++j) {
 730                 ((pdp_entry_t *)KPML4phys)[DMPML4I + j] =
 731                         (DMPDPphys + ((vm_paddr_t)j << PML4SHIFT)) |
 732                         PG_RW | PG_V | PG_U;
 733         }
 734
 735         /*
 736          * Connect the KVA slot up to the PML4
 737          */
 738         ((pdp_entry_t *)KPML4phys)[KPML4I] = KPDPphys;
 739         ((pdp_entry_t *)KPML4phys)[KPML4I] |= PG_RW | PG_V | PG_U;
 740 }
 741
 742 /*
 743  *      Bootstrap the system enough to run with virtual memory.
 744  *
 745  *      On the i386 this is called after mapping has already been enabled
 746  *      and just syncs the pmap module with what has already been done.
 747  *      [We can't call it easily with mapping off since the kernel is not
 748  *      mapped with PA == VA, hence we would have to relocate every address
 749  *      from the linked base (virtual) address "KERNBASE" to the actual
 750  *      (physical) address starting relative to 0]
 751  */
 752 void
 753 pmap_bootstrap(vm_paddr_t *firstaddr)
 754 {
 755         vm_offset_t va;
 756         pt_entry_t *pte;
 757         struct mdglobaldata *gd;
 758         int pg;
 759
 760         KvaStart = VM_MIN_KERNEL_ADDRESS;
 761         KvaEnd = VM_MAX_KERNEL_ADDRESS;
 762         KvaSize = KvaEnd - KvaStart;
 763
 764         avail_start = *firstaddr;
 765
 766         /*
 767          * Create an initial set of page tables to run the kernel in.
 768          */
 769         create_pagetables(firstaddr);
 770
 771         virtual2_start = KvaStart;
 772         virtual2_end = PTOV_OFFSET;
 773
 774         virtual_start = (vm_offset_t) PTOV_OFFSET + *firstaddr;
 775         virtual_start = pmap_kmem_choose(virtual_start);
 776
 777         virtual_end = VM_MAX_KERNEL_ADDRESS;
 778
 779         /* XXX do %cr0 as well */
 780         load_cr4(rcr4() | CR4_PGE | CR4_PSE);
 781         load_cr3(KPML4phys);
 782
 783         /*
 784          * Initialize protection array.
 785          */
 786         i386_protection_init();
 787
 788         /*
 789          * The kernel's pmap is statically allocated so we don't have to use
 790          * pmap_create, which is unlikely to work correctly at this part of
 791          * the boot sequence (XXX and which no longer exists).
 792          */
 793         kernel_pmap.pm_pml4 = (pdp_entry_t *) (PTOV_OFFSET + KPML4phys);
 794         kernel_pmap.pm_count = 1;
 795         kernel_pmap.pm_active = (cpumask_t)-1 & ~CPUMASK_LOCK;
 796         RB_INIT(&kernel_pmap.pm_pvroot);
 797         spin_init(&kernel_pmap.pm_spin);
 798         lwkt_token_init(&kernel_pmap.pm_token, "kpmap_tok");
 799
 800         /*
 801          * Reserve some special page table entries/VA space for temporary
 802          * mapping of pages.
 803          */
 804 #define SYSMAP(c, p, v, n)      \
 805         v = (c)va; va += ((n)*PAGE_SIZE); p = pte; pte += (n);
 806
 807         va = virtual_start;
 808         pte = vtopte(va);
 809
 810         /*
 811          * CMAP1/CMAP2 are used for zeroing and copying pages.
 812          */
 813         SYSMAP(caddr_t, CMAP1, CADDR1, 1)
 814
 815         /*
 816          * Crashdump maps.
 817          */
 818         SYSMAP(caddr_t, pt_crashdumpmap, crashdumpmap, MAXDUMPPGS);
 819
 820         /*
 821          * ptvmmap is used for reading arbitrary physical pages via
 822          * /dev/mem.
 823          */
 824         SYSMAP(caddr_t, ptmmap, ptvmmap, 1)
 825
 826         /*
 827          * msgbufp is used to map the system message buffer.
 828          * XXX msgbufmap is not used.
 829          */
 830         SYSMAP(struct msgbuf *, msgbufmap, msgbufp,
 831                atop(round_page(MSGBUF_SIZE)))
 832
 833         virtual_start = va;
 834
 835         *CMAP1 = 0;
 836
 837         /*
 838          * PG_G is terribly broken on SMP because we IPI invltlb's in some
 839          * cases rather then invl1pg.  Actually, I don't even know why it
 840          * works under UP because self-referential page table mappings
 841          */
 842 #ifdef SMP
 843         pgeflag = 0;
 844 #else
 845         if (cpu_feature & CPUID_PGE)
 846                 pgeflag = PG_G;
 847 #endif
 848
 849 /*
 850  * Initialize the 4MB page size flag
 851  */
 852         pseflag = 0;
 853 /*
 854  * The 4MB page version of the initial
 855  * kernel page mapping.
 856  */
 857         pdir4mb = 0;
 858
 859 #if !defined(DISABLE_PSE)
 860         if (cpu_feature & CPUID_PSE) {
 861                 pt_entry_t ptditmp;
 862                 /*
 863                  * Note that we have enabled PSE mode
 864                  */
 865                 pseflag = PG_PS;
 866                 ptditmp = *(PTmap + x86_64_btop(KERNBASE));
 867                 ptditmp &= ~(NBPDR - 1);
 868                 ptditmp |= PG_V | PG_RW | PG_PS | PG_U | pgeflag;
 869                 pdir4mb = ptditmp;
 870
 871 #ifndef SMP
 872                 /*
 873                  * Enable the PSE mode.  If we are SMP we can't do this
 874                  * now because the APs will not be able to use it when
 875                  * they boot up.
 876                  */
 877                 load_cr4(rcr4() | CR4_PSE);
 878
 879                 /*
 880                  * We can do the mapping here for the single processor
 881                  * case.  We simply ignore the old page table page from
 882                  * now on.
 883                  */
 884                 /*
 885                  * For SMP, we still need 4K pages to bootstrap APs,
 886                  * PSE will be enabled as soon as all APs are up.
 887                  */
 888                 PTD[KPTDI] = (pd_entry_t)ptditmp;
 889                 cpu_invltlb();
 890 #endif
 891         }
 892 #endif
 893
 894         /*
 895          * We need to finish setting up the globaldata page for the BSP.
 896          * locore has already populated the page table for the mdglobaldata
 897          * portion.
 898          */
 899         pg = MDGLOBALDATA_BASEALLOC_PAGES;
 900         gd = &CPU_prvspace[0].mdglobaldata;
 901
 902         cpu_invltlb();
 903 }
 904
 905 #ifdef SMP
 906 /*
 907  * Set 4mb pdir for mp startup
 908  */
 909 void
 910 pmap_set_opt(void)
 911 {
 912         if (pseflag && (cpu_feature & CPUID_PSE)) {
 913                 load_cr4(rcr4() | CR4_PSE);
 914                 if (pdir4mb && mycpu->gd_cpuid == 0) {  /* only on BSP */
 915                         cpu_invltlb();
 916                 }
 917         }
 918 }
 919 #endif
 920
 921 /*
 922  *      Initialize the pmap module.
 923  *      Called by vm_init, to initialize any structures that the pmap
 924  *      system needs to map virtual memory.
 925  *      pmap_init has been enhanced to support in a fairly consistant
 926  *      way, discontiguous physical memory.
 927  */
 928 void
 929 pmap_init(void)
 930 {
 931         int i;
 932         int initial_pvs;
 933
 934         /*
 935          * Allocate memory for random pmap data structures.  Includes the
 936          * pv_head_table.
 937          */
 938
 939         for (i = 0; i < vm_page_array_size; i++) {
 940                 vm_page_t m;
 941
 942                 m = &vm_page_array[i];
 943                 TAILQ_INIT(&m->md.pv_list);
 944         }
 945
 946         /*
 947          * init the pv free list
 948          */
 949         initial_pvs = vm_page_array_size;
 950         if (initial_pvs < MINPV)
 951                 initial_pvs = MINPV;
 952         pvzone = &pvzone_store;
 953         pvinit = (void *)kmem_alloc(&kernel_map,
 954                                     initial_pvs * sizeof (struct pv_entry));
 955         zbootinit(pvzone, "PV ENTRY", sizeof (struct pv_entry),
 956                   pvinit, initial_pvs);
 957
 958         /*
 959          * Now it is safe to enable pv_table recording.
 960          */
 961         pmap_initialized = TRUE;
 962 }
 963
 964 /*
 965  * Initialize the address space (zone) for the pv_entries.  Set a
 966  * high water mark so that the system can recover from excessive
 967  * numbers of pv entries.
 968  */
 969 void
 970 pmap_init2(void)
 971 {
 972         int shpgperproc = PMAP_SHPGPERPROC;
 973         int entry_max;
 974
 975         TUNABLE_INT_FETCH("vm.pmap.shpgperproc", &shpgperproc);
 976         pv_entry_max = shpgperproc * maxproc + vm_page_array_size;
 977         TUNABLE_INT_FETCH("vm.pmap.pv_entries", &pv_entry_max);
 978         pv_entry_high_water = 9 * (pv_entry_max / 10);
 979
 980         /*
 981          * Subtract out pages already installed in the zone (hack)
 982          */
 983         entry_max = pv_entry_max - vm_page_array_size;
 984         if (entry_max <= 0)
 985                 entry_max = 1;
 986
 987         zinitna(pvzone, &pvzone_obj, NULL, 0, entry_max, ZONE_INTERRUPT, 1);
 988 }
 989
 990
 991 /***************************************************
 992  * Low level helper routines.....
 993  ***************************************************/
 994
 995 /*
 996  * this routine defines the region(s) of memory that should
 997  * not be tested for the modified bit.
 998  */
 999 static __inline
1000 int
1001 pmap_track_modified(vm_pindex_t pindex)
1002 {
1003         vm_offset_t va = (vm_offset_t)pindex << PAGE_SHIFT;
1004         if ((va < clean_sva) || (va >= clean_eva))
1005                 return 1;
1006         else
1007                 return 0;
1008 }
1009
1010 /*
1011  * Extract the physical page address associated with the map/VA pair.
1012  * The page must be wired for this to work reliably.
1013  *
1014  * XXX for the moment we're using pv_find() instead of pv_get(), as
1015  *     callers might be expecting non-blocking operation.
1016  */
1017 vm_paddr_t
1018 pmap_extract(pmap_t pmap, vm_offset_t va)
1019 {
1020         vm_paddr_t rtval;
1021         pv_entry_t pt_pv;
1022         pt_entry_t *ptep;
1023
1024         rtval = 0;
1025         if (va >= VM_MAX_USER_ADDRESS) {
1026                 /*
1027                  * Kernel page directories might be direct-mapped and
1028                  * there is typically no PV tracking of pte's
1029                  */
1030                 pd_entry_t *pt;
1031
1032                 pt = pmap_pt(pmap, va);
1033                 if (pt && (*pt & PG_V)) {
1034                         if (*pt & PG_PS) {
1035                                 rtval = *pt & PG_PS_FRAME;
1036                                 rtval |= va & PDRMASK;
1037                         } else {
1038                                 ptep = pmap_pt_to_pte(*pt, va);
1039                                 if (*pt & PG_V) {
1040                                         rtval = *ptep & PG_FRAME;
1041                                         rtval |= va & PAGE_MASK;
1042                                 }
1043                         }
1044                 }
1045         } else {
1046                 /*
1047                  * User pages currently do not direct-map the page directory
1048                  * and some pages might not used managed PVs.  But all PT's
1049                  * will have a PV.
1050                  */
1051                 pt_pv = pv_find(pmap, pmap_pt_pindex(va));
1052                 if (pt_pv) {
1053                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(va));
1054                         if (*ptep & PG_V) {
1055                                 rtval = *ptep & PG_FRAME;
1056                                 rtval |= va & PAGE_MASK;
1057                         }
1058                         pv_drop(pt_pv);
1059                 }
1060         }
1061         return rtval;
1062 }
1063
1064 /*
1065  * Extract the physical page address associated kernel virtual address.
1066  */
1067 vm_paddr_t
1068 pmap_kextract(vm_offset_t va)
1069 {
1070         pd_entry_t pt;          /* pt entry in pd */
1071         vm_paddr_t pa;
1072
1073         if (va >= DMAP_MIN_ADDRESS && va < DMAP_MAX_ADDRESS) {
1074                 pa = DMAP_TO_PHYS(va);
1075         } else {
1076                 pt = *vtopt(va);
1077                 if (pt & PG_PS) {
1078                         pa = (pt & PG_PS_FRAME) | (va & PDRMASK);
1079                 } else {
1080                         /*
1081                          * Beware of a concurrent promotion that changes the
1082                          * PDE at this point!  For example, vtopte() must not
1083                          * be used to access the PTE because it would use the
1084                          * new PDE.  It is, however, safe to use the old PDE
1085                          * because the page table page is preserved by the
1086                          * promotion.
1087                          */
1088                         pa = *pmap_pt_to_pte(pt, va);
1089                         pa = (pa & PG_FRAME) | (va & PAGE_MASK);
1090                 }
1091         }
1092         return pa;
1093 }
1094
1095 /***************************************************
1096  * Low level mapping routines.....
1097  ***************************************************/
1098
1099 /*
1100  * Routine: pmap_kenter
1101  * Function:
1102  *      Add a wired page to the KVA
1103  *      NOTE! note that in order for the mapping to take effect -- you
1104  *      should do an invltlb after doing the pmap_kenter().
1105  */
1106 void
1107 pmap_kenter(vm_offset_t va, vm_paddr_t pa)
1108 {
1109         pt_entry_t *pte;
1110         pt_entry_t npte;
1111         pmap_inval_info info;
1112
1113         pmap_inval_init(&info);                         /* XXX remove */
1114         npte = pa | PG_RW | PG_V | pgeflag;
1115         pte = vtopte(va);
1116         pmap_inval_interlock(&info, &kernel_pmap, va);  /* XXX remove */
1117         *pte = npte;
1118         pmap_inval_deinterlock(&info, &kernel_pmap);    /* XXX remove */
1119         pmap_inval_done(&info);                         /* XXX remove */
1120 }
1121
1122 /*
1123  * Routine: pmap_kenter_quick
1124  * Function:
1125  *      Similar to pmap_kenter(), except we only invalidate the
1126  *      mapping on the current CPU.
1127  */
1128 void
1129 pmap_kenter_quick(vm_offset_t va, vm_paddr_t pa)
1130 {
1131         pt_entry_t *pte;
1132         pt_entry_t npte;
1133
1134         npte = pa | PG_RW | PG_V | pgeflag;
1135         pte = vtopte(va);
1136         *pte = npte;
1137         cpu_invlpg((void *)va);
1138 }
1139
1140 void
1141 pmap_kenter_sync(vm_offset_t va)
1142 {
1143         pmap_inval_info info;
1144
1145         pmap_inval_init(&info);
1146         pmap_inval_interlock(&info, &kernel_pmap, va);
1147         pmap_inval_deinterlock(&info, &kernel_pmap);
1148         pmap_inval_done(&info);
1149 }
1150
1151 void
1152 pmap_kenter_sync_quick(vm_offset_t va)
1153 {
1154         cpu_invlpg((void *)va);
1155 }
1156
1157 /*
1158  * remove a page from the kernel pagetables
1159  */
1160 void
1161 pmap_kremove(vm_offset_t va)
1162 {
1163         pt_entry_t *pte;
1164         pmap_inval_info info;
1165
1166         pmap_inval_init(&info);
1167         pte = vtopte(va);
1168         pmap_inval_interlock(&info, &kernel_pmap, va);
1169         (void)pte_load_clear(pte);
1170         pmap_inval_deinterlock(&info, &kernel_pmap);
1171         pmap_inval_done(&info);
1172 }
1173
1174 void
1175 pmap_kremove_quick(vm_offset_t va)
1176 {
1177         pt_entry_t *pte;
1178         pte = vtopte(va);
1179         (void)pte_load_clear(pte);
1180         cpu_invlpg((void *)va);
1181 }
1182
1183 /*
1184  * XXX these need to be recoded.  They are not used in any critical path.
1185  */
1186 void
1187 pmap_kmodify_rw(vm_offset_t va)
1188 {
1189         atomic_set_long(vtopte(va), PG_RW);
1190         cpu_invlpg((void *)va);
1191 }
1192
1193 void
1194 pmap_kmodify_nc(vm_offset_t va)
1195 {
1196         atomic_set_long(vtopte(va), PG_N);
1197         cpu_invlpg((void *)va);
1198 }
1199
1200 /*
1201  * Used to map a range of physical addresses into kernel virtual
1202  * address space during the low level boot, typically to map the
1203  * dump bitmap, message buffer, and vm_page_array.
1204  *
1205  * These mappings are typically made at some pointer after the end of the
1206  * kernel text+data.
1207  *
1208  * We could return PHYS_TO_DMAP(start) here and not allocate any
1209  * via (*virtp), but then kmem from userland and kernel dumps won't
1210  * have access to the related pointers.
1211  */
1212 vm_offset_t
1213 pmap_map(vm_offset_t *virtp, vm_paddr_t start, vm_paddr_t end, int prot)
1214 {
1215         vm_offset_t va;
1216         vm_offset_t va_start;
1217
1218         /*return PHYS_TO_DMAP(start);*/
1219
1220         va_start = *virtp;
1221         va = va_start;
1222
1223         while (start < end) {
1224                 pmap_kenter_quick(va, start);
1225                 va += PAGE_SIZE;
1226                 start += PAGE_SIZE;
1227         }
1228         *virtp = va;
1229         return va_start;
1230 }
1231
1232
1233 /*
1234  * Add a list of wired pages to the kva
1235  * this routine is only used for temporary
1236  * kernel mappings that do not need to have
1237  * page modification or references recorded.
1238  * Note that old mappings are simply written
1239  * over.  The page *must* be wired.
1240  */
1241 void
1242 pmap_qenter(vm_offset_t va, vm_page_t *m, int count)
1243 {
1244         vm_offset_t end_va;
1245
1246         end_va = va + count * PAGE_SIZE;
1247
1248         while (va < end_va) {
1249                 pt_entry_t *pte;
1250
1251                 pte = vtopte(va);
1252                 *pte = VM_PAGE_TO_PHYS(*m) | PG_RW | PG_V | pgeflag;
1253                 cpu_invlpg((void *)va);
1254                 va += PAGE_SIZE;
1255                 m++;
1256         }
1257         smp_invltlb();
1258 }
1259
1260 /*
1261  * This routine jerks page mappings from the
1262  * kernel -- it is meant only for temporary mappings.
1263  *
1264  * MPSAFE, INTERRUPT SAFE (cluster callback)
1265  */
1266 void
1267 pmap_qremove(vm_offset_t va, int count)
1268 {
1269         vm_offset_t end_va;
1270
1271         end_va = va + count * PAGE_SIZE;
1272
1273         while (va < end_va) {
1274                 pt_entry_t *pte;
1275
1276                 pte = vtopte(va);
1277                 (void)pte_load_clear(pte);
1278                 cpu_invlpg((void *)va);
1279                 va += PAGE_SIZE;
1280         }
1281         smp_invltlb();
1282 }
1283
1284 /*
1285  * Create a new thread and optionally associate it with a (new) process.
1286  * NOTE! the new thread's cpu may not equal the current cpu.
1287  */
1288 void
1289 pmap_init_thread(thread_t td)
1290 {
1291         /* enforce pcb placement & alignment */
1292         td->td_pcb = (struct pcb *)(td->td_kstack + td->td_kstack_size) - 1;
1293         td->td_pcb = (struct pcb *)((intptr_t)td->td_pcb & ~(intptr_t)0xF);
1294         td->td_savefpu = &td->td_pcb->pcb_save;
1295         td->td_sp = (char *)td->td_pcb; /* no -16 */
1296 }
1297
1298 /*
1299  * This routine directly affects the fork perf for a process.
1300  */
1301 void
1302 pmap_init_proc(struct proc *p)
1303 {
1304 }
1305
1306 /*
1307  * Initialize pmap0/vmspace0.  This pmap is not added to pmap_list because
1308  * it, and IdlePTD, represents the template used to update all other pmaps.
1309  *
1310  * On architectures where the kernel pmap is not integrated into the user
1311  * process pmap, this pmap represents the process pmap, not the kernel pmap.
1312  * kernel_pmap should be used to directly access the kernel_pmap.
1313  */
1314 void
1315 pmap_pinit0(struct pmap *pmap)
1316 {
1317         pmap->pm_pml4 = (pml4_entry_t *)(PTOV_OFFSET + KPML4phys);
1318         pmap->pm_count = 1;
1319         pmap->pm_active = 0;
1320         pmap->pm_pvhint = NULL;
1321         RB_INIT(&pmap->pm_pvroot);
1322         spin_init(&pmap->pm_spin);
1323         lwkt_token_init(&pmap->pm_token, "pmap_tok");
1324         bzero(&pmap->pm_stats, sizeof pmap->pm_stats);
1325 }
1326
1327 /*
1328  * Initialize a preallocated and zeroed pmap structure,
1329  * such as one in a vmspace structure.
1330  */
1331 static void
1332 pmap_pinit_simple(struct pmap *pmap)
1333 {
1334         /*
1335          * Misc initialization
1336          */
1337         pmap->pm_count = 1;
1338         pmap->pm_active = 0;
1339         pmap->pm_pvhint = NULL;
1340         pmap->pm_flags = PMAP_FLAG_SIMPLE;
1341
1342         /*
1343          * Don't blow up locks/tokens on re-use (XXX fix/use drop code
1344          * for this).
1345          */
1346         if (pmap->pm_pmlpv == NULL) {
1347                 RB_INIT(&pmap->pm_pvroot);
1348                 bzero(&pmap->pm_stats, sizeof pmap->pm_stats);
1349                 spin_init(&pmap->pm_spin);
1350                 lwkt_token_init(&pmap->pm_token, "pmap_tok");
1351         }
1352 }
1353
1354 void
1355 pmap_pinit(struct pmap *pmap)
1356 {
1357         pv_entry_t pv;
1358         int j;
1359
1360         pmap_pinit_simple(pmap);
1361         pmap->pm_flags &= ~PMAP_FLAG_SIMPLE;
1362
1363         /*
1364          * No need to allocate page table space yet but we do need a valid
1365          * page directory table.
1366          */
1367         if (pmap->pm_pml4 == NULL) {
1368                 pmap->pm_pml4 =
1369                     (pml4_entry_t *)kmem_alloc_pageable(&kernel_map, PAGE_SIZE);
1370         }
1371
1372         /*
1373          * Allocate the page directory page, which wires it even though
1374          * it isn't being entered into some higher level page table (it
1375          * being the highest level).  If one is already cached we don't
1376          * have to do anything.
1377          */
1378         if ((pv = pmap->pm_pmlpv) == NULL) {
1379                 pv = pmap_allocpte(pmap, pmap_pml4_pindex(), NULL);
1380                 pmap->pm_pmlpv = pv;
1381                 pmap_kenter((vm_offset_t)pmap->pm_pml4,
1382                             VM_PAGE_TO_PHYS(pv->pv_m));
1383                 pv_put(pv);
1384
1385                 /*
1386                  * Install DMAP and KMAP.
1387                  */
1388                 for (j = 0; j < NDMPML4E; ++j) {
1389                         pmap->pm_pml4[DMPML4I + j] =
1390                                 (DMPDPphys + ((vm_paddr_t)j << PML4SHIFT)) |
1391                                 PG_RW | PG_V | PG_U;
1392                 }
1393                 pmap->pm_pml4[KPML4I] = KPDPphys | PG_RW | PG_V | PG_U;
1394
1395                 /*
1396                  * install self-referential address mapping entry
1397                  */
1398                 pmap->pm_pml4[PML4PML4I] = VM_PAGE_TO_PHYS(pv->pv_m) |
1399                                            PG_V | PG_RW | PG_A | PG_M;
1400         } else {
1401                 KKASSERT(pv->pv_m->flags & PG_MAPPED);
1402                 KKASSERT(pv->pv_m->flags & PG_WRITEABLE);
1403         }
1404         KKASSERT(pmap->pm_pml4[255] == 0);
1405         KKASSERT(RB_ROOT(&pmap->pm_pvroot) == pv);
1406         KKASSERT(pv->pv_entry.rbe_left == NULL);
1407         KKASSERT(pv->pv_entry.rbe_right == NULL);
1408 }
1409
1410 /*
1411  * Clean up a pmap structure so it can be physically freed.  This routine
1412  * is called by the vmspace dtor function.  A great deal of pmap data is
1413  * left passively mapped to improve vmspace management so we have a bit
1414  * of cleanup work to do here.
1415  */
1416 void
1417 pmap_puninit(pmap_t pmap)
1418 {
1419         pv_entry_t pv;
1420         vm_page_t p;
1421
1422         KKASSERT(pmap->pm_active == 0);
1423         if ((pv = pmap->pm_pmlpv) != NULL) {
1424                 if (pv_hold_try(pv) == 0)
1425                         pv_lock(pv);
1426                 p = pmap_remove_pv_page(pv);
1427                 pv_free(pv);
1428                 pmap_kremove((vm_offset_t)pmap->pm_pml4);
1429                 vm_page_busy_wait(p, FALSE, "pgpun");
1430                 KKASSERT(p->flags & (PG_FICTITIOUS|PG_UNMANAGED));
1431                 vm_page_unwire(p, 0);
1432                 vm_page_flag_clear(p, PG_MAPPED | PG_WRITEABLE);
1433
1434                 /*
1435                  * XXX eventually clean out PML4 static entries and
1436                  * use vm_page_free_zero()
1437                  */
1438                 vm_page_free(p);
1439                 pmap->pm_pmlpv = NULL;
1440         }
1441         if (pmap->pm_pml4) {
1442                 KKASSERT(pmap->pm_pml4 != (void *)(PTOV_OFFSET + KPML4phys));
1443                 kmem_free(&kernel_map, (vm_offset_t)pmap->pm_pml4, PAGE_SIZE);
1444                 pmap->pm_pml4 = NULL;
1445         }
1446         KKASSERT(pmap->pm_stats.resident_count == 0);
1447         KKASSERT(pmap->pm_stats.wired_count == 0);
1448 }
1449
1450 /*
1451  * Wire in kernel global address entries.  To avoid a race condition
1452  * between pmap initialization and pmap_growkernel, this procedure
1453  * adds the pmap to the master list (which growkernel scans to update),
1454  * then copies the template.
1455  */
1456 void
1457 pmap_pinit2(struct pmap *pmap)
1458 {
1459         spin_lock(&pmap_spin);
1460         TAILQ_INSERT_TAIL(&pmap_list, pmap, pm_pmnode);
1461         spin_unlock(&pmap_spin);
1462 }
1463
1464 /*
1465  * This routine is called when various levels in the page table need to
1466  * be populated.  This routine cannot fail.
1467  *
1468  * This function returns two locked pv_entry's, one representing the
1469  * requested pv and one representing the requested pv's parent pv.  If
1470  * the pv did not previously exist it will be mapped into its parent
1471  * and wired, otherwise no additional wire count will be added.
1472  */
1473 static
1474 pv_entry_t
1475 pmap_allocpte(pmap_t pmap, vm_pindex_t ptepindex, pv_entry_t *pvpp)
1476 {
1477         pt_entry_t *ptep;
1478         pv_entry_t pv;
1479         pv_entry_t pvp;
1480         vm_pindex_t pt_pindex;
1481         vm_page_t m;
1482         int isnew;
1483         int ispt;
1484
1485         /*
1486          * If the pv already exists and we aren't being asked for the
1487          * parent page table page we can just return it.  A locked+held pv
1488          * is returned.
1489          */
1490         ispt = 0;
1491         pv = pv_alloc(pmap, ptepindex, &isnew);
1492         if (isnew == 0 && pvpp == NULL)
1493                 return(pv);
1494
1495         /*
1496          * This is a new PV, we have to resolve its parent page table and
1497          * add an additional wiring to the page if necessary.
1498          */
1499
1500         /*
1501          * Special case terminal PVs.  These are not page table pages so
1502          * no vm_page is allocated (the caller supplied the vm_page).  If
1503          * pvpp is non-NULL we are being asked to also removed the pt_pv
1504          * for this pv.
1505          *
1506          * Note that pt_pv's are only returned for user VAs. We assert that
1507          * a pt_pv is not being requested for kernel VAs.
1508          */
1509         if (ptepindex < pmap_pt_pindex(0)) {
1510                 if (ptepindex >= NUPTE_USER)
1511                         KKASSERT(pvpp == NULL);
1512                 else
1513                         KKASSERT(pvpp != NULL);
1514                 if (pvpp) {
1515                         pt_pindex = NUPTE_TOTAL + (ptepindex >> NPTEPGSHIFT);
1516                         pvp = pmap_allocpte(pmap, pt_pindex, NULL);
1517                         if (isnew)
1518                                 vm_page_wire_quick(pvp->pv_m);
1519                         *pvpp = pvp;
1520                 } else {
1521                         pvp = NULL;
1522                 }
1523                 return(pv);
1524         }
1525
1526         /*
1527          * Non-terminal PVs allocate a VM page to represent the page table,
1528          * so we have to resolve pvp and calculate ptepindex for the pvp
1529          * and then for the page table entry index in the pvp for
1530          * fall-through.
1531          */
1532         if (ptepindex < pmap_pd_pindex(0)) {
1533                 /*
1534                  * pv is PT, pvp is PD
1535                  */
1536                 ptepindex = (ptepindex - pmap_pt_pindex(0)) >> NPDEPGSHIFT;
1537                 ptepindex += NUPTE_TOTAL + NUPT_TOTAL;
1538                 pvp = pmap_allocpte(pmap, ptepindex, NULL);
1539                 if (!isnew)
1540                         goto notnew;
1541
1542                 /*
1543                  * PT index in PD
1544                  */
1545                 ptepindex = pv->pv_pindex - pmap_pt_pindex(0);
1546                 ptepindex &= ((1ul << NPDEPGSHIFT) - 1);
1547                 ispt = 1;
1548         } else if (ptepindex < pmap_pdp_pindex(0)) {
1549                 /*
1550                  * pv is PD, pvp is PDP
1551                  *
1552                  * SIMPLE PMAP NOTE: Simple pmaps do not allocate above
1553                  *                   the PD.
1554                  */
1555                 ptepindex = (ptepindex - pmap_pd_pindex(0)) >> NPDPEPGSHIFT;
1556                 ptepindex += NUPTE_TOTAL + NUPT_TOTAL + NUPD_TOTAL;
1557
1558                 if (pmap->pm_flags & PMAP_FLAG_SIMPLE) {
1559                         KKASSERT(pvpp == NULL);
1560                         pvp = NULL;
1561                 } else {
1562                         pvp = pmap_allocpte(pmap, ptepindex, NULL);
1563                 }
1564                 if (!isnew)
1565                         goto notnew;
1566
1567                 /*
1568                  * PD index in PDP
1569                  */
1570                 ptepindex = pv->pv_pindex - pmap_pd_pindex(0);
1571                 ptepindex &= ((1ul << NPDPEPGSHIFT) - 1);
1572         } else if (ptepindex < pmap_pml4_pindex()) {
1573                 /*
1574                  * pv is PDP, pvp is the root pml4 table
1575                  */
1576                 pvp = pmap_allocpte(pmap, pmap_pml4_pindex(), NULL);
1577                 if (!isnew)
1578                         goto notnew;
1579
1580                 /*
1581                  * PDP index in PML4
1582                  */
1583                 ptepindex = pv->pv_pindex - pmap_pdp_pindex(0);
1584                 ptepindex &= ((1ul << NPML4EPGSHIFT) - 1);
1585         } else {
1586                 /*
1587                  * pv represents the top-level PML4, there is no parent.
1588                  */
1589                 pvp = NULL;
1590                 if (!isnew)
1591                         goto notnew;
1592         }
1593
1594         /*
1595          * This code is only reached if isnew is TRUE and this is not a
1596          * terminal PV.  We need to allocate a vm_page for the page table
1597          * at this level and enter it into the parent page table.
1598          *
1599          * page table pages are marked PG_WRITEABLE and PG_MAPPED.
1600          */
1601         for (;;) {
1602                 m = vm_page_alloc(NULL, pv->pv_pindex,
1603                                   VM_ALLOC_NORMAL | VM_ALLOC_SYSTEM |
1604                                   VM_ALLOC_INTERRUPT);
1605                 if (m)
1606                         break;
1607                 vm_wait(0);
1608         }
1609         vm_page_spin_lock(m);
1610         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_list);
1611         pv->pv_m = m;
1612         vm_page_flag_set(m, PG_MAPPED | PG_WRITEABLE);
1613         vm_page_spin_unlock(m);
1614         vm_page_unmanage(m);    /* m must be spinunlocked */
1615
1616         if ((m->flags & PG_ZERO) == 0) {
1617                 pmap_zero_page(VM_PAGE_TO_PHYS(m));
1618         }
1619 #ifdef PMAP_DEBUG
1620         else {
1621                 pmap_page_assertzero(VM_PAGE_TO_PHYS(m));
1622         }
1623 #endif
1624         m->valid = VM_PAGE_BITS_ALL;
1625         vm_page_flag_clear(m, PG_ZERO);
1626         vm_page_wire(m);        /* wire for mapping in parent */
1627
1628         /*
1629          * Wire the page into pvp, bump the wire-count for pvp's page table
1630          * page.  Bump the resident_count for the pmap.  There is no pvp
1631          * for the top level, address the pm_pml4[] array directly.
1632          *
1633          * If the caller wants the parent we return it, otherwise
1634          * we just put it away.
1635          *
1636          * No interlock is needed for pte 0 -> non-zero.
1637          *
1638          * In the situation where *ptep is valid we might have an unmanaged
1639          * page table page shared from another page table which we need to
1640          * unshare before installing our private page table page.
1641          */
1642         if (pvp) {
1643                 ptep = pv_pte_lookup(pvp, ptepindex);
1644                 if (*ptep & PG_V) {
1645                         pt_entry_t pte;
1646                         pmap_inval_info info;
1647
1648                         kprintf("pmap_allocpte: restate shared pg table pg\n");
1649
1650                         if (ispt == 0) {
1651                                 panic("pmap_allocpte: unexpected pte %p/%d",
1652                                       pvp, (int)ptepindex);
1653                         }
1654                         pmap_inval_init(&info);
1655                         pmap_inval_interlock(&info, pmap, (vm_offset_t)-1);
1656                         pte = pte_load_clear(ptep);
1657                         pmap_inval_deinterlock(&info, pmap);
1658                         pmap_inval_done(&info);
1659                         if (vm_page_unwire_quick(PHYS_TO_VM_PAGE(pte & PG_FRAME)))
1660                                 panic("pmap_allocpte: shared pgtable pg bad wirecount");
1661                 } else {
1662                         vm_page_wire_quick(pvp->pv_m);
1663                 }
1664                 *ptep = VM_PAGE_TO_PHYS(m) | (PG_U | PG_RW | PG_V |
1665                                               PG_A | PG_M);
1666         }
1667         vm_page_wakeup(m);
1668 notnew:
1669         if (pvpp)
1670                 *pvpp = pvp;
1671         else if (pvp)
1672                 pv_put(pvp);
1673         return (pv);
1674 }
1675
1676 /*
1677  * This version of pmap_allocpte() checks for possible segment optimizations
1678  * that would allow page-table sharing.  It can be called for terminal
1679  * page or page table page ptepindex's.
1680  *
1681  * The function is called with page table page ptepindex's for fictitious
1682  * and unmanaged terminal pages.  That is, we don't want to allocate a
1683  * terminal pv, we just want the pt_pv.  pvpp is usually passed as NULL
1684  * for this case.
1685  *
1686  * This function can return a pv and *pvpp associated with the passed in pmap
1687  * OR a pv and *pvpp associated with the shared pmap.  In the latter case
1688  * an unmanaged page table page will be entered into the pass in pmap.
1689  */
1690 static
1691 pv_entry_t
1692 pmap_allocpte_seg(pmap_t pmap, vm_pindex_t ptepindex, pv_entry_t *pvpp,
1693                   vm_map_entry_t entry, vm_offset_t va)
1694 {
1695         struct pmap_inval_info info;
1696         vm_object_t object;
1697         pmap_t obpmap;
1698         pmap_t *obpmapp;
1699         vm_offset_t b;
1700         pv_entry_t pte_pv;      /* in original or shared pmap */
1701         pv_entry_t pt_pv;       /* in original or shared pmap */
1702         pv_entry_t proc_pd_pv;  /* in original pmap */
1703         pv_entry_t proc_pt_pv;  /* in original pmap */
1704         pv_entry_t xpv;         /* PT in shared pmap */
1705         pd_entry_t *pt;         /* PT entry in PD of original pmap */
1706         pd_entry_t opte;        /* contents of *pt */
1707         pd_entry_t npte;        /* contents of *pt */
1708         vm_page_t m;
1709
1710         /*
1711          * Basic tests, require a non-NULL vm_map_entry, require proper
1712          * alignment and type for the vm_map_entry, require that the
1713          * underlying object already be allocated.
1714          *
1715          * We currently allow any type of object to use this optimization.
1716          * The object itself does NOT have to be sized to a multiple of the
1717          * segment size, but the memory mapping does.
1718          */
1719         if (entry == NULL ||
1720             pmap_mmu_optimize == 0 ||                   /* not enabled */
1721             ptepindex >= pmap_pd_pindex(0) ||           /* not terminal */
1722             entry->inheritance != VM_INHERIT_SHARE ||   /* not shared */
1723             entry->maptype != VM_MAPTYPE_NORMAL ||      /* weird map type */
1724             entry->object.vm_object == NULL ||          /* needs VM object */
1725             (entry->offset & SEG_MASK) ||               /* must be aligned */
1726             (entry->start & SEG_MASK)) {
1727                 return(pmap_allocpte(pmap, ptepindex, pvpp));
1728         }
1729
1730         /*
1731          * Make sure the full segment can be represented.
1732          */
1733         b = va & ~(vm_offset_t)SEG_MASK;
1734         if (b < entry->start && b + SEG_SIZE > entry->end)
1735                 return(pmap_allocpte(pmap, ptepindex, pvpp));
1736
1737         /*
1738          * If the full segment can be represented dive the VM object's
1739          * shared pmap, allocating as required.
1740          */
1741         object = entry->object.vm_object;
1742
1743         if (entry->protection & VM_PROT_WRITE)
1744                 obpmapp = &object->md.pmap_rw;
1745         else
1746                 obpmapp = &object->md.pmap_ro;
1747
1748         /*
1749          * We allocate what appears to be a normal pmap but because portions
1750          * of this pmap are shared with other unrelated pmaps we have to
1751          * set pm_active to point to all cpus.
1752          *
1753          * XXX Currently using pmap_spin to interlock the update, can't use
1754          *     vm_object_hold/drop because the token might already be held
1755          *     shared OR exclusive and we don't know.
1756          */
1757         while ((obpmap = *obpmapp) == NULL) {
1758                 obpmap = kmalloc(sizeof(*obpmap), M_OBJPMAP, M_WAITOK|M_ZERO);
1759                 pmap_pinit_simple(obpmap);
1760                 pmap_pinit2(obpmap);
1761                 spin_lock(&pmap_spin);
1762                 if (*obpmapp != NULL) {
1763                         /*
1764                          * Handle race
1765                          */
1766                         spin_unlock(&pmap_spin);
1767                         pmap_release(obpmap);
1768                         pmap_puninit(obpmap);
1769                         kfree(obpmap, M_OBJPMAP);
1770                 } else {
1771                         obpmap->pm_active = smp_active_mask;
1772                         *obpmapp = obpmap;
1773                         spin_unlock(&pmap_spin);
1774                 }
1775         }
1776
1777         /*
1778          * Layering is: PTE, PT, PD, PDP, PML4.  We have to return the
1779          * pte/pt using the shared pmap from the object but also adjust
1780          * the process pmap's page table page as a side effect.
1781          */
1782
1783         /*
1784          * Resolve the terminal PTE and PT in the shared pmap.  This is what
1785          * we will return.  This is true if ptepindex represents a terminal
1786          * page, otherwise pte_pv is actually the PT and pt_pv is actually
1787          * the PD.
1788          */
1789         pt_pv = NULL;
1790         pte_pv = pmap_allocpte(obpmap, ptepindex, &pt_pv);
1791         if (ptepindex >= pmap_pt_pindex(0))
1792                 xpv = pte_pv;
1793         else
1794                 xpv = pt_pv;
1795
1796         /*
1797          * Resolve the PD in the process pmap so we can properly share the
1798          * page table page.  Lock order is bottom-up (leaf first)!
1799          *
1800          * NOTE: proc_pt_pv can be NULL.
1801          */
1802         proc_pt_pv = pv_get(pmap, pmap_pt_pindex(b));
1803         proc_pd_pv = pmap_allocpte(pmap, pmap_pd_pindex(b), NULL);
1804
1805         /*
1806          * xpv is the page table page pv from the shared object
1807          * (for convenience).
1808          *
1809          * Calculate the pte value for the PT to load into the process PD.
1810          * If we have to change it we must properly dispose of the previous
1811          * entry.
1812          */
1813         pt = pv_pte_lookup(proc_pd_pv, pmap_pt_index(b));
1814         npte = VM_PAGE_TO_PHYS(xpv->pv_m) |
1815                (PG_U | PG_RW | PG_V | PG_A | PG_M);
1816
1817         /*
1818          * Dispose of previous entry if it was local to the process pmap.
1819          * (This should zero-out *pt)
1820          */
1821         if (proc_pt_pv) {
1822                 pmap_release_pv(proc_pt_pv);
1823                 proc_pt_pv = NULL;
1824                 /* relookup */
1825                 pt = pv_pte_lookup(proc_pd_pv, pmap_pt_index(b));
1826         }
1827
1828         /*
1829          * Handle remaining cases.
1830          */
1831         if (*pt == 0) {
1832                 *pt = npte;
1833                 vm_page_wire_quick(xpv->pv_m);
1834                 vm_page_wire_quick(proc_pd_pv->pv_m);
1835                 atomic_add_long(&pmap->pm_stats.resident_count, 1);
1836         } else if (*pt != npte) {
1837                 pmap_inval_init(&info);
1838                 pmap_inval_interlock(&info, pmap, (vm_offset_t)-1);
1839
1840                 opte = pte_load_clear(pt);
1841                 KKASSERT(opte && opte != npte);
1842
1843                 *pt = npte;
1844                 vm_page_wire_quick(xpv->pv_m);  /* pgtable pg that is npte */
1845
1846                 /*
1847                  * Clean up opte, bump the wire_count for the process
1848                  * PD page representing the new entry if it was
1849                  * previously empty.
1850                  *
1851                  * If the entry was not previously empty and we have
1852                  * a PT in the proc pmap then opte must match that
1853                  * pt.  The proc pt must be retired (this is done
1854                  * later on in this procedure).
1855                  *
1856                  * NOTE: replacing valid pte, wire_count on proc_pd_pv
1857                  * stays the same.
1858                  */
1859                 KKASSERT(opte & PG_V);
1860                 m = PHYS_TO_VM_PAGE(opte & PG_FRAME);
1861                 if (vm_page_unwire_quick(m)) {
1862                         panic("pmap_allocpte_seg: "
1863                               "bad wire count %p",
1864                               m);
1865                 }
1866
1867                 pmap_inval_deinterlock(&info, pmap);
1868                 pmap_inval_done(&info);
1869         }
1870
1871         /*
1872          * The existing process page table was replaced and must be destroyed
1873          * here.
1874          */
1875         if (proc_pd_pv)
1876                 pv_put(proc_pd_pv);
1877         if (pvpp)
1878                 *pvpp = pt_pv;
1879         else
1880                 pv_put(pt_pv);
1881
1882         return (pte_pv);
1883 }
1884
1885 /*
1886  * Release any resources held by the given physical map.
1887  *
1888  * Called when a pmap initialized by pmap_pinit is being released.  Should
1889  * only be called if the map contains no valid mappings.
1890  *
1891  * Caller must hold pmap->pm_token
1892  */
1893 struct pmap_release_info {
1894         pmap_t  pmap;
1895         int     retry;
1896 };
1897
1898 static int pmap_release_callback(pv_entry_t pv, void *data);
1899
1900 void
1901 pmap_release(struct pmap *pmap)
1902 {
1903         struct pmap_release_info info;
1904
1905         KASSERT(pmap->pm_active == 0,
1906                 ("pmap still active! %016jx", (uintmax_t)pmap->pm_active));
1907
1908         spin_lock(&pmap_spin);
1909         TAILQ_REMOVE(&pmap_list, pmap, pm_pmnode);
1910         spin_unlock(&pmap_spin);
1911
1912         /*
1913          * Pull pv's off the RB tree in order from low to high and release
1914          * each page.
1915          */
1916         info.pmap = pmap;
1917         do {
1918                 info.retry = 0;
1919                 spin_lock(&pmap->pm_spin);
1920                 RB_SCAN(pv_entry_rb_tree, &pmap->pm_pvroot, NULL,
1921                         pmap_release_callback, &info);
1922                 spin_unlock(&pmap->pm_spin);
1923         } while (info.retry);
1924
1925
1926         /*
1927          * One resident page (the pml4 page) should remain.
1928          * No wired pages should remain.
1929          */
1930         KKASSERT(pmap->pm_stats.resident_count ==
1931                  ((pmap->pm_flags & PMAP_FLAG_SIMPLE) ? 0 : 1));
1932
1933         KKASSERT(pmap->pm_stats.wired_count == 0);
1934 }
1935
1936 static int
1937 pmap_release_callback(pv_entry_t pv, void *data)
1938 {
1939         struct pmap_release_info *info = data;
1940         pmap_t pmap = info->pmap;
1941         int r;
1942
1943         if (pv_hold_try(pv)) {
1944                 spin_unlock(&pmap->pm_spin);
1945         } else {
1946                 spin_unlock(&pmap->pm_spin);
1947                 pv_lock(pv);
1948                 if (pv->pv_pmap != pmap) {
1949                         pv_put(pv);
1950                         spin_lock(&pmap->pm_spin);
1951                         info->retry = 1;
1952                         return(-1);
1953                 }
1954         }
1955         r = pmap_release_pv(pv);
1956         spin_lock(&pmap->pm_spin);
1957         return(r);
1958 }
1959
1960 /*
1961  * Called with held (i.e. also locked) pv.  This function will dispose of
1962  * the lock along with the pv.
1963  */
1964 static int
1965 pmap_release_pv(pv_entry_t pv)
1966 {
1967         vm_page_t p;
1968
1969         /*
1970          * The pmap is currently not spinlocked, pv is held+locked.
1971          * Remove the pv's page from its parent's page table.  The
1972          * parent's page table page's wire_count will be decremented.
1973          */
1974         pmap_remove_pv_pte(pv, NULL, NULL);
1975
1976         /*
1977          * Terminal pvs are unhooked from their vm_pages.  Because
1978          * terminal pages aren't page table pages they aren't wired
1979          * by us, so we have to be sure not to unwire them either.
1980          */
1981         if (pv->pv_pindex < pmap_pt_pindex(0)) {
1982                 pmap_remove_pv_page(pv);
1983                 goto skip;
1984         }
1985
1986         /*
1987          * We leave the top-level page table page cached, wired, and
1988          * mapped in the pmap until the dtor function (pmap_puninit())
1989          * gets called.
1990          *
1991          * Since we are leaving the top-level pv intact we need
1992          * to break out of what would otherwise be an infinite loop.
1993          */
1994         if (pv->pv_pindex == pmap_pml4_pindex()) {
1995                 pv_put(pv);
1996                 return(-1);
1997         }
1998
1999         /*
2000          * For page table pages (other than the top-level page),
2001          * remove and free the vm_page.  The representitive mapping
2002          * removed above by pmap_remove_pv_pte() did not undo the
2003          * last wire_count so we have to do that as well.
2004          */
2005         p = pmap_remove_pv_page(pv);
2006         vm_page_busy_wait(p, FALSE, "pmaprl");
2007         if (p->wire_count != 1) {
2008                 kprintf("p->wire_count was %016lx %d\n",
2009                         pv->pv_pindex, p->wire_count);
2010         }
2011         KKASSERT(p->wire_count == 1);
2012         KKASSERT(p->flags & PG_UNMANAGED);
2013
2014         vm_page_unwire(p, 0);
2015         KKASSERT(p->wire_count == 0);
2016
2017         /*
2018          * Theoretically this page, if not the pml4 page, should contain
2019          * all-zeros.  But its just too dangerous to mark it PG_ZERO.  Free
2020          * normally.
2021          */
2022         vm_page_free(p);
2023 skip:
2024         pv_free(pv);
2025         return 0;
2026 }
2027
2028 /*
2029  * This function will remove the pte associated with a pv from its parent.
2030  * Terminal pv's are supported.  The removal will be interlocked if info
2031  * is non-NULL.  The caller must dispose of pv instead of just unlocking
2032  * it.
2033  *
2034  * The wire count will be dropped on the parent page table.  The wire
2035  * count on the page being removed (pv->pv_m) from the parent page table
2036  * is NOT touched.  Note that terminal pages will not have any additional
2037  * wire counts while page table pages will have at least one representing
2038  * the mapping, plus others representing sub-mappings.
2039  *
2040  * NOTE: Cannot be called on kernel page table pages, only KVM terminal
2041  *       pages and user page table and terminal pages.
2042  *
2043  * The pv must be locked.
2044  *
2045  * XXX must lock parent pv's if they exist to remove pte XXX
2046  */
2047 static
2048 void
2049 pmap_remove_pv_pte(pv_entry_t pv, pv_entry_t pvp, struct pmap_inval_info *info)
2050 {
2051         vm_pindex_t ptepindex = pv->pv_pindex;
2052         pmap_t pmap = pv->pv_pmap;
2053         vm_page_t p;
2054         int gotpvp = 0;
2055
2056         KKASSERT(pmap);
2057
2058         if (ptepindex == pmap_pml4_pindex()) {
2059                 /*
2060                  * We are the top level pml4 table, there is no parent.
2061                  */
2062                 p = pmap->pm_pmlpv->pv_m;
2063         } else if (ptepindex >= pmap_pdp_pindex(0)) {
2064                 /*
2065                  * Remove a PDP page from the pml4e.  This can only occur
2066                  * with user page tables.  We do not have to lock the
2067                  * pml4 PV so just ignore pvp.
2068                  */
2069                 vm_pindex_t pml4_pindex;
2070                 vm_pindex_t pdp_index;
2071                 pml4_entry_t *pdp;
2072
2073                 pdp_index = ptepindex - pmap_pdp_pindex(0);
2074                 if (pvp == NULL) {
2075                         pml4_pindex = pmap_pml4_pindex();
2076                         pvp = pv_get(pv->pv_pmap, pml4_pindex);
2077                         KKASSERT(pvp);
2078                         gotpvp = 1;
2079                 }
2080                 pdp = &pmap->pm_pml4[pdp_index & ((1ul << NPML4EPGSHIFT) - 1)];
2081                 KKASSERT((*pdp & PG_V) != 0);
2082                 p = PHYS_TO_VM_PAGE(*pdp & PG_FRAME);
2083                 *pdp = 0;
2084                 KKASSERT(info == NULL);
2085         } else if (ptepindex >= pmap_pd_pindex(0)) {
2086                 /*
2087                  * Remove a PD page from the pdp
2088                  *
2089                  * SIMPLE PMAP NOTE: Non-existant pvp's are ok in the case
2090                  *                   of a simple pmap because it stops at
2091                  *                   the PD page.
2092                  */
2093                 vm_pindex_t pdp_pindex;
2094                 vm_pindex_t pd_index;
2095                 pdp_entry_t *pd;
2096
2097                 pd_index = ptepindex - pmap_pd_pindex(0);
2098
2099                 if (pvp == NULL) {
2100                         pdp_pindex = NUPTE_TOTAL + NUPT_TOTAL + NUPD_TOTAL +
2101                                      (pd_index >> NPML4EPGSHIFT);
2102                         pvp = pv_get(pv->pv_pmap, pdp_pindex);
2103                         if (pvp)
2104                                 gotpvp = 1;
2105                 }
2106                 if (pvp) {
2107                         pd = pv_pte_lookup(pvp, pd_index &
2108                                                 ((1ul << NPDPEPGSHIFT) - 1));
2109                         KKASSERT((*pd & PG_V) != 0);
2110                         p = PHYS_TO_VM_PAGE(*pd & PG_FRAME);
2111                         *pd = 0;
2112                 } else {
2113                         KKASSERT(pmap->pm_flags & PMAP_FLAG_SIMPLE);
2114                         p = pv->pv_m;           /* degenerate test later */
2115                 }
2116                 KKASSERT(info == NULL);
2117         } else if (ptepindex >= pmap_pt_pindex(0)) {
2118                 /*
2119                  *  Remove a PT page from the pd
2120                  */
2121                 vm_pindex_t pd_pindex;
2122                 vm_pindex_t pt_index;
2123                 pd_entry_t *pt;
2124
2125                 pt_index = ptepindex - pmap_pt_pindex(0);
2126
2127                 if (pvp == NULL) {
2128                         pd_pindex = NUPTE_TOTAL + NUPT_TOTAL +
2129                                     (pt_index >> NPDPEPGSHIFT);
2130                         pvp = pv_get(pv->pv_pmap, pd_pindex);
2131                         KKASSERT(pvp);
2132                         gotpvp = 1;
2133                 }
2134                 pt = pv_pte_lookup(pvp, pt_index & ((1ul << NPDPEPGSHIFT) - 1));
2135                 KKASSERT((*pt & PG_V) != 0);
2136                 p = PHYS_TO_VM_PAGE(*pt & PG_FRAME);
2137                 *pt = 0;
2138                 KKASSERT(info == NULL);
2139         } else {
2140                 /*
2141                  * Remove a PTE from the PT page
2142                  *
2143                  * NOTE: pv's must be locked bottom-up to avoid deadlocking.
2144                  *       pv is a pte_pv so we can safely lock pt_pv.
2145                  */
2146                 vm_pindex_t pt_pindex;
2147                 pt_entry_t *ptep;
2148                 pt_entry_t pte;
2149                 vm_offset_t va;
2150
2151                 pt_pindex = ptepindex >> NPTEPGSHIFT;
2152                 va = (vm_offset_t)ptepindex << PAGE_SHIFT;
2153
2154                 if (ptepindex >= NUPTE_USER) {
2155                         ptep = vtopte(ptepindex << PAGE_SHIFT);
2156                         KKASSERT(pvp == NULL);
2157                 } else {
2158                         if (pvp == NULL) {
2159                                 pt_pindex = NUPTE_TOTAL +
2160                                             (ptepindex >> NPDPEPGSHIFT);
2161                                 pvp = pv_get(pv->pv_pmap, pt_pindex);
2162                                 KKASSERT(pvp);
2163                                 gotpvp = 1;
2164                         }
2165                         ptep = pv_pte_lookup(pvp, ptepindex &
2166                                                   ((1ul << NPDPEPGSHIFT) - 1));
2167                 }
2168
2169                 if (info)
2170                         pmap_inval_interlock(info, pmap, va);
2171                 pte = pte_load_clear(ptep);
2172                 if (info)
2173                         pmap_inval_deinterlock(info, pmap);
2174                 else
2175                         cpu_invlpg((void *)va);
2176
2177                 /*
2178                  * Now update the vm_page_t
2179                  */
2180                 if ((pte & (PG_MANAGED|PG_V)) != (PG_MANAGED|PG_V)) {
2181                         kprintf("remove_pte badpte %016lx %016lx %d\n",
2182                                 pte, pv->pv_pindex,
2183                                 pv->pv_pindex < pmap_pt_pindex(0));
2184                 }
2185                 /*KKASSERT((pte & (PG_MANAGED|PG_V)) == (PG_MANAGED|PG_V));*/
2186                 p = PHYS_TO_VM_PAGE(pte & PG_FRAME);
2187
2188                 if (pte & PG_M) {
2189                         if (pmap_track_modified(ptepindex))
2190                                 vm_page_dirty(p);
2191                 }
2192                 if (pte & PG_A) {
2193                         vm_page_flag_set(p, PG_REFERENCED);
2194                 }
2195                 if (pte & PG_W)
2196                         atomic_add_long(&pmap->pm_stats.wired_count, -1);
2197                 if (pte & PG_G)
2198                         cpu_invlpg((void *)va);
2199         }
2200
2201         /*
2202          * Unwire the parent page table page.  The wire_count cannot go below
2203          * 1 here because the parent page table page is itself still mapped.
2204          *
2205          * XXX remove the assertions later.
2206          */
2207         KKASSERT(pv->pv_m == p);
2208         if (pvp && vm_page_unwire_quick(pvp->pv_m))
2209                 panic("pmap_remove_pv_pte: Insufficient wire_count");
2210
2211         if (gotpvp)
2212                 pv_put(pvp);
2213 }
2214
2215 static
2216 vm_page_t
2217 pmap_remove_pv_page(pv_entry_t pv)
2218 {
2219         vm_page_t m;
2220
2221         m = pv->pv_m;
2222         KKASSERT(m);
2223         vm_page_spin_lock(m);
2224         pv->pv_m = NULL;
2225         TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
2226         /*
2227         if (m->object)
2228                 atomic_add_int(&m->object->agg_pv_list_count, -1);
2229         */
2230         if (TAILQ_EMPTY(&m->md.pv_list))
2231                 vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
2232         vm_page_spin_unlock(m);
2233         return(m);
2234 }
2235
2236 /*
2237  * Grow the number of kernel page table entries, if needed.
2238  *
2239  * This routine is always called to validate any address space
2240  * beyond KERNBASE (for kldloads).  kernel_vm_end only governs the address
2241  * space below KERNBASE.
2242  */
2243 void
2244 pmap_growkernel(vm_offset_t kstart, vm_offset_t kend)
2245 {
2246         vm_paddr_t paddr;
2247         vm_offset_t ptppaddr;
2248         vm_page_t nkpg;
2249         pd_entry_t *pt, newpt;
2250         pdp_entry_t newpd;
2251         int update_kernel_vm_end;
2252
2253         /*
2254          * bootstrap kernel_vm_end on first real VM use
2255          */
2256         if (kernel_vm_end == 0) {
2257                 kernel_vm_end = VM_MIN_KERNEL_ADDRESS;
2258                 nkpt = 0;
2259                 while ((*pmap_pt(&kernel_pmap, kernel_vm_end) & PG_V) != 0) {
2260                         kernel_vm_end = (kernel_vm_end + PAGE_SIZE * NPTEPG) &
2261                                         ~(PAGE_SIZE * NPTEPG - 1);
2262                         nkpt++;
2263                         if (kernel_vm_end - 1 >= kernel_map.max_offset) {
2264                                 kernel_vm_end = kernel_map.max_offset;
2265                                 break;
2266                         }
2267                 }
2268         }
2269
2270         /*
2271          * Fill in the gaps.  kernel_vm_end is only adjusted for ranges
2272          * below KERNBASE.  Ranges above KERNBASE are kldloaded and we
2273          * do not want to force-fill 128G worth of page tables.
2274          */
2275         if (kstart < KERNBASE) {
2276                 if (kstart > kernel_vm_end)
2277                         kstart = kernel_vm_end;
2278                 KKASSERT(kend <= KERNBASE);
2279                 update_kernel_vm_end = 1;
2280         } else {
2281                 update_kernel_vm_end = 0;
2282         }
2283
2284         kstart = rounddown2(kstart, PAGE_SIZE * NPTEPG);
2285         kend = roundup2(kend, PAGE_SIZE * NPTEPG);
2286
2287         if (kend - 1 >= kernel_map.max_offset)
2288                 kend = kernel_map.max_offset;
2289
2290         while (kstart < kend) {
2291                 pt = pmap_pt(&kernel_pmap, kstart);
2292                 if (pt == NULL) {
2293                         /* We need a new PDP entry */
2294                         nkpg = vm_page_alloc(NULL, nkpt,
2295                                              VM_ALLOC_NORMAL |
2296                                              VM_ALLOC_SYSTEM |
2297                                              VM_ALLOC_INTERRUPT);
2298                         if (nkpg == NULL) {
2299                                 panic("pmap_growkernel: no memory to grow "
2300                                       "kernel");
2301                         }
2302                         paddr = VM_PAGE_TO_PHYS(nkpg);
2303                         if ((nkpg->flags & PG_ZERO) == 0)
2304                                 pmap_zero_page(paddr);
2305                         vm_page_flag_clear(nkpg, PG_ZERO);
2306                         newpd = (pdp_entry_t)
2307                                 (paddr | PG_V | PG_RW | PG_A | PG_M);
2308                         *pmap_pd(&kernel_pmap, kstart) = newpd;
2309                         nkpt++;
2310                         continue; /* try again */
2311                 }
2312                 if ((*pt & PG_V) != 0) {
2313                         kstart = (kstart + PAGE_SIZE * NPTEPG) &
2314                                  ~(PAGE_SIZE * NPTEPG - 1);
2315                         if (kstart - 1 >= kernel_map.max_offset) {
2316                                 kstart = kernel_map.max_offset;
2317                                 break;
2318                         }
2319                         continue;
2320                 }
2321
2322                 /*
2323                  * This index is bogus, but out of the way
2324                  */
2325                 nkpg = vm_page_alloc(NULL, nkpt,
2326                                      VM_ALLOC_NORMAL |
2327                                      VM_ALLOC_SYSTEM |
2328                                      VM_ALLOC_INTERRUPT);
2329                 if (nkpg == NULL)
2330                         panic("pmap_growkernel: no memory to grow kernel");
2331
2332                 vm_page_wire(nkpg);
2333                 ptppaddr = VM_PAGE_TO_PHYS(nkpg);
2334                 pmap_zero_page(ptppaddr);
2335                 vm_page_flag_clear(nkpg, PG_ZERO);
2336                 newpt = (pd_entry_t) (ptppaddr | PG_V | PG_RW | PG_A | PG_M);
2337                 *pmap_pt(&kernel_pmap, kstart) = newpt;
2338                 nkpt++;
2339
2340                 kstart = (kstart + PAGE_SIZE * NPTEPG) &
2341                           ~(PAGE_SIZE * NPTEPG - 1);
2342
2343                 if (kstart - 1 >= kernel_map.max_offset) {
2344                         kstart = kernel_map.max_offset;
2345                         break;
2346                 }
2347         }
2348
2349         /*
2350          * Only update kernel_vm_end for areas below KERNBASE.
2351          */
2352         if (update_kernel_vm_end && kernel_vm_end < kstart)
2353                 kernel_vm_end = kstart;
2354 }
2355
2356 /*
2357  *      Add a reference to the specified pmap.
2358  */
2359 void
2360 pmap_reference(pmap_t pmap)
2361 {
2362         if (pmap != NULL) {
2363                 lwkt_gettoken(&pmap->pm_token);
2364                 ++pmap->pm_count;
2365                 lwkt_reltoken(&pmap->pm_token);
2366         }
2367 }
2368
2369 void
2370 pmap_drop(pmap_t pmap)
2371 {
2372         if (pmap != NULL) {
2373                 lwkt_gettoken(&pmap->pm_token);
2374                 --pmap->pm_count;
2375                 lwkt_reltoken(&pmap->pm_token);
2376         }
2377 }
2378
2379 /***************************************************
2380  * page management routines.
2381  ***************************************************/
2382
2383 /*
2384  * Hold a pv without locking it
2385  */
2386 static void
2387 pv_hold(pv_entry_t pv)
2388 {
2389         u_int count;
2390
2391         if (atomic_cmpset_int(&pv->pv_hold, 0, 1))
2392                 return;
2393
2394         for (;;) {
2395                 count = pv->pv_hold;
2396                 cpu_ccfence();
2397                 if (atomic_cmpset_int(&pv->pv_hold, count, count + 1))
2398                         return;
2399                 /* retry */
2400         }
2401 }
2402
2403 /*
2404  * Hold a pv_entry, preventing its destruction.  TRUE is returned if the pv
2405  * was successfully locked, FALSE if it wasn't.  The caller must dispose of
2406  * the pv properly.
2407  *
2408  * Either the pmap->pm_spin or the related vm_page_spin (if traversing a
2409  * pv list via its page) must be held by the caller.
2410  */
2411 static int
2412 _pv_hold_try(pv_entry_t pv PMAP_DEBUG_DECL)
2413 {
2414         u_int count;
2415
2416         if (atomic_cmpset_int(&pv->pv_hold, 0, PV_HOLD_LOCKED | 1)) {
2417 #ifdef PMAP_DEBUG
2418                 pv->pv_func = func;
2419                 pv->pv_line = lineno;
2420 #endif
2421                 return TRUE;
2422         }
2423
2424         for (;;) {
2425                 count = pv->pv_hold;
2426                 cpu_ccfence();
2427                 if ((count & PV_HOLD_LOCKED) == 0) {
2428                         if (atomic_cmpset_int(&pv->pv_hold, count,
2429                                               (count + 1) | PV_HOLD_LOCKED)) {
2430 #ifdef PMAP_DEBUG
2431                                 pv->pv_func = func;
2432                                 pv->pv_line = lineno;
2433 #endif
2434                                 return TRUE;
2435                         }
2436                 } else {
2437                         if (atomic_cmpset_int(&pv->pv_hold, count, count + 1))
2438                                 return FALSE;
2439                 }
2440                 /* retry */
2441         }
2442 }
2443
2444 /*
2445  * Drop a previously held pv_entry which could not be locked, allowing its
2446  * destruction.
2447  *
2448  * Must not be called with a spinlock held as we might zfree() the pv if it
2449  * is no longer associated with a pmap and this was the last hold count.
2450  */
2451 static void
2452 pv_drop(pv_entry_t pv)
2453 {
2454         u_int count;
2455
2456         if (atomic_cmpset_int(&pv->pv_hold, 1, 0)) {
2457                 if (pv->pv_pmap == NULL)
2458                         zfree(pvzone, pv);
2459                 return;
2460         }
2461
2462         for (;;) {
2463                 count = pv->pv_hold;
2464                 cpu_ccfence();
2465                 KKASSERT((count & PV_HOLD_MASK) > 0);
2466                 KKASSERT((count & (PV_HOLD_LOCKED | PV_HOLD_MASK)) !=
2467                          (PV_HOLD_LOCKED | 1));
2468                 if (atomic_cmpset_int(&pv->pv_hold, count, count - 1)) {
2469                         if (count == 1 && pv->pv_pmap == NULL)
2470                                 zfree(pvzone, pv);
2471                         return;
2472                 }
2473                 /* retry */
2474         }
2475 }
2476
2477 /*
2478  * Find or allocate the requested PV entry, returning a locked pv
2479  */
2480 static
2481 pv_entry_t
2482 _pv_alloc(pmap_t pmap, vm_pindex_t pindex, int *isnew PMAP_DEBUG_DECL)
2483 {
2484         pv_entry_t pv;
2485         pv_entry_t pnew = NULL;
2486
2487         spin_lock(&pmap->pm_spin);
2488         for (;;) {
2489                 if ((pv = pmap->pm_pvhint) == NULL || pv->pv_pindex != pindex) {
2490                         pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot,
2491                                                         pindex);
2492                 }
2493                 if (pv == NULL) {
2494                         if (pnew == NULL) {
2495                                 spin_unlock(&pmap->pm_spin);
2496                                 pnew = zalloc(pvzone);
2497                                 spin_lock(&pmap->pm_spin);
2498                                 continue;
2499                         }
2500                         pnew->pv_pmap = pmap;
2501                         pnew->pv_pindex = pindex;
2502                         pnew->pv_hold = PV_HOLD_LOCKED | 1;
2503 #ifdef PMAP_DEBUG
2504                         pnew->pv_func = func;
2505                         pnew->pv_line = lineno;
2506 #endif
2507                         pv_entry_rb_tree_RB_INSERT(&pmap->pm_pvroot, pnew);
2508                         atomic_add_long(&pmap->pm_stats.resident_count, 1);
2509                         spin_unlock(&pmap->pm_spin);
2510                         *isnew = 1;
2511                         return(pnew);
2512                 }
2513                 if (pnew) {
2514                         spin_unlock(&pmap->pm_spin);
2515                         zfree(pvzone, pnew);
2516                         pnew = NULL;
2517                         spin_lock(&pmap->pm_spin);
2518                         continue;
2519                 }
2520                 if (_pv_hold_try(pv PMAP_DEBUG_COPY)) {
2521                         spin_unlock(&pmap->pm_spin);
2522                         *isnew = 0;
2523                         return(pv);
2524                 }
2525                 spin_unlock(&pmap->pm_spin);
2526                 _pv_lock(pv PMAP_DEBUG_COPY);
2527                 if (pv->pv_pmap == pmap && pv->pv_pindex == pindex) {
2528                         *isnew = 0;
2529                         return(pv);
2530                 }
2531                 pv_put(pv);
2532                 spin_lock(&pmap->pm_spin);
2533         }
2534
2535
2536 }
2537
2538 /*
2539  * Find the requested PV entry, returning a locked+held pv or NULL
2540  */
2541 static
2542 pv_entry_t
2543 _pv_get(pmap_t pmap, vm_pindex_t pindex PMAP_DEBUG_DECL)
2544 {
2545         pv_entry_t pv;
2546
2547         spin_lock(&pmap->pm_spin);
2548         for (;;) {
2549                 /*
2550                  * Shortcut cache
2551                  */
2552                 if ((pv = pmap->pm_pvhint) == NULL || pv->pv_pindex != pindex) {
2553                         pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot,
2554                                                         pindex);
2555                 }
2556                 if (pv == NULL) {
2557                         spin_unlock(&pmap->pm_spin);
2558                         return NULL;
2559                 }
2560                 if (_pv_hold_try(pv PMAP_DEBUG_COPY)) {
2561                         pv_cache(pv, pindex);
2562                         spin_unlock(&pmap->pm_spin);
2563                         return(pv);
2564                 }
2565                 spin_unlock(&pmap->pm_spin);
2566                 _pv_lock(pv PMAP_DEBUG_COPY);
2567                 if (pv->pv_pmap == pmap && pv->pv_pindex == pindex)
2568                         return(pv);
2569                 pv_put(pv);
2570                 spin_lock(&pmap->pm_spin);
2571         }
2572 }
2573
2574 /*
2575  * Lookup, hold, and attempt to lock (pmap,pindex).
2576  *
2577  * If the entry does not exist NULL is returned and *errorp is set to 0
2578  *
2579  * If the entry exists and could be successfully locked it is returned and
2580  * errorp is set to 0.
2581  *
2582  * If the entry exists but could NOT be successfully locked it is returned
2583  * held and *errorp is set to 1.
2584  */
2585 static
2586 pv_entry_t
2587 pv_get_try(pmap_t pmap, vm_pindex_t pindex, int *errorp)
2588 {
2589         pv_entry_t pv;
2590
2591         spin_lock(&pmap->pm_spin);
2592         if ((pv = pmap->pm_pvhint) == NULL || pv->pv_pindex != pindex)
2593                 pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot, pindex);
2594         if (pv == NULL) {
2595                 spin_unlock(&pmap->pm_spin);
2596                 *errorp = 0;
2597                 return NULL;
2598         }
2599         if (pv_hold_try(pv)) {
2600                 pv_cache(pv, pindex);
2601                 spin_unlock(&pmap->pm_spin);
2602                 *errorp = 0;
2603                 return(pv);     /* lock succeeded */
2604         }
2605         spin_unlock(&pmap->pm_spin);
2606         *errorp = 1;
2607         return (pv);            /* lock failed */
2608 }
2609
2610 /*
2611  * Find the requested PV entry, returning a held pv or NULL
2612  */
2613 static
2614 pv_entry_t
2615 pv_find(pmap_t pmap, vm_pindex_t pindex)
2616 {
2617         pv_entry_t pv;
2618
2619         spin_lock(&pmap->pm_spin);
2620
2621         if ((pv = pmap->pm_pvhint) == NULL || pv->pv_pindex != pindex)
2622                 pv = pv_entry_rb_tree_RB_LOOKUP(&pmap->pm_pvroot, pindex);
2623         if (pv == NULL) {
2624                 spin_unlock(&pmap->pm_spin);
2625                 return NULL;
2626         }
2627         pv_hold(pv);
2628         pv_cache(pv, pindex);
2629         spin_unlock(&pmap->pm_spin);
2630         return(pv);
2631 }
2632
2633 /*
2634  * Lock a held pv, keeping the hold count
2635  */
2636 static
2637 void
2638 _pv_lock(pv_entry_t pv PMAP_DEBUG_DECL)
2639 {
2640         u_int count;
2641
2642         for (;;) {
2643                 count = pv->pv_hold;
2644                 cpu_ccfence();
2645                 if ((count & PV_HOLD_LOCKED) == 0) {
2646                         if (atomic_cmpset_int(&pv->pv_hold, count,
2647                                               count | PV_HOLD_LOCKED)) {
2648 #ifdef PMAP_DEBUG
2649                                 pv->pv_func = func;
2650                                 pv->pv_line = lineno;
2651 #endif
2652                                 return;
2653                         }
2654                         continue;
2655                 }
2656                 tsleep_interlock(pv, 0);
2657                 if (atomic_cmpset_int(&pv->pv_hold, count,
2658                                       count | PV_HOLD_WAITING)) {
2659 #ifdef PMAP_DEBUG
2660                         kprintf("pv waiting on %s:%d\n",
2661                                         pv->pv_func, pv->pv_line);
2662 #endif
2663                         tsleep(pv, PINTERLOCKED, "pvwait", hz);
2664                 }
2665                 /* retry */
2666         }
2667 }
2668
2669 /*
2670  * Unlock a held and locked pv, keeping the hold count.
2671  */
2672 static
2673 void
2674 pv_unlock(pv_entry_t pv)
2675 {
2676         u_int count;
2677
2678         if (atomic_cmpset_int(&pv->pv_hold, PV_HOLD_LOCKED | 1, 1))
2679                 return;
2680
2681         for (;;) {
2682                 count = pv->pv_hold;
2683                 cpu_ccfence();
2684                 KKASSERT((count & (PV_HOLD_LOCKED|PV_HOLD_MASK)) >=
2685                          (PV_HOLD_LOCKED | 1));
2686                 if (atomic_cmpset_int(&pv->pv_hold, count,
2687                                       count &
2688                                       ~(PV_HOLD_LOCKED | PV_HOLD_WAITING))) {
2689                         if (count & PV_HOLD_WAITING)
2690                                 wakeup(pv);
2691                         break;
2692                 }
2693         }
2694 }
2695
2696 /*
2697  * Unlock and drop a pv.  If the pv is no longer associated with a pmap
2698  * and the hold count drops to zero we will free it.
2699  *
2700  * Caller should not hold any spin locks.  We are protected from hold races
2701  * by virtue of holds only occuring only with a pmap_spin or vm_page_spin
2702  * lock held.  A pv cannot be located otherwise.
2703  */
2704 static
2705 void
2706 pv_put(pv_entry_t pv)
2707 {
2708         if (atomic_cmpset_int(&pv->pv_hold, PV_HOLD_LOCKED | 1, 0)) {
2709                 if (pv->pv_pmap == NULL)
2710                         zfree(pvzone, pv);
2711                 return;
2712         }
2713         pv_unlock(pv);
2714         pv_drop(pv);
2715 }
2716
2717 /*
2718  * Unlock, drop, and free a pv, destroying it.  The pv is removed from its
2719  * pmap.  Any pte operations must have already been completed.
2720  */
2721 static
2722 void
2723 pv_free(pv_entry_t pv)
2724 {
2725         pmap_t pmap;
2726
2727         KKASSERT(pv->pv_m == NULL);
2728         if ((pmap = pv->pv_pmap) != NULL) {
2729                 spin_lock(&pmap->pm_spin);
2730                 pv_entry_rb_tree_RB_REMOVE(&pmap->pm_pvroot, pv);
2731                 if (pmap->pm_pvhint == pv)
2732                         pmap->pm_pvhint = NULL;
2733                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
2734                 pv->pv_pmap = NULL;
2735                 pv->pv_pindex = 0;
2736                 spin_unlock(&pmap->pm_spin);
2737         }
2738         pv_put(pv);
2739 }
2740
2741 /*
2742  * This routine is very drastic, but can save the system
2743  * in a pinch.
2744  */
2745 void
2746 pmap_collect(void)
2747 {
2748         int i;
2749         vm_page_t m;
2750         static int warningdone=0;
2751
2752         if (pmap_pagedaemon_waken == 0)
2753                 return;
2754         pmap_pagedaemon_waken = 0;
2755         if (warningdone < 5) {
2756                 kprintf("pmap_collect: collecting pv entries -- "
2757                         "suggest increasing PMAP_SHPGPERPROC\n");
2758                 warningdone++;
2759         }
2760
2761         for (i = 0; i < vm_page_array_size; i++) {
2762                 m = &vm_page_array[i];
2763                 if (m->wire_count || m->hold_count)
2764                         continue;
2765                 if (vm_page_busy_try(m, TRUE) == 0) {
2766                         if (m->wire_count == 0 && m->hold_count == 0) {
2767                                 pmap_remove_all(m);
2768                         }
2769                         vm_page_wakeup(m);
2770                 }
2771         }
2772 }
2773
2774 /*
2775  * Scan the pmap for active page table entries and issue a callback.
2776  * The callback must dispose of pte_pv, whos PTE entry is at *ptep in
2777  * its parent page table.
2778  *
2779  * pte_pv will be NULL if the page or page table is unmanaged.
2780  * pt_pv will point to the page table page containing the pte for the page.
2781  *
2782  * NOTE! If we come across an unmanaged page TABLE (verses an unmanaged page),
2783  *       we pass a NULL pte_pv and we pass a pt_pv pointing to the passed
2784  *       process pmap's PD and page to the callback function.  This can be
2785  *       confusing because the pt_pv is really a pd_pv, and the target page
2786  *       table page is simply aliased by the pmap and not owned by it.
2787  *
2788  * It is assumed that the start and end are properly rounded to the page size.
2789  *
2790  * It is assumed that PD pages and above are managed and thus in the RB tree,
2791  * allowing us to use RB_SCAN from the PD pages down for ranged scans.
2792  */
2793 struct pmap_scan_info {
2794         struct pmap *pmap;
2795         vm_offset_t sva;
2796         vm_offset_t eva;
2797         vm_pindex_t sva_pd_pindex;
2798         vm_pindex_t eva_pd_pindex;
2799         void (*func)(pmap_t, struct pmap_inval_info *,
2800                      pv_entry_t, pv_entry_t, int, vm_offset_t,
2801                      pt_entry_t *, void *);
2802         void *arg;
2803         struct pmap_inval_info inval;
2804 };
2805
2806 static int pmap_scan_cmp(pv_entry_t pv, void *data);
2807 static int pmap_scan_callback(pv_entry_t pv, void *data);
2808
2809 static void
2810 pmap_scan(struct pmap_scan_info *info)
2811 {
2812         struct pmap *pmap = info->pmap;
2813         pv_entry_t pd_pv;       /* A page directory PV */
2814         pv_entry_t pt_pv;       /* A page table PV */
2815         pv_entry_t pte_pv;      /* A page table entry PV */
2816         pt_entry_t *ptep;
2817         struct pv_entry dummy_pv;
2818
2819         if (pmap == NULL)
2820                 return;
2821
2822         /*
2823          * Hold the token for stability; if the pmap is empty we have nothing
2824          * to do.
2825          */
2826         lwkt_gettoken(&pmap->pm_token);
2827 #if 0
2828         if (pmap->pm_stats.resident_count == 0) {
2829                 lwkt_reltoken(&pmap->pm_token);
2830                 return;
2831         }
2832 #endif
2833
2834         pmap_inval_init(&info->inval);
2835
2836         /*
2837          * Special handling for scanning one page, which is a very common
2838          * operation (it is?).
2839          *
2840          * NOTE: Locks must be ordered bottom-up. pte,pt,pd,pdp,pml4
2841          */
2842         if (info->sva + PAGE_SIZE == info->eva) {
2843                 if (info->sva >= VM_MAX_USER_ADDRESS) {
2844                         /*
2845                          * Kernel mappings do not track wire counts on
2846                          * page table pages and only maintain pd_pv and
2847                          * pte_pv levels so pmap_scan() works.
2848                          */
2849                         pt_pv = NULL;
2850                         pte_pv = pv_get(pmap, pmap_pte_pindex(info->sva));
2851                         ptep = vtopte(info->sva);
2852                 } else {
2853                         /*
2854                          * User pages which are unmanaged will not have a
2855                          * pte_pv.  User page table pages which are unmanaged
2856                          * (shared from elsewhere) will also not have a pt_pv.
2857                          * The func() callback will pass both pte_pv and pt_pv
2858                          * as NULL in that case.
2859                          */
2860                         pte_pv = pv_get(pmap, pmap_pte_pindex(info->sva));
2861                         pt_pv = pv_get(pmap, pmap_pt_pindex(info->sva));
2862                         if (pt_pv == NULL) {
2863                                 KKASSERT(pte_pv == NULL);
2864                                 pd_pv = pv_get(pmap, pmap_pd_pindex(info->sva));
2865                                 if (pd_pv) {
2866                                         ptep = pv_pte_lookup(pd_pv,
2867                                                     pmap_pt_index(info->sva));
2868                                         if (*ptep) {
2869                                                 info->func(pmap, &info->inval,
2870                                                      NULL, pd_pv, 1,
2871                                                      info->sva, ptep,
2872                                                      info->arg);
2873                                         }
2874                                         pv_put(pd_pv);
2875                                 }
2876                                 goto fast_skip;
2877                         }
2878                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(info->sva));
2879                 }
2880                 if (*ptep == 0) {
2881                         /*
2882                          * Unlike the pv_find() case below we actually
2883                          * acquired a locked pv in this case so any
2884                          * race should have been resolved.  It is expected
2885                          * to not exist.
2886                          */
2887                         KKASSERT(pte_pv == NULL);
2888                 } else if (pte_pv) {
2889                         KASSERT((*ptep & (PG_MANAGED|PG_V)) == (PG_MANAGED|
2890                                                                 PG_V),
2891                                 ("bad *ptep %016lx sva %016lx pte_pv %p",
2892                                 *ptep, info->sva, pte_pv));
2893                         info->func(pmap, &info->inval, pte_pv, pt_pv, 0,
2894                                    info->sva, ptep, info->arg);
2895                 } else {
2896                         KASSERT((*ptep & (PG_MANAGED|PG_V)) == PG_V,
2897                                 ("bad *ptep %016lx sva %016lx pte_pv NULL",
2898                                 *ptep, info->sva));
2899                         info->func(pmap, &info->inval, NULL, pt_pv, 0,
2900                                    info->sva, ptep, info->arg);
2901                 }
2902                 if (pt_pv)
2903                         pv_put(pt_pv);
2904 fast_skip:
2905                 pmap_inval_done(&info->inval);
2906                 lwkt_reltoken(&pmap->pm_token);
2907                 return;
2908         }
2909
2910         /*
2911          * Nominal scan case, RB_SCAN() for PD pages and iterate from
2912          * there.
2913          */
2914         info->sva_pd_pindex = pmap_pd_pindex(info->sva);
2915         info->eva_pd_pindex = pmap_pd_pindex(info->eva + NBPDP - 1);
2916
2917         if (info->sva >= VM_MAX_USER_ADDRESS) {
2918                 /*
2919                  * The kernel does not currently maintain any pv_entry's for
2920                  * higher-level page tables.
2921                  */
2922                 bzero(&dummy_pv, sizeof(dummy_pv));
2923                 dummy_pv.pv_pindex = info->sva_pd_pindex;
2924                 spin_lock(&pmap->pm_spin);
2925                 while (dummy_pv.pv_pindex < info->eva_pd_pindex) {
2926                         pmap_scan_callback(&dummy_pv, info);
2927                         ++dummy_pv.pv_pindex;
2928                 }
2929                 spin_unlock(&pmap->pm_spin);
2930         } else {
2931                 /*
2932                  * User page tables maintain local PML4, PDP, and PD
2933                  * pv_entry's at the very least.  PT pv's might be
2934                  * unmanaged and thus not exist.  PTE pv's might be
2935                  * unmanaged and thus not exist.
2936                  */
2937                 spin_lock(&pmap->pm_spin);
2938                 pv_entry_rb_tree_RB_SCAN(&pmap->pm_pvroot,
2939                         pmap_scan_cmp, pmap_scan_callback, info);
2940                 spin_unlock(&pmap->pm_spin);
2941         }
2942         pmap_inval_done(&info->inval);
2943         lwkt_reltoken(&pmap->pm_token);
2944 }
2945
2946 /*
2947  * WARNING! pmap->pm_spin held
2948  */
2949 static int
2950 pmap_scan_cmp(pv_entry_t pv, void *data)
2951 {
2952         struct pmap_scan_info *info = data;
2953         if (pv->pv_pindex < info->sva_pd_pindex)
2954                 return(-1);
2955         if (pv->pv_pindex >= info->eva_pd_pindex)
2956                 return(1);
2957         return(0);
2958 }
2959
2960 /*
2961  * WARNING! pmap->pm_spin held
2962  */
2963 static int
2964 pmap_scan_callback(pv_entry_t pv, void *data)
2965 {
2966         struct pmap_scan_info *info = data;
2967         struct pmap *pmap = info->pmap;
2968         pv_entry_t pd_pv;       /* A page directory PV */
2969         pv_entry_t pt_pv;       /* A page table PV */
2970         pv_entry_t pte_pv;      /* A page table entry PV */
2971         pt_entry_t *ptep;
2972         vm_offset_t sva;
2973         vm_offset_t eva;
2974         vm_offset_t va_next;
2975         vm_pindex_t pd_pindex;
2976         int error;
2977
2978         /*
2979          * Pull the PD pindex from the pv before releasing the spinlock.
2980          *
2981          * WARNING: pv is faked for kernel pmap scans.
2982          */
2983         pd_pindex = pv->pv_pindex;
2984         spin_unlock(&pmap->pm_spin);
2985         pv = NULL;      /* invalid after spinlock unlocked */
2986
2987         /*
2988          * Calculate the page range within the PD.  SIMPLE pmaps are
2989          * direct-mapped for the entire 2^64 address space.  Normal pmaps
2990          * reflect the user and kernel address space which requires
2991          * cannonicalization w/regards to converting pd_pindex's back
2992          * into addresses.
2993          */
2994         sva = (pd_pindex - NUPTE_TOTAL - NUPT_TOTAL) << PDPSHIFT;
2995         if ((pmap->pm_flags & PMAP_FLAG_SIMPLE) == 0 &&
2996             (sva & PML4_SIGNMASK)) {
2997                 sva |= PML4_SIGNMASK;
2998         }
2999         eva = sva + NBPDP;      /* can overflow */
3000         if (sva < info->sva)
3001                 sva = info->sva;
3002         if (eva < info->sva || eva > info->eva)
3003                 eva = info->eva;
3004
3005         /*
3006          * NOTE: kernel mappings do not track page table pages, only
3007          *       terminal pages.
3008          *
3009          * NOTE: Locks must be ordered bottom-up. pte,pt,pd,pdp,pml4.
3010          *       However, for the scan to be efficient we try to
3011          *       cache items top-down.
3012          */
3013         pd_pv = NULL;
3014         pt_pv = NULL;
3015
3016         for (; sva < eva; sva = va_next) {
3017                 lwkt_yield();
3018                 if (sva >= VM_MAX_USER_ADDRESS) {
3019                         if (pt_pv) {
3020                                 pv_put(pt_pv);
3021                                 pt_pv = NULL;
3022                         }
3023                         goto kernel_skip;
3024                 }
3025
3026                 /*
3027                  * PD cache (degenerate case if we skip).  It is possible
3028                  * for the PD to not exist due to races.  This is ok.
3029                  */
3030                 if (pd_pv == NULL) {
3031                         pd_pv = pv_get(pmap, pmap_pd_pindex(sva));
3032                 } else if (pd_pv->pv_pindex != pmap_pd_pindex(sva)) {
3033                         pv_put(pd_pv);
3034                         pd_pv = pv_get(pmap, pmap_pd_pindex(sva));
3035                 }
3036                 if (pd_pv == NULL) {
3037                         va_next = (sva + NBPDP) & ~PDPMASK;
3038                         if (va_next < sva)
3039                                 va_next = eva;
3040                         continue;
3041                 }
3042
3043                 /*
3044                  * PT cache
3045                  */
3046                 if (pt_pv == NULL) {
3047                         if (pd_pv) {
3048                                 pv_put(pd_pv);
3049                                 pd_pv = NULL;
3050                         }
3051                         pt_pv = pv_get(pmap, pmap_pt_pindex(sva));
3052                 } else if (pt_pv->pv_pindex != pmap_pt_pindex(sva)) {
3053                         if (pd_pv) {
3054                                 pv_put(pd_pv);
3055                                 pd_pv = NULL;
3056                         }
3057                         pv_put(pt_pv);
3058                         pt_pv = pv_get(pmap, pmap_pt_pindex(sva));
3059                 }
3060
3061                 /*
3062                  * If pt_pv is NULL we either have an shared page table
3063                  * page and must issue a callback specific to that case,
3064                  * or there is no page table page.
3065                  *
3066                  * Either way we can skip the page table page.
3067                  */
3068                 if (pt_pv == NULL) {
3069                         /*
3070                          * Possible unmanaged (shared from another pmap)
3071                          * page table page.
3072                          */
3073                         if (pd_pv == NULL)
3074                                 pd_pv = pv_get(pmap, pmap_pd_pindex(sva));
3075                         KKASSERT(pd_pv != NULL);
3076                         ptep = pv_pte_lookup(pd_pv, pmap_pt_index(sva));
3077                         if (*ptep & PG_V) {
3078                                 info->func(pmap, &info->inval, NULL, pd_pv, 1,
3079                                            sva, ptep, info->arg);
3080                         }
3081
3082                         /*
3083                          * Done, move to next page table page.
3084                          */
3085                         va_next = (sva + NBPDR) & ~PDRMASK;
3086                         if (va_next < sva)
3087                                 va_next = eva;
3088                         continue;
3089                 }
3090
3091                 /*
3092                  * From this point in the loop testing pt_pv for non-NULL
3093                  * means we are in UVM, else if it is NULL we are in KVM.
3094                  *
3095                  * Limit our scan to either the end of the va represented
3096                  * by the current page table page, or to the end of the
3097                  * range being removed.
3098                  */
3099 kernel_skip:
3100                 va_next = (sva + NBPDR) & ~PDRMASK;
3101                 if (va_next < sva)
3102                         va_next = eva;
3103                 if (va_next > eva)
3104                         va_next = eva;
3105
3106                 /*
3107                  * Scan the page table for pages.  Some pages may not be
3108                  * managed (might not have a pv_entry).
3109                  *
3110                  * There is no page table management for kernel pages so
3111                  * pt_pv will be NULL in that case, but otherwise pt_pv
3112                  * is non-NULL, locked, and referenced.
3113                  */
3114
3115                 /*
3116                  * At this point a non-NULL pt_pv means a UVA, and a NULL
3117                  * pt_pv means a KVA.
3118                  */
3119                 if (pt_pv)
3120                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(sva));
3121                 else
3122                         ptep = vtopte(sva);
3123
3124                 while (sva < va_next) {
3125                         /*
3126                          * Acquire the related pte_pv, if any.  If *ptep == 0
3127                          * the related pte_pv should not exist, but if *ptep
3128                          * is not zero the pte_pv may or may not exist (e.g.
3129                          * will not exist for an unmanaged page).
3130                          *
3131                          * However a multitude of races are possible here.
3132                          *
3133                          * In addition, the (pt_pv, pte_pv) lock order is
3134                          * backwards, so we have to be careful in aquiring
3135                          * a properly locked pte_pv.
3136                          */
3137                         lwkt_yield();
3138                         if (pt_pv) {
3139                                 pte_pv = pv_get_try(pmap, pmap_pte_pindex(sva),
3140                                                     &error);
3141                                 if (error) {
3142                                         if (pd_pv) {
3143                                                 pv_put(pd_pv);
3144                                                 pd_pv = NULL;
3145                                         }
3146                                         pv_put(pt_pv);   /* must be non-NULL */
3147                                         pt_pv = NULL;
3148                                         pv_lock(pte_pv); /* safe to block now */
3149                                         pv_put(pte_pv);
3150                                         pte_pv = NULL;
3151                                         pt_pv = pv_get(pmap,
3152                                                        pmap_pt_pindex(sva));
3153                                         /*
3154                                          * pt_pv reloaded, need new ptep
3155                                          */
3156                                         KKASSERT(pt_pv != NULL);
3157                                         ptep = pv_pte_lookup(pt_pv,
3158                                                         pmap_pte_index(sva));
3159                                         continue;
3160                                 }
3161                         } else {
3162                                 pte_pv = pv_get(pmap, pmap_pte_pindex(sva));
3163                         }
3164
3165                         /*
3166                          * Ok, if *ptep == 0 we had better NOT have a pte_pv.
3167                          */
3168                         if (*ptep == 0) {
3169                                 if (pte_pv) {
3170                                         kprintf("Unexpected non-NULL pte_pv "
3171                                                 "%p pt_pv %p *ptep = %016lx\n",
3172                                                 pte_pv, pt_pv, *ptep);
3173                                         panic("Unexpected non-NULL pte_pv");
3174                                 }
3175                                 sva += PAGE_SIZE;
3176                                 ++ptep;
3177                                 continue;
3178                         }
3179
3180                         /*
3181                          * Ready for the callback.  The locked pte_pv (if any)
3182                          * is consumed by the callback.  pte_pv will exist if
3183                          *  the page is managed, and will not exist if it
3184                          * isn't.
3185                          */
3186                         if (pte_pv) {
3187                                 KASSERT((*ptep & (PG_MANAGED|PG_V)) ==
3188                                          (PG_MANAGED|PG_V),
3189                                         ("bad *ptep %016lx sva %016lx "
3190                                          "pte_pv %p",
3191                                          *ptep, sva, pte_pv));
3192                                 info->func(pmap, &info->inval, pte_pv, pt_pv, 0,
3193                                            sva, ptep, info->arg);
3194                         } else {
3195                                 KASSERT((*ptep & (PG_MANAGED|PG_V)) ==
3196                                          PG_V,
3197                                         ("bad *ptep %016lx sva %016lx "
3198                                          "pte_pv NULL",
3199                                          *ptep, sva));
3200                                 info->func(pmap, &info->inval, NULL, pt_pv, 0,
3201                                            sva, ptep, info->arg);
3202                         }
3203                         pte_pv = NULL;
3204                         sva += PAGE_SIZE;
3205                         ++ptep;
3206                 }
3207         }
3208         if (pd_pv) {
3209                 pv_put(pd_pv);
3210                 pd_pv = NULL;
3211         }
3212         if (pt_pv) {
3213                 pv_put(pt_pv);
3214                 pt_pv = NULL;
3215         }
3216
3217         /*
3218          * Relock before returning.
3219          */
3220         spin_lock(&pmap->pm_spin);
3221         return (0);
3222 }
3223
3224 void
3225 pmap_remove(struct pmap *pmap, vm_offset_t sva, vm_offset_t eva)
3226 {
3227         struct pmap_scan_info info;
3228
3229         info.pmap = pmap;
3230         info.sva = sva;
3231         info.eva = eva;
3232         info.func = pmap_remove_callback;
3233         info.arg = NULL;
3234         pmap_scan(&info);
3235 }
3236
3237 static void
3238 pmap_remove_callback(pmap_t pmap, struct pmap_inval_info *info,
3239                      pv_entry_t pte_pv, pv_entry_t pt_pv, int sharept,
3240                      vm_offset_t va, pt_entry_t *ptep, void *arg __unused)
3241 {
3242         pt_entry_t pte;
3243
3244         if (pte_pv) {
3245                 /*
3246                  * This will also drop pt_pv's wire_count. Note that
3247                  * terminal pages are not wired based on mmu presence.
3248                  */
3249                 pmap_remove_pv_pte(pte_pv, pt_pv, info);
3250                 pmap_remove_pv_page(pte_pv);
3251                 pv_free(pte_pv);
3252         } else if (sharept == 0) {
3253                 /*
3254                  * Unmanaged page
3255                  *
3256                  * pt_pv's wire_count is still bumped by unmanaged pages
3257                  * so we must decrement it manually.
3258                  */
3259                 pmap_inval_interlock(info, pmap, va);
3260                 pte = pte_load_clear(ptep);
3261                 pmap_inval_deinterlock(info, pmap);
3262                 if (pte & PG_W)
3263                         atomic_add_long(&pmap->pm_stats.wired_count, -1);
3264                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
3265                 if (vm_page_unwire_quick(pt_pv->pv_m))
3266                         panic("pmap_remove: insufficient wirecount");
3267         } else {
3268                 /*
3269                  * Unmanaged page table, pt_pv is actually the pd_pv
3270                  * for our pmap (not the share object pmap).
3271                  *
3272                  * We have to unwire the target page table page and we
3273                  * have to unwire our page directory page.
3274                  */
3275                 pmap_inval_interlock(info, pmap, va);
3276                 pte = pte_load_clear(ptep);
3277                 pmap_inval_deinterlock(info, pmap);
3278                 atomic_add_long(&pmap->pm_stats.resident_count, -1);
3279                 if (vm_page_unwire_quick(PHYS_TO_VM_PAGE(pte & PG_FRAME)))
3280                         panic("pmap_remove: shared pgtable1 bad wirecount");
3281                 if (vm_page_unwire_quick(pt_pv->pv_m))
3282                         panic("pmap_remove: shared pgtable2 bad wirecount");
3283         }
3284 }
3285
3286 /*
3287  * Removes this physical page from all physical maps in which it resides.
3288  * Reflects back modify bits to the pager.
3289  *
3290  * This routine may not be called from an interrupt.
3291  */
3292 static
3293 void
3294 pmap_remove_all(vm_page_t m)
3295 {
3296         struct pmap_inval_info info;
3297         pv_entry_t pv;
3298
3299         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
3300                 return;
3301
3302         pmap_inval_init(&info);
3303         vm_page_spin_lock(m);
3304         while ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
3305                 KKASSERT(pv->pv_m == m);
3306                 if (pv_hold_try(pv)) {
3307                         vm_page_spin_unlock(m);
3308                 } else {
3309                         vm_page_spin_unlock(m);
3310                         pv_lock(pv);
3311                         if (pv->pv_m != m) {
3312                                 pv_put(pv);
3313                                 vm_page_spin_lock(m);
3314                                 continue;
3315                         }
3316                 }
3317                 /*
3318                  * Holding no spinlocks, pv is locked.
3319                  */
3320                 pmap_remove_pv_pte(pv, NULL, &info);
3321                 pmap_remove_pv_page(pv);
3322                 pv_free(pv);
3323                 vm_page_spin_lock(m);
3324         }
3325         KKASSERT((m->flags & (PG_MAPPED|PG_WRITEABLE)) == 0);
3326         vm_page_spin_unlock(m);
3327         pmap_inval_done(&info);
3328 }
3329
3330 /*
3331  * Set the physical protection on the specified range of this map
3332  * as requested.  This function is typically only used for debug watchpoints
3333  * and COW pages.
3334  *
3335  * This function may not be called from an interrupt if the map is
3336  * not the kernel_pmap.
3337  *
3338  * NOTE!  For shared page table pages we just unmap the page.
3339  */
3340 void
3341 pmap_protect(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, vm_prot_t prot)
3342 {
3343         struct pmap_scan_info info;
3344         /* JG review for NX */
3345
3346         if (pmap == NULL)
3347                 return;
3348         if ((prot & VM_PROT_READ) == VM_PROT_NONE) {
3349                 pmap_remove(pmap, sva, eva);
3350                 return;
3351         }
3352         if (prot & VM_PROT_WRITE)
3353                 return;
3354         info.pmap = pmap;
3355         info.sva = sva;
3356         info.eva = eva;
3357         info.func = pmap_protect_callback;
3358         info.arg = &prot;
3359         pmap_scan(&info);
3360 }
3361
3362 static
3363 void
3364 pmap_protect_callback(pmap_t pmap, struct pmap_inval_info *info,
3365                       pv_entry_t pte_pv, pv_entry_t pt_pv, int sharept,
3366                       vm_offset_t va, pt_entry_t *ptep, void *arg __unused)
3367 {
3368         pt_entry_t pbits;
3369         pt_entry_t cbits;
3370         pt_entry_t pte;
3371         vm_page_t m;
3372
3373         /*
3374          * XXX non-optimal.
3375          */
3376         pmap_inval_interlock(info, pmap, va);
3377 again:
3378         pbits = *ptep;
3379         cbits = pbits;
3380         if (pte_pv) {
3381                 m = NULL;
3382                 if (pbits & PG_A) {
3383                         m = PHYS_TO_VM_PAGE(pbits & PG_FRAME);
3384                         KKASSERT(m == pte_pv->pv_m);
3385                         vm_page_flag_set(m, PG_REFERENCED);
3386                         cbits &= ~PG_A;
3387                 }
3388                 if (pbits & PG_M) {
3389                         if (pmap_track_modified(pte_pv->pv_pindex)) {
3390                                 if (m == NULL)
3391                                         m = PHYS_TO_VM_PAGE(pbits & PG_FRAME);
3392                                 vm_page_dirty(m);
3393                                 cbits &= ~PG_M;
3394                         }
3395                 }
3396         } else if (sharept) {
3397                 /*
3398                  * Unmanaged page table, pt_pv is actually the pd_pv
3399                  * for our pmap (not the share object pmap).
3400                  *
3401                  * When asked to protect something in a shared page table
3402                  * page we just unmap the page table page.  We have to
3403                  * invalidate the tlb in this situation.
3404                  */
3405                 pte = pte_load_clear(ptep);
3406                 pmap_inval_invltlb(info);
3407                 if (vm_page_unwire_quick(PHYS_TO_VM_PAGE(pte & PG_FRAME)))
3408                         panic("pmap_protect: pgtable1 pg bad wirecount");
3409                 if (vm_page_unwire_quick(pt_pv->pv_m))
3410                         panic("pmap_protect: pgtable2 pg bad wirecount");
3411                 ptep = NULL;
3412         }
3413         /* else unmanaged page, adjust bits, no wire changes */
3414
3415         if (ptep) {
3416                 cbits &= ~PG_RW;
3417                 if (pbits != cbits && !atomic_cmpset_long(ptep, pbits, cbits)) {
3418                         goto again;
3419                 }
3420         }
3421         pmap_inval_deinterlock(info, pmap);
3422         if (pte_pv)
3423                 pv_put(pte_pv);
3424 }
3425
3426 /*
3427  * Insert the vm_page (m) at the virtual address (va), replacing any prior
3428  * mapping at that address.  Set protection and wiring as requested.
3429  *
3430  * If entry is non-NULL we check to see if the SEG_SIZE optimization is
3431  * possible.  If it is we enter the page into the appropriate shared pmap
3432  * hanging off the related VM object instead of the passed pmap, then we
3433  * share the page table page from the VM object's pmap into the current pmap.
3434  *
3435  * NOTE: This routine MUST insert the page into the pmap now, it cannot
3436  *       lazy-evaluate.
3437  */
3438 void
3439 pmap_enter(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
3440            boolean_t wired, vm_map_entry_t entry __unused)
3441 {
3442         pmap_inval_info info;
3443         pv_entry_t pt_pv;       /* page table */
3444         pv_entry_t pte_pv;      /* page table entry */
3445         pt_entry_t *ptep;
3446         vm_paddr_t opa;
3447         pt_entry_t origpte, newpte;
3448         vm_paddr_t pa;
3449
3450         if (pmap == NULL)
3451                 return;
3452         va = trunc_page(va);
3453 #ifdef PMAP_DIAGNOSTIC
3454         if (va >= KvaEnd)
3455                 panic("pmap_enter: toobig");
3456         if ((va >= UPT_MIN_ADDRESS) && (va < UPT_MAX_ADDRESS))
3457                 panic("pmap_enter: invalid to pmap_enter page table "
3458                       "pages (va: 0x%lx)", va);
3459 #endif
3460         if (va < UPT_MAX_ADDRESS && pmap == &kernel_pmap) {
3461                 kprintf("Warning: pmap_enter called on UVA with "
3462                         "kernel_pmap\n");
3463 #ifdef DDB
3464                 db_print_backtrace();
3465 #endif
3466         }
3467         if (va >= UPT_MAX_ADDRESS && pmap != &kernel_pmap) {
3468                 kprintf("Warning: pmap_enter called on KVA without"
3469                         "kernel_pmap\n");
3470 #ifdef DDB
3471                 db_print_backtrace();
3472 #endif
3473         }
3474
3475         /*
3476          * Get locked PV entries for our new page table entry (pte_pv)
3477          * and for its parent page table (pt_pv).  We need the parent
3478          * so we can resolve the location of the ptep.
3479          *
3480          * Only hardware MMU actions can modify the ptep out from
3481          * under us.
3482          *
3483          * if (m) is fictitious or unmanaged we do not create a managing
3484          * pte_pv for it.  Any pre-existing page's management state must
3485          * match (avoiding code complexity).
3486          *
3487          * If the pmap is still being initialized we assume existing
3488          * page tables.
3489          *
3490          * Kernel mapppings do not track page table pages (i.e. pt_pv).
3491          * pmap_allocpte() checks the
3492          */
3493         if (pmap_initialized == FALSE) {
3494                 pte_pv = NULL;
3495                 pt_pv = NULL;
3496                 ptep = vtopte(va);
3497         } else if (m->flags & (PG_FICTITIOUS | PG_UNMANAGED)) { /* XXX */
3498                 pte_pv = NULL;
3499                 if (va >= VM_MAX_USER_ADDRESS) {
3500                         pt_pv = NULL;
3501                         ptep = vtopte(va);
3502                 } else {
3503                         pt_pv = pmap_allocpte_seg(pmap, pmap_pt_pindex(va),
3504                                                   NULL, entry, va);
3505                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(va));
3506                 }
3507                 KKASSERT(*ptep == 0 || (*ptep & PG_MANAGED) == 0);
3508         } else {
3509                 if (va >= VM_MAX_USER_ADDRESS) {
3510                         /*
3511                          * Kernel map, pv_entry-tracked.
3512                          */
3513                         pt_pv = NULL;
3514                         pte_pv = pmap_allocpte(pmap, pmap_pte_pindex(va), NULL);
3515                         ptep = vtopte(va);
3516                 } else {
3517                         /*
3518                          * User map
3519                          */
3520                         pte_pv = pmap_allocpte_seg(pmap, pmap_pte_pindex(va),
3521                                                    &pt_pv, entry, va);
3522                         ptep = pv_pte_lookup(pt_pv, pmap_pte_index(va));
3523                 }
3524                 KKASSERT(*ptep == 0 || (*ptep & PG_MANAGED));
3525         }
3526
3527         pa = VM_PAGE_TO_PHYS(m);
3528         origpte = *ptep;
3529         opa = origpte & PG_FRAME;
3530
3531         newpte = (pt_entry_t)(pa | pte_prot(pmap, prot) | PG_V | PG_A);
3532         if (wired)
3533                 newpte |= PG_W;
3534         if (va < VM_MAX_USER_ADDRESS)
3535                 newpte |= PG_U;
3536         if (pte_pv)
3537                 newpte |= PG_MANAGED;
3538         if (pmap == &kernel_pmap)
3539                 newpte |= pgeflag;
3540
3541         /*
3542          * It is possible for multiple faults to occur in threaded
3543          * environments, the existing pte might be correct.
3544          */
3545         if (((origpte ^ newpte) & ~(pt_entry_t)(PG_M|PG_A)) == 0)
3546                 goto done;
3547
3548         if ((prot & VM_PROT_NOSYNC) == 0)
3549                 pmap_inval_init(&info);
3550
3551         /*
3552          * Ok, either the address changed or the protection or wiring
3553          * changed.
3554          *
3555          * Clear the current entry, interlocking the removal.  For managed
3556          * pte's this will also flush the modified state to the vm_page.
3557          * Atomic ops are mandatory in order to ensure that PG_M events are
3558          * not lost during any transition.
3559          */
3560         if (opa) {
3561                 if (pte_pv) {
3562                         /*
3563                          * pmap_remove_pv_pte() unwires pt_pv and assumes
3564                          * we will free pte_pv, but since we are reusing
3565                          * pte_pv we want to retain the wire count.
3566                          *
3567                          * pt_pv won't exist for a kernel page (managed or
3568                          * otherwise).
3569                          */
3570                         if (pt_pv)
3571                                 vm_page_wire_quick(pt_pv->pv_m);
3572                         if (prot & VM_PROT_NOSYNC)
3573                                 pmap_remove_pv_pte(pte_pv, pt_pv, NULL);
3574                         else
3575                                 pmap_remove_pv_pte(pte_pv, pt_pv, &info);
3576                         if (pte_pv->pv_m)
3577                                 pmap_remove_pv_page(pte_pv);
3578                 } else if (prot & VM_PROT_NOSYNC) {
3579                         /*
3580                          * Unmanaged page, NOSYNC (no mmu sync) requested.
3581                          *
3582                          * Leave wire count on PT page intact.
3583                          */
3584                         (void)pte_load_clear(ptep);
3585                         cpu_invlpg((void *)va);
3586                         atomic_add_long(&pmap->pm_stats.resident_count, -1);
3587                 } else {
3588                         /*
3589                          * Unmanaged page, normal enter.
3590                          *
3591                          * Leave wire count on PT page intact.
3592                          */
3593                         pmap_inval_interlock(&info, pmap, va);
3594                         (void)pte_load_clear(ptep);
3595                         pmap_inval_deinterlock(&info, pmap);
3596                         atomic_add_long(&pmap->pm_stats.resident_count, -1);
3597                 }
3598                 KKASSERT(*ptep == 0);
3599         }
3600
3601         if (pte_pv) {
3602                 /*
3603                  * Enter on the PV list if part of our managed memory.
3604                  * Wiring of the PT page is already handled.
3605                  */
3606                 KKASSERT(pte_pv->pv_m == NULL);
3607                 vm_page_spin_lock(m);
3608                 pte_pv->pv_m = m;
3609                 TAILQ_INSERT_TAIL(&m->md.pv_list, pte_pv, pv_list);
3610                 /*
3611                 if (m->object)
3612                         atomic_add_int(&m->object->agg_pv_list_count, 1);
3613                 */
3614                 vm_page_flag_set(m, PG_MAPPED);
3615                 vm_page_spin_unlock(m);
3616         } else if (pt_pv && opa == 0) {
3617                 /*
3618                  * We have to adjust the wire count on the PT page ourselves
3619                  * for unmanaged entries.  If opa was non-zero we retained
3620                  * the existing wire count from the removal.
3621                  */
3622                 vm_page_wire_quick(pt_pv->pv_m);
3623         }
3624
3625         /*
3626          * Kernel VMAs (pt_pv == NULL) require pmap invalidation interlocks.
3627          *
3628          * User VMAs do not because those will be zero->non-zero, so no
3629          * stale entries to worry about at this point.
3630          *
3631          * For KVM there appear to still be issues.  Theoretically we
3632          * should be able to scrap the interlocks entirely but we
3633          * get crashes.
3634          */
3635         if ((prot & VM_PROT_NOSYNC) == 0 && pt_pv == NULL)
3636                 pmap_inval_interlock(&info, pmap, va);
3637
3638         /*
3639          * Set the pte
3640          */
3641         *(volatile pt_entry_t *)ptep = newpte;
3642
3643         if ((prot & VM_PROT_NOSYNC) == 0 && pt_pv == NULL)
3644                 pmap_inval_deinterlock(&info, pmap);
3645         else if (pt_pv == NULL)
3646                 cpu_invlpg((void *)va);
3647
3648         if (wired) {
3649                 if (pte_pv) {
3650                         atomic_add_long(&pte_pv->pv_pmap->pm_stats.wired_count,
3651                                         1);
3652                 } else {
3653                         atomic_add_long(&pmap->pm_stats.wired_count, 1);
3654                 }
3655         }
3656         if (newpte & PG_RW)
3657                 vm_page_flag_set(m, PG_WRITEABLE);
3658
3659         /*
3660          * Unmanaged pages need manual resident_count tracking.
3661          */
3662         if (pte_pv == NULL && pt_pv)
3663                 atomic_add_long(&pt_pv->pv_pmap->pm_stats.resident_count, 1);
3664
3665         /*
3666          * Cleanup
3667          */
3668         if ((prot & VM_PROT_NOSYNC) == 0 || pte_pv == NULL)
3669                 pmap_inval_done(&info);
3670 done:
3671         KKASSERT((newpte & PG_MANAGED) == 0 || (m->flags & PG_MAPPED));
3672
3673         /*
3674          * Cleanup the pv entry, allowing other accessors.
3675          */
3676         if (pte_pv)
3677                 pv_put(pte_pv);
3678         if (pt_pv)
3679                 pv_put(pt_pv);
3680 }
3681
3682 /*
3683  * This code works like pmap_enter() but assumes VM_PROT_READ and not-wired.
3684  * This code also assumes that the pmap has no pre-existing entry for this
3685  * VA.
3686  *
3687  * This code currently may only be used on user pmaps, not kernel_pmap.
3688  */
3689 void
3690 pmap_enter_quick(pmap_t pmap, vm_offset_t va, vm_page_t m)
3691 {
3692         pmap_enter(pmap, va, m, VM_PROT_READ, FALSE, NULL);
3693 }
3694
3695 /*
3696  * Make a temporary mapping for a physical address.  This is only intended
3697  * to be used for panic dumps.
3698  *
3699  * The caller is responsible for calling smp_invltlb().
3700  */
3701 void *
3702 pmap_kenter_temporary(vm_paddr_t pa, long i)
3703 {
3704         pmap_kenter_quick((vm_offset_t)crashdumpmap + (i * PAGE_SIZE), pa);
3705         return ((void *)crashdumpmap);
3706 }
3707
3708 #define MAX_INIT_PT (96)
3709
3710 /*
3711  * This routine preloads the ptes for a given object into the specified pmap.
3712  * This eliminates the blast of soft faults on process startup and
3713  * immediately after an mmap.
3714  */
3715 static int pmap_object_init_pt_callback(vm_page_t p, void *data);
3716
3717 void
3718 pmap_object_init_pt(pmap_t pmap, vm_offset_t addr, vm_prot_t prot,
3719                     vm_object_t object, vm_pindex_t pindex,
3720                     vm_size_t size, int limit)
3721 {
3722         struct rb_vm_page_scan_info info;
3723         struct lwp *lp;
3724         vm_size_t psize;
3725
3726         /*
3727          * We can't preinit if read access isn't set or there is no pmap
3728          * or object.
3729          */
3730         if ((prot & VM_PROT_READ) == 0 || pmap == NULL || object == NULL)
3731                 return;
3732
3733         /*
3734          * We can't preinit if the pmap is not the current pmap
3735          */
3736         lp = curthread->td_lwp;
3737         if (lp == NULL || pmap != vmspace_pmap(lp->lwp_vmspace))
3738                 return;
3739
3740         /*
3741          * Misc additional checks
3742          */
3743         psize = x86_64_btop(size);
3744
3745         if ((object->type != OBJT_VNODE) ||
3746                 ((limit & MAP_PREFAULT_PARTIAL) && (psize > MAX_INIT_PT) &&
3747                         (object->resident_page_count > MAX_INIT_PT))) {
3748                 return;
3749         }
3750
3751         if (pindex + psize > object->size) {
3752                 if (object->size < pindex)
3753                         return;
3754                 psize = object->size - pindex;
3755         }
3756
3757         if (psize == 0)
3758                 return;
3759
3760         /*
3761          * If everything is segment-aligned do not pre-init here.  Instead
3762          * allow the normal vm_fault path to pass a segment hint to
3763          * pmap_enter() which will then use an object-referenced shared
3764          * page table page.
3765          */
3766         if ((addr & SEG_MASK) == 0 &&
3767             (ctob(psize) & SEG_MASK) == 0 &&
3768             (ctob(pindex) & SEG_MASK) == 0) {
3769                 return;
3770         }
3771
3772         /*
3773          * Use a red-black scan to traverse the requested range and load
3774          * any valid pages found into the pmap.
3775          *
3776          * We cannot safely scan the object's memq without holding the
3777          * object token.
3778          */
3779         info.start_pindex = pindex;
3780         info.end_pindex = pindex + psize - 1;
3781         info.limit = limit;
3782         info.mpte = NULL;
3783         info.addr = addr;
3784         info.pmap = pmap;
3785
3786         vm_object_hold_shared(object);
3787         vm_page_rb_tree_RB_SCAN(&object->rb_memq, rb_vm_page_scancmp,
3788                                 pmap_object_init_pt_callback, &info);
3789         vm_object_drop(object);
3790 }
3791
3792 static
3793 int
3794 pmap_object_init_pt_callback(vm_page_t p, void *data)
3795 {
3796         struct rb_vm_page_scan_info *info = data;
3797         vm_pindex_t rel_index;
3798
3799         /*
3800          * don't allow an madvise to blow away our really
3801          * free pages allocating pv entries.
3802          */
3803         if ((info->limit & MAP_PREFAULT_MADVISE) &&
3804                 vmstats.v_free_count < vmstats.v_free_reserved) {
3805                     return(-1);
3806         }
3807
3808         /*
3809          * Ignore list markers and ignore pages we cannot instantly
3810          * busy (while holding the object token).
3811          */
3812         if (p->flags & PG_MARKER)
3813                 return 0;
3814         if (vm_page_busy_try(p, TRUE))
3815                 return 0;
3816         if (((p->valid & VM_PAGE_BITS_ALL) == VM_PAGE_BITS_ALL) &&
3817             (p->flags & PG_FICTITIOUS) == 0) {
3818                 if ((p->queue - p->pc) == PQ_CACHE)
3819                         vm_page_deactivate(p);
3820                 rel_index = p->pindex - info->start_pindex;
3821                 pmap_enter_quick(info->pmap,
3822                                  info->addr + x86_64_ptob(rel_index), p);
3823         }
3824         vm_page_wakeup(p);
3825         lwkt_yield();
3826         return(0);
3827 }
3828
3829 /*
3830  * Return TRUE if the pmap is in shape to trivially pre-fault the specified
3831  * address.
3832  *
3833  * Returns FALSE if it would be non-trivial or if a pte is already loaded
3834  * into the slot.
3835  *
3836  * XXX This is safe only because page table pages are not freed.
3837  */
3838 int
3839 pmap_prefault_ok(pmap_t pmap, vm_offset_t addr)
3840 {
3841         pt_entry_t *pte;
3842
3843         /*spin_lock(&pmap->pm_spin);*/
3844         if ((pte = pmap_pte(pmap, addr)) != NULL) {
3845                 if (*pte & PG_V) {
3846                         /*spin_unlock(&pmap->pm_spin);*/
3847                         return FALSE;
3848                 }
3849         }
3850         /*spin_unlock(&pmap->pm_spin);*/
3851         return TRUE;
3852 }
3853
3854 /*
3855  * Change the wiring attribute for a pmap/va pair.  The mapping must already
3856  * exist in the pmap.  The mapping may or may not be managed.
3857  */
3858 void
3859 pmap_change_wiring(pmap_t pmap, vm_offset_t va, boolean_t wired,
3860                    vm_map_entry_t entry)
3861 {
3862         pt_entry_t *ptep;
3863         pv_entry_t pv;
3864
3865         if (pmap == NULL)
3866                 return;
3867         lwkt_gettoken(&pmap->pm_token);
3868         pv = pmap_allocpte_seg(pmap, pmap_pt_pindex(va), NULL, entry, va);
3869         ptep = pv_pte_lookup(pv, pmap_pte_index(va));
3870
3871         if (wired && !pmap_pte_w(ptep))
3872                 atomic_add_long(&pv->pv_pmap->pm_stats.wired_count, 1);
3873         else if (!wired && pmap_pte_w(ptep))
3874                 atomic_add_long(&pv->pv_pmap->pm_stats.wired_count, -1);
3875
3876         /*
3877          * Wiring is not a hardware characteristic so there is no need to
3878          * invalidate TLB.  However, in an SMP environment we must use
3879          * a locked bus cycle to update the pte (if we are not using
3880          * the pmap_inval_*() API that is)... it's ok to do this for simple
3881          * wiring changes.
3882          */
3883 #ifdef SMP
3884         if (wired)
3885                 atomic_set_long(ptep, PG_W);
3886         else
3887                 atomic_clear_long(ptep, PG_W);
3888 #else
3889         if (wired)
3890                 atomic_set_long_nonlocked(ptep, PG_W);
3891         else
3892                 atomic_clear_long_nonlocked(ptep, PG_W);
3893 #endif
3894         pv_put(pv);
3895         lwkt_reltoken(&pmap->pm_token);
3896 }
3897
3898
3899
3900 /*
3901  * Copy the range specified by src_addr/len from the source map to
3902  * the range dst_addr/len in the destination map.
3903  *
3904  * This routine is only advisory and need not do anything.
3905  */
3906 void
3907 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr,
3908           vm_size_t len, vm_offset_t src_addr)
3909 {
3910 }
3911
3912 /*
3913  * pmap_zero_page:
3914  *
3915  *      Zero the specified physical page.
3916  *
3917  *      This function may be called from an interrupt and no locking is
3918  *      required.
3919  */
3920 void
3921 pmap_zero_page(vm_paddr_t phys)
3922 {
3923         vm_offset_t va = PHYS_TO_DMAP(phys);
3924
3925         pagezero((void *)va);
3926 }
3927
3928 /*
3929  * pmap_page_assertzero:
3930  *
3931  *      Assert that a page is empty, panic if it isn't.
3932  */
3933 void
3934 pmap_page_assertzero(vm_paddr_t phys)
3935 {
3936         vm_offset_t va = PHYS_TO_DMAP(phys);
3937         size_t i;
3938
3939         for (i = 0; i < PAGE_SIZE; i += sizeof(long)) {
3940                 if (*(long *)((char *)va + i) != 0) {
3941                         panic("pmap_page_assertzero() @ %p not zero!",
3942                               (void *)(intptr_t)va);
3943                 }
3944         }
3945 }
3946
3947 /*
3948  * pmap_zero_page:
3949  *
3950  *      Zero part of a physical page by mapping it into memory and clearing
3951  *      its contents with bzero.
3952  *
3953  *      off and size may not cover an area beyond a single hardware page.
3954  */
3955 void
3956 pmap_zero_page_area(vm_paddr_t phys, int off, int size)
3957 {
3958         vm_offset_t virt = PHYS_TO_DMAP(phys);
3959
3960         bzero((char *)virt + off, size);
3961 }
3962
3963 /*
3964  * pmap_copy_page:
3965  *
3966  *      Copy the physical page from the source PA to the target PA.
3967  *      This function may be called from an interrupt.  No locking
3968  *      is required.
3969  */
3970 void
3971 pmap_copy_page(vm_paddr_t src, vm_paddr_t dst)
3972 {
3973         vm_offset_t src_virt, dst_virt;
3974
3975         src_virt = PHYS_TO_DMAP(src);
3976         dst_virt = PHYS_TO_DMAP(dst);
3977         bcopy((void *)src_virt, (void *)dst_virt, PAGE_SIZE);
3978 }
3979
3980 /*
3981  * pmap_copy_page_frag:
3982  *
3983  *      Copy the physical page from the source PA to the target PA.
3984  *      This function may be called from an interrupt.  No locking
3985  *      is required.
3986  */
3987 void
3988 pmap_copy_page_frag(vm_paddr_t src, vm_paddr_t dst, size_t bytes)
3989 {
3990         vm_offset_t src_virt, dst_virt;
3991
3992         src_virt = PHYS_TO_DMAP(src);
3993         dst_virt = PHYS_TO_DMAP(dst);
3994
3995         bcopy((char *)src_virt + (src & PAGE_MASK),
3996               (char *)dst_virt + (dst & PAGE_MASK),
3997               bytes);
3998 }
3999
4000 /*
4001  * Returns true if the pmap's pv is one of the first 16 pvs linked to from
4002  * this page.  This count may be changed upwards or downwards in the future;
4003  * it is only necessary that true be returned for a small subset of pmaps
4004  * for proper page aging.
4005  */
4006 boolean_t
4007 pmap_page_exists_quick(pmap_t pmap, vm_page_t m)
4008 {
4009         pv_entry_t pv;
4010         int loops = 0;
4011
4012         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
4013                 return FALSE;
4014
4015         vm_page_spin_lock(m);
4016         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
4017                 if (pv->pv_pmap == pmap) {
4018                         vm_page_spin_unlock(m);
4019                         return TRUE;
4020                 }
4021                 loops++;
4022                 if (loops >= 16)
4023                         break;
4024         }
4025         vm_page_spin_unlock(m);
4026         return (FALSE);
4027 }
4028
4029 /*
4030  * Remove all pages from specified address space this aids process exit
4031  * speeds.  Also, this code may be special cased for the current process
4032  * only.
4033  */
4034 void
4035 pmap_remove_pages(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
4036 {
4037         pmap_remove(pmap, sva, eva);
4038 }
4039
4040 /*
4041  * pmap_testbit tests bits in pte's note that the testbit/clearbit
4042  * routines are inline, and a lot of things compile-time evaluate.
4043  */
4044 static
4045 boolean_t
4046 pmap_testbit(vm_page_t m, int bit)
4047 {
4048         pv_entry_t pv;
4049         pt_entry_t *pte;
4050
4051         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
4052                 return FALSE;
4053
4054         if (TAILQ_FIRST(&m->md.pv_list) == NULL)
4055                 return FALSE;
4056         vm_page_spin_lock(m);
4057         if (TAILQ_FIRST(&m->md.pv_list) == NULL) {
4058                 vm_page_spin_unlock(m);
4059                 return FALSE;
4060         }
4061
4062         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
4063                 /*
4064                  * if the bit being tested is the modified bit, then
4065                  * mark clean_map and ptes as never
4066                  * modified.
4067                  */
4068                 if (bit & (PG_A|PG_M)) {
4069                         if (!pmap_track_modified(pv->pv_pindex))
4070                                 continue;
4071                 }
4072
4073 #if defined(PMAP_DIAGNOSTIC)
4074                 if (pv->pv_pmap == NULL) {
4075                         kprintf("Null pmap (tb) at pindex: %"PRIu64"\n",
4076                             pv->pv_pindex);
4077                         continue;
4078                 }
4079 #endif
4080                 pte = pmap_pte_quick(pv->pv_pmap, pv->pv_pindex << PAGE_SHIFT);
4081                 if (*pte & bit) {
4082                         vm_page_spin_unlock(m);
4083                         return TRUE;
4084                 }
4085         }
4086         vm_page_spin_unlock(m);
4087         return (FALSE);
4088 }
4089
4090 /*
4091  * This routine is used to modify bits in ptes.  Only one bit should be
4092  * specified.  PG_RW requires special handling.
4093  *
4094  * Caller must NOT hold any spin locks
4095  */
4096 static __inline
4097 void
4098 pmap_clearbit(vm_page_t m, int bit)
4099 {
4100         struct pmap_inval_info info;
4101         pv_entry_t pv;
4102         pt_entry_t *pte;
4103         pt_entry_t pbits;
4104         pmap_t save_pmap;
4105
4106         if (bit == PG_RW)
4107                 vm_page_flag_clear(m, PG_WRITEABLE);
4108         if (!pmap_initialized || (m->flags & PG_FICTITIOUS)) {
4109                 return;
4110         }
4111
4112         /*
4113          * PG_M or PG_A case
4114          *
4115          * Loop over all current mappings setting/clearing as appropos If
4116          * setting RO do we need to clear the VAC?
4117          *
4118          * NOTE: When clearing PG_M we could also (not implemented) drop
4119          *       through to the PG_RW code and clear PG_RW too, forcing
4120          *       a fault on write to redetect PG_M for virtual kernels, but
4121          *       it isn't necessary since virtual kernels invalidate the
4122          *       pte when they clear the VPTE_M bit in their virtual page
4123          *       tables.
4124          *
4125          * NOTE: Does not re-dirty the page when clearing only PG_M.
4126          */
4127         if ((bit & PG_RW) == 0) {
4128                 vm_page_spin_lock(m);
4129                 TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
4130         #if defined(PMAP_DIAGNOSTIC)
4131                         if (pv->pv_pmap == NULL) {
4132                                 kprintf("Null pmap (cb) at pindex: %"PRIu64"\n",
4133                                     pv->pv_pindex);
4134                                 continue;
4135                         }
4136         #endif
4137                         pte = pmap_pte_quick(pv->pv_pmap,
4138                                              pv->pv_pindex << PAGE_SHIFT);
4139                         pbits = *pte;
4140                         if (pbits & bit)
4141                                 atomic_clear_long(pte, bit);
4142                 }
4143                 vm_page_spin_unlock(m);
4144                 return;
4145         }
4146
4147         /*
4148          * Clear PG_RW.  Also clears PG_M and marks the page dirty if PG_M
4149          * was set.
4150          */
4151         pmap_inval_init(&info);
4152
4153 restart:
4154         vm_page_spin_lock(m);
4155         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
4156                 /*
4157                  * don't write protect pager mappings
4158                  */
4159                 if (!pmap_track_modified(pv->pv_pindex))
4160                         continue;
4161
4162 #if defined(PMAP_DIAGNOSTIC)
4163                 if (pv->pv_pmap == NULL) {
4164                         kprintf("Null pmap (cb) at pindex: %"PRIu64"\n",
4165                             pv->pv_pindex);
4166                         continue;
4167                 }
4168 #endif
4169                 /*
4170                  * Skip pages which do not have PG_RW set.
4171                  */
4172                 pte = pmap_pte_quick(pv->pv_pmap, pv->pv_pindex << PAGE_SHIFT);
4173                 if ((*pte & PG_RW) == 0)
4174                         continue;
4175
4176                 /*
4177                  * Lock the PV
4178                  */
4179                 if (pv_hold_try(pv) == 0) {
4180                         vm_page_spin_unlock(m);
4181                         pv_lock(pv);    /* held, now do a blocking lock */
4182                         pv_put(pv);     /* and release */
4183                         goto restart;   /* anything could have happened */
4184                 }
4185
4186                 save_pmap = pv->pv_pmap;
4187                 vm_page_spin_unlock(m);
4188                 pmap_inval_interlock(&info, save_pmap,
4189                                      (vm_offset_t)pv->pv_pindex << PAGE_SHIFT);
4190                 KKASSERT(pv->pv_pmap == save_pmap);
4191                 for (;;) {
4192                         pbits = *pte;
4193                         cpu_ccfence();
4194                         if (atomic_cmpset_long(pte, pbits,
4195                                                pbits & ~(PG_RW|PG_M))) {
4196                                 break;
4197                         }
4198                 }
4199                 pmap_inval_deinterlock(&info, save_pmap);
4200                 vm_page_spin_lock(m);
4201
4202                 /*
4203                  * If PG_M was found to be set while we were clearing PG_RW
4204                  * we also clear PG_M (done above) and mark the page dirty.
4205                  * Callers expect this behavior.
4206                  */
4207                 if (pbits & PG_M)
4208                         vm_page_dirty(m);
4209                 pv_put(pv);
4210         }
4211         vm_page_spin_unlock(m);
4212         pmap_inval_done(&info);
4213 }
4214
4215 /*
4216  * Lower the permission for all mappings to a given page.
4217  *
4218  * Page must be busied by caller.
4219  */
4220 void
4221 pmap_page_protect(vm_page_t m, vm_prot_t prot)
4222 {
4223         /* JG NX support? */
4224         if ((prot & VM_PROT_WRITE) == 0) {
4225                 if (prot & (VM_PROT_READ | VM_PROT_EXECUTE)) {
4226                         /*
4227                          * NOTE: pmap_clearbit(.. PG_RW) also clears
4228                          *       the PG_WRITEABLE flag in (m).
4229                          */
4230                         pmap_clearbit(m, PG_RW);
4231                 } else {
4232                         pmap_remove_all(m);
4233                 }
4234         }
4235 }
4236
4237 vm_paddr_t
4238 pmap_phys_address(vm_pindex_t ppn)
4239 {
4240         return (x86_64_ptob(ppn));
4241 }
4242
4243 /*
4244  * Return a count of reference bits for a page, clearing those bits.
4245  * It is not necessary for every reference bit to be cleared, but it
4246  * is necessary that 0 only be returned when there are truly no
4247  * reference bits set.
4248  *
4249  * XXX: The exact number of bits to check and clear is a matter that
4250  * should be tested and standardized at some point in the future for
4251  * optimal aging of shared pages.
4252  *
4253  * This routine may not block.
4254  */
4255 int
4256 pmap_ts_referenced(vm_page_t m)
4257 {
4258         pv_entry_t pv;
4259         pt_entry_t *pte;
4260         int rtval = 0;
4261
4262         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
4263                 return (rtval);
4264
4265         vm_page_spin_lock(m);
4266         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
4267                 if (!pmap_track_modified(pv->pv_pindex))
4268                         continue;
4269                 pte = pmap_pte_quick(pv->pv_pmap, pv->pv_pindex << PAGE_SHIFT);
4270                 if (pte && (*pte & PG_A)) {
4271 #ifdef SMP
4272                         atomic_clear_long(pte, PG_A);
4273 #else
4274                         atomic_clear_long_nonlocked(pte, PG_A);
4275 #endif
4276                         rtval++;
4277                         if (rtval > 4)
4278                                 break;
4279                 }
4280         }
4281         vm_page_spin_unlock(m);
4282         return (rtval);
4283 }
4284
4285 /*
4286  *      pmap_is_modified:
4287  *
4288  *      Return whether or not the specified physical page was modified
4289  *      in any physical maps.
4290  */
4291 boolean_t
4292 pmap_is_modified(vm_page_t m)
4293 {
4294         boolean_t res;
4295
4296         res = pmap_testbit(m, PG_M);
4297         return (res);
4298 }
4299
4300 /*
4301  *      Clear the modify bits on the specified physical page.
4302  */
4303 void
4304 pmap_clear_modify(vm_page_t m)
4305 {
4306         pmap_clearbit(m, PG_M);
4307 }
4308
4309 /*
4310  *      pmap_clear_reference:
4311  *
4312  *      Clear the reference bit on the specified physical page.
4313  */
4314 void
4315 pmap_clear_reference(vm_page_t m)
4316 {
4317         pmap_clearbit(m, PG_A);
4318 }
4319
4320 /*
4321  * Miscellaneous support routines follow
4322  */
4323
4324 static
4325 void
4326 i386_protection_init(void)
4327 {
4328         int *kp, prot;
4329
4330         /* JG NX support may go here; No VM_PROT_EXECUTE ==> set NX bit  */
4331         kp = protection_codes;
4332         for (prot = 0; prot < 8; prot++) {
4333                 switch (prot) {
4334                 case VM_PROT_NONE | VM_PROT_NONE | VM_PROT_NONE:
4335                         /*
4336                          * Read access is also 0. There isn't any execute bit,
4337                          * so just make it readable.
4338                          */
4339                 case VM_PROT_READ | VM_PROT_NONE | VM_PROT_NONE:
4340                 case VM_PROT_READ | VM_PROT_NONE | VM_PROT_EXECUTE:
4341                 case VM_PROT_NONE | VM_PROT_NONE | VM_PROT_EXECUTE:
4342                         *kp++ = 0;
4343                         break;
4344                 case VM_PROT_NONE | VM_PROT_WRITE | VM_PROT_NONE:
4345                 case VM_PROT_NONE | VM_PROT_WRITE | VM_PROT_EXECUTE:
4346                 case VM_PROT_READ | VM_PROT_WRITE | VM_PROT_NONE:
4347                 case VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE:
4348                         *kp++ = PG_RW;
4349                         break;
4350                 }
4351         }
4352 }
4353
4354 /*
4355  * Map a set of physical memory pages into the kernel virtual
4356  * address space. Return a pointer to where it is mapped. This
4357  * routine is intended to be used for mapping device memory,
4358  * NOT real memory.
4359  *
4360  * NOTE: we can't use pgeflag unless we invalidate the pages one at
4361  * a time.
4362  */
4363 void *
4364 pmap_mapdev(vm_paddr_t pa, vm_size_t size)
4365 {
4366         vm_offset_t va, tmpva, offset;
4367         pt_entry_t *pte;
4368
4369         offset = pa & PAGE_MASK;
4370         size = roundup(offset + size, PAGE_SIZE);
4371
4372         va = kmem_alloc_nofault(&kernel_map, size, PAGE_SIZE);
4373         if (va == 0)
4374                 panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
4375
4376         pa = pa & ~PAGE_MASK;
4377         for (tmpva = va; size > 0;) {
4378                 pte = vtopte(tmpva);
4379                 *pte = pa | PG_RW | PG_V; /* | pgeflag; */
4380                 size -= PAGE_SIZE;
4381                 tmpva += PAGE_SIZE;
4382                 pa += PAGE_SIZE;
4383         }
4384         cpu_invltlb();
4385         smp_invltlb();
4386
4387         return ((void *)(va + offset));
4388 }
4389
4390 void *
4391 pmap_mapdev_uncacheable(vm_paddr_t pa, vm_size_t size)
4392 {
4393         vm_offset_t va, tmpva, offset;
4394         pt_entry_t *pte;
4395
4396         offset = pa & PAGE_MASK;
4397         size = roundup(offset + size, PAGE_SIZE);
4398
4399         va = kmem_alloc_nofault(&kernel_map, size, PAGE_SIZE);
4400         if (va == 0)
4401                 panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
4402
4403         pa = pa & ~PAGE_MASK;
4404         for (tmpva = va; size > 0;) {
4405                 pte = vtopte(tmpva);
4406                 *pte = pa | PG_RW | PG_V | PG_N; /* | pgeflag; */
4407                 size -= PAGE_SIZE;
4408                 tmpva += PAGE_SIZE;
4409                 pa += PAGE_SIZE;
4410         }
4411         cpu_invltlb();
4412         smp_invltlb();
4413
4414         return ((void *)(va + offset));
4415 }
4416
4417 void
4418 pmap_unmapdev(vm_offset_t va, vm_size_t size)
4419 {
4420         vm_offset_t base, offset;
4421
4422         base = va & ~PAGE_MASK;
4423         offset = va & PAGE_MASK;
4424         size = roundup(offset + size, PAGE_SIZE);
4425         pmap_qremove(va, size >> PAGE_SHIFT);
4426         kmem_free(&kernel_map, base, size);
4427 }
4428
4429 /*
4430  * perform the pmap work for mincore
4431  */
4432 int
4433 pmap_mincore(pmap_t pmap, vm_offset_t addr)
4434 {
4435         pt_entry_t *ptep, pte;
4436         vm_page_t m;
4437         int val = 0;
4438
4439         lwkt_gettoken(&pmap->pm_token);
4440         ptep = pmap_pte(pmap, addr);
4441
4442         if (ptep && (pte = *ptep) != 0) {
4443                 vm_offset_t pa;
4444
4445                 val = MINCORE_INCORE;
4446                 if ((pte & PG_MANAGED) == 0)
4447                         goto done;
4448
4449                 pa = pte & PG_FRAME;
4450
4451                 m = PHYS_TO_VM_PAGE(pa);
4452
4453                 /*
4454                  * Modified by us
4455                  */
4456                 if (pte & PG_M)
4457                         val |= MINCORE_MODIFIED|MINCORE_MODIFIED_OTHER;
4458                 /*
4459                  * Modified by someone
4460                  */
4461                 else if (m->dirty || pmap_is_modified(m))
4462                         val |= MINCORE_MODIFIED_OTHER;
4463                 /*
4464                  * Referenced by us
4465                  */
4466                 if (pte & PG_A)
4467                         val |= MINCORE_REFERENCED|MINCORE_REFERENCED_OTHER;
4468
4469                 /*
4470                  * Referenced by someone
4471                  */
4472                 else if ((m->flags & PG_REFERENCED) || pmap_ts_referenced(m)) {
4473                         val |= MINCORE_REFERENCED_OTHER;
4474                         vm_page_flag_set(m, PG_REFERENCED);
4475                 }
4476         }
4477 done:
4478         lwkt_reltoken(&pmap->pm_token);
4479
4480         return val;
4481 }
4482
4483 /*
4484  * Replace p->p_vmspace with a new one.  If adjrefs is non-zero the new
4485  * vmspace will be ref'd and the old one will be deref'd.
4486  *
4487  * The vmspace for all lwps associated with the process will be adjusted
4488  * and cr3 will be reloaded if any lwp is the current lwp.
4489  *
4490  * The process must hold the vmspace->vm_map.token for oldvm and newvm
4491  */
4492 void
4493 pmap_replacevm(struct proc *p, struct vmspace *newvm, int adjrefs)
4494 {
4495         struct vmspace *oldvm;
4496         struct lwp *lp;
4497
4498         oldvm = p->p_vmspace;
4499         if (oldvm != newvm) {
4500                 if (adjrefs)
4501                         sysref_get(&newvm->vm_sysref);
4502                 p->p_vmspace = newvm;
4503                 KKASSERT(p->p_nthreads == 1);
4504                 lp = RB_ROOT(&p->p_lwp_tree);
4505                 pmap_setlwpvm(lp, newvm);
4506                 if (adjrefs)
4507                         sysref_put(&oldvm->vm_sysref);
4508         }
4509 }
4510
4511 /*
4512  * Set the vmspace for a LWP.  The vmspace is almost universally set the
4513  * same as the process vmspace, but virtual kernels need to swap out contexts
4514  * on a per-lwp basis.
4515  *
4516  * Caller does not necessarily hold any vmspace tokens.  Caller must control
4517  * the lwp (typically be in the context of the lwp).  We use a critical
4518  * section to protect against statclock and hardclock (statistics collection).
4519  */
4520 void
4521 pmap_setlwpvm(struct lwp *lp, struct vmspace *newvm)
4522 {
4523         struct vmspace *oldvm;
4524         struct pmap *pmap;
4525
4526         oldvm = lp->lwp_vmspace;
4527
4528         if (oldvm != newvm) {
4529                 crit_enter();
4530                 lp->lwp_vmspace = newvm;
4531                 if (curthread->td_lwp == lp) {
4532                         pmap = vmspace_pmap(newvm);
4533 #if defined(SMP)
4534                         atomic_set_cpumask(&pmap->pm_active, mycpu->gd_cpumask);
4535                         if (pmap->pm_active & CPUMASK_LOCK)
4536                                 pmap_interlock_wait(newvm);
4537 #else
4538                         pmap->pm_active |= 1;
4539 #endif
4540 #if defined(SWTCH_OPTIM_STATS)
4541                         tlb_flush_count++;
4542 #endif
4543                         curthread->td_pcb->pcb_cr3 = vtophys(pmap->pm_pml4);
4544                         curthread->td_pcb->pcb_cr3 |= PG_RW | PG_U | PG_V;
4545                         load_cr3(curthread->td_pcb->pcb_cr3);
4546                         pmap = vmspace_pmap(oldvm);
4547 #if defined(SMP)
4548                         atomic_clear_cpumask(&pmap->pm_active, mycpu->gd_cpumask);
4549 #else
4550                         pmap->pm_active &= ~(cpumask_t)1;
4551 #endif
4552                 }
4553                 crit_exit();
4554         }
4555 }
4556
4557 #ifdef SMP
4558
4559 /*
4560  * Called when switching to a locked pmap, used to interlock against pmaps
4561  * undergoing modifications to prevent us from activating the MMU for the
4562  * target pmap until all such modifications have completed.  We have to do
4563  * this because the thread making the modifications has already set up its
4564  * SMP synchronization mask.
4565  *
4566  * This function cannot sleep!
4567  *
4568  * No requirements.
4569  */
4570 void
4571 pmap_interlock_wait(struct vmspace *vm)
4572 {
4573         struct pmap *pmap = &vm->vm_pmap;
4574
4575         if (pmap->pm_active & CPUMASK_LOCK) {
4576                 crit_enter();
4577                 KKASSERT(curthread->td_critcount >= 2);
4578                 DEBUG_PUSH_INFO("pmap_interlock_wait");
4579                 while (pmap->pm_active & CPUMASK_LOCK) {
4580                         cpu_ccfence();
4581                         lwkt_process_ipiq();
4582                 }
4583                 DEBUG_POP_INFO();
4584                 crit_exit();
4585         }
4586 }
4587
4588 #endif
4589
4590 vm_offset_t
4591 pmap_addr_hint(vm_object_t obj, vm_offset_t addr, vm_size_t size)
4592 {
4593
4594         if ((obj == NULL) || (size < NBPDR) || (obj->type != OBJT_DEVICE)) {
4595                 return addr;
4596         }
4597
4598         addr = (addr + (NBPDR - 1)) & ~(NBPDR - 1);
4599         return addr;
4600 }
4601
4602 /*
4603  * Used by kmalloc/kfree, page already exists at va
4604  */
4605 vm_page_t
4606 pmap_kvtom(vm_offset_t va)
4607 {
4608         return(PHYS_TO_VM_PAGE(*vtopte(va) & PG_FRAME));
4609 }
4610
4611 /*
4612  * Initialize machine-specific shared page directory support.  This
4613  * is executed when a VM object is created.
4614  */
4615 void
4616 pmap_object_init(vm_object_t object)
4617 {
4618         object->md.pmap_rw = NULL;
4619         object->md.pmap_ro = NULL;
4620 }
4621
4622 /*
4623  * Clean up machine-specific shared page directory support.  This
4624  * is executed when a VM object is destroyed.
4625  */
4626 void
4627 pmap_object_free(vm_object_t object)
4628 {
4629         pmap_t pmap;
4630
4631         if ((pmap = object->md.pmap_rw) != NULL) {
4632                 object->md.pmap_rw = NULL;
4633                 kprintf("pmap_object_free: destroying pmap %p in obj %p\n",
4634                         pmap, object);
4635                 pmap_remove_pages(pmap,
4636                                   VM_MIN_USER_ADDRESS, VM_MAX_USER_ADDRESS);
4637                 pmap->pm_active = 0;
4638                 pmap_release(pmap);
4639                 pmap_puninit(pmap);
4640                 kfree(pmap, M_OBJPMAP);
4641         }
4642         if ((pmap = object->md.pmap_ro) != NULL) {
4643                 object->md.pmap_ro = NULL;
4644                 kprintf("pmap_object_free: destroying pmap %p in obj %p\n",
4645                         pmap, object);
4646                 pmap_remove_pages(pmap,
4647                                   VM_MIN_USER_ADDRESS, VM_MAX_USER_ADDRESS);
4648                 pmap->pm_active = 0;
4649                 pmap_release(pmap);
4650                 pmap_puninit(pmap);
4651                 kfree(pmap, M_OBJPMAP);
4652         }
4653 }