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