sys/platform/vkernel/platform/pmap.c

   1 /*
   2  * Copyright (c) 2006 The DragonFly Project.  All rights reserved.
   3  * Copyright (c) 1991 Regents of the University of California.
   4  * All rights reserved.
   5  * Copyright (c) 1994 John S. Dyson
   6  * All rights reserved.
   7  * Copyright (c) 1994 David Greenman
   8  * All rights reserved.
   9  * Copyright (c) 2004-2006 Matthew Dillon
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  *
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in
  20  *    the documentation and/or other materials provided with the
  21  *    distribution.
  22  * 3. Neither the name of The DragonFly Project nor the names of its
  23  *    contributors may be used to endorse or promote products derived
  24  *    from this software without specific, prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  28  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  29  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  30  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  31  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  32  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  33  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  34  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  35  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  36  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  * from:   @(#)pmap.c      7.7 (Berkeley)  5/12/91
  40  * $FreeBSD: src/sys/i386/i386/pmap.c,v 1.250.2.18 2002/03/06 22:48:53 silby Exp $
  41  * $DragonFly: src/sys/platform/vkernel/platform/pmap.c,v 1.20 2007/02/26 21:41:08 corecode Exp $
  42  */
  43 /*
  44  * NOTE: PMAP_INVAL_ADD: In pc32 this function is called prior to adjusting
  45  * the PTE in the page table, because a cpu synchronization might be required.
  46  * The actual invalidation is delayed until the following call or flush.  In
  47  * the VKERNEL build this function is called prior to adjusting the PTE and
  48  * invalidates the table synchronously (not delayed), and is not SMP safe
  49  * as a consequence.
  50  */
  51
  52 #include <sys/types.h>
  53 #include <sys/systm.h>
  54 #include <sys/kernel.h>
  55 #include <sys/stat.h>
  56 #include <sys/mman.h>
  57 #include <sys/vkernel.h>
  58 #include <sys/proc.h>
  59 #include <sys/thread.h>
  60 #include <sys/user.h>
  61 #include <sys/vmspace.h>
  62
  63 #include <vm/pmap.h>
  64 #include <vm/vm_page.h>
  65 #include <vm/vm_extern.h>
  66 #include <vm/vm_kern.h>
  67 #include <vm/vm_object.h>
  68 #include <vm/vm_zone.h>
  69 #include <vm/vm_pageout.h>
  70
  71 #include <machine/md_var.h>
  72 #include <machine/pcb.h>
  73 #include <machine/pmap_inval.h>
  74 #include <machine/globaldata.h>
  75
  76 #include <assert.h>
  77
  78 struct pmap kernel_pmap;
  79
  80 static struct vm_zone pvzone;
  81 static struct vm_object pvzone_obj;
  82 static TAILQ_HEAD(,pmap) pmap_list = TAILQ_HEAD_INITIALIZER(pmap_list);
  83 static int pv_entry_count;
  84 static int pv_entry_max;
  85 static int pv_entry_high_water;
  86 static int pmap_pagedaemon_waken;
  87 static boolean_t pmap_initialized = FALSE;
  88 static int protection_codes[8];
  89
  90 static void i386_protection_init(void);
  91 static void pmap_remove_all(vm_page_t m);
  92 static int pmap_release_free_page(struct pmap *pmap, vm_page_t p);
  93
  94 #define MINPV   2048
  95 #ifndef PMAP_SHPGPERPROC
  96 #define PMAP_SHPGPERPROC 200
  97 #endif
  98
  99 #define pmap_pde(m, v)  (&((m)->pm_pdir[(vm_offset_t)(v) >> PDRSHIFT]))
 100
 101 #define pte_prot(m, p) \
 102         (protection_codes[p & (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE)])
 103
 104 void
 105 pmap_init(void)
 106 {
 107         int i;
 108         struct pv_entry *pvinit;
 109
 110         for (i = 0; i < vm_page_array_size; i++) {
 111                 vm_page_t m;
 112
 113                 m = &vm_page_array[i];
 114                 TAILQ_INIT(&m->md.pv_list);
 115                 m->md.pv_list_count = 0;
 116         }
 117
 118         i = vm_page_array_size;
 119         if (i < MINPV)
 120                 i = MINPV;
 121         pvinit = (struct pv_entry *)kmem_alloc(&kernel_map, i*sizeof(*pvinit));
 122         zbootinit(&pvzone, "PV ENTRY", sizeof(*pvinit), pvinit, i);
 123         pmap_initialized = TRUE;
 124 }
 125
 126 void
 127 pmap_init2(void)
 128 {
 129         int shpgperproc = PMAP_SHPGPERPROC;
 130
 131         TUNABLE_INT_FETCH("vm.pmap.shpgperproc", &shpgperproc);
 132         pv_entry_max = shpgperproc * maxproc + vm_page_array_size;
 133         TUNABLE_INT_FETCH("vm.pmap.pv_entries", &pv_entry_max);
 134         pv_entry_high_water = 9 * (pv_entry_max / 10);
 135         zinitna(&pvzone, &pvzone_obj, NULL, 0, pv_entry_max, ZONE_INTERRUPT, 1);
 136 }
 137
 138 /*
 139  * Bootstrap the kernel_pmap so it can be used with pmap_enter().
 140  *
 141  * NOTE! pm_pdir for the kernel pmap is offset so VA's translate
 142  * directly into PTD indexes (PTA is also offset for the same reason).
 143  * This is necessary because, for now, KVA is not mapped at address 0.
 144  *
 145  * Page table pages are not managed like they are in normal pmaps, so
 146  * no pteobj is needed.
 147  */
 148 void
 149 pmap_bootstrap(void)
 150 {
 151         vm_pindex_t i = (vm_offset_t)KernelPTD >> PAGE_SHIFT;
 152
 153         kernel_pmap.pm_pdir = KernelPTD - (KvaStart >> SEG_SHIFT);
 154         kernel_pmap.pm_pdirpte = KernelPTA[i];
 155         kernel_pmap.pm_count = 1;
 156         kernel_pmap.pm_active = (cpumask_t)-1;
 157         TAILQ_INIT(&kernel_pmap.pm_pvlist);
 158         i386_protection_init();
 159 }
 160
 161 /*
 162  * Initialize pmap0/vmspace0 .  Since process 0 never enters user mode we
 163  * just dummy it up so it works well enough for fork().
 164  *
 165  * In DragonFly, process pmaps may only be used to manipulate user address
 166  * space, never kernel address space.
 167  */
 168 void
 169 pmap_pinit0(struct pmap *pmap)
 170 {
 171         pmap_pinit(pmap);
 172 }
 173
 174 /************************************************************************
 175  *              Procedures to manage whole physical maps                *
 176  ************************************************************************
 177  *
 178  * Initialize a preallocated and zeroed pmap structure,
 179  * such as one in a vmspace structure.
 180  */
 181 void
 182 pmap_pinit(struct pmap *pmap)
 183 {
 184         vm_page_t ptdpg;
 185         int npages;
 186
 187         /*
 188          * No need to allocate page table space yet but we do need a valid
 189          * page directory table.
 190          */
 191         if (pmap->pm_pdir == NULL) {
 192                 pmap->pm_pdir =
 193                     (pd_entry_t *)kmem_alloc_pageable(&kernel_map, PAGE_SIZE);
 194         }
 195
 196         /*
 197          * allocate object for the pte array and page directory
 198          */
 199         npages = VPTE_PAGETABLE_SIZE +
 200                  (VM_MAX_USER_ADDRESS / PAGE_SIZE) * sizeof(vpte_t);
 201         npages = (npages + PAGE_MASK) / PAGE_SIZE;
 202
 203         if (pmap->pm_pteobj == NULL)
 204                 pmap->pm_pteobj = vm_object_allocate(OBJT_DEFAULT, npages);
 205         pmap->pm_pdindex = npages - 1;
 206
 207         /*
 208          * allocate the page directory page
 209          */
 210         ptdpg = vm_page_grab(pmap->pm_pteobj, pmap->pm_pdindex,
 211                              VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
 212
 213         ptdpg->wire_count = 1;
 214         ++vmstats.v_wire_count;
 215
 216         /* not usually mapped */
 217         vm_page_flag_clear(ptdpg, PG_MAPPED | PG_BUSY);
 218         ptdpg->valid = VM_PAGE_BITS_ALL;
 219
 220         pmap_kenter((vm_offset_t)pmap->pm_pdir, VM_PAGE_TO_PHYS(ptdpg));
 221         pmap->pm_pdirpte = KernelPTA[(vm_offset_t)pmap->pm_pdir >> PAGE_SHIFT];
 222         if ((ptdpg->flags & PG_ZERO) == 0)
 223                 bzero(pmap->pm_pdir, PAGE_SIZE);
 224
 225         pmap->pm_count = 1;
 226         pmap->pm_active = 0;
 227         pmap->pm_ptphint = NULL;
 228         TAILQ_INIT(&pmap->pm_pvlist);
 229         bzero(&pmap->pm_stats, sizeof pmap->pm_stats);
 230 }
 231
 232 /*
 233  * Wire in kernel global address entries.  To avoid a race condition
 234  * between pmap initialization and pmap_growkernel, this procedure
 235  * adds the pmap to the master list (which growkernel scans to update),
 236  * then copies the template.
 237  *
 238  * In a virtual kernel there are no kernel global address entries.
 239  */
 240 void
 241 pmap_pinit2(struct pmap *pmap)
 242 {
 243         crit_enter();
 244         TAILQ_INSERT_TAIL(&pmap_list, pmap, pm_pmnode);
 245         crit_exit();
 246 }
 247
 248 /*
 249  * Release all resources held by the given physical map.
 250  *
 251  * Should only be called if the map contains no valid mappings.
 252  */
 253 static int pmap_release_callback(struct vm_page *p, void *data);
 254
 255 void
 256 pmap_release(struct pmap *pmap)
 257 {
 258         struct mdglobaldata *gd = mdcpu;
 259         vm_object_t object = pmap->pm_pteobj;
 260         struct rb_vm_page_scan_info info;
 261
 262         KKASSERT(pmap != &kernel_pmap);
 263
 264 #if defined(DIAGNOSTIC)
 265         if (object->ref_count != 1)
 266                 panic("pmap_release: pteobj reference count != 1");
 267 #endif
 268 #ifdef SMP
 269 #error "Must write code to clear PTxpdir cache across all CPUs"
 270 #endif
 271         /*
 272          * Once we destroy the page table, the mapping becomes invalid.
 273          * Rather then waste time doing a madvise
 274          */
 275         if (pmap->pm_pdir == gd->gd_PT1pdir) {
 276                 gd->gd_PT1pdir = NULL;
 277                 *gd->gd_PT1pde = 0;
 278                 /* madvise(gd->gd_PT1map, SEG_SIZE, MADV_INVAL); */
 279         }
 280         if (pmap->pm_pdir == gd->gd_PT2pdir) {
 281                 gd->gd_PT2pdir = NULL;
 282                 *gd->gd_PT2pde = 0;
 283                 /* madvise(gd->gd_PT2map, SEG_SIZE, MADV_INVAL); */
 284         }
 285
 286         info.pmap = pmap;
 287         info.object = object;
 288         crit_enter();
 289         TAILQ_REMOVE(&pmap_list, pmap, pm_pmnode);
 290         crit_exit();
 291
 292         do {
 293                 crit_enter();
 294                 info.error = 0;
 295                 info.mpte = NULL;
 296                 info.limit = object->generation;
 297
 298                 vm_page_rb_tree_RB_SCAN(&object->rb_memq, NULL,
 299                                         pmap_release_callback, &info);
 300                 if (info.error == 0 && info.mpte) {
 301                         if (!pmap_release_free_page(pmap, info.mpte))
 302                                 info.error = 1;
 303                 }
 304                 crit_exit();
 305         } while (info.error);
 306
 307         /*
 308          * Leave the KVA reservation for pm_pdir cached for later reuse.
 309          */
 310         pmap->pm_pdirpte = 0;
 311 }
 312
 313 static int
 314 pmap_release_callback(struct vm_page *p, void *data)
 315 {
 316         struct rb_vm_page_scan_info *info = data;
 317
 318         if (p->pindex == info->pmap->pm_pdindex) {
 319                 info->mpte = p;
 320                 return(0);
 321         }
 322         if (!pmap_release_free_page(info->pmap, p)) {
 323                 info->error = 1;
 324                 return(-1);
 325         }
 326         if (info->object->generation != info->limit) {
 327                 info->error = 1;
 328                 return(-1);
 329         }
 330         return(0);
 331 }
 332
 333 /*
 334  * Retire the given physical map from service.  Should only be called if
 335  * the map contains no valid mappings.
 336  */
 337 void
 338 pmap_destroy(pmap_t pmap)
 339 {
 340         int count;
 341
 342         if (pmap == NULL)
 343                 return;
 344
 345         count = --pmap->pm_count;
 346         if (count == 0) {
 347                 pmap_release(pmap);
 348                 panic("destroying a pmap is not yet implemented");
 349         }
 350 }
 351
 352 /*
 353  * Add a reference to the specified pmap.
 354  */
 355 void
 356 pmap_reference(pmap_t pmap)
 357 {
 358         if (pmap != NULL) {
 359                 pmap->pm_count++;
 360         }
 361 }
 362
 363 /************************************************************************
 364  *                      VMSPACE MANAGEMENT                              *
 365  ************************************************************************
 366  *
 367  * The VMSPACE management we do in our virtual kernel must be reflected
 368  * in the real kernel.  This is accomplished by making vmspace system
 369  * calls to the real kernel.
 370  */
 371 void
 372 cpu_vmspace_alloc(struct vmspace *vm)
 373 {
 374         int r;
 375         void *rp;
 376
 377 #define LAST_EXTENT     (VM_MAX_USER_ADDRESS - 0x80000000)
 378
 379         if (vmspace_create(&vm->vm_pmap, 0, NULL) < 0)
 380                 panic("vmspace_create() failed");
 381
 382         rp = vmspace_mmap(&vm->vm_pmap, (void *)0x00000000, 0x40000000,
 383                           PROT_READ|PROT_WRITE,
 384                           MAP_FILE|MAP_SHARED|MAP_VPAGETABLE|MAP_FIXED,
 385                           MemImageFd, 0);
 386         if (rp == MAP_FAILED)
 387                 panic("vmspace_mmap: failed1");
 388         vmspace_mcontrol(&vm->vm_pmap, (void *)0x00000000, 0x40000000,
 389                          MADV_NOSYNC, 0);
 390         rp = vmspace_mmap(&vm->vm_pmap, (void *)0x40000000, 0x40000000,
 391                           PROT_READ|PROT_WRITE,
 392                           MAP_FILE|MAP_SHARED|MAP_VPAGETABLE|MAP_FIXED,
 393                           MemImageFd, 0x40000000);
 394         if (rp == MAP_FAILED)
 395                 panic("vmspace_mmap: failed2");
 396         vmspace_mcontrol(&vm->vm_pmap, (void *)0x40000000, 0x40000000,
 397                          MADV_NOSYNC, 0);
 398         rp = vmspace_mmap(&vm->vm_pmap, (void *)0x80000000, LAST_EXTENT,
 399                           PROT_READ|PROT_WRITE,
 400                           MAP_FILE|MAP_SHARED|MAP_VPAGETABLE|MAP_FIXED,
 401                           MemImageFd, 0x80000000);
 402         vmspace_mcontrol(&vm->vm_pmap, (void *)0x80000000, LAST_EXTENT,
 403                          MADV_NOSYNC, 0);
 404         if (rp == MAP_FAILED)
 405                 panic("vmspace_mmap: failed3");
 406
 407         r = vmspace_mcontrol(&vm->vm_pmap, (void *)0x00000000, 0x40000000,
 408                              MADV_SETMAP, vmspace_pmap(vm)->pm_pdirpte);
 409         if (r < 0)
 410                 panic("vmspace_mcontrol: failed1");
 411         r = vmspace_mcontrol(&vm->vm_pmap, (void *)0x40000000, 0x40000000,
 412                              MADV_SETMAP, vmspace_pmap(vm)->pm_pdirpte);
 413         if (r < 0)
 414                 panic("vmspace_mcontrol: failed2");
 415         r = vmspace_mcontrol(&vm->vm_pmap, (void *)0x80000000, LAST_EXTENT,
 416                              MADV_SETMAP, vmspace_pmap(vm)->pm_pdirpte);
 417         if (r < 0)
 418                 panic("vmspace_mcontrol: failed3");
 419 }
 420
 421 void
 422 cpu_vmspace_free(struct vmspace *vm)
 423 {
 424         if (vmspace_destroy(&vm->vm_pmap) < 0)
 425                 panic("vmspace_destroy() failed");
 426 }
 427
 428 /************************************************************************
 429  *          Procedures which operate directly on the kernel PMAP        *
 430  ************************************************************************/
 431
 432 /*
 433  * This maps the requested page table and gives us access to it.
 434  */
 435 static vpte_t *
 436 get_ptbase(struct pmap *pmap, vm_offset_t va)
 437 {
 438         struct mdglobaldata *gd = mdcpu;
 439
 440         if (pmap == &kernel_pmap) {
 441                 KKASSERT(va >= KvaStart && va < KvaEnd);
 442                 return(KernelPTA + (va >> PAGE_SHIFT));
 443         } else if (pmap->pm_pdir == gd->gd_PT1pdir) {
 444                 return(gd->gd_PT1map + (va >> PAGE_SHIFT));
 445         } else if (pmap->pm_pdir == gd->gd_PT2pdir) {
 446                 return(gd->gd_PT2map + (va >> PAGE_SHIFT));
 447         }
 448
 449         /*
 450          * Otherwise choose one or the other and map the page table
 451          * in the KVA space reserved for it.
 452          */
 453         KKASSERT(gd->mi.gd_intr_nesting_level == 0 &&
 454                  (gd->mi.gd_curthread->td_flags & TDF_INTTHREAD) == 0);
 455
 456         if ((gd->gd_PTflip = 1 - gd->gd_PTflip) == 0) {
 457                 gd->gd_PT1pdir = pmap->pm_pdir;
 458                 *gd->gd_PT1pde = pmap->pm_pdirpte;
 459                 madvise(gd->gd_PT1map, SEG_SIZE, MADV_INVAL);
 460                 return(gd->gd_PT1map + (va >> PAGE_SHIFT));
 461         } else {
 462                 gd->gd_PT2pdir = pmap->pm_pdir;
 463                 *gd->gd_PT2pde = pmap->pm_pdirpte;
 464                 madvise(gd->gd_PT2map, SEG_SIZE, MADV_INVAL);
 465                 return(gd->gd_PT2map + (va >> PAGE_SHIFT));
 466         }
 467 }
 468
 469 static vpte_t *
 470 get_ptbase1(struct pmap *pmap, vm_offset_t va)
 471 {
 472         struct mdglobaldata *gd = mdcpu;
 473
 474         if (pmap == &kernel_pmap) {
 475                 KKASSERT(va >= KvaStart && va < KvaEnd);
 476                 return(KernelPTA + (va >> PAGE_SHIFT));
 477         } else if (pmap->pm_pdir == gd->gd_PT1pdir) {
 478                 return(gd->gd_PT1map + (va >> PAGE_SHIFT));
 479         }
 480         KKASSERT(gd->mi.gd_intr_nesting_level == 0 &&
 481                  (gd->mi.gd_curthread->td_flags & TDF_INTTHREAD) == 0);
 482         gd->gd_PT1pdir = pmap->pm_pdir;
 483         *gd->gd_PT1pde = pmap->pm_pdirpte;
 484         madvise(gd->gd_PT1map, SEG_SIZE, MADV_INVAL);
 485         return(gd->gd_PT1map + (va >> PAGE_SHIFT));
 486 }
 487
 488 static vpte_t *
 489 get_ptbase2(struct pmap *pmap, vm_offset_t va)
 490 {
 491         struct mdglobaldata *gd = mdcpu;
 492
 493         if (pmap == &kernel_pmap) {
 494                 KKASSERT(va >= KvaStart && va < KvaEnd);
 495                 return(KernelPTA + (va >> PAGE_SHIFT));
 496         } else if (pmap->pm_pdir == gd->gd_PT2pdir) {
 497                 return(gd->gd_PT2map + (va >> PAGE_SHIFT));
 498         }
 499         KKASSERT(gd->mi.gd_intr_nesting_level == 0 &&
 500                  (gd->mi.gd_curthread->td_flags & TDF_INTTHREAD) == 0);
 501         gd->gd_PT2pdir = pmap->pm_pdir;
 502         *gd->gd_PT2pde = pmap->pm_pdirpte;
 503         madvise(gd->gd_PT2map, SEG_SIZE, MADV_INVAL);
 504         return(gd->gd_PT2map + (va >> PAGE_SHIFT));
 505 }
 506
 507 /*
 508  * When removing a page directory the related VA range in the self-mapping
 509  * of the page table must be invalidated.
 510  */
 511 static void
 512 inval_ptbase_pagedir(pmap_t pmap, vm_pindex_t pindex)
 513 {
 514         struct mdglobaldata *gd = mdcpu;
 515         vm_offset_t va;
 516
 517 #ifdef SMP
 518 #error "Must inval self-mappings in all gd's"
 519 #endif
 520         if (pmap == &kernel_pmap) {
 521                 va = (vm_offset_t)KernelPTA + (pindex << PAGE_SHIFT);
 522                 madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 523         } else {
 524                 /*
 525                  * XXX this should not strictly be needed because the page
 526                  * dir should alread be invalidated.  test and remove
 527                  */
 528                 va = (vm_offset_t)pindex << PAGE_SHIFT;
 529                 vmspace_mcontrol(pmap, (void *)va, SEG_SIZE, MADV_INVAL, 0);
 530         }
 531         if (pmap->pm_pdir == gd->gd_PT1pdir) {
 532                 va = (vm_offset_t)gd->gd_PT1map + (pindex << PAGE_SHIFT);
 533                 madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 534         }
 535         if (pmap->pm_pdir == gd->gd_PT2pdir) {
 536                 va = (vm_offset_t)gd->gd_PT2map + (pindex << PAGE_SHIFT);
 537                 madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 538         }
 539 }
 540
 541 /*
 542  * Return a pointer to the page table entry for the specified va in the
 543  * specified pmap.  NULL is returned if there is no valid page table page
 544  * for the VA.
 545  */
 546 static __inline vpte_t *
 547 pmap_pte(struct pmap *pmap, vm_offset_t va)
 548 {
 549         vpte_t *ptep;
 550
 551         ptep = &pmap->pm_pdir[va >> SEG_SHIFT];
 552         if (*ptep & VPTE_PS)
 553                 return(ptep);
 554         if (*ptep)
 555                 return (get_ptbase(pmap, va));
 556         return(NULL);
 557 }
 558
 559
 560 /*
 561  * Enter a mapping into kernel_pmap.  Mappings created in this fashion
 562  * are not managed.
 563  */
 564 void
 565 pmap_kenter(vm_offset_t va, vm_paddr_t pa)
 566 {
 567         vpte_t *ptep;
 568         vpte_t npte;
 569 #ifdef SMP
 570         pmap_inval_info info;
 571 #endif
 572
 573         KKASSERT(va >= KvaStart && va < KvaEnd);
 574         npte = (vpte_t)pa | VPTE_R | VPTE_W | VPTE_V;
 575         ptep = KernelPTA + (va >> PAGE_SHIFT);
 576         if (*ptep & VPTE_V) {
 577 #ifdef SMP
 578                 pmap_inval_init(&info);
 579                 pmap_inval_add(&info, &kernel_pmap, va);
 580 #endif
 581                 *ptep = npte;
 582 #ifdef SMP
 583                 pmap_inval_flush(&info);
 584 #else
 585                 madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 586 #endif
 587         } else {
 588                 *ptep = npte;
 589         }
 590 }
 591
 592 void
 593 pmap_kenter_sync(vm_offset_t va)
 594 {
 595         pmap_inval_info info;
 596
 597         pmap_inval_init(&info);
 598         pmap_inval_add(&info, &kernel_pmap, va);
 599         pmap_inval_flush(&info);
 600 }
 601
 602 void
 603 pmap_kenter_sync_quick(vm_offset_t va)
 604 {
 605         madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 606 }
 607
 608 /*
 609  * XXX these need to be recoded.  They are not used in any critical path.
 610  */
 611 void
 612 pmap_kmodify_rw(vm_offset_t va)
 613 {
 614         *pmap_kpte(va) |= VPTE_R | VPTE_W;
 615         madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 616 }
 617
 618 void
 619 pmap_kmodify_nc(vm_offset_t va)
 620 {
 621 #if 0
 622         *pmap_kpte(va) |= VPTE_N;
 623         madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 624 #endif
 625 }
 626
 627 /*
 628  * Map a contiguous range of physical memory to a KVM
 629  */
 630 vm_offset_t
 631 pmap_map(vm_offset_t virt, vm_paddr_t start, vm_paddr_t end, int prot)
 632 {
 633         while (start < end) {
 634                 pmap_kenter(virt, start);
 635                 virt += PAGE_SIZE;
 636                 start += PAGE_SIZE;
 637         }
 638         return (virt);
 639 }
 640
 641 vpte_t *
 642 pmap_kpte(vm_offset_t va)
 643 {
 644         vpte_t *ptep;
 645
 646         KKASSERT(va >= KvaStart && va < KvaEnd);
 647         ptep = KernelPTA + (va >> PAGE_SHIFT);
 648         return(ptep);
 649 }
 650
 651 /*
 652  * Enter a mapping into kernel_pmap without any SMP interactions.
 653  *
 654  * Mappings created in this fashion are not managed.
 655  */
 656 void
 657 pmap_kenter_quick(vm_offset_t va, vm_paddr_t pa)
 658 {
 659         vpte_t *ptep;
 660         vpte_t npte;
 661
 662         KKASSERT(va >= KvaStart && va < KvaEnd);
 663
 664         npte = (vpte_t)pa | VPTE_R | VPTE_W | VPTE_V;
 665         ptep = KernelPTA + (va >> PAGE_SHIFT);
 666         if (*ptep & VPTE_V) {
 667                 *ptep = npte;
 668                 madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 669         } else {
 670                 *ptep = npte;
 671         }
 672 }
 673
 674 /*
 675  * Make a temporary mapping for a physical address.  This is only intended
 676  * to be used for panic dumps.
 677  */
 678 void *
 679 pmap_kenter_temporary(vm_paddr_t pa, int i)
 680 {
 681         pmap_kenter(crashdumpmap + (i * PAGE_SIZE), pa);
 682         return ((void *)crashdumpmap);
 683 }
 684
 685 /*
 686  * Remove an unmanaged mapping created with pmap_kenter*().
 687  */
 688 void
 689 pmap_kremove(vm_offset_t va)
 690 {
 691         vpte_t *ptep;
 692 #ifdef SMP
 693         pmap_inval_info info;
 694 #endif
 695
 696         KKASSERT(va >= KvaStart && va < KvaEnd);
 697
 698         ptep = KernelPTA + (va >> PAGE_SHIFT);
 699         if (*ptep & VPTE_V) {
 700 #ifdef SMP
 701                 pmap_inval_init(&info);
 702                 pmap_inval_add(&info, &kernel_pmap, va);
 703 #endif
 704                 *ptep = 0;
 705 #ifdef SMP
 706                 pmap_inval_flush(&info);
 707 #else
 708                 madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 709 #endif
 710         } else {
 711                 *ptep = 0;
 712         }
 713
 714 }
 715
 716 /*
 717  * Remove an unmanaged mapping created with pmap_kenter*() without
 718  * going through any SMP interactions.
 719  */
 720 void
 721 pmap_kremove_quick(vm_offset_t va)
 722 {
 723         vpte_t *ptep;
 724
 725         KKASSERT(va >= KvaStart && va < KvaEnd);
 726
 727         ptep = KernelPTA + (va >> PAGE_SHIFT);
 728         if (*ptep & VPTE_V) {
 729                 *ptep = 0;
 730                 madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 731         } else {
 732                 *ptep = 0;
 733         }
 734 }
 735
 736 /*
 737  * Extract the physical address from the kernel_pmap that is associated
 738  * with the specified virtual address.
 739  */
 740 vm_paddr_t
 741 pmap_kextract(vm_offset_t va)
 742 {
 743         vpte_t *ptep;
 744         vm_paddr_t pa;
 745
 746         KKASSERT(va >= KvaStart && va < KvaEnd);
 747
 748         ptep = KernelPTA + (va >> PAGE_SHIFT);
 749         pa = (vm_paddr_t)(*ptep & VPTE_FRAME) | (va & PAGE_MASK);
 750         return(pa);
 751 }
 752
 753 /*
 754  * Map a set of unmanaged VM pages into KVM.
 755  */
 756 void
 757 pmap_qenter(vm_offset_t va, struct vm_page **m, int count)
 758 {
 759         KKASSERT(va >= KvaStart && va + count * PAGE_SIZE < KvaEnd);
 760         while (count) {
 761                 vpte_t *ptep;
 762
 763                 ptep = KernelPTA + (va >> PAGE_SHIFT);
 764                 if (*ptep & VPTE_V)
 765                         madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 766                 *ptep = (vpte_t)(*m)->phys_addr | VPTE_R | VPTE_W | VPTE_V;
 767                 --count;
 768                 ++m;
 769                 va += PAGE_SIZE;
 770         }
 771 #ifdef SMP
 772         XXX
 773         smp_invltlb();
 774 #endif
 775 }
 776
 777 /*
 778  * Map a set of VM pages to kernel virtual memory.  If a mapping changes
 779  * clear the supplied mask.  The caller handles any SMP interactions.
 780  * The mask is used to provide the caller with hints on what SMP interactions
 781  * might be needed.
 782  */
 783 void
 784 pmap_qenter2(vm_offset_t va, struct vm_page **m, int count, cpumask_t *mask)
 785 {
 786         cpumask_t cmask = mycpu->gd_cpumask;
 787
 788         KKASSERT(va >= KvaStart && va + count * PAGE_SIZE < KvaEnd);
 789         while (count) {
 790                 vpte_t *ptep;
 791                 vpte_t npte;
 792
 793                 ptep = KernelPTA + (va >> PAGE_SHIFT);
 794                 npte = (vpte_t)(*m)->phys_addr | VPTE_R | VPTE_W | VPTE_V;
 795                 if (*ptep != npte) {
 796                         *mask = 0;
 797                         *ptep = npte;
 798                         madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 799                 } else if ((*mask & cmask) == 0) {
 800                         madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 801                 }
 802                 --count;
 803                 ++m;
 804                 va += PAGE_SIZE;
 805         }
 806         *mask |= cmask;
 807 }
 808
 809 /*
 810  * Undo the effects of pmap_qenter*().
 811  */
 812 void
 813 pmap_qremove(vm_offset_t va, int count)
 814 {
 815         KKASSERT(va >= KvaStart && va + count * PAGE_SIZE < KvaEnd);
 816         while (count) {
 817                 vpte_t *ptep;
 818
 819                 ptep = KernelPTA + (va >> PAGE_SHIFT);
 820                 if (*ptep & VPTE_V)
 821                         madvise((void *)va, PAGE_SIZE, MADV_INVAL);
 822                 *ptep = 0;
 823                 --count;
 824                 va += PAGE_SIZE;
 825         }
 826 #ifdef SMP
 827         XXX
 828         smp_invltlb();
 829 #endif
 830 }
 831
 832 /************************************************************************
 833  *        Misc support glue called by machine independant code          *
 834  ************************************************************************
 835  *
 836  * These routines are called by machine independant code to operate on
 837  * certain machine-dependant aspects of processes, threads, and pmaps.
 838  */
 839
 840 /*
 841  * Initialize MD portions of the thread structure.
 842  */
 843 void
 844 pmap_init_thread(thread_t td)
 845 {
 846         /* enforce pcb placement */
 847         td->td_pcb = (struct pcb *)(td->td_kstack + td->td_kstack_size) - 1;
 848         td->td_savefpu = &td->td_pcb->pcb_save;
 849         td->td_sp = (char *)td->td_pcb - 16;
 850 }
 851
 852 /*
 853  * This routine directly affects the fork perf for a process.
 854  */
 855 void
 856 pmap_init_proc(struct proc *p)
 857 {
 858 }
 859
 860 /*
 861  * Destroy the UPAGES for a process that has exited and disassociate
 862  * the process from its thread.
 863  */
 864 void
 865 pmap_dispose_proc(struct proc *p)
 866 {
 867         KASSERT(p->p_lock == 0, ("attempt to dispose referenced proc! %p", p));
 868 }
 869
 870 /*
 871  * We pre-allocate all page table pages for kernel virtual memory so
 872  * this routine will only be called if KVM has been exhausted.
 873  */
 874 void
 875 pmap_growkernel(vm_offset_t addr)
 876 {
 877         addr = (addr + PAGE_SIZE * NPTEPG) & ~(PAGE_SIZE * NPTEPG - 1);
 878
 879         if (addr > virtual_end - SEG_SIZE)
 880                 panic("KVM exhausted");
 881         kernel_vm_end = addr;
 882 }
 883
 884 /*
 885  * The modification bit is not tracked for any pages in this range. XXX
 886  * such pages in this maps should always use pmap_k*() functions and not
 887  * be managed anyhow.
 888  *
 889  * XXX User and kernel address spaces are independant for virtual kernels,
 890  * this function only applies to the kernel pmap.
 891  */
 892 static int
 893 pmap_track_modified(pmap_t pmap, vm_offset_t va)
 894 {
 895         if (pmap != &kernel_pmap)
 896                 return 1;
 897         if ((va < clean_sva) || (va >= clean_eva))
 898                 return 1;
 899         else
 900                 return 0;
 901 }
 902
 903 /************************************************************************
 904  *          Procedures supporting managed page table pages              *
 905  ************************************************************************
 906  *
 907  * These procedures are used to track managed page table pages.  These pages
 908  * use the page table page's vm_page_t to track PTEs in the page.  The
 909  * page table pages themselves are arranged in a VM object, pmap->pm_pteobj.
 910  *
 911  * This allows the system to throw away page table pages for user processes
 912  * at will and reinstantiate them on demand.
 913  */
 914
 915 /*
 916  * This routine works like vm_page_lookup() but also blocks as long as the
 917  * page is busy.  This routine does not busy the page it returns.
 918  *
 919  * Unless the caller is managing objects whos pages are in a known state,
 920  * the call should be made with a critical section held so the page's object
 921  * association remains valid on return.
 922  */
 923 static vm_page_t
 924 pmap_page_lookup(vm_object_t object, vm_pindex_t pindex)
 925 {
 926         vm_page_t m;
 927
 928 retry:
 929         m = vm_page_lookup(object, pindex);
 930         if (m && vm_page_sleep_busy(m, FALSE, "pplookp"))
 931                 goto retry;
 932         return(m);
 933 }
 934
 935 /*
 936  * This routine unholds page table pages, and if the hold count
 937  * drops to zero, then it decrements the wire count.
 938  */
 939 static int
 940 _pmap_unwire_pte_hold(pmap_t pmap, vm_page_t m, pmap_inval_info_t info)
 941 {
 942         pmap_inval_flush(info);
 943         while (vm_page_sleep_busy(m, FALSE, "pmuwpt"))
 944                 ;
 945
 946         if (m->hold_count == 0) {
 947                 /*
 948                  * unmap the page table page
 949                  */
 950                 pmap->pm_pdir[m->pindex] = 0;
 951                 --pmap->pm_stats.resident_count;
 952                 inval_ptbase_pagedir(pmap, m->pindex);
 953
 954                 if (pmap->pm_ptphint == m)
 955                         pmap->pm_ptphint = NULL;
 956
 957                 /*
 958                  * If the page is finally unwired, simply free it.
 959                  */
 960                 --m->wire_count;
 961                 if (m->wire_count == 0) {
 962                         vm_page_flash(m);
 963                         vm_page_busy(m);
 964                         vm_page_free_zero(m);
 965                         --vmstats.v_wire_count;
 966                 }
 967                 return 1;
 968         }
 969         return 0;
 970 }
 971
 972 static __inline int
 973 pmap_unwire_pte_hold(pmap_t pmap, vm_page_t m, pmap_inval_info_t info)
 974 {
 975         vm_page_unhold(m);
 976         if (m->hold_count == 0)
 977                 return _pmap_unwire_pte_hold(pmap, m, info);
 978         else
 979                 return 0;
 980 }
 981
 982 /*
 983  * After removing a page table entry, this routine is used to
 984  * conditionally free the page, and manage the hold/wire counts.
 985  */
 986 static int
 987 pmap_unuse_pt(pmap_t pmap, vm_offset_t va, vm_page_t mpte,
 988                 pmap_inval_info_t info)
 989 {
 990         unsigned ptepindex;
 991
 992         if (mpte == NULL) {
 993                 /*
 994                  * page table pages in the kernel_pmap are not managed.
 995                  */
 996                 if (pmap == &kernel_pmap)
 997                         return(0);
 998                 ptepindex = (va >> PDRSHIFT);
 999                 if (pmap->pm_ptphint &&
1000                         (pmap->pm_ptphint->pindex == ptepindex)) {
1001                         mpte = pmap->pm_ptphint;
1002                 } else {
1003                         pmap_inval_flush(info);
1004                         mpte = pmap_page_lookup( pmap->pm_pteobj, ptepindex);
1005                         pmap->pm_ptphint = mpte;
1006                 }
1007         }
1008         return pmap_unwire_pte_hold(pmap, mpte, info);
1009 }
1010
1011 /*
1012  * Attempt to release and free an vm_page in a pmap.  Returns 1 on success,
1013  * 0 on failure (if the procedure had to sleep).
1014  */
1015 static int
1016 pmap_release_free_page(struct pmap *pmap, vm_page_t p)
1017 {
1018         vpte_t *pde = pmap->pm_pdir;
1019         /*
1020          * This code optimizes the case of freeing non-busy
1021          * page-table pages.  Those pages are zero now, and
1022          * might as well be placed directly into the zero queue.
1023          */
1024         if (vm_page_sleep_busy(p, FALSE, "pmaprl"))
1025                 return 0;
1026
1027         vm_page_busy(p);
1028         pmap->pm_stats.resident_count--;
1029
1030         if (p->hold_count)  {
1031                 panic("pmap_release: freeing held page table page");
1032         }
1033         /*
1034          * Page directory pages need to have the kernel stuff cleared, so
1035          * they can go into the zero queue also.
1036          *
1037          * In virtual kernels there is no 'kernel stuff'.  For the moment
1038          * I just make sure the whole thing has been zero'd even though
1039          * it should already be completely zero'd.
1040          *
1041          * pmaps for vkernels do not self-map because they do not share
1042          * their address space with the vkernel.  Clearing of pde[] thus
1043          * only applies to page table pages and not to the page directory
1044          * page.
1045          */
1046         if (p->pindex == pmap->pm_pdindex) {
1047                 bzero(pde, VPTE_PAGETABLE_SIZE);
1048                 pmap_kremove((vm_offset_t)pmap->pm_pdir);
1049         } else {
1050                 pde[p->pindex] = 0;
1051         }
1052
1053         /*
1054          * Clear the matching hint
1055          */
1056         if (pmap->pm_ptphint && (pmap->pm_ptphint->pindex == p->pindex))
1057                 pmap->pm_ptphint = NULL;
1058
1059         /*
1060          * And throw the page away.  The page is completely zero'd out so
1061          * optimize the free call.
1062          */
1063         p->wire_count--;
1064         vmstats.v_wire_count--;
1065         vm_page_free_zero(p);
1066         return 1;
1067 }
1068
1069 /*
1070  * This routine is called if the page table page is not mapped in the page
1071  * table directory.
1072  *
1073  * The routine is broken up into two parts for readability.
1074  */
1075 static vm_page_t
1076 _pmap_allocpte(pmap_t pmap, unsigned ptepindex)
1077 {
1078         vm_paddr_t ptepa;
1079         vm_page_t m;
1080
1081         /*
1082          * Find or fabricate a new pagetable page
1083          */
1084         m = vm_page_grab(pmap->pm_pteobj, ptepindex,
1085                          VM_ALLOC_NORMAL | VM_ALLOC_ZERO | VM_ALLOC_RETRY);
1086
1087         KASSERT(m->queue == PQ_NONE,
1088                 ("_pmap_allocpte: %p->queue != PQ_NONE", m));
1089
1090         if (m->wire_count == 0)
1091                 vmstats.v_wire_count++;
1092         m->wire_count++;
1093
1094         /*
1095          * Increment the hold count for the page table page
1096          * (denoting a new mapping.)
1097          */
1098         m->hold_count++;
1099
1100         /*
1101          * Map the pagetable page into the process address space, if
1102          * it isn't already there.
1103          */
1104         pmap->pm_stats.resident_count++;
1105
1106         ptepa = VM_PAGE_TO_PHYS(m);
1107         pmap->pm_pdir[ptepindex] = (vpte_t)ptepa | VPTE_R | VPTE_W | VPTE_V |
1108                                    VPTE_A | VPTE_M;
1109
1110         /*
1111          * We are likely about to access this page table page, so set the
1112          * page table hint to reduce overhead.
1113          */
1114         pmap->pm_ptphint = m;
1115
1116         /*
1117          * Try to use the new mapping, but if we cannot, then
1118          * do it with the routine that maps the page explicitly.
1119          */
1120         if ((m->flags & PG_ZERO) == 0)
1121                 pmap_zero_page(ptepa);
1122
1123         m->valid = VM_PAGE_BITS_ALL;
1124         vm_page_flag_clear(m, PG_ZERO);
1125         vm_page_flag_set(m, PG_MAPPED);
1126         vm_page_wakeup(m);
1127
1128         return (m);
1129 }
1130
1131 /*
1132  * Determine the page table page required to access the VA in the pmap
1133  * and allocate it if necessary.  Return a held vm_page_t for the page.
1134  *
1135  * Only used with user pmaps.
1136  */
1137 static vm_page_t
1138 pmap_allocpte(pmap_t pmap, vm_offset_t va)
1139 {
1140         unsigned ptepindex;
1141         vm_offset_t ptepa;
1142         vm_page_t m;
1143
1144         /*
1145          * Calculate pagetable page index
1146          */
1147         ptepindex = va >> PDRSHIFT;
1148
1149         /*
1150          * Get the page directory entry
1151          */
1152         ptepa = (vm_offset_t) pmap->pm_pdir[ptepindex];
1153
1154         /*
1155          * This supports switching from a 4MB page to a
1156          * normal 4K page.
1157          */
1158         if (ptepa & VPTE_PS) {
1159                 pmap->pm_pdir[ptepindex] = 0;
1160                 ptepa = 0;
1161                 cpu_invltlb();
1162                 smp_invltlb();
1163         }
1164
1165         /*
1166          * If the page table page is mapped, we just increment the
1167          * hold count, and activate it.
1168          */
1169         if (ptepa) {
1170                 /*
1171                  * In order to get the page table page, try the
1172                  * hint first.
1173                  */
1174                 if (pmap->pm_ptphint &&
1175                         (pmap->pm_ptphint->pindex == ptepindex)) {
1176                         m = pmap->pm_ptphint;
1177                 } else {
1178                         m = pmap_page_lookup( pmap->pm_pteobj, ptepindex);
1179                         pmap->pm_ptphint = m;
1180                 }
1181                 m->hold_count++;
1182                 return m;
1183         }
1184         /*
1185          * Here if the pte page isn't mapped, or if it has been deallocated.
1186          */
1187         return _pmap_allocpte(pmap, ptepindex);
1188 }
1189
1190 /************************************************************************
1191  *                      Managed pages in pmaps                          *
1192  ************************************************************************
1193  *
1194  * All pages entered into user pmaps and some pages entered into the kernel
1195  * pmap are managed, meaning that pmap_protect() and other related management
1196  * functions work on these pages.
1197  */
1198
1199 /*
1200  * free the pv_entry back to the free list.  This function may be
1201  * called from an interrupt.
1202  */
1203 static __inline void
1204 free_pv_entry(pv_entry_t pv)
1205 {
1206         pv_entry_count--;
1207         zfree(&pvzone, pv);
1208 }
1209
1210 /*
1211  * get a new pv_entry, allocating a block from the system
1212  * when needed.  This function may be called from an interrupt.
1213  */
1214 static pv_entry_t
1215 get_pv_entry(void)
1216 {
1217         pv_entry_count++;
1218         if (pv_entry_high_water &&
1219                 (pv_entry_count > pv_entry_high_water) &&
1220                 (pmap_pagedaemon_waken == 0)) {
1221                 pmap_pagedaemon_waken = 1;
1222                 wakeup (&vm_pages_needed);
1223         }
1224         return zalloc(&pvzone);
1225 }
1226
1227 /*
1228  * This routine is very drastic, but can save the system
1229  * in a pinch.
1230  */
1231 void
1232 pmap_collect(void)
1233 {
1234         int i;
1235         vm_page_t m;
1236         static int warningdone=0;
1237
1238         if (pmap_pagedaemon_waken == 0)
1239                 return;
1240
1241         if (warningdone < 5) {
1242                 kprintf("pmap_collect: collecting pv entries -- suggest increasing PMAP_SHPGPERPROC\n");
1243                 warningdone++;
1244         }
1245
1246         for(i = 0; i < vm_page_array_size; i++) {
1247                 m = &vm_page_array[i];
1248                 if (m->wire_count || m->hold_count || m->busy ||
1249                     (m->flags & PG_BUSY))
1250                         continue;
1251                 pmap_remove_all(m);
1252         }
1253         pmap_pagedaemon_waken = 0;
1254 }
1255
1256 /*
1257  * If it is the first entry on the list, it is actually
1258  * in the header and we must copy the following entry up
1259  * to the header.  Otherwise we must search the list for
1260  * the entry.  In either case we free the now unused entry.
1261  */
1262 static int
1263 pmap_remove_entry(struct pmap *pmap, vm_page_t m,
1264                   vm_offset_t va, pmap_inval_info_t info)
1265 {
1266         pv_entry_t pv;
1267         int rtval;
1268
1269         crit_enter();
1270         if (m->md.pv_list_count < pmap->pm_stats.resident_count) {
1271                 TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
1272                         if (pmap == pv->pv_pmap && va == pv->pv_va)
1273                                 break;
1274                 }
1275         } else {
1276                 TAILQ_FOREACH(pv, &pmap->pm_pvlist, pv_plist) {
1277                         if (va == pv->pv_va)
1278                                 break;
1279                 }
1280         }
1281
1282         /*
1283          * Note that pv_ptem is NULL if the page table page itself is not
1284          * managed, even if the page being removed IS managed.
1285          */
1286         rtval = 0;
1287         if (pv) {
1288                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
1289                 m->md.pv_list_count--;
1290                 if (TAILQ_FIRST(&m->md.pv_list) == NULL)
1291                         vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
1292                 TAILQ_REMOVE(&pmap->pm_pvlist, pv, pv_plist);
1293                 ++pmap->pm_generation;
1294                 rtval = pmap_unuse_pt(pmap, va, pv->pv_ptem, info);
1295                 free_pv_entry(pv);
1296         }
1297         crit_exit();
1298         return rtval;
1299 }
1300
1301 /*
1302  * Create a pv entry for page at pa for (pmap, va).  If the page table page
1303  * holding the VA is managed, mpte will be non-NULL.
1304  */
1305 static void
1306 pmap_insert_entry(pmap_t pmap, vm_offset_t va, vm_page_t mpte, vm_page_t m)
1307 {
1308         pv_entry_t pv;
1309
1310         crit_enter();
1311         pv = get_pv_entry();
1312         pv->pv_va = va;
1313         pv->pv_pmap = pmap;
1314         pv->pv_ptem = mpte;
1315
1316         TAILQ_INSERT_TAIL(&pmap->pm_pvlist, pv, pv_plist);
1317         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_list);
1318         m->md.pv_list_count++;
1319
1320         crit_exit();
1321 }
1322
1323 /*
1324  * pmap_remove_pte: do the things to unmap a page in a process
1325  */
1326 static int
1327 pmap_remove_pte(struct pmap *pmap, vpte_t *ptq, vm_offset_t va,
1328         pmap_inval_info_t info)
1329 {
1330         vpte_t oldpte;
1331         vm_page_t m;
1332
1333         oldpte = loadandclear(ptq);
1334         pmap_inval_add(info, pmap, va); /* See NOTE: PMAP_INVAL_ADD */
1335         if (oldpte & VPTE_WIRED)
1336                 --pmap->pm_stats.wired_count;
1337         KKASSERT(pmap->pm_stats.wired_count >= 0);
1338
1339 #if 0
1340         /*
1341          * Machines that don't support invlpg, also don't support
1342          * VPTE_G.  XXX VPTE_G is disabled for SMP so don't worry about
1343          * the SMP case.
1344          */
1345         if (oldpte & VPTE_G)
1346                 madvise((void *)va, PAGE_SIZE, MADV_INVAL);
1347 #endif
1348         pmap->pm_stats.resident_count -= 1;
1349         if (oldpte & VPTE_MANAGED) {
1350                 m = PHYS_TO_VM_PAGE(oldpte);
1351                 if (oldpte & VPTE_M) {
1352 #if defined(PMAP_DIAGNOSTIC)
1353                         if (pmap_nw_modified((pt_entry_t) oldpte)) {
1354                                 kprintf(
1355         "pmap_remove: modified page not writable: va: 0x%x, pte: 0x%x\n",
1356                                     va, oldpte);
1357                         }
1358 #endif
1359                         if (pmap_track_modified(pmap, va))
1360                                 vm_page_dirty(m);
1361                 }
1362                 if (oldpte & VPTE_A)
1363                         vm_page_flag_set(m, PG_REFERENCED);
1364                 return pmap_remove_entry(pmap, m, va, info);
1365         } else {
1366                 return pmap_unuse_pt(pmap, va, NULL, info);
1367         }
1368
1369         return 0;
1370 }
1371
1372 /*
1373  * pmap_remove_page:
1374  *
1375  *      Remove a single page from a process address space.
1376  *
1377  *      This function may not be called from an interrupt if the pmap is
1378  *      not kernel_pmap.
1379  */
1380 static void
1381 pmap_remove_page(struct pmap *pmap, vm_offset_t va, pmap_inval_info_t info)
1382 {
1383         vpte_t *ptq;
1384
1385         /*
1386          * if there is no pte for this address, just skip it!!!  Otherwise
1387          * get a local va for mappings for this pmap and remove the entry.
1388          */
1389         if (*pmap_pde(pmap, va) != 0) {
1390                 ptq = get_ptbase(pmap, va);
1391                 if (*ptq) {
1392                         pmap_remove_pte(pmap, ptq, va, info);
1393                 }
1394         }
1395 }
1396
1397 /*
1398  * pmap_remove:
1399  *
1400  *      Remove the given range of addresses from the specified map.
1401  *
1402  *      It is assumed that the start and end are properly
1403  *      rounded to the page size.
1404  *
1405  *      This function may not be called from an interrupt if the pmap is
1406  *      not kernel_pmap.
1407  */
1408 void
1409 pmap_remove(struct pmap *pmap, vm_offset_t sva, vm_offset_t eva)
1410 {
1411         vpte_t *ptbase;
1412         vm_offset_t pdnxt;
1413         vm_offset_t ptpaddr;
1414         vm_pindex_t sindex, eindex;
1415         struct pmap_inval_info info;
1416
1417         if (pmap == NULL)
1418                 return;
1419
1420         KKASSERT(pmap->pm_stats.resident_count >= 0);
1421         if (pmap->pm_stats.resident_count == 0)
1422                 return;
1423
1424         pmap_inval_init(&info);
1425
1426         /*
1427          * special handling of removing one page.  a very
1428          * common operation and easy to short circuit some
1429          * code.
1430          */
1431         if (((sva + PAGE_SIZE) == eva) &&
1432                 ((pmap->pm_pdir[(sva >> PDRSHIFT)] & VPTE_PS) == 0)) {
1433                 pmap_remove_page(pmap, sva, &info);
1434                 pmap_inval_flush(&info);
1435                 return;
1436         }
1437
1438         /*
1439          * Get a local virtual address for the mappings that are being
1440          * worked with.
1441          *
1442          * XXX this is really messy because the kernel pmap is not relative
1443          * to address 0
1444          */
1445         sindex = (sva >> PAGE_SHIFT);
1446         eindex = (eva >> PAGE_SHIFT);
1447
1448         for (; sindex < eindex; sindex = pdnxt) {
1449                 vpte_t pdirindex;
1450
1451                 /*
1452                  * Calculate index for next page table.
1453                  */
1454                 pdnxt = ((sindex + NPTEPG) & ~(NPTEPG - 1));
1455                 if (pmap->pm_stats.resident_count == 0)
1456                         break;
1457
1458                 pdirindex = sindex / NPDEPG;
1459                 if (((ptpaddr = pmap->pm_pdir[pdirindex]) & VPTE_PS) != 0) {
1460                         pmap->pm_pdir[pdirindex] = 0;
1461                         pmap->pm_stats.resident_count -= NBPDR / PAGE_SIZE;
1462                         inval_ptbase_pagedir(pmap, pdirindex);
1463                         continue;
1464                 }
1465
1466                 /*
1467                  * Weed out invalid mappings. Note: we assume that the page
1468                  * directory table is always allocated, and in kernel virtual.
1469                  */
1470                 if (ptpaddr == 0)
1471                         continue;
1472
1473                 /*
1474                  * Limit our scan to either the end of the va represented
1475                  * by the current page table page, or to the end of the
1476                  * range being removed.
1477                  */
1478                 if (pdnxt > eindex)
1479                         pdnxt = eindex;
1480
1481                 /*
1482                  * NOTE: pmap_remove_pte() can block.
1483                  */
1484                 for (; sindex != pdnxt; sindex++) {
1485                         vm_offset_t va;
1486
1487                         ptbase = get_ptbase(pmap, sindex << PAGE_SHIFT);
1488                         if (*ptbase == 0)
1489                                 continue;
1490                         va = i386_ptob(sindex);
1491                         if (pmap_remove_pte(pmap, ptbase, va, &info))
1492                                 break;
1493                 }
1494         }
1495         pmap_inval_flush(&info);
1496 }
1497
1498 /*
1499  * pmap_remove_all:
1500  *
1501  * Removes this physical page from all physical maps in which it resides.
1502  * Reflects back modify bits to the pager.
1503  *
1504  * This routine may not be called from an interrupt.
1505  */
1506 static void
1507 pmap_remove_all(vm_page_t m)
1508 {
1509         struct pmap_inval_info info;
1510         vpte_t *pte, tpte;
1511         pv_entry_t pv;
1512
1513 #if defined(PMAP_DIAGNOSTIC)
1514         /*
1515          * XXX this makes pmap_page_protect(NONE) illegal for non-managed
1516          * pages!
1517          */
1518         if (!pmap_initialized || (m->flags & PG_FICTITIOUS)) {
1519                 panic("pmap_page_protect: illegal for unmanaged page, va: 0x%08llx", (long long)VM_PAGE_TO_PHYS(m));
1520         }
1521 #endif
1522
1523         pmap_inval_init(&info);
1524         crit_enter();
1525         while ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
1526                 pv->pv_pmap->pm_stats.resident_count--;
1527
1528                 pte = pmap_pte(pv->pv_pmap, pv->pv_va);
1529                 KKASSERT(pte != NULL);
1530
1531                 tpte = loadandclear(pte);
1532                 /* See NOTE: PMAP_INVAL_ADD */
1533                 pmap_inval_add(&info, pv->pv_pmap, pv->pv_va);
1534                 if (tpte & VPTE_WIRED)
1535                         --pv->pv_pmap->pm_stats.wired_count;
1536                 KKASSERT(pv->pv_pmap->pm_stats.wired_count >= 0);
1537
1538                 if (tpte & VPTE_A)
1539                         vm_page_flag_set(m, PG_REFERENCED);
1540
1541                 /*
1542                  * Update the vm_page_t clean and reference bits.
1543                  */
1544                 if (tpte & VPTE_M) {
1545 #if defined(PMAP_DIAGNOSTIC)
1546                         if (pmap_nw_modified((pt_entry_t) tpte)) {
1547                                 kprintf(
1548         "pmap_remove_all: modified page not writable: va: 0x%x, pte: 0x%x\n",
1549                                     pv->pv_va, tpte);
1550                         }
1551 #endif
1552                         if (pmap_track_modified(pv->pv_pmap, pv->pv_va))
1553                                 vm_page_dirty(m);
1554                 }
1555                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
1556                 TAILQ_REMOVE(&pv->pv_pmap->pm_pvlist, pv, pv_plist);
1557                 ++pv->pv_pmap->pm_generation;
1558                 m->md.pv_list_count--;
1559                 pmap_unuse_pt(pv->pv_pmap, pv->pv_va, pv->pv_ptem, &info);
1560                 free_pv_entry(pv);
1561         }
1562
1563         vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
1564         crit_exit();
1565         pmap_inval_flush(&info);
1566 }
1567
1568 /*
1569  * pmap_protect:
1570  *
1571  *      Set the physical protection on the specified range of this map
1572  *      as requested.
1573  *
1574  *      This function may not be called from an interrupt if the map is
1575  *      not the kernel_pmap.
1576  */
1577 void
1578 pmap_protect(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, vm_prot_t prot)
1579 {
1580         vpte_t *ptbase;
1581         vm_offset_t pdnxt, ptpaddr;
1582         vm_pindex_t sindex, eindex;
1583         vm_pindex_t sbase;
1584         pmap_inval_info info;
1585
1586         if (pmap == NULL)
1587                 return;
1588
1589         if ((prot & VM_PROT_READ) == VM_PROT_NONE) {
1590                 pmap_remove(pmap, sva, eva);
1591                 return;
1592         }
1593
1594         if (prot & VM_PROT_WRITE)
1595                 return;
1596
1597         pmap_inval_init(&info);
1598
1599         ptbase = get_ptbase(pmap, sva);
1600
1601         sindex = (sva >> PAGE_SHIFT);
1602         eindex = (eva >> PAGE_SHIFT);
1603         sbase = sindex;
1604
1605         for (; sindex < eindex; sindex = pdnxt) {
1606
1607                 unsigned pdirindex;
1608
1609                 pdnxt = ((sindex + NPTEPG) & ~(NPTEPG - 1));
1610
1611                 pdirindex = sindex / NPDEPG;
1612                 if (((ptpaddr = pmap->pm_pdir[pdirindex]) & VPTE_PS) != 0) {
1613                         pmap->pm_pdir[pdirindex] &= ~(VPTE_M|VPTE_W);
1614                         pmap->pm_stats.resident_count -= NBPDR / PAGE_SIZE;
1615                         inval_ptbase_pagedir(pmap, pdirindex);
1616                         continue;
1617                 }
1618
1619                 /*
1620                  * Weed out invalid mappings. Note: we assume that the page
1621                  * directory table is always allocated, and in kernel virtual.
1622                  */
1623                 if (ptpaddr == 0)
1624                         continue;
1625
1626                 if (pdnxt > eindex) {
1627                         pdnxt = eindex;
1628                 }
1629
1630                 for (; sindex != pdnxt; sindex++) {
1631                         vpte_t pbits;
1632                         vm_page_t m;
1633
1634                         pbits = ptbase[sindex - sbase];
1635
1636                         if (pbits & VPTE_MANAGED) {
1637                                 m = NULL;
1638                                 if (pbits & VPTE_A) {
1639                                         m = PHYS_TO_VM_PAGE(pbits);
1640                                         vm_page_flag_set(m, PG_REFERENCED);
1641                                         pbits &= ~VPTE_A;
1642                                 }
1643                                 if (pbits & VPTE_M) {
1644                                         if (pmap_track_modified(pmap, i386_ptob(sindex))) {
1645                                                 if (m == NULL)
1646                                                         m = PHYS_TO_VM_PAGE(pbits);
1647                                                 vm_page_dirty(m);
1648                                                 pbits &= ~VPTE_M;
1649                                         }
1650                                 }
1651                         }
1652
1653                         pbits &= ~VPTE_W;
1654
1655                         if (pbits != ptbase[sindex - sbase]) {
1656                                 ptbase[sindex - sbase] = pbits;
1657                                 /* See NOTE: PMAP_INVAL_ADD */
1658                                 pmap_inval_add(&info, pmap, i386_ptob(sindex));
1659                         }
1660                 }
1661         }
1662         pmap_inval_flush(&info);
1663 }
1664
1665 /*
1666  * Enter a managed page into a pmap.  If the page is not wired related pmap
1667  * data can be destroyed at any time for later demand-operation.
1668  *
1669  * Insert the vm_page (m) at virtual address (v) in (pmap), with the
1670  * specified protection, and wire the mapping if requested.
1671  *
1672  * NOTE: This routine may not lazy-evaluate or lose information.  The
1673  * page must actually be inserted into the given map NOW.
1674  *
1675  * NOTE: When entering a page at a KVA address, the pmap must be the
1676  * kernel_pmap.
1677  */
1678 void
1679 pmap_enter(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot,
1680            boolean_t wired)
1681 {
1682         vm_paddr_t pa;
1683         vpte_t *pte;
1684         vm_paddr_t opa;
1685         vm_offset_t origpte, newpte;
1686         vm_page_t mpte;
1687         pmap_inval_info info;
1688
1689         if (pmap == NULL)
1690                 return;
1691
1692         va &= VPTE_FRAME;
1693
1694         /*
1695          * Get the page table page.   The kernel_pmap's page table pages
1696          * are preallocated and have no associated vm_page_t.
1697          */
1698         if (pmap == &kernel_pmap)
1699                 mpte = NULL;
1700         else
1701                 mpte = pmap_allocpte(pmap, va);
1702
1703         pmap_inval_init(&info);
1704         pte = pmap_pte(pmap, va);
1705
1706         /*
1707          * Page Directory table entry not valid, we need a new PT page
1708          * and pmap_allocpte() didn't give us one.  Oops!
1709          */
1710         if (pte == NULL) {
1711                 panic("pmap_enter: invalid page directory pmap=%p, va=0x%p\n",
1712                       pmap, (void *)va);
1713         }
1714
1715         pa = VM_PAGE_TO_PHYS(m) & VPTE_FRAME;
1716         origpte = *pte;
1717         opa = origpte & VPTE_FRAME;
1718 #if 0
1719         printf("pmap_enter: pmap %p va %08x pa %08x PDE %08x origpte %08x\n", pmap, va, (int)pa, pmap->pm_pdir[va >> SEG_SHIFT], origpte);
1720 #endif
1721
1722         if (origpte & VPTE_PS)
1723                 panic("pmap_enter: attempted pmap_enter on 4MB page");
1724
1725         /*
1726          * Mapping has not changed, must be protection or wiring change.
1727          */
1728         if (origpte && (opa == pa)) {
1729                 /*
1730                  * Wiring change, just update stats. We don't worry about
1731                  * wiring PT pages as they remain resident as long as there
1732                  * are valid mappings in them. Hence, if a user page is wired,
1733                  * the PT page will be also.
1734                  */
1735                 if (wired && ((origpte & VPTE_WIRED) == 0))
1736                         ++pmap->pm_stats.wired_count;
1737                 else if (!wired && (origpte & VPTE_WIRED))
1738                         --pmap->pm_stats.wired_count;
1739                 KKASSERT(pmap->pm_stats.wired_count >= 0);
1740
1741 #if defined(PMAP_DIAGNOSTIC)
1742                 if (pmap_nw_modified((pt_entry_t) origpte)) {
1743                         kprintf(
1744         "pmap_enter: modified page not writable: va: 0x%x, pte: 0x%x\n",
1745                             va, origpte);
1746                 }
1747 #endif
1748
1749                 /*
1750                  * Remove the extra pte reference.  Note that we cannot
1751                  * optimize the RO->RW case because we have adjusted the
1752                  * wiring count above and may need to adjust the wiring
1753                  * bits below.
1754                  */
1755                 if (mpte)
1756                         mpte->hold_count--;
1757
1758                 /*
1759                  * We might be turning off write access to the page,
1760                  * so we go ahead and sense modify status.
1761                  */
1762                 if (origpte & VPTE_MANAGED) {
1763                         if ((origpte & VPTE_M) && pmap_track_modified(pmap, va)) {
1764                                 vm_page_t om;
1765                                 om = PHYS_TO_VM_PAGE(opa);
1766                                 vm_page_dirty(om);
1767                         }
1768                         pa |= VPTE_MANAGED;
1769                 }
1770                 goto validate;
1771         }
1772         /*
1773          * Mapping has changed, invalidate old range and fall through to
1774          * handle validating new mapping.
1775          */
1776         if (opa) {
1777                 int err;
1778                 err = pmap_remove_pte(pmap, pte, va, &info);
1779                 if (err)
1780                         panic("pmap_enter: pte vanished, va: 0x%x", va);
1781         }
1782
1783         /*
1784          * Enter on the PV list if part of our managed memory. Note that we
1785          * raise IPL while manipulating pv_table since pmap_enter can be
1786          * called at interrupt time.
1787          */
1788         if (pmap_initialized &&
1789             (m->flags & (PG_FICTITIOUS|PG_UNMANAGED)) == 0) {
1790                 pmap_insert_entry(pmap, va, mpte, m);
1791                 pa |= VPTE_MANAGED;
1792         }
1793
1794         /*
1795          * Increment counters
1796          */
1797         pmap->pm_stats.resident_count++;
1798         if (wired)
1799                 pmap->pm_stats.wired_count++;
1800
1801 validate:
1802         /*
1803          * Now validate mapping with desired protection/wiring.
1804          */
1805         newpte = (vm_offset_t) (pa | pte_prot(pmap, prot) | VPTE_V);
1806
1807         if (wired)
1808                 newpte |= VPTE_WIRED;
1809         newpte |= VPTE_U;
1810
1811         /*
1812          * if the mapping or permission bits are different, we need
1813          * to update the pte.
1814          */
1815         if ((origpte & ~(VPTE_M|VPTE_A)) != newpte) {
1816                 *pte = newpte | VPTE_A;
1817                 /* See NOTE: PMAP_INVAL_ADD */
1818                 pmap_inval_add(&info, pmap, va); /* XXX non-optimal */
1819         }
1820         pmap_inval_flush(&info);
1821 }
1822
1823 /*
1824  * This is a quick version of pmap_enter().  It is used only under the
1825  * following conditions:
1826  *
1827  * (1) The pmap is not the kernel_pmap
1828  * (2) The page is not to be wired into the map
1829  * (3) The page is to mapped read-only in the pmap (initially that is)
1830  * (4) The calling procedure is responsible for flushing the TLB
1831  * (5) The page is always managed
1832  * (6) There is no prior mapping at the VA
1833  */
1834
1835 static vm_page_t
1836 pmap_enter_quick(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_page_t mpte)
1837 {
1838         vpte_t *pte;
1839         vm_paddr_t pa;
1840         pmap_inval_info info;
1841         unsigned ptepindex;
1842         vm_offset_t ptepa;
1843
1844         KKASSERT(pmap != &kernel_pmap);
1845         pmap_inval_init(&info);
1846
1847         KKASSERT(va >= VM_MIN_USER_ADDRESS && va < VM_MAX_USER_ADDRESS);
1848
1849         /*
1850          * Instantiate the page table page if required
1851          */
1852
1853         /*
1854          * Calculate pagetable page index
1855          */
1856         ptepindex = va >> PDRSHIFT;
1857         if (mpte && (mpte->pindex == ptepindex)) {
1858                 mpte->hold_count++;
1859         } else {
1860 retry:
1861                 /*
1862                  * Get the page directory entry
1863                  */
1864                 ptepa = (vm_offset_t) pmap->pm_pdir[ptepindex];
1865
1866                 /*
1867                  * If the page table page is mapped, we just increment
1868                  * the hold count, and activate it.
1869                  */
1870                 if (ptepa) {
1871                         if (ptepa & VPTE_PS)
1872                                 panic("pmap_enter_quick: unexpected mapping into 4MB page");
1873                         if (pmap->pm_ptphint &&
1874                                 (pmap->pm_ptphint->pindex == ptepindex)) {
1875                                 mpte = pmap->pm_ptphint;
1876                         } else {
1877                                 mpte = pmap_page_lookup( pmap->pm_pteobj, ptepindex);
1878                                 pmap->pm_ptphint = mpte;
1879                         }
1880                         if (mpte == NULL)
1881                                 goto retry;
1882                         mpte->hold_count++;
1883                 } else {
1884                         mpte = _pmap_allocpte(pmap, ptepindex);
1885                 }
1886         }
1887
1888         /*
1889          * Ok, now that the page table page has been validated, get the pte.
1890          * If the pte is already mapped undo mpte's hold_count and
1891          * just return.
1892          */
1893         pte = pmap_pte(pmap, va);
1894         if (*pte) {
1895                 if (mpte)
1896                         pmap_unwire_pte_hold(pmap, mpte, &info);
1897                 return 0;
1898         }
1899
1900         /*
1901          * Enter on the PV list if part of our managed memory. Note that we
1902          * raise IPL while manipulating pv_table since pmap_enter can be
1903          * called at interrupt time.
1904          */
1905         if ((m->flags & (PG_FICTITIOUS|PG_UNMANAGED)) == 0)
1906                 pmap_insert_entry(pmap, va, mpte, m);
1907
1908         /*
1909          * Increment counters
1910          */
1911         pmap->pm_stats.resident_count++;
1912
1913         pa = VM_PAGE_TO_PHYS(m);
1914
1915         /*
1916          * Now validate mapping with RO protection
1917          */
1918         if (m->flags & (PG_FICTITIOUS|PG_UNMANAGED))
1919                 *pte = pa | VPTE_V | VPTE_U;
1920         else
1921                 *pte = pa | VPTE_V | VPTE_U | VPTE_MANAGED;
1922
1923         return mpte;
1924 }
1925
1926 /*
1927  * Extract the physical address for the translation at the specified
1928  * virtual address in the pmap.
1929  */
1930 vm_paddr_t
1931 pmap_extract(pmap_t pmap, vm_offset_t va)
1932 {
1933         vm_paddr_t rtval;
1934         vpte_t pte;
1935
1936         if (pmap && (pte = pmap->pm_pdir[va >> SEG_SHIFT]) != 0) {
1937                 if (pte & VPTE_PS) {
1938                         rtval = pte & ~((vpte_t)(1 << SEG_SHIFT) - 1);
1939                         rtval |= va & SEG_MASK;
1940                 } else {
1941                         pte = *get_ptbase(pmap, va);
1942                         rtval = (pte & VPTE_FRAME) | (va & PAGE_MASK);
1943                 }
1944                 return(rtval);
1945         }
1946         return(0);
1947 }
1948
1949 #define MAX_INIT_PT (96)
1950
1951 /*
1952  * This routine preloads the ptes for a given object into the specified pmap.
1953  * This eliminates the blast of soft faults on process startup and
1954  * immediately after an mmap.
1955  */
1956 static int pmap_object_init_pt_callback(vm_page_t p, void *data);
1957
1958 void
1959 pmap_object_init_pt(pmap_t pmap, vm_offset_t addr, vm_prot_t prot,
1960                     vm_object_t object, vm_pindex_t pindex,
1961                     vm_size_t size, int limit)
1962 {
1963         struct rb_vm_page_scan_info info;
1964         int psize;
1965
1966         /*
1967          * We can't preinit if read access isn't set or there is no pmap
1968          * or object.
1969          */
1970         if ((prot & VM_PROT_READ) == 0 || pmap == NULL || object == NULL)
1971                 return;
1972
1973         /*
1974          * We can't preinit if the pmap is not the current pmap
1975          */
1976         if (curproc == NULL || pmap != vmspace_pmap(curproc->p_vmspace))
1977                 return;
1978
1979         psize = size >> PAGE_SHIFT;
1980
1981         if ((object->type != OBJT_VNODE) ||
1982                 ((limit & MAP_PREFAULT_PARTIAL) && (psize > MAX_INIT_PT) &&
1983                         (object->resident_page_count > MAX_INIT_PT))) {
1984                 return;
1985         }
1986
1987         if (psize + pindex > object->size) {
1988                 if (object->size < pindex)
1989                         return;
1990                 psize = object->size - pindex;
1991         }
1992
1993         if (psize == 0)
1994                 return;
1995
1996         /*
1997          * Use a red-black scan to traverse the requested range and load
1998          * any valid pages found into the pmap.
1999          *
2000          * We cannot safely scan the object's memq unless we are in a
2001          * critical section since interrupts can remove pages from objects.
2002          */
2003         info.start_pindex = pindex;
2004         info.end_pindex = pindex + psize - 1;
2005         info.limit = limit;
2006         info.mpte = NULL;
2007         info.addr = addr;
2008         info.pmap = pmap;
2009
2010         crit_enter();
2011         vm_page_rb_tree_RB_SCAN(&object->rb_memq, rb_vm_page_scancmp,
2012                                 pmap_object_init_pt_callback, &info);
2013         crit_exit();
2014 }
2015
2016 static
2017 int
2018 pmap_object_init_pt_callback(vm_page_t p, void *data)
2019 {
2020         struct rb_vm_page_scan_info *info = data;
2021         vm_pindex_t rel_index;
2022         /*
2023          * don't allow an madvise to blow away our really
2024          * free pages allocating pv entries.
2025          */
2026         if ((info->limit & MAP_PREFAULT_MADVISE) &&
2027                 vmstats.v_free_count < vmstats.v_free_reserved) {
2028                     return(-1);
2029         }
2030         if (((p->valid & VM_PAGE_BITS_ALL) == VM_PAGE_BITS_ALL) &&
2031             (p->busy == 0) && (p->flags & (PG_BUSY | PG_FICTITIOUS)) == 0) {
2032                 if ((p->queue - p->pc) == PQ_CACHE)
2033                         vm_page_deactivate(p);
2034                 vm_page_busy(p);
2035                 rel_index = p->pindex - info->start_pindex;
2036                 info->mpte = pmap_enter_quick(info->pmap,
2037                                               info->addr + i386_ptob(rel_index),
2038                                               p, info->mpte);
2039                 vm_page_flag_set(p, PG_MAPPED);
2040                 vm_page_wakeup(p);
2041         }
2042         return(0);
2043 }
2044
2045 /*
2046  * pmap_prefault provides a quick way of clustering pagefaults into a
2047  * processes address space.  It is a "cousin" of pmap_object_init_pt,
2048  * except it runs at page fault time instead of mmap time.
2049  */
2050 #define PFBAK 4
2051 #define PFFOR 4
2052 #define PAGEORDER_SIZE (PFBAK+PFFOR)
2053
2054 static int pmap_prefault_pageorder[] = {
2055         -PAGE_SIZE, PAGE_SIZE,
2056         -2 * PAGE_SIZE, 2 * PAGE_SIZE,
2057         -3 * PAGE_SIZE, 3 * PAGE_SIZE,
2058         -4 * PAGE_SIZE, 4 * PAGE_SIZE
2059 };
2060
2061 void
2062 pmap_prefault(pmap_t pmap, vm_offset_t addra, vm_map_entry_t entry)
2063 {
2064         int i;
2065         vm_offset_t starta;
2066         vm_offset_t addr;
2067         vm_pindex_t pindex;
2068         vm_page_t m, mpte;
2069         vm_object_t object;
2070
2071         /*
2072          * We do not currently prefault mappings that use virtual page
2073          * tables.  We do not prefault foreign pmaps.
2074          */
2075         if (entry->maptype == VM_MAPTYPE_VPAGETABLE)
2076                 return;
2077         if (curproc == NULL || (pmap != vmspace_pmap(curproc->p_vmspace)))
2078                 return;
2079
2080         object = entry->object.vm_object;
2081
2082         starta = addra - PFBAK * PAGE_SIZE;
2083         if (starta < entry->start)
2084                 starta = entry->start;
2085         else if (starta > addra)
2086                 starta = 0;
2087
2088         /*
2089          * critical section protection is required to maintain the
2090          * page/object association, interrupts can free pages and remove
2091          * them from their objects.
2092          */
2093         mpte = NULL;
2094         crit_enter();
2095         for (i = 0; i < PAGEORDER_SIZE; i++) {
2096                 vm_object_t lobject;
2097                 vpte_t *pte;
2098
2099                 addr = addra + pmap_prefault_pageorder[i];
2100                 if (addr > addra + (PFFOR * PAGE_SIZE))
2101                         addr = 0;
2102
2103                 if (addr < starta || addr >= entry->end)
2104                         continue;
2105
2106                 /*
2107                  * Make sure the page table page already exists
2108                  */
2109                 if ((*pmap_pde(pmap, addr)) == NULL)
2110                         continue;
2111
2112                 /*
2113                  * Get a pointer to the pte and make sure that no valid page
2114                  * has been mapped.
2115                  */
2116                 pte = get_ptbase(pmap, addr);
2117                 if (*pte)
2118                         continue;
2119
2120                 /*
2121                  * Get the page to be mapped
2122                  */
2123                 pindex = ((addr - entry->start) + entry->offset) >> PAGE_SHIFT;
2124                 lobject = object;
2125
2126                 for (m = vm_page_lookup(lobject, pindex);
2127                     (!m && (lobject->type == OBJT_DEFAULT) &&
2128                      (lobject->backing_object));
2129                     lobject = lobject->backing_object
2130                 ) {
2131                         if (lobject->backing_object_offset & PAGE_MASK)
2132                                 break;
2133                         pindex += (lobject->backing_object_offset >> PAGE_SHIFT);
2134                         m = vm_page_lookup(lobject->backing_object, pindex);
2135                 }
2136
2137                 /*
2138                  * give-up when a page is not in memory
2139                  */
2140                 if (m == NULL)
2141                         break;
2142
2143                 /*
2144                  * If everything meets the requirements for pmap_enter_quick(),
2145                  * then enter the page.
2146                  */
2147
2148                 if (((m->valid & VM_PAGE_BITS_ALL) == VM_PAGE_BITS_ALL) &&
2149                         (m->busy == 0) &&
2150                     (m->flags & (PG_BUSY | PG_FICTITIOUS)) == 0) {
2151
2152                         if ((m->queue - m->pc) == PQ_CACHE) {
2153                                 vm_page_deactivate(m);
2154                         }
2155                         vm_page_busy(m);
2156                         mpte = pmap_enter_quick(pmap, addr, m, mpte);
2157                         vm_page_flag_set(m, PG_MAPPED);
2158                         vm_page_wakeup(m);
2159                 }
2160         }
2161         crit_exit();
2162 }
2163
2164 /*
2165  *      Routine:        pmap_change_wiring
2166  *      Function:       Change the wiring attribute for a map/virtual-address
2167  *                      pair.
2168  *      In/out conditions:
2169  *                      The mapping must already exist in the pmap.
2170  */
2171 void
2172 pmap_change_wiring(pmap_t pmap, vm_offset_t va, boolean_t wired)
2173 {
2174         vpte_t *pte;
2175
2176         if (pmap == NULL)
2177                 return;
2178
2179         pte = get_ptbase(pmap, va);
2180
2181         if (wired && (*pte & VPTE_WIRED) == 0)
2182                 ++pmap->pm_stats.wired_count;
2183         else if (!wired && (*pte & VPTE_WIRED))
2184                 --pmap->pm_stats.wired_count;
2185         KKASSERT(pmap->pm_stats.wired_count >= 0);
2186
2187         /*
2188          * Wiring is not a hardware characteristic so there is no need to
2189          * invalidate TLB.  However, in an SMP environment we must use
2190          * a locked bus cycle to update the pte (if we are not using
2191          * the pmap_inval_*() API that is)... it's ok to do this for simple
2192          * wiring changes.
2193          */
2194         if (wired)
2195                 atomic_set_int(pte, VPTE_WIRED);
2196         else
2197                 atomic_clear_int(pte, VPTE_WIRED);
2198 }
2199
2200 /*
2201  *      Copy the range specified by src_addr/len
2202  *      from the source map to the range dst_addr/len
2203  *      in the destination map.
2204  *
2205  *      This routine is only advisory and need not do anything.
2206  */
2207 void
2208 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr,
2209         vm_size_t len, vm_offset_t src_addr)
2210 {
2211         pmap_inval_info info;
2212         vm_offset_t addr;
2213         vm_offset_t end_addr = src_addr + len;
2214         vm_offset_t pdnxt;
2215         vpte_t *src_frame;
2216         vpte_t *dst_frame;
2217         vm_page_t m;
2218
2219         if (dst_addr != src_addr)
2220                 return;
2221         if (dst_pmap->pm_pdir == NULL)
2222                 return;
2223         if (src_pmap->pm_pdir == NULL)
2224                 return;
2225
2226         src_frame = get_ptbase1(src_pmap, src_addr);
2227         dst_frame = get_ptbase2(dst_pmap, src_addr);
2228
2229         pmap_inval_init(&info);
2230 #if 0
2231         /* XXX */
2232         pmap_inval_add(&info, dst_pmap, -1);
2233         pmap_inval_add(&info, src_pmap, -1);
2234 #endif
2235
2236         /*
2237          * critical section protection is required to maintain the page/object
2238          * association, interrupts can free pages and remove them from
2239          * their objects.
2240          */
2241         crit_enter();
2242         for (addr = src_addr; addr < end_addr; addr = pdnxt) {
2243                 vpte_t *src_pte, *dst_pte;
2244                 vm_page_t dstmpte, srcmpte;
2245                 vm_offset_t srcptepaddr;
2246                 unsigned ptepindex;
2247
2248                 if (addr >= VM_MAX_USER_ADDRESS)
2249                         panic("pmap_copy: invalid to pmap_copy page tables\n");
2250
2251                 /*
2252                  * Don't let optional prefaulting of pages make us go
2253                  * way below the low water mark of free pages or way
2254                  * above high water mark of used pv entries.
2255                  */
2256                 if (vmstats.v_free_count < vmstats.v_free_reserved ||
2257                     pv_entry_count > pv_entry_high_water)
2258                         break;
2259
2260                 pdnxt = ((addr + PAGE_SIZE*NPTEPG) & ~(PAGE_SIZE*NPTEPG - 1));
2261                 ptepindex = addr >> PDRSHIFT;
2262
2263                 srcptepaddr = (vm_offset_t) src_pmap->pm_pdir[ptepindex];
2264                 if (srcptepaddr == 0)
2265                         continue;
2266
2267                 if (srcptepaddr & VPTE_PS) {
2268                         if (dst_pmap->pm_pdir[ptepindex] == 0) {
2269                                 dst_pmap->pm_pdir[ptepindex] = (pd_entry_t) srcptepaddr;
2270                                 dst_pmap->pm_stats.resident_count += NBPDR / PAGE_SIZE;
2271                         }
2272                         continue;
2273                 }
2274
2275                 srcmpte = vm_page_lookup(src_pmap->pm_pteobj, ptepindex);
2276                 if ((srcmpte == NULL) ||
2277                         (srcmpte->hold_count == 0) || (srcmpte->flags & PG_BUSY))
2278                         continue;
2279
2280                 if (pdnxt > end_addr)
2281                         pdnxt = end_addr;
2282
2283                 src_pte = src_frame + ((addr - src_addr) >> PAGE_SHIFT);
2284                 dst_pte = dst_frame + ((addr - src_addr) >> PAGE_SHIFT);
2285                 while (addr < pdnxt) {
2286                         vpte_t ptetemp;
2287                         ptetemp = *src_pte;
2288                         /*
2289                          * we only virtual copy managed pages
2290                          */
2291                         if ((ptetemp & VPTE_MANAGED) != 0) {
2292                                 /*
2293                                  * We have to check after allocpte for the
2294                                  * pte still being around...  allocpte can
2295                                  * block.
2296                                  */
2297                                 dstmpte = pmap_allocpte(dst_pmap, addr);
2298                                 if ((*dst_pte == 0) && (ptetemp = *src_pte)) {
2299                                         /*
2300                                          * Clear the modified and accessed
2301                                          * (referenced) bits during the copy.
2302                                          *
2303                                          * We do not have to clear the write
2304                                          * bit to force a fault-on-modify
2305                                          * because the real kernel's target
2306                                          * pmap is empty and will fault anyway.
2307                                          */
2308                                         m = PHYS_TO_VM_PAGE(ptetemp);
2309                                         *dst_pte = ptetemp & ~(VPTE_M | VPTE_A);
2310                                         dst_pmap->pm_stats.resident_count++;
2311                                         pmap_insert_entry(dst_pmap, addr,
2312                                                 dstmpte, m);
2313                                 } else {
2314                                         pmap_unwire_pte_hold(dst_pmap, dstmpte, &info);
2315                                 }
2316                                 if (dstmpte->hold_count >= srcmpte->hold_count)
2317                                         break;
2318                         }
2319                         addr += PAGE_SIZE;
2320                         src_pte++;
2321                         dst_pte++;
2322                 }
2323         }
2324         crit_exit();
2325         pmap_inval_flush(&info);
2326 }
2327
2328 /*
2329  * pmap_zero_page:
2330  *
2331  *      Zero the specified PA by mapping the page into KVM and clearing its
2332  *      contents.
2333  *
2334  *      This function may be called from an interrupt and no locking is
2335  *      required.
2336  */
2337 void
2338 pmap_zero_page(vm_paddr_t phys)
2339 {
2340         struct mdglobaldata *gd = mdcpu;
2341
2342         crit_enter();
2343         if (*gd->gd_CMAP3)
2344                 panic("pmap_zero_page: CMAP3 busy");
2345         *gd->gd_CMAP3 = VPTE_V | VPTE_R | VPTE_W | (phys & VPTE_FRAME) | VPTE_A | VPTE_M;
2346         madvise(gd->gd_CADDR3, PAGE_SIZE, MADV_INVAL);
2347
2348         bzero(gd->gd_CADDR3, PAGE_SIZE);
2349         *gd->gd_CMAP3 = 0;
2350         crit_exit();
2351 }
2352
2353 /*
2354  * pmap_page_assertzero:
2355  *
2356  *      Assert that a page is empty, panic if it isn't.
2357  */
2358 void
2359 pmap_page_assertzero(vm_paddr_t phys)
2360 {
2361         struct mdglobaldata *gd = mdcpu;
2362         int i;
2363
2364         crit_enter();
2365         if (*gd->gd_CMAP3)
2366                 panic("pmap_zero_page: CMAP3 busy");
2367         *gd->gd_CMAP3 = VPTE_V | VPTE_R | VPTE_W |
2368                         (phys & VPTE_FRAME) | VPTE_A | VPTE_M;
2369         madvise(gd->gd_CADDR3, PAGE_SIZE, MADV_INVAL);
2370         for (i = 0; i < PAGE_SIZE; i += 4) {
2371             if (*(int *)((char *)gd->gd_CADDR3 + i) != 0) {
2372                 panic("pmap_page_assertzero() @ %p not zero!\n",
2373                     (void *)gd->gd_CADDR3);
2374             }
2375         }
2376         *gd->gd_CMAP3 = 0;
2377         crit_exit();
2378 }
2379
2380 /*
2381  * pmap_zero_page:
2382  *
2383  *      Zero part of a physical page by mapping it into memory and clearing
2384  *      its contents with bzero.
2385  *
2386  *      off and size may not cover an area beyond a single hardware page.
2387  */
2388 void
2389 pmap_zero_page_area(vm_paddr_t phys, int off, int size)
2390 {
2391         struct mdglobaldata *gd = mdcpu;
2392
2393         crit_enter();
2394         if (*gd->gd_CMAP3)
2395                 panic("pmap_zero_page: CMAP3 busy");
2396         *gd->gd_CMAP3 = VPTE_V | VPTE_R | VPTE_W |
2397                         (phys & VPTE_FRAME) | VPTE_A | VPTE_M;
2398         madvise(gd->gd_CADDR3, PAGE_SIZE, MADV_INVAL);
2399
2400         bzero((char *)gd->gd_CADDR3 + off, size);
2401         *gd->gd_CMAP3 = 0;
2402         crit_exit();
2403 }
2404
2405 /*
2406  * pmap_copy_page:
2407  *
2408  *      Copy the physical page from the source PA to the target PA.
2409  *      This function may be called from an interrupt.  No locking
2410  *      is required.
2411  */
2412 void
2413 pmap_copy_page(vm_paddr_t src, vm_paddr_t dst)
2414 {
2415         struct mdglobaldata *gd = mdcpu;
2416
2417         crit_enter();
2418         if (*(int *) gd->gd_CMAP1)
2419                 panic("pmap_copy_page: CMAP1 busy");
2420         if (*(int *) gd->gd_CMAP2)
2421                 panic("pmap_copy_page: CMAP2 busy");
2422
2423         *(int *) gd->gd_CMAP1 = VPTE_V | VPTE_R | (src & PG_FRAME) | VPTE_A;
2424         *(int *) gd->gd_CMAP2 = VPTE_V | VPTE_R | VPTE_W | (dst & VPTE_FRAME) | VPTE_A | VPTE_M;
2425
2426         madvise(gd->gd_CADDR1, PAGE_SIZE, MADV_INVAL);
2427         madvise(gd->gd_CADDR2, PAGE_SIZE, MADV_INVAL);
2428
2429         bcopy(gd->gd_CADDR1, gd->gd_CADDR2, PAGE_SIZE);
2430
2431         *(int *) gd->gd_CMAP1 = 0;
2432         *(int *) gd->gd_CMAP2 = 0;
2433         crit_exit();
2434 }
2435
2436 /*
2437  * pmap_copy_page_frag:
2438  *
2439  *      Copy the physical page from the source PA to the target PA.
2440  *      This function may be called from an interrupt.  No locking
2441  *      is required.
2442  */
2443 void
2444 pmap_copy_page_frag(vm_paddr_t src, vm_paddr_t dst, size_t bytes)
2445 {
2446         struct mdglobaldata *gd = mdcpu;
2447
2448         crit_enter();
2449         if (*(int *) gd->gd_CMAP1)
2450                 panic("pmap_copy_page: CMAP1 busy");
2451         if (*(int *) gd->gd_CMAP2)
2452                 panic("pmap_copy_page: CMAP2 busy");
2453
2454         *(int *) gd->gd_CMAP1 = VPTE_V | (src & VPTE_FRAME) | VPTE_A;
2455         *(int *) gd->gd_CMAP2 = VPTE_V | VPTE_R | VPTE_W | (dst & VPTE_FRAME) | VPTE_A | VPTE_M;
2456
2457         madvise(gd->gd_CADDR1, PAGE_SIZE, MADV_INVAL);
2458         madvise(gd->gd_CADDR2, PAGE_SIZE, MADV_INVAL);
2459
2460         bcopy((char *)gd->gd_CADDR1 + (src & PAGE_MASK),
2461               (char *)gd->gd_CADDR2 + (dst & PAGE_MASK),
2462               bytes);
2463
2464         *(int *) gd->gd_CMAP1 = 0;
2465         *(int *) gd->gd_CMAP2 = 0;
2466         crit_exit();
2467 }
2468
2469 /*
2470  * Returns true if the pmap's pv is one of the first
2471  * 16 pvs linked to from this page.  This count may
2472  * be changed upwards or downwards in the future; it
2473  * is only necessary that true be returned for a small
2474  * subset of pmaps for proper page aging.
2475  */
2476 boolean_t
2477 pmap_page_exists_quick(pmap_t pmap, vm_page_t m)
2478 {
2479         pv_entry_t pv;
2480         int loops = 0;
2481
2482         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
2483                 return FALSE;
2484
2485         crit_enter();
2486
2487         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
2488                 if (pv->pv_pmap == pmap) {
2489                         crit_exit();
2490                         return TRUE;
2491                 }
2492                 loops++;
2493                 if (loops >= 16)
2494                         break;
2495         }
2496         crit_exit();
2497         return (FALSE);
2498 }
2499
2500 /*
2501  * Remove all pages from specified address space
2502  * this aids process exit speeds.  Also, this code
2503  * is special cased for current process only, but
2504  * can have the more generic (and slightly slower)
2505  * mode enabled.  This is much faster than pmap_remove
2506  * in the case of running down an entire address space.
2507  */
2508 void
2509 pmap_remove_pages(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
2510 {
2511         vpte_t *pte, tpte;
2512         pv_entry_t pv, npv;
2513         vm_page_t m;
2514         pmap_inval_info info;
2515         int iscurrentpmap;
2516         int32_t save_generation;
2517
2518         if (curproc && pmap == vmspace_pmap(curproc->p_vmspace))
2519                 iscurrentpmap = 1;
2520         else
2521                 iscurrentpmap = 0;
2522
2523         pmap_inval_init(&info);
2524         crit_enter();
2525         for (pv = TAILQ_FIRST(&pmap->pm_pvlist); pv; pv = npv) {
2526                 if (pv->pv_va >= eva || pv->pv_va < sva) {
2527                         npv = TAILQ_NEXT(pv, pv_plist);
2528                         continue;
2529                 }
2530
2531                 KKASSERT(pmap == pv->pv_pmap);
2532
2533                 pte = pmap_pte(pmap, pv->pv_va);
2534                 tpte = *pte;
2535
2536                 /*
2537                  * We cannot remove wired pages from a process' mapping
2538                  * at this time
2539                  */
2540                 if (tpte & VPTE_WIRED) {
2541                         npv = TAILQ_NEXT(pv, pv_plist);
2542                         continue;
2543                 }
2544                 *pte = 0;
2545                 /* See NOTE: PMAP_INVAL_ADD */
2546                 pmap_inval_add(&info, pmap, pv->pv_va);
2547
2548                 m = PHYS_TO_VM_PAGE(tpte);
2549
2550                 KASSERT(m < &vm_page_array[vm_page_array_size],
2551                         ("pmap_remove_pages: bad tpte %x", tpte));
2552
2553                 pmap->pm_stats.resident_count--;
2554
2555                 /*
2556                  * Update the vm_page_t clean and reference bits.
2557                  */
2558                 if (tpte & VPTE_M) {
2559                         vm_page_dirty(m);
2560                 }
2561
2562                 npv = TAILQ_NEXT(pv, pv_plist);
2563                 TAILQ_REMOVE(&pmap->pm_pvlist, pv, pv_plist);
2564                 save_generation = ++pmap->pm_generation;
2565
2566                 m->md.pv_list_count--;
2567                 TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
2568                 if (TAILQ_FIRST(&m->md.pv_list) == NULL) {
2569                         vm_page_flag_clear(m, PG_MAPPED | PG_WRITEABLE);
2570                 }
2571
2572                 pmap_unuse_pt(pmap, pv->pv_va, pv->pv_ptem, &info);
2573                 free_pv_entry(pv);
2574
2575                 /*
2576                  * Restart the scan if we blocked during the unuse or free
2577                  * calls and other removals were made.
2578                  */
2579                 if (save_generation != pmap->pm_generation) {
2580                         kprintf("Warning: pmap_remove_pages race-A avoided\n");
2581                         pv = TAILQ_FIRST(&pmap->pm_pvlist);
2582                 }
2583         }
2584         pmap_inval_flush(&info);
2585         crit_exit();
2586 }
2587
2588 /*
2589  * pmap_testbit tests bits in pte's
2590  * note that the testbit/changebit routines are inline,
2591  * and a lot of things compile-time evaluate.
2592  */
2593 static boolean_t
2594 pmap_testbit(vm_page_t m, int bit)
2595 {
2596         pv_entry_t pv;
2597         vpte_t *pte;
2598
2599         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
2600                 return FALSE;
2601
2602         if (TAILQ_FIRST(&m->md.pv_list) == NULL)
2603                 return FALSE;
2604
2605         crit_enter();
2606
2607         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
2608                 /*
2609                  * if the bit being tested is the modified bit, then
2610                  * mark clean_map and ptes as never
2611                  * modified.
2612                  */
2613                 if (bit & (VPTE_A|VPTE_M)) {
2614                         if (!pmap_track_modified(pv->pv_pmap, pv->pv_va))
2615                                 continue;
2616                 }
2617
2618 #if defined(PMAP_DIAGNOSTIC)
2619                 if (!pv->pv_pmap) {
2620                         kprintf("Null pmap (tb) at va: 0x%x\n", pv->pv_va);
2621                         continue;
2622                 }
2623 #endif
2624                 pte = pmap_pte(pv->pv_pmap, pv->pv_va);
2625                 if (*pte & bit) {
2626                         crit_exit();
2627                         return TRUE;
2628                 }
2629         }
2630         crit_exit();
2631         return (FALSE);
2632 }
2633
2634 /*
2635  * This routine is used to clear bits in ptes.  Certain bits require special
2636  * handling, in particular (on virtual kernels) the VPTE_M (modify) bit.
2637  */
2638 static __inline void
2639 pmap_clearbit(vm_page_t m, int bit)
2640 {
2641         struct pmap_inval_info info;
2642         pv_entry_t pv;
2643         vpte_t *pte;
2644         vpte_t pbits;
2645
2646         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
2647                 return;
2648
2649         pmap_inval_init(&info);
2650         crit_enter();
2651
2652         /*
2653          * Loop over all current mappings setting/clearing as appropos If
2654          * setting RO do we need to clear the VAC?
2655          */
2656         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
2657                 /*
2658                  * don't write protect pager mappings
2659                  */
2660                 if (bit == VPTE_W) {
2661                         if (!pmap_track_modified(pv->pv_pmap, pv->pv_va))
2662                                 continue;
2663                 }
2664
2665 #if defined(PMAP_DIAGNOSTIC)
2666                 if (!pv->pv_pmap) {
2667                         kprintf("Null pmap (cb) at va: 0x%x\n", pv->pv_va);
2668                         continue;
2669                 }
2670 #endif
2671
2672                 /*
2673                  * Careful here.  We can use a locked bus instruction to
2674                  * clear VPTE_A or VPTE_M safely but we need to synchronize
2675                  * with the target cpus when we mess with VPTE_W.
2676                  *
2677                  * On virtual kernels we must force a new fault-on-write
2678                  * in the real kernel if we clear the Modify bit ourselves,
2679                  * otherwise the real kernel will not get a new fault and
2680                  * will never set our Modify bit again.
2681                  */
2682                 pte = pmap_pte(pv->pv_pmap, pv->pv_va);
2683                 if (bit & (VPTE_W|VPTE_M))
2684                         pmap_inval_add(&info, pv->pv_pmap, pv->pv_va);
2685
2686                 pbits = *pte;
2687                 if (pbits & bit) {
2688                         if (bit == VPTE_W) {
2689                                 if (pbits & VPTE_M) {
2690                                         vm_page_dirty(m);
2691                                 }
2692                                 atomic_clear_int(pte, VPTE_M|VPTE_W);
2693                         } else if (bit == VPTE_M) {
2694                                 /*
2695                                  * We do not have to make the page read-only
2696                                  * when clearing the Modify bit.  The real
2697                                  * kernel will make the real PTE read-only
2698                                  * or otherwise detect the write and set
2699                                  * our VPTE_M again simply by us invalidating
2700                                  * the real kernel VA for the pmap (as we did
2701                                  * above).  This allows the real kernel to
2702                                  * handle the write fault without forwarding
2703                                  * the fault to us.
2704                                  */
2705                                 atomic_clear_int(pte, VPTE_M);
2706                         } else {
2707                                 atomic_clear_int(pte, bit);
2708                         }
2709                 }
2710         }
2711         pmap_inval_flush(&info);
2712         crit_exit();
2713 }
2714
2715 /*
2716  *      pmap_page_protect:
2717  *
2718  *      Lower the permission for all mappings to a given page.
2719  */
2720 void
2721 pmap_page_protect(vm_page_t m, vm_prot_t prot)
2722 {
2723         if ((prot & VM_PROT_WRITE) == 0) {
2724                 if (prot & (VM_PROT_READ | VM_PROT_EXECUTE)) {
2725                         pmap_clearbit(m, VPTE_W);
2726                 } else {
2727                         pmap_remove_all(m);
2728                 }
2729         }
2730 }
2731
2732 vm_paddr_t
2733 pmap_phys_address(int ppn)
2734 {
2735         return (i386_ptob(ppn));
2736 }
2737
2738 /*
2739  *      pmap_ts_referenced:
2740  *
2741  *      Return a count of reference bits for a page, clearing those bits.
2742  *      It is not necessary for every reference bit to be cleared, but it
2743  *      is necessary that 0 only be returned when there are truly no
2744  *      reference bits set.
2745  *
2746  *      XXX: The exact number of bits to check and clear is a matter that
2747  *      should be tested and standardized at some point in the future for
2748  *      optimal aging of shared pages.
2749  */
2750 int
2751 pmap_ts_referenced(vm_page_t m)
2752 {
2753         pv_entry_t pv, pvf, pvn;
2754         vpte_t *pte;
2755         int rtval = 0;
2756
2757         if (!pmap_initialized || (m->flags & PG_FICTITIOUS))
2758                 return (rtval);
2759
2760         crit_enter();
2761
2762         if ((pv = TAILQ_FIRST(&m->md.pv_list)) != NULL) {
2763
2764                 pvf = pv;
2765
2766                 do {
2767                         pvn = TAILQ_NEXT(pv, pv_list);
2768
2769                         TAILQ_REMOVE(&m->md.pv_list, pv, pv_list);
2770
2771                         TAILQ_INSERT_TAIL(&m->md.pv_list, pv, pv_list);
2772
2773                         if (!pmap_track_modified(pv->pv_pmap, pv->pv_va))
2774                                 continue;
2775
2776                         pte = pmap_pte(pv->pv_pmap, pv->pv_va);
2777
2778                         if (pte && (*pte & VPTE_A)) {
2779 #ifdef SMP
2780                                 atomic_clear_int(pte, VPTE_A);
2781 #else
2782                                 atomic_clear_int_nonlocked(pte, VPTE_A);
2783 #endif
2784                                 rtval++;
2785                                 if (rtval > 4) {
2786                                         break;
2787                                 }
2788                         }
2789                 } while ((pv = pvn) != NULL && pv != pvf);
2790         }
2791         crit_exit();
2792
2793         return (rtval);
2794 }
2795
2796 /*
2797  *      pmap_is_modified:
2798  *
2799  *      Return whether or not the specified physical page was modified
2800  *      in any physical maps.
2801  */
2802 boolean_t
2803 pmap_is_modified(vm_page_t m)
2804 {
2805         return pmap_testbit(m, VPTE_M);
2806 }
2807
2808 /*
2809  *      Clear the modify bits on the specified physical page.
2810  */
2811 void
2812 pmap_clear_modify(vm_page_t m)
2813 {
2814         pmap_clearbit(m, VPTE_M);
2815 }
2816
2817 /*
2818  *      pmap_clear_reference:
2819  *
2820  *      Clear the reference bit on the specified physical page.
2821  */
2822 void
2823 pmap_clear_reference(vm_page_t m)
2824 {
2825         pmap_clearbit(m, VPTE_A);
2826 }
2827
2828 /*
2829  * Miscellaneous support routines follow
2830  */
2831
2832 static void
2833 i386_protection_init(void)
2834 {
2835         int *kp, prot;
2836
2837         kp = protection_codes;
2838         for (prot = 0; prot < 8; prot++) {
2839                 if (prot & VM_PROT_READ)
2840                         *kp |= VPTE_R;
2841                 if (prot & VM_PROT_WRITE)
2842                         *kp |= VPTE_W;
2843                 if (prot & VM_PROT_EXECUTE)
2844                         *kp |= VPTE_X;
2845                 ++kp;
2846         }
2847 }
2848
2849 /*
2850  * Map a set of physical memory pages into the kernel virtual
2851  * address space. Return a pointer to where it is mapped. This
2852  * routine is intended to be used for mapping device memory,
2853  * NOT real memory.
2854  *
2855  * NOTE: we can't use pgeflag unless we invalidate the pages one at
2856  * a time.
2857  */
2858 void *
2859 pmap_mapdev(vm_paddr_t pa, vm_size_t size)
2860 {
2861         vm_offset_t va, tmpva, offset;
2862         vpte_t *pte;
2863
2864         offset = pa & PAGE_MASK;
2865         size = roundup(offset + size, PAGE_SIZE);
2866
2867         va = kmem_alloc_nofault(&kernel_map, size);
2868         if (!va)
2869                 panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
2870
2871         pa = pa & VPTE_FRAME;
2872         for (tmpva = va; size > 0;) {
2873                 pte = KernelPTA + (tmpva >> PAGE_SHIFT);
2874                 *pte = pa | VPTE_R | VPTE_W | VPTE_V; /* | pgeflag; */
2875                 size -= PAGE_SIZE;
2876                 tmpva += PAGE_SIZE;
2877                 pa += PAGE_SIZE;
2878         }
2879         cpu_invltlb();
2880         smp_invltlb();
2881
2882         return ((void *)(va + offset));
2883 }
2884
2885 void
2886 pmap_unmapdev(vm_offset_t va, vm_size_t size)
2887 {
2888         vm_offset_t base, offset;
2889
2890         base = va & VPTE_FRAME;
2891         offset = va & PAGE_MASK;
2892         size = roundup(offset + size, PAGE_SIZE);
2893         pmap_qremove(va, size >> PAGE_SHIFT);
2894         kmem_free(&kernel_map, base, size);
2895 }
2896
2897 /*
2898  * perform the pmap work for mincore
2899  */
2900 int
2901 pmap_mincore(pmap_t pmap, vm_offset_t addr)
2902 {
2903         vpte_t *ptep, pte;
2904         vm_page_t m;
2905         int val = 0;
2906
2907         ptep = pmap_pte(pmap, addr);
2908         if (ptep == 0) {
2909                 return 0;
2910         }
2911
2912         if ((pte = *ptep) != 0) {
2913                 vm_offset_t pa;
2914
2915                 val = MINCORE_INCORE;
2916                 if ((pte & VPTE_MANAGED) == 0)
2917                         return val;
2918
2919                 pa = pte & VPTE_FRAME;
2920
2921                 m = PHYS_TO_VM_PAGE(pa);
2922
2923                 /*
2924                  * Modified by us
2925                  */
2926                 if (pte & VPTE_M)
2927                         val |= MINCORE_MODIFIED|MINCORE_MODIFIED_OTHER;
2928                 /*
2929                  * Modified by someone
2930                  */
2931                 else if (m->dirty || pmap_is_modified(m))
2932                         val |= MINCORE_MODIFIED_OTHER;
2933                 /*
2934                  * Referenced by us
2935                  */
2936                 if (pte & VPTE_A)
2937                         val |= MINCORE_REFERENCED|MINCORE_REFERENCED_OTHER;
2938
2939                 /*
2940                  * Referenced by someone
2941                  */
2942                 else if ((m->flags & PG_REFERENCED) || pmap_ts_referenced(m)) {
2943                         val |= MINCORE_REFERENCED_OTHER;
2944                         vm_page_flag_set(m, PG_REFERENCED);
2945                 }
2946         }
2947         return val;
2948 }
2949
2950 void
2951 pmap_activate(struct proc *p)
2952 {
2953         pmap_t  pmap;
2954
2955         pmap = vmspace_pmap(p->p_vmspace);
2956 #if defined(SMP)
2957         atomic_set_int(&pmap->pm_active, 1 << mycpu->gd_cpuid);
2958 #else
2959         pmap->pm_active |= 1;
2960 #endif
2961 #if defined(SWTCH_OPTIM_STATS)
2962         tlb_flush_count++;
2963 #endif
2964 #if 0
2965         KKASSERT((p == curproc));
2966
2967         curthread->td_pcb->pcb_cr3 = vtophys(pmap->pm_pdir);
2968         load_cr3(curthread->td_pcb->pcb_cr3);
2969 #endif
2970 }
2971
2972 void
2973 pmap_deactivate(struct proc *p)
2974 {
2975         pmap_t  pmap;
2976
2977         pmap = vmspace_pmap(p->p_vmspace);
2978 #if defined(SMP)
2979         atomic_clear_int(&pmap->pm_active, 1 << mycpu->gd_cpuid);
2980 #else
2981         pmap->pm_active &= ~1;
2982 #endif
2983         /*
2984          * XXX - note we do not adjust %cr3.  The caller is expected to
2985          * activate a new pmap or do a thread-exit.
2986          */
2987 }
2988
2989 vm_offset_t
2990 pmap_addr_hint(vm_object_t obj, vm_offset_t addr, vm_size_t size)
2991 {
2992
2993         if ((obj == NULL) || (size < NBPDR) || (obj->type != OBJT_DEVICE)) {
2994                 return addr;
2995         }
2996
2997         addr = (addr + (NBPDR - 1)) & ~(NBPDR - 1);
2998         return addr;
2999 }
3000
3001
3002 #if defined(DEBUG)
3003
3004 static void     pads (pmap_t pm);
3005 void            pmap_pvdump (vm_paddr_t pa);
3006
3007 /* print address space of pmap*/
3008 static void
3009 pads(pmap_t pm)
3010 {
3011         vm_offset_t va;
3012         int i, j;
3013         vpte_t *ptep;
3014
3015         if (pm == &kernel_pmap)
3016                 return;
3017         for (i = 0; i < 1024; i++)
3018                 if (pm->pm_pdir[i])
3019                         for (j = 0; j < 1024; j++) {
3020                                 va = (i << PDRSHIFT) + (j << PAGE_SHIFT);
3021                                 if (pm == &kernel_pmap && va < KERNBASE)
3022                                         continue;
3023                                 if (pm != &kernel_pmap && va > UPT_MAX_ADDRESS)
3024                                         continue;
3025                                 ptep = pmap_pte(pm, va);
3026                                 if (ptep && (*ptep & VPTE_V)) {
3027                                         kprintf("%p:%x ",
3028                                                 (void *)va, (unsigned)*ptep);
3029                                 }
3030                         };
3031
3032 }
3033
3034 void
3035 pmap_pvdump(vm_paddr_t pa)
3036 {
3037         pv_entry_t pv;
3038         vm_page_t m;
3039
3040         kprintf("pa %08llx", (long long)pa);
3041         m = PHYS_TO_VM_PAGE(pa);
3042         TAILQ_FOREACH(pv, &m->md.pv_list, pv_list) {
3043 #ifdef used_to_be
3044                 kprintf(" -> pmap %p, va %x, flags %x",
3045                     (void *)pv->pv_pmap, pv->pv_va, pv->pv_flags);
3046 #endif
3047                 kprintf(" -> pmap %p, va %x", (void *)pv->pv_pmap, pv->pv_va);
3048                 pads(pv->pv_pmap);
3049         }
3050         kprintf(" ");
3051 }
3052 #endif
3053