sys/vm/vm_page.c

   1 /*-
   2  * Copyright (c) 1991 Regents of the University of California.
   3  * All rights reserved.
   4  * Copyright (c) 1998 Matthew Dillon.  All Rights Reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * The Mach Operating System project at Carnegie-Mellon University.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      from: @(#)vm_page.c     7.4 (Berkeley) 5/7/91
  34  */
  35
  36 /*-
  37  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
  38  * All rights reserved.
  39  *
  40  * Authors: Avadis Tevanian, Jr., Michael Wayne Young
  41  *
  42  * Permission to use, copy, modify and distribute this software and
  43  * its documentation is hereby granted, provided that both the copyright
  44  * notice and this permission notice appear in all copies of the
  45  * software, derivative works or modified versions, and any portions
  46  * thereof, and that both notices appear in supporting documentation.
  47  *
  48  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  49  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  50  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  51  *
  52  * Carnegie Mellon requests users of this software to return to
  53  *
  54  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  55  *  School of Computer Science
  56  *  Carnegie Mellon University
  57  *  Pittsburgh PA 15213-3890
  58  *
  59  * any improvements or extensions that they make and grant Carnegie the
  60  * rights to redistribute these changes.
  61  */
  62
  63 /*
  64  *                      GENERAL RULES ON VM_PAGE MANIPULATION
  65  *
  66  *      - A page queue lock is required when adding or removing a page from a
  67  *        page queue regardless of other locks or the busy state of a page.
  68  *
  69  *              * In general, no thread besides the page daemon can acquire or
  70  *                hold more than one page queue lock at a time.
  71  *
  72  *              * The page daemon can acquire and hold any pair of page queue
  73  *                locks in any order.
  74  *
  75  *      - The object lock is required when inserting or removing
  76  *        pages from an object (vm_page_insert() or vm_page_remove()).
  77  *
  78  */
  79
  80 /*
  81  *      Resident memory management module.
  82  */
  83
  84 #include <sys/cdefs.h>
  85 __FBSDID("$FreeBSD$");
  86
  87 #include "opt_vm.h"
  88
  89 #include <sys/param.h>
  90 #include <sys/systm.h>
  91 #include <sys/lock.h>
  92 #include <sys/kernel.h>
  93 #include <sys/limits.h>
  94 #include <sys/linker.h>
  95 #include <sys/malloc.h>
  96 #include <sys/mman.h>
  97 #include <sys/msgbuf.h>
  98 #include <sys/mutex.h>
  99 #include <sys/proc.h>
 100 #include <sys/rwlock.h>
 101 #include <sys/sbuf.h>
 102 #include <sys/smp.h>
 103 #include <sys/sysctl.h>
 104 #include <sys/vmmeter.h>
 105 #include <sys/vnode.h>
 106
 107 #include <vm/vm.h>
 108 #include <vm/pmap.h>
 109 #include <vm/vm_param.h>
 110 #include <vm/vm_kern.h>
 111 #include <vm/vm_object.h>
 112 #include <vm/vm_page.h>
 113 #include <vm/vm_pageout.h>
 114 #include <vm/vm_pager.h>
 115 #include <vm/vm_phys.h>
 116 #include <vm/vm_radix.h>
 117 #include <vm/vm_reserv.h>
 118 #include <vm/vm_extern.h>
 119 #include <vm/uma.h>
 120 #include <vm/uma_int.h>
 121
 122 #include <machine/md_var.h>
 123
 124 /*
 125  *      Associated with page of user-allocatable memory is a
 126  *      page structure.
 127  */
 128
 129 struct vm_domain vm_dom[MAXMEMDOM];
 130 struct mtx_padalign vm_page_queue_free_mtx;
 131
 132 struct mtx_padalign pa_lock[PA_LOCK_COUNT];
 133
 134 vm_page_t vm_page_array;
 135 long vm_page_array_size;
 136 long first_page;
 137
 138 static int boot_pages = UMA_BOOT_PAGES;
 139 SYSCTL_INT(_vm, OID_AUTO, boot_pages, CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
 140     &boot_pages, 0,
 141     "number of pages allocated for bootstrapping the VM system");
 142
 143 static int pa_tryrelock_restart;
 144 SYSCTL_INT(_vm, OID_AUTO, tryrelock_restart, CTLFLAG_RD,
 145     &pa_tryrelock_restart, 0, "Number of tryrelock restarts");
 146
 147 static TAILQ_HEAD(, vm_page) blacklist_head;
 148 static int sysctl_vm_page_blacklist(SYSCTL_HANDLER_ARGS);
 149 SYSCTL_PROC(_vm, OID_AUTO, page_blacklist, CTLTYPE_STRING | CTLFLAG_RD |
 150     CTLFLAG_MPSAFE, NULL, 0, sysctl_vm_page_blacklist, "A", "Blacklist pages");
 151
 152 /* Is the page daemon waiting for free pages? */
 153 static int vm_pageout_pages_needed;
 154
 155 static uma_zone_t fakepg_zone;
 156
 157 static void vm_page_alloc_check(vm_page_t m);
 158 static void vm_page_clear_dirty_mask(vm_page_t m, vm_page_bits_t pagebits);
 159 static void vm_page_enqueue(uint8_t queue, vm_page_t m);
 160 static void vm_page_free_wakeup(void);
 161 static void vm_page_init_fakepg(void *dummy);
 162 static int vm_page_insert_after(vm_page_t m, vm_object_t object,
 163     vm_pindex_t pindex, vm_page_t mpred);
 164 static void vm_page_insert_radixdone(vm_page_t m, vm_object_t object,
 165     vm_page_t mpred);
 166 static int vm_page_reclaim_run(int req_class, u_long npages, vm_page_t m_run,
 167     vm_paddr_t high);
 168
 169 SYSINIT(vm_page, SI_SUB_VM, SI_ORDER_SECOND, vm_page_init_fakepg, NULL);
 170
 171 static void
 172 vm_page_init_fakepg(void *dummy)
 173 {
 174
 175         fakepg_zone = uma_zcreate("fakepg", sizeof(struct vm_page), NULL, NULL,
 176             NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE | UMA_ZONE_VM);
 177 }
 178
 179 /* Make sure that u_long is at least 64 bits when PAGE_SIZE is 32K. */
 180 #if PAGE_SIZE == 32768
 181 #ifdef CTASSERT
 182 CTASSERT(sizeof(u_long) >= 8);
 183 #endif
 184 #endif
 185
 186 /*
 187  * Try to acquire a physical address lock while a pmap is locked.  If we
 188  * fail to trylock we unlock and lock the pmap directly and cache the
 189  * locked pa in *locked.  The caller should then restart their loop in case
 190  * the virtual to physical mapping has changed.
 191  */
 192 int
 193 vm_page_pa_tryrelock(pmap_t pmap, vm_paddr_t pa, vm_paddr_t *locked)
 194 {
 195         vm_paddr_t lockpa;
 196
 197         lockpa = *locked;
 198         *locked = pa;
 199         if (lockpa) {
 200                 PA_LOCK_ASSERT(lockpa, MA_OWNED);
 201                 if (PA_LOCKPTR(pa) == PA_LOCKPTR(lockpa))
 202                         return (0);
 203                 PA_UNLOCK(lockpa);
 204         }
 205         if (PA_TRYLOCK(pa))
 206                 return (0);
 207         PMAP_UNLOCK(pmap);
 208         atomic_add_int(&pa_tryrelock_restart, 1);
 209         PA_LOCK(pa);
 210         PMAP_LOCK(pmap);
 211         return (EAGAIN);
 212 }
 213
 214 /*
 215  *      vm_set_page_size:
 216  *
 217  *      Sets the page size, perhaps based upon the memory
 218  *      size.  Must be called before any use of page-size
 219  *      dependent functions.
 220  */
 221 void
 222 vm_set_page_size(void)
 223 {
 224         if (vm_cnt.v_page_size == 0)
 225                 vm_cnt.v_page_size = PAGE_SIZE;
 226         if (((vm_cnt.v_page_size - 1) & vm_cnt.v_page_size) != 0)
 227                 panic("vm_set_page_size: page size not a power of two");
 228 }
 229
 230 /*
 231  *      vm_page_blacklist_next:
 232  *
 233  *      Find the next entry in the provided string of blacklist
 234  *      addresses.  Entries are separated by space, comma, or newline.
 235  *      If an invalid integer is encountered then the rest of the
 236  *      string is skipped.  Updates the list pointer to the next
 237  *      character, or NULL if the string is exhausted or invalid.
 238  */
 239 static vm_paddr_t
 240 vm_page_blacklist_next(char **list, char *end)
 241 {
 242         vm_paddr_t bad;
 243         char *cp, *pos;
 244
 245         if (list == NULL || *list == NULL)
 246                 return (0);
 247         if (**list =='\0') {
 248                 *list = NULL;
 249                 return (0);
 250         }
 251
 252         /*
 253          * If there's no end pointer then the buffer is coming from
 254          * the kenv and we know it's null-terminated.
 255          */
 256         if (end == NULL)
 257                 end = *list + strlen(*list);
 258
 259         /* Ensure that strtoq() won't walk off the end */
 260         if (*end != '\0') {
 261                 if (*end == '\n' || *end == ' ' || *end  == ',')
 262                         *end = '\0';
 263                 else {
 264                         printf("Blacklist not terminated, skipping\n");
 265                         *list = NULL;
 266                         return (0);
 267                 }
 268         }
 269
 270         for (pos = *list; *pos != '\0'; pos = cp) {
 271                 bad = strtoq(pos, &cp, 0);
 272                 if (*cp == '\0' || *cp == ' ' || *cp == ',' || *cp == '\n') {
 273                         if (bad == 0) {
 274                                 if (++cp < end)
 275                                         continue;
 276                                 else
 277                                         break;
 278                         }
 279                 } else
 280                         break;
 281                 if (*cp == '\0' || ++cp >= end)
 282                         *list = NULL;
 283                 else
 284                         *list = cp;
 285                 return (trunc_page(bad));
 286         }
 287         printf("Garbage in RAM blacklist, skipping\n");
 288         *list = NULL;
 289         return (0);
 290 }
 291
 292 /*
 293  *      vm_page_blacklist_check:
 294  *
 295  *      Iterate through the provided string of blacklist addresses, pulling
 296  *      each entry out of the physical allocator free list and putting it
 297  *      onto a list for reporting via the vm.page_blacklist sysctl.
 298  */
 299 static void
 300 vm_page_blacklist_check(char *list, char *end)
 301 {
 302         vm_paddr_t pa;
 303         vm_page_t m;
 304         char *next;
 305         int ret;
 306
 307         next = list;
 308         while (next != NULL) {
 309                 if ((pa = vm_page_blacklist_next(&next, end)) == 0)
 310                         continue;
 311                 m = vm_phys_paddr_to_vm_page(pa);
 312                 if (m == NULL)
 313                         continue;
 314                 mtx_lock(&vm_page_queue_free_mtx);
 315                 ret = vm_phys_unfree_page(m);
 316                 mtx_unlock(&vm_page_queue_free_mtx);
 317                 if (ret == TRUE) {
 318                         TAILQ_INSERT_TAIL(&blacklist_head, m, listq);
 319                         if (bootverbose)
 320                                 printf("Skipping page with pa 0x%jx\n",
 321                                     (uintmax_t)pa);
 322                 }
 323         }
 324 }
 325
 326 /*
 327  *      vm_page_blacklist_load:
 328  *
 329  *      Search for a special module named "ram_blacklist".  It'll be a
 330  *      plain text file provided by the user via the loader directive
 331  *      of the same name.
 332  */
 333 static void
 334 vm_page_blacklist_load(char **list, char **end)
 335 {
 336         void *mod;
 337         u_char *ptr;
 338         u_int len;
 339
 340         mod = NULL;
 341         ptr = NULL;
 342
 343         mod = preload_search_by_type("ram_blacklist");
 344         if (mod != NULL) {
 345                 ptr = preload_fetch_addr(mod);
 346                 len = preload_fetch_size(mod);
 347         }
 348         *list = ptr;
 349         if (ptr != NULL)
 350                 *end = ptr + len;
 351         else
 352                 *end = NULL;
 353         return;
 354 }
 355
 356 static int
 357 sysctl_vm_page_blacklist(SYSCTL_HANDLER_ARGS)
 358 {
 359         vm_page_t m;
 360         struct sbuf sbuf;
 361         int error, first;
 362
 363         first = 1;
 364         error = sysctl_wire_old_buffer(req, 0);
 365         if (error != 0)
 366                 return (error);
 367         sbuf_new_for_sysctl(&sbuf, NULL, 128, req);
 368         TAILQ_FOREACH(m, &blacklist_head, listq) {
 369                 sbuf_printf(&sbuf, "%s%#jx", first ? "" : ",",
 370                     (uintmax_t)m->phys_addr);
 371                 first = 0;
 372         }
 373         error = sbuf_finish(&sbuf);
 374         sbuf_delete(&sbuf);
 375         return (error);
 376 }
 377
 378 static void
 379 vm_page_domain_init(struct vm_domain *vmd)
 380 {
 381         struct vm_pagequeue *pq;
 382         int i;
 383
 384         *__DECONST(char **, &vmd->vmd_pagequeues[PQ_INACTIVE].pq_name) =
 385             "vm inactive pagequeue";
 386         *__DECONST(u_int **, &vmd->vmd_pagequeues[PQ_INACTIVE].pq_vcnt) =
 387             &vm_cnt.v_inactive_count;
 388         *__DECONST(char **, &vmd->vmd_pagequeues[PQ_ACTIVE].pq_name) =
 389             "vm active pagequeue";
 390         *__DECONST(u_int **, &vmd->vmd_pagequeues[PQ_ACTIVE].pq_vcnt) =
 391             &vm_cnt.v_active_count;
 392         *__DECONST(char **, &vmd->vmd_pagequeues[PQ_LAUNDRY].pq_name) =
 393             "vm laundry pagequeue";
 394         *__DECONST(int **, &vmd->vmd_pagequeues[PQ_LAUNDRY].pq_vcnt) =
 395             &vm_cnt.v_laundry_count;
 396         vmd->vmd_page_count = 0;
 397         vmd->vmd_free_count = 0;
 398         vmd->vmd_segs = 0;
 399         vmd->vmd_oom = FALSE;
 400         for (i = 0; i < PQ_COUNT; i++) {
 401                 pq = &vmd->vmd_pagequeues[i];
 402                 TAILQ_INIT(&pq->pq_pl);
 403                 mtx_init(&pq->pq_mutex, pq->pq_name, "vm pagequeue",
 404                     MTX_DEF | MTX_DUPOK);
 405         }
 406 }
 407
 408 /*
 409  *      vm_page_startup:
 410  *
 411  *      Initializes the resident memory module.
 412  *
 413  *      Allocates memory for the page cells, and
 414  *      for the object/offset-to-page hash table headers.
 415  *      Each page cell is initialized and placed on the free list.
 416  */
 417 vm_offset_t
 418 vm_page_startup(vm_offset_t vaddr)
 419 {
 420         vm_offset_t mapped;
 421         vm_paddr_t page_range;
 422         vm_paddr_t new_end;
 423         int i;
 424         vm_paddr_t pa;
 425         vm_paddr_t last_pa;
 426         char *list, *listend;
 427         vm_paddr_t end;
 428         vm_paddr_t biggestsize;
 429         vm_paddr_t low_water, high_water;
 430         int biggestone;
 431         int pages_per_zone;
 432
 433         biggestsize = 0;
 434         biggestone = 0;
 435         vaddr = round_page(vaddr);
 436
 437         for (i = 0; phys_avail[i + 1]; i += 2) {
 438                 phys_avail[i] = round_page(phys_avail[i]);
 439                 phys_avail[i + 1] = trunc_page(phys_avail[i + 1]);
 440         }
 441
 442         low_water = phys_avail[0];
 443         high_water = phys_avail[1];
 444
 445         for (i = 0; i < vm_phys_nsegs; i++) {
 446                 if (vm_phys_segs[i].start < low_water)
 447                         low_water = vm_phys_segs[i].start;
 448                 if (vm_phys_segs[i].end > high_water)
 449                         high_water = vm_phys_segs[i].end;
 450         }
 451         for (i = 0; phys_avail[i + 1]; i += 2) {
 452                 vm_paddr_t size = phys_avail[i + 1] - phys_avail[i];
 453
 454                 if (size > biggestsize) {
 455                         biggestone = i;
 456                         biggestsize = size;
 457                 }
 458                 if (phys_avail[i] < low_water)
 459                         low_water = phys_avail[i];
 460                 if (phys_avail[i + 1] > high_water)
 461                         high_water = phys_avail[i + 1];
 462         }
 463
 464         end = phys_avail[biggestone+1];
 465
 466         /*
 467          * Initialize the page and queue locks.
 468          */
 469         mtx_init(&vm_page_queue_free_mtx, "vm page free queue", NULL, MTX_DEF);
 470         for (i = 0; i < PA_LOCK_COUNT; i++)
 471                 mtx_init(&pa_lock[i], "vm page", NULL, MTX_DEF);
 472         for (i = 0; i < vm_ndomains; i++)
 473                 vm_page_domain_init(&vm_dom[i]);
 474
 475         /*
 476          * Almost all of the pages needed for boot strapping UMA are used
 477          * for zone structures, so if the number of CPUs results in those
 478          * structures taking more than one page each, we set aside more pages
 479          * in proportion to the zone structure size.
 480          */
 481         pages_per_zone = howmany(sizeof(struct uma_zone) +
 482             sizeof(struct uma_cache) * (mp_maxid + 1), UMA_SLAB_SIZE);
 483         if (pages_per_zone > 1) {
 484                 /* Reserve more pages so that we don't run out. */
 485                 boot_pages = UMA_BOOT_PAGES_ZONES * pages_per_zone;
 486         }
 487
 488         /*
 489          * Allocate memory for use when boot strapping the kernel memory
 490          * allocator.
 491          *
 492          * CTFLAG_RDTUN doesn't work during the early boot process, so we must
 493          * manually fetch the value.
 494          */
 495         TUNABLE_INT_FETCH("vm.boot_pages", &boot_pages);
 496         new_end = end - (boot_pages * UMA_SLAB_SIZE);
 497         new_end = trunc_page(new_end);
 498         mapped = pmap_map(&vaddr, new_end, end,
 499             VM_PROT_READ | VM_PROT_WRITE);
 500         bzero((void *)mapped, end - new_end);
 501         uma_startup((void *)mapped, boot_pages);
 502
 503 #if defined(__aarch64__) || defined(__amd64__) || defined(__arm__) || \
 504     defined(__i386__) || defined(__mips__)
 505         /*
 506          * Allocate a bitmap to indicate that a random physical page
 507          * needs to be included in a minidump.
 508          *
 509          * The amd64 port needs this to indicate which direct map pages
 510          * need to be dumped, via calls to dump_add_page()/dump_drop_page().
 511          *
 512          * However, i386 still needs this workspace internally within the
 513          * minidump code.  In theory, they are not needed on i386, but are
 514          * included should the sf_buf code decide to use them.
 515          */
 516         last_pa = 0;
 517         for (i = 0; dump_avail[i + 1] != 0; i += 2)
 518                 if (dump_avail[i + 1] > last_pa)
 519                         last_pa = dump_avail[i + 1];
 520         page_range = last_pa / PAGE_SIZE;
 521         vm_page_dump_size = round_page(roundup2(page_range, NBBY) / NBBY);
 522         new_end -= vm_page_dump_size;
 523         vm_page_dump = (void *)(uintptr_t)pmap_map(&vaddr, new_end,
 524             new_end + vm_page_dump_size, VM_PROT_READ | VM_PROT_WRITE);
 525         bzero((void *)vm_page_dump, vm_page_dump_size);
 526 #endif
 527 #ifdef __amd64__
 528         /*
 529          * Request that the physical pages underlying the message buffer be
 530          * included in a crash dump.  Since the message buffer is accessed
 531          * through the direct map, they are not automatically included.
 532          */
 533         pa = DMAP_TO_PHYS((vm_offset_t)msgbufp->msg_ptr);
 534         last_pa = pa + round_page(msgbufsize);
 535         while (pa < last_pa) {
 536                 dump_add_page(pa);
 537                 pa += PAGE_SIZE;
 538         }
 539 #endif
 540         /*
 541          * Compute the number of pages of memory that will be available for
 542          * use (taking into account the overhead of a page structure per
 543          * page).
 544          */
 545         first_page = low_water / PAGE_SIZE;
 546 #ifdef VM_PHYSSEG_SPARSE
 547         page_range = 0;
 548         for (i = 0; i < vm_phys_nsegs; i++) {
 549                 page_range += atop(vm_phys_segs[i].end -
 550                     vm_phys_segs[i].start);
 551         }
 552         for (i = 0; phys_avail[i + 1] != 0; i += 2)
 553                 page_range += atop(phys_avail[i + 1] - phys_avail[i]);
 554 #elif defined(VM_PHYSSEG_DENSE)
 555         page_range = high_water / PAGE_SIZE - first_page;
 556 #else
 557 #error "Either VM_PHYSSEG_DENSE or VM_PHYSSEG_SPARSE must be defined."
 558 #endif
 559         end = new_end;
 560
 561         /*
 562          * Reserve an unmapped guard page to trap access to vm_page_array[-1].
 563          */
 564         vaddr += PAGE_SIZE;
 565
 566         /*
 567          * Initialize the mem entry structures now, and put them in the free
 568          * queue.
 569          */
 570         new_end = trunc_page(end - page_range * sizeof(struct vm_page));
 571         mapped = pmap_map(&vaddr, new_end, end,
 572             VM_PROT_READ | VM_PROT_WRITE);
 573         vm_page_array = (vm_page_t) mapped;
 574 #if VM_NRESERVLEVEL > 0
 575         /*
 576          * Allocate memory for the reservation management system's data
 577          * structures.
 578          */
 579         new_end = vm_reserv_startup(&vaddr, new_end, high_water);
 580 #endif
 581 #if defined(__aarch64__) || defined(__amd64__) || defined(__mips__)
 582         /*
 583          * pmap_map on arm64, amd64, and mips can come out of the direct-map,
 584          * not kvm like i386, so the pages must be tracked for a crashdump to
 585          * include this data.  This includes the vm_page_array and the early
 586          * UMA bootstrap pages.
 587          */
 588         for (pa = new_end; pa < phys_avail[biggestone + 1]; pa += PAGE_SIZE)
 589                 dump_add_page(pa);
 590 #endif
 591         phys_avail[biggestone + 1] = new_end;
 592
 593         /*
 594          * Add physical memory segments corresponding to the available
 595          * physical pages.
 596          */
 597         for (i = 0; phys_avail[i + 1] != 0; i += 2)
 598                 vm_phys_add_seg(phys_avail[i], phys_avail[i + 1]);
 599
 600         /*
 601          * Clear all of the page structures
 602          */
 603         bzero((caddr_t) vm_page_array, page_range * sizeof(struct vm_page));
 604         for (i = 0; i < page_range; i++)
 605                 vm_page_array[i].order = VM_NFREEORDER;
 606         vm_page_array_size = page_range;
 607
 608         /*
 609          * Initialize the physical memory allocator.
 610          */
 611         vm_phys_init();
 612
 613         /*
 614          * Add every available physical page that is not blacklisted to
 615          * the free lists.
 616          */
 617         vm_cnt.v_page_count = 0;
 618         vm_cnt.v_free_count = 0;
 619         for (i = 0; phys_avail[i + 1] != 0; i += 2) {
 620                 pa = phys_avail[i];
 621                 last_pa = phys_avail[i + 1];
 622                 while (pa < last_pa) {
 623                         vm_phys_add_page(pa);
 624                         pa += PAGE_SIZE;
 625                 }
 626         }
 627
 628         TAILQ_INIT(&blacklist_head);
 629         vm_page_blacklist_load(&list, &listend);
 630         vm_page_blacklist_check(list, listend);
 631
 632         list = kern_getenv("vm.blacklist");
 633         vm_page_blacklist_check(list, NULL);
 634
 635         freeenv(list);
 636 #if VM_NRESERVLEVEL > 0
 637         /*
 638          * Initialize the reservation management system.
 639          */
 640         vm_reserv_init();
 641 #endif
 642         return (vaddr);
 643 }
 644
 645 void
 646 vm_page_reference(vm_page_t m)
 647 {
 648
 649         vm_page_aflag_set(m, PGA_REFERENCED);
 650 }
 651
 652 /*
 653  *      vm_page_busy_downgrade:
 654  *
 655  *      Downgrade an exclusive busy page into a single shared busy page.
 656  */
 657 void
 658 vm_page_busy_downgrade(vm_page_t m)
 659 {
 660         u_int x;
 661         bool locked;
 662
 663         vm_page_assert_xbusied(m);
 664         locked = mtx_owned(vm_page_lockptr(m));
 665
 666         for (;;) {
 667                 x = m->busy_lock;
 668                 x &= VPB_BIT_WAITERS;
 669                 if (x != 0 && !locked)
 670                         vm_page_lock(m);
 671                 if (atomic_cmpset_rel_int(&m->busy_lock,
 672                     VPB_SINGLE_EXCLUSIVER | x, VPB_SHARERS_WORD(1)))
 673                         break;
 674                 if (x != 0 && !locked)
 675                         vm_page_unlock(m);
 676         }
 677         if (x != 0) {
 678                 wakeup(m);
 679                 if (!locked)
 680                         vm_page_unlock(m);
 681         }
 682 }
 683
 684 /*
 685  *      vm_page_sbusied:
 686  *
 687  *      Return a positive value if the page is shared busied, 0 otherwise.
 688  */
 689 int
 690 vm_page_sbusied(vm_page_t m)
 691 {
 692         u_int x;
 693
 694         x = m->busy_lock;
 695         return ((x & VPB_BIT_SHARED) != 0 && x != VPB_UNBUSIED);
 696 }
 697
 698 /*
 699  *      vm_page_sunbusy:
 700  *
 701  *      Shared unbusy a page.
 702  */
 703 void
 704 vm_page_sunbusy(vm_page_t m)
 705 {
 706         u_int x;
 707
 708         vm_page_assert_sbusied(m);
 709
 710         for (;;) {
 711                 x = m->busy_lock;
 712                 if (VPB_SHARERS(x) > 1) {
 713                         if (atomic_cmpset_int(&m->busy_lock, x,
 714                             x - VPB_ONE_SHARER))
 715                                 break;
 716                         continue;
 717                 }
 718                 if ((x & VPB_BIT_WAITERS) == 0) {
 719                         KASSERT(x == VPB_SHARERS_WORD(1),
 720                             ("vm_page_sunbusy: invalid lock state"));
 721                         if (atomic_cmpset_int(&m->busy_lock,
 722                             VPB_SHARERS_WORD(1), VPB_UNBUSIED))
 723                                 break;
 724                         continue;
 725                 }
 726                 KASSERT(x == (VPB_SHARERS_WORD(1) | VPB_BIT_WAITERS),
 727                     ("vm_page_sunbusy: invalid lock state for waiters"));
 728
 729                 vm_page_lock(m);
 730                 if (!atomic_cmpset_int(&m->busy_lock, x, VPB_UNBUSIED)) {
 731                         vm_page_unlock(m);
 732                         continue;
 733                 }
 734                 wakeup(m);
 735                 vm_page_unlock(m);
 736                 break;
 737         }
 738 }
 739
 740 /*
 741  *      vm_page_busy_sleep:
 742  *
 743  *      Sleep and release the page lock, using the page pointer as wchan.
 744  *      This is used to implement the hard-path of busying mechanism.
 745  *
 746  *      The given page must be locked.
 747  *
 748  *      If nonshared is true, sleep only if the page is xbusy.
 749  */
 750 void
 751 vm_page_busy_sleep(vm_page_t m, const char *wmesg, bool nonshared)
 752 {
 753         u_int x;
 754
 755         vm_page_assert_locked(m);
 756
 757         x = m->busy_lock;
 758         if (x == VPB_UNBUSIED || (nonshared && (x & VPB_BIT_SHARED) != 0) ||
 759             ((x & VPB_BIT_WAITERS) == 0 &&
 760             !atomic_cmpset_int(&m->busy_lock, x, x | VPB_BIT_WAITERS))) {
 761                 vm_page_unlock(m);
 762                 return;
 763         }
 764         msleep(m, vm_page_lockptr(m), PVM | PDROP, wmesg, 0);
 765 }
 766
 767 /*
 768  *      vm_page_trysbusy:
 769  *
 770  *      Try to shared busy a page.
 771  *      If the operation succeeds 1 is returned otherwise 0.
 772  *      The operation never sleeps.
 773  */
 774 int
 775 vm_page_trysbusy(vm_page_t m)
 776 {
 777         u_int x;
 778
 779         for (;;) {
 780                 x = m->busy_lock;
 781                 if ((x & VPB_BIT_SHARED) == 0)
 782                         return (0);
 783                 if (atomic_cmpset_acq_int(&m->busy_lock, x, x + VPB_ONE_SHARER))
 784                         return (1);
 785         }
 786 }
 787
 788 static void
 789 vm_page_xunbusy_locked(vm_page_t m)
 790 {
 791
 792         vm_page_assert_xbusied(m);
 793         vm_page_assert_locked(m);
 794
 795         atomic_store_rel_int(&m->busy_lock, VPB_UNBUSIED);
 796         /* There is a waiter, do wakeup() instead of vm_page_flash(). */
 797         wakeup(m);
 798 }
 799
 800 void
 801 vm_page_xunbusy_maybelocked(vm_page_t m)
 802 {
 803         bool lockacq;
 804
 805         vm_page_assert_xbusied(m);
 806
 807         /*
 808          * Fast path for unbusy.  If it succeeds, we know that there
 809          * are no waiters, so we do not need a wakeup.
 810          */
 811         if (atomic_cmpset_rel_int(&m->busy_lock, VPB_SINGLE_EXCLUSIVER,
 812             VPB_UNBUSIED))
 813                 return;
 814
 815         lockacq = !mtx_owned(vm_page_lockptr(m));
 816         if (lockacq)
 817                 vm_page_lock(m);
 818         vm_page_xunbusy_locked(m);
 819         if (lockacq)
 820                 vm_page_unlock(m);
 821 }
 822
 823 /*
 824  *      vm_page_xunbusy_hard:
 825  *
 826  *      Called after the first try the exclusive unbusy of a page failed.
 827  *      It is assumed that the waiters bit is on.
 828  */
 829 void
 830 vm_page_xunbusy_hard(vm_page_t m)
 831 {
 832
 833         vm_page_assert_xbusied(m);
 834
 835         vm_page_lock(m);
 836         vm_page_xunbusy_locked(m);
 837         vm_page_unlock(m);
 838 }
 839
 840 /*
 841  *      vm_page_flash:
 842  *
 843  *      Wakeup anyone waiting for the page.
 844  *      The ownership bits do not change.
 845  *
 846  *      The given page must be locked.
 847  */
 848 void
 849 vm_page_flash(vm_page_t m)
 850 {
 851         u_int x;
 852
 853         vm_page_lock_assert(m, MA_OWNED);
 854
 855         for (;;) {
 856                 x = m->busy_lock;
 857                 if ((x & VPB_BIT_WAITERS) == 0)
 858                         return;
 859                 if (atomic_cmpset_int(&m->busy_lock, x,
 860                     x & (~VPB_BIT_WAITERS)))
 861                         break;
 862         }
 863         wakeup(m);
 864 }
 865
 866 /*
 867  * Keep page from being freed by the page daemon
 868  * much of the same effect as wiring, except much lower
 869  * overhead and should be used only for *very* temporary
 870  * holding ("wiring").
 871  */
 872 void
 873 vm_page_hold(vm_page_t mem)
 874 {
 875
 876         vm_page_lock_assert(mem, MA_OWNED);
 877         mem->hold_count++;
 878 }
 879
 880 void
 881 vm_page_unhold(vm_page_t mem)
 882 {
 883
 884         vm_page_lock_assert(mem, MA_OWNED);
 885         KASSERT(mem->hold_count >= 1, ("vm_page_unhold: hold count < 0!!!"));
 886         --mem->hold_count;
 887         if (mem->hold_count == 0 && (mem->flags & PG_UNHOLDFREE) != 0)
 888                 vm_page_free_toq(mem);
 889 }
 890
 891 /*
 892  *      vm_page_unhold_pages:
 893  *
 894  *      Unhold each of the pages that is referenced by the given array.
 895  */
 896 void
 897 vm_page_unhold_pages(vm_page_t *ma, int count)
 898 {
 899         struct mtx *mtx, *new_mtx;
 900
 901         mtx = NULL;
 902         for (; count != 0; count--) {
 903                 /*
 904                  * Avoid releasing and reacquiring the same page lock.
 905                  */
 906                 new_mtx = vm_page_lockptr(*ma);
 907                 if (mtx != new_mtx) {
 908                         if (mtx != NULL)
 909                                 mtx_unlock(mtx);
 910                         mtx = new_mtx;
 911                         mtx_lock(mtx);
 912                 }
 913                 vm_page_unhold(*ma);
 914                 ma++;
 915         }
 916         if (mtx != NULL)
 917                 mtx_unlock(mtx);
 918 }
 919
 920 vm_page_t
 921 PHYS_TO_VM_PAGE(vm_paddr_t pa)
 922 {
 923         vm_page_t m;
 924
 925 #ifdef VM_PHYSSEG_SPARSE
 926         m = vm_phys_paddr_to_vm_page(pa);
 927         if (m == NULL)
 928                 m = vm_phys_fictitious_to_vm_page(pa);
 929         return (m);
 930 #elif defined(VM_PHYSSEG_DENSE)
 931         long pi;
 932
 933         pi = atop(pa);
 934         if (pi >= first_page && (pi - first_page) < vm_page_array_size) {
 935                 m = &vm_page_array[pi - first_page];
 936                 return (m);
 937         }
 938         return (vm_phys_fictitious_to_vm_page(pa));
 939 #else
 940 #error "Either VM_PHYSSEG_DENSE or VM_PHYSSEG_SPARSE must be defined."
 941 #endif
 942 }
 943
 944 /*
 945  *      vm_page_getfake:
 946  *
 947  *      Create a fictitious page with the specified physical address and
 948  *      memory attribute.  The memory attribute is the only the machine-
 949  *      dependent aspect of a fictitious page that must be initialized.
 950  */
 951 vm_page_t
 952 vm_page_getfake(vm_paddr_t paddr, vm_memattr_t memattr)
 953 {
 954         vm_page_t m;
 955
 956         m = uma_zalloc(fakepg_zone, M_WAITOK | M_ZERO);
 957         vm_page_initfake(m, paddr, memattr);
 958         return (m);
 959 }
 960
 961 void
 962 vm_page_initfake(vm_page_t m, vm_paddr_t paddr, vm_memattr_t memattr)
 963 {
 964
 965         if ((m->flags & PG_FICTITIOUS) != 0) {
 966                 /*
 967                  * The page's memattr might have changed since the
 968                  * previous initialization.  Update the pmap to the
 969                  * new memattr.
 970                  */
 971                 goto memattr;
 972         }
 973         m->phys_addr = paddr;
 974         m->queue = PQ_NONE;
 975         /* Fictitious pages don't use "segind". */
 976         m->flags = PG_FICTITIOUS;
 977         /* Fictitious pages don't use "order" or "pool". */
 978         m->oflags = VPO_UNMANAGED;
 979         m->busy_lock = VPB_SINGLE_EXCLUSIVER;
 980         m->wire_count = 1;
 981         pmap_page_init(m);
 982 memattr:
 983         pmap_page_set_memattr(m, memattr);
 984 }
 985
 986 /*
 987  *      vm_page_putfake:
 988  *
 989  *      Release a fictitious page.
 990  */
 991 void
 992 vm_page_putfake(vm_page_t m)
 993 {
 994
 995         KASSERT((m->oflags & VPO_UNMANAGED) != 0, ("managed %p", m));
 996         KASSERT((m->flags & PG_FICTITIOUS) != 0,
 997             ("vm_page_putfake: bad page %p", m));
 998         uma_zfree(fakepg_zone, m);
 999 }
1000
1001 /*
1002  *      vm_page_updatefake:
1003  *
1004  *      Update the given fictitious page to the specified physical address and
1005  *      memory attribute.
1006  */
1007 void
1008 vm_page_updatefake(vm_page_t m, vm_paddr_t paddr, vm_memattr_t memattr)
1009 {
1010
1011         KASSERT((m->flags & PG_FICTITIOUS) != 0,
1012             ("vm_page_updatefake: bad page %p", m));
1013         m->phys_addr = paddr;
1014         pmap_page_set_memattr(m, memattr);
1015 }
1016
1017 /*
1018  *      vm_page_free:
1019  *
1020  *      Free a page.
1021  */
1022 void
1023 vm_page_free(vm_page_t m)
1024 {
1025
1026         m->flags &= ~PG_ZERO;
1027         vm_page_free_toq(m);
1028 }
1029
1030 /*
1031  *      vm_page_free_zero:
1032  *
1033  *      Free a page to the zerod-pages queue
1034  */
1035 void
1036 vm_page_free_zero(vm_page_t m)
1037 {
1038
1039         m->flags |= PG_ZERO;
1040         vm_page_free_toq(m);
1041 }
1042
1043 /*
1044  * Unbusy and handle the page queueing for a page from a getpages request that
1045  * was optionally read ahead or behind.
1046  */
1047 void
1048 vm_page_readahead_finish(vm_page_t m)
1049 {
1050
1051         /* We shouldn't put invalid pages on queues. */
1052         KASSERT(m->valid != 0, ("%s: %p is invalid", __func__, m));
1053
1054         /*
1055          * Since the page is not the actually needed one, whether it should
1056          * be activated or deactivated is not obvious.  Empirical results
1057          * have shown that deactivating the page is usually the best choice,
1058          * unless the page is wanted by another thread.
1059          */
1060         vm_page_lock(m);
1061         if ((m->busy_lock & VPB_BIT_WAITERS) != 0)
1062                 vm_page_activate(m);
1063         else
1064                 vm_page_deactivate(m);
1065         vm_page_unlock(m);
1066         vm_page_xunbusy(m);
1067 }
1068
1069 /*
1070  *      vm_page_sleep_if_busy:
1071  *
1072  *      Sleep and release the page queues lock if the page is busied.
1073  *      Returns TRUE if the thread slept.
1074  *
1075  *      The given page must be unlocked and object containing it must
1076  *      be locked.
1077  */
1078 int
1079 vm_page_sleep_if_busy(vm_page_t m, const char *msg)
1080 {
1081         vm_object_t obj;
1082
1083         vm_page_lock_assert(m, MA_NOTOWNED);
1084         VM_OBJECT_ASSERT_WLOCKED(m->object);
1085
1086         if (vm_page_busied(m)) {
1087                 /*
1088                  * The page-specific object must be cached because page
1089                  * identity can change during the sleep, causing the
1090                  * re-lock of a different object.
1091                  * It is assumed that a reference to the object is already
1092                  * held by the callers.
1093                  */
1094                 obj = m->object;
1095                 vm_page_lock(m);
1096                 VM_OBJECT_WUNLOCK(obj);
1097                 vm_page_busy_sleep(m, msg, false);
1098                 VM_OBJECT_WLOCK(obj);
1099                 return (TRUE);
1100         }
1101         return (FALSE);
1102 }
1103
1104 /*
1105  *      vm_page_dirty_KBI:              [ internal use only ]
1106  *
1107  *      Set all bits in the page's dirty field.
1108  *
1109  *      The object containing the specified page must be locked if the
1110  *      call is made from the machine-independent layer.
1111  *
1112  *      See vm_page_clear_dirty_mask().
1113  *
1114  *      This function should only be called by vm_page_dirty().
1115  */
1116 void
1117 vm_page_dirty_KBI(vm_page_t m)
1118 {
1119
1120         /* Refer to this operation by its public name. */
1121         KASSERT(m->valid == VM_PAGE_BITS_ALL,
1122             ("vm_page_dirty: page is invalid!"));
1123         m->dirty = VM_PAGE_BITS_ALL;
1124 }
1125
1126 /*
1127  *      vm_page_insert:         [ internal use only ]
1128  *
1129  *      Inserts the given mem entry into the object and object list.
1130  *
1131  *      The object must be locked.
1132  */
1133 int
1134 vm_page_insert(vm_page_t m, vm_object_t object, vm_pindex_t pindex)
1135 {
1136         vm_page_t mpred;
1137
1138         VM_OBJECT_ASSERT_WLOCKED(object);
1139         mpred = vm_radix_lookup_le(&object->rtree, pindex);
1140         return (vm_page_insert_after(m, object, pindex, mpred));
1141 }
1142
1143 /*
1144  *      vm_page_insert_after:
1145  *
1146  *      Inserts the page "m" into the specified object at offset "pindex".
1147  *
1148  *      The page "mpred" must immediately precede the offset "pindex" within
1149  *      the specified object.
1150  *
1151  *      The object must be locked.
1152  */
1153 static int
1154 vm_page_insert_after(vm_page_t m, vm_object_t object, vm_pindex_t pindex,
1155     vm_page_t mpred)
1156 {
1157         vm_page_t msucc;
1158
1159         VM_OBJECT_ASSERT_WLOCKED(object);
1160         KASSERT(m->object == NULL,
1161             ("vm_page_insert_after: page already inserted"));
1162         if (mpred != NULL) {
1163                 KASSERT(mpred->object == object,
1164                     ("vm_page_insert_after: object doesn't contain mpred"));
1165                 KASSERT(mpred->pindex < pindex,
1166                     ("vm_page_insert_after: mpred doesn't precede pindex"));
1167                 msucc = TAILQ_NEXT(mpred, listq);
1168         } else
1169                 msucc = TAILQ_FIRST(&object->memq);
1170         if (msucc != NULL)
1171                 KASSERT(msucc->pindex > pindex,
1172                     ("vm_page_insert_after: msucc doesn't succeed pindex"));
1173
1174         /*
1175          * Record the object/offset pair in this page
1176          */
1177         m->object = object;
1178         m->pindex = pindex;
1179
1180         /*
1181          * Now link into the object's ordered list of backed pages.
1182          */
1183         if (vm_radix_insert(&object->rtree, m)) {
1184                 m->object = NULL;
1185                 m->pindex = 0;
1186                 return (1);
1187         }
1188         vm_page_insert_radixdone(m, object, mpred);
1189         return (0);
1190 }
1191
1192 /*
1193  *      vm_page_insert_radixdone:
1194  *
1195  *      Complete page "m" insertion into the specified object after the
1196  *      radix trie hooking.
1197  *
1198  *      The page "mpred" must precede the offset "m->pindex" within the
1199  *      specified object.
1200  *
1201  *      The object must be locked.
1202  */
1203 static void
1204 vm_page_insert_radixdone(vm_page_t m, vm_object_t object, vm_page_t mpred)
1205 {
1206
1207         VM_OBJECT_ASSERT_WLOCKED(object);
1208         KASSERT(object != NULL && m->object == object,
1209             ("vm_page_insert_radixdone: page %p has inconsistent object", m));
1210         if (mpred != NULL) {
1211                 KASSERT(mpred->object == object,
1212                     ("vm_page_insert_after: object doesn't contain mpred"));
1213                 KASSERT(mpred->pindex < m->pindex,
1214                     ("vm_page_insert_after: mpred doesn't precede pindex"));
1215         }
1216
1217         if (mpred != NULL)
1218                 TAILQ_INSERT_AFTER(&object->memq, mpred, m, listq);
1219         else
1220                 TAILQ_INSERT_HEAD(&object->memq, m, listq);
1221
1222         /*
1223          * Show that the object has one more resident page.
1224          */
1225         object->resident_page_count++;
1226
1227         /*
1228          * Hold the vnode until the last page is released.
1229          */
1230         if (object->resident_page_count == 1 && object->type == OBJT_VNODE)
1231                 vhold(object->handle);
1232
1233         /*
1234          * Since we are inserting a new and possibly dirty page,
1235          * update the object's OBJ_MIGHTBEDIRTY flag.
1236          */
1237         if (pmap_page_is_write_mapped(m))
1238                 vm_object_set_writeable_dirty(object);
1239 }
1240
1241 /*
1242  *      vm_page_remove:
1243  *
1244  *      Removes the given mem entry from the object/offset-page
1245  *      table and the object page list, but do not invalidate/terminate
1246  *      the backing store.
1247  *
1248  *      The object must be locked.  The page must be locked if it is managed.
1249  */
1250 void
1251 vm_page_remove(vm_page_t m)
1252 {
1253         vm_object_t object;
1254
1255         if ((m->oflags & VPO_UNMANAGED) == 0)
1256                 vm_page_assert_locked(m);
1257         if ((object = m->object) == NULL)
1258                 return;
1259         VM_OBJECT_ASSERT_WLOCKED(object);
1260         if (vm_page_xbusied(m))
1261                 vm_page_xunbusy_maybelocked(m);
1262
1263         /*
1264          * Now remove from the object's list of backed pages.
1265          */
1266         vm_radix_remove(&object->rtree, m->pindex);
1267         TAILQ_REMOVE(&object->memq, m, listq);
1268
1269         /*
1270          * And show that the object has one fewer resident page.
1271          */
1272         object->resident_page_count--;
1273
1274         /*
1275          * The vnode may now be recycled.
1276          */
1277         if (object->resident_page_count == 0 && object->type == OBJT_VNODE)
1278                 vdrop(object->handle);
1279
1280         m->object = NULL;
1281 }
1282
1283 /*
1284  *      vm_page_lookup:
1285  *
1286  *      Returns the page associated with the object/offset
1287  *      pair specified; if none is found, NULL is returned.
1288  *
1289  *      The object must be locked.
1290  */
1291 vm_page_t
1292 vm_page_lookup(vm_object_t object, vm_pindex_t pindex)
1293 {
1294
1295         VM_OBJECT_ASSERT_LOCKED(object);
1296         return (vm_radix_lookup(&object->rtree, pindex));
1297 }
1298
1299 /*
1300  *      vm_page_find_least:
1301  *
1302  *      Returns the page associated with the object with least pindex
1303  *      greater than or equal to the parameter pindex, or NULL.
1304  *
1305  *      The object must be locked.
1306  */
1307 vm_page_t
1308 vm_page_find_least(vm_object_t object, vm_pindex_t pindex)
1309 {
1310         vm_page_t m;
1311
1312         VM_OBJECT_ASSERT_LOCKED(object);
1313         if ((m = TAILQ_FIRST(&object->memq)) != NULL && m->pindex < pindex)
1314                 m = vm_radix_lookup_ge(&object->rtree, pindex);
1315         return (m);
1316 }
1317
1318 /*
1319  * Returns the given page's successor (by pindex) within the object if it is
1320  * resident; if none is found, NULL is returned.
1321  *
1322  * The object must be locked.
1323  */
1324 vm_page_t
1325 vm_page_next(vm_page_t m)
1326 {
1327         vm_page_t next;
1328
1329         VM_OBJECT_ASSERT_LOCKED(m->object);
1330         if ((next = TAILQ_NEXT(m, listq)) != NULL &&
1331             next->pindex != m->pindex + 1)
1332                 next = NULL;
1333         return (next);
1334 }
1335
1336 /*
1337  * Returns the given page's predecessor (by pindex) within the object if it is
1338  * resident; if none is found, NULL is returned.
1339  *
1340  * The object must be locked.
1341  */
1342 vm_page_t
1343 vm_page_prev(vm_page_t m)
1344 {
1345         vm_page_t prev;
1346
1347         VM_OBJECT_ASSERT_LOCKED(m->object);
1348         if ((prev = TAILQ_PREV(m, pglist, listq)) != NULL &&
1349             prev->pindex != m->pindex - 1)
1350                 prev = NULL;
1351         return (prev);
1352 }
1353
1354 /*
1355  * Uses the page mnew as a replacement for an existing page at index
1356  * pindex which must be already present in the object.
1357  *
1358  * The existing page must not be on a paging queue.
1359  */
1360 vm_page_t
1361 vm_page_replace(vm_page_t mnew, vm_object_t object, vm_pindex_t pindex)
1362 {
1363         vm_page_t mold;
1364
1365         VM_OBJECT_ASSERT_WLOCKED(object);
1366         KASSERT(mnew->object == NULL,
1367             ("vm_page_replace: page already in object"));
1368
1369         /*
1370          * This function mostly follows vm_page_insert() and
1371          * vm_page_remove() without the radix, object count and vnode
1372          * dance.  Double check such functions for more comments.
1373          */
1374
1375         mnew->object = object;
1376         mnew->pindex = pindex;
1377         mold = vm_radix_replace(&object->rtree, mnew);
1378         KASSERT(mold->queue == PQ_NONE,
1379             ("vm_page_replace: mold is on a paging queue"));
1380
1381         /* Keep the resident page list in sorted order. */
1382         TAILQ_INSERT_AFTER(&object->memq, mold, mnew, listq);
1383         TAILQ_REMOVE(&object->memq, mold, listq);
1384
1385         mold->object = NULL;
1386         vm_page_xunbusy_maybelocked(mold);
1387
1388         /*
1389          * The object's resident_page_count does not change because we have
1390          * swapped one page for another, but OBJ_MIGHTBEDIRTY.
1391          */
1392         if (pmap_page_is_write_mapped(mnew))
1393                 vm_object_set_writeable_dirty(object);
1394         return (mold);
1395 }
1396
1397 /*
1398  *      vm_page_rename:
1399  *
1400  *      Move the given memory entry from its
1401  *      current object to the specified target object/offset.
1402  *
1403  *      Note: swap associated with the page must be invalidated by the move.  We
1404  *            have to do this for several reasons:  (1) we aren't freeing the
1405  *            page, (2) we are dirtying the page, (3) the VM system is probably
1406  *            moving the page from object A to B, and will then later move
1407  *            the backing store from A to B and we can't have a conflict.
1408  *
1409  *      Note: we *always* dirty the page.  It is necessary both for the
1410  *            fact that we moved it, and because we may be invalidating
1411  *            swap.  If the page is on the cache, we have to deactivate it
1412  *            or vm_page_dirty() will panic.  Dirty pages are not allowed
1413  *            on the cache.
1414  *
1415  *      The objects must be locked.
1416  */
1417 int
1418 vm_page_rename(vm_page_t m, vm_object_t new_object, vm_pindex_t new_pindex)
1419 {
1420         vm_page_t mpred;
1421         vm_pindex_t opidx;
1422
1423         VM_OBJECT_ASSERT_WLOCKED(new_object);
1424
1425         mpred = vm_radix_lookup_le(&new_object->rtree, new_pindex);
1426         KASSERT(mpred == NULL || mpred->pindex != new_pindex,
1427             ("vm_page_rename: pindex already renamed"));
1428
1429         /*
1430          * Create a custom version of vm_page_insert() which does not depend
1431          * by m_prev and can cheat on the implementation aspects of the
1432          * function.
1433          */
1434         opidx = m->pindex;
1435         m->pindex = new_pindex;
1436         if (vm_radix_insert(&new_object->rtree, m)) {
1437                 m->pindex = opidx;
1438                 return (1);
1439         }
1440
1441         /*
1442          * The operation cannot fail anymore.  The removal must happen before
1443          * the listq iterator is tainted.
1444          */
1445         m->pindex = opidx;
1446         vm_page_lock(m);
1447         vm_page_remove(m);
1448
1449         /* Return back to the new pindex to complete vm_page_insert(). */
1450         m->pindex = new_pindex;
1451         m->object = new_object;
1452         vm_page_unlock(m);
1453         vm_page_insert_radixdone(m, new_object, mpred);
1454         vm_page_dirty(m);
1455         return (0);
1456 }
1457
1458 /*
1459  *      vm_page_alloc:
1460  *
1461  *      Allocate and return a page that is associated with the specified
1462  *      object and offset pair.  By default, this page is exclusive busied.
1463  *
1464  *      The caller must always specify an allocation class.
1465  *
1466  *      allocation classes:
1467  *      VM_ALLOC_NORMAL         normal process request
1468  *      VM_ALLOC_SYSTEM         system *really* needs a page
1469  *      VM_ALLOC_INTERRUPT      interrupt time request
1470  *
1471  *      optional allocation flags:
1472  *      VM_ALLOC_COUNT(number)  the number of additional pages that the caller
1473  *                              intends to allocate
1474  *      VM_ALLOC_NOBUSY         do not exclusive busy the page
1475  *      VM_ALLOC_NODUMP         do not include the page in a kernel core dump
1476  *      VM_ALLOC_NOOBJ          page is not associated with an object and
1477  *                              should not be exclusive busy
1478  *      VM_ALLOC_SBUSY          shared busy the allocated page
1479  *      VM_ALLOC_WIRED          wire the allocated page
1480  *      VM_ALLOC_ZERO           prefer a zeroed page
1481  *
1482  *      This routine may not sleep.
1483  */
1484 vm_page_t
1485 vm_page_alloc(vm_object_t object, vm_pindex_t pindex, int req)
1486 {
1487         vm_page_t m, mpred;
1488         int flags, req_class;
1489
1490         mpred = 0;      /* XXX: pacify gcc */
1491         KASSERT((object != NULL) == ((req & VM_ALLOC_NOOBJ) == 0) &&
1492             (object != NULL || (req & VM_ALLOC_SBUSY) == 0) &&
1493             ((req & (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)) !=
1494             (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)),
1495             ("vm_page_alloc: inconsistent object(%p)/req(%x)", (void *)object,
1496             req));
1497         if (object != NULL)
1498                 VM_OBJECT_ASSERT_WLOCKED(object);
1499
1500         req_class = req & VM_ALLOC_CLASS_MASK;
1501
1502         /*
1503          * The page daemon is allowed to dig deeper into the free page list.
1504          */
1505         if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
1506                 req_class = VM_ALLOC_SYSTEM;
1507
1508         if (object != NULL) {
1509                 mpred = vm_radix_lookup_le(&object->rtree, pindex);
1510                 KASSERT(mpred == NULL || mpred->pindex != pindex,
1511                    ("vm_page_alloc: pindex already allocated"));
1512         }
1513
1514         /*
1515          * The page allocation request can came from consumers which already
1516          * hold the free page queue mutex, like vm_page_insert() in
1517          * vm_page_cache().
1518          */
1519         mtx_lock_flags(&vm_page_queue_free_mtx, MTX_RECURSE);
1520         if (vm_cnt.v_free_count + vm_cnt.v_cache_count > vm_cnt.v_free_reserved ||
1521             (req_class == VM_ALLOC_SYSTEM &&
1522             vm_cnt.v_free_count + vm_cnt.v_cache_count > vm_cnt.v_interrupt_free_min) ||
1523             (req_class == VM_ALLOC_INTERRUPT &&
1524             vm_cnt.v_free_count + vm_cnt.v_cache_count > 0)) {
1525                 /*
1526                  * Allocate from the free queue if the number of free pages
1527                  * exceeds the minimum for the request class.
1528                  */
1529 #if VM_NRESERVLEVEL > 0
1530                 if (object == NULL || (object->flags & (OBJ_COLORED |
1531                     OBJ_FICTITIOUS)) != OBJ_COLORED || (m =
1532                     vm_reserv_alloc_page(object, pindex, mpred)) == NULL)
1533 #endif
1534                 {
1535                         m = vm_phys_alloc_pages(object != NULL ?
1536                             VM_FREEPOOL_DEFAULT : VM_FREEPOOL_DIRECT, 0);
1537 #if VM_NRESERVLEVEL > 0
1538                         if (m == NULL && vm_reserv_reclaim_inactive()) {
1539                                 m = vm_phys_alloc_pages(object != NULL ?
1540                                     VM_FREEPOOL_DEFAULT : VM_FREEPOOL_DIRECT,
1541                                     0);
1542                         }
1543 #endif
1544                 }
1545         } else {
1546                 /*
1547                  * Not allocatable, give up.
1548                  */
1549                 mtx_unlock(&vm_page_queue_free_mtx);
1550                 atomic_add_int(&vm_pageout_deficit,
1551                     max((u_int)req >> VM_ALLOC_COUNT_SHIFT, 1));
1552                 pagedaemon_wakeup();
1553                 return (NULL);
1554         }
1555
1556         /*
1557          *  At this point we had better have found a good page.
1558          */
1559         KASSERT(m != NULL, ("vm_page_alloc: missing page"));
1560         vm_phys_freecnt_adj(m, -1);
1561         mtx_unlock(&vm_page_queue_free_mtx);
1562         vm_page_alloc_check(m);
1563
1564         /*
1565          * Initialize the page.  Only the PG_ZERO flag is inherited.
1566          */
1567         flags = 0;
1568         if ((req & VM_ALLOC_ZERO) != 0)
1569                 flags = PG_ZERO;
1570         flags &= m->flags;
1571         if ((req & VM_ALLOC_NODUMP) != 0)
1572                 flags |= PG_NODUMP;
1573         m->flags = flags;
1574         m->aflags = 0;
1575         m->oflags = object == NULL || (object->flags & OBJ_UNMANAGED) != 0 ?
1576             VPO_UNMANAGED : 0;
1577         m->busy_lock = VPB_UNBUSIED;
1578         if ((req & (VM_ALLOC_NOBUSY | VM_ALLOC_NOOBJ | VM_ALLOC_SBUSY)) == 0)
1579                 m->busy_lock = VPB_SINGLE_EXCLUSIVER;
1580         if ((req & VM_ALLOC_SBUSY) != 0)
1581                 m->busy_lock = VPB_SHARERS_WORD(1);
1582         if (req & VM_ALLOC_WIRED) {
1583                 /*
1584                  * The page lock is not required for wiring a page until that
1585                  * page is inserted into the object.
1586                  */
1587                 atomic_add_int(&vm_cnt.v_wire_count, 1);
1588                 m->wire_count = 1;
1589         }
1590         m->act_count = 0;
1591
1592         if (object != NULL) {
1593                 if (vm_page_insert_after(m, object, pindex, mpred)) {
1594                         pagedaemon_wakeup();
1595                         if (req & VM_ALLOC_WIRED) {
1596                                 atomic_subtract_int(&vm_cnt.v_wire_count, 1);
1597                                 m->wire_count = 0;
1598                         }
1599                         m->object = NULL;
1600                         m->oflags = VPO_UNMANAGED;
1601                         m->busy_lock = VPB_UNBUSIED;
1602                         vm_page_free(m);
1603                         return (NULL);
1604                 }
1605
1606                 /* Ignore device objects; the pager sets "memattr" for them. */
1607                 if (object->memattr != VM_MEMATTR_DEFAULT &&
1608                     (object->flags & OBJ_FICTITIOUS) == 0)
1609                         pmap_page_set_memattr(m, object->memattr);
1610         } else
1611                 m->pindex = pindex;
1612
1613         /*
1614          * Don't wakeup too often - wakeup the pageout daemon when
1615          * we would be nearly out of memory.
1616          */
1617         if (vm_paging_needed())
1618                 pagedaemon_wakeup();
1619
1620         return (m);
1621 }
1622
1623 /*
1624  *      vm_page_alloc_contig:
1625  *
1626  *      Allocate a contiguous set of physical pages of the given size "npages"
1627  *      from the free lists.  All of the physical pages must be at or above
1628  *      the given physical address "low" and below the given physical address
1629  *      "high".  The given value "alignment" determines the alignment of the
1630  *      first physical page in the set.  If the given value "boundary" is
1631  *      non-zero, then the set of physical pages cannot cross any physical
1632  *      address boundary that is a multiple of that value.  Both "alignment"
1633  *      and "boundary" must be a power of two.
1634  *
1635  *      If the specified memory attribute, "memattr", is VM_MEMATTR_DEFAULT,
1636  *      then the memory attribute setting for the physical pages is configured
1637  *      to the object's memory attribute setting.  Otherwise, the memory
1638  *      attribute setting for the physical pages is configured to "memattr",
1639  *      overriding the object's memory attribute setting.  However, if the
1640  *      object's memory attribute setting is not VM_MEMATTR_DEFAULT, then the
1641  *      memory attribute setting for the physical pages cannot be configured
1642  *      to VM_MEMATTR_DEFAULT.
1643  *
1644  *      The caller must always specify an allocation class.
1645  *
1646  *      allocation classes:
1647  *      VM_ALLOC_NORMAL         normal process request
1648  *      VM_ALLOC_SYSTEM         system *really* needs a page
1649  *      VM_ALLOC_INTERRUPT      interrupt time request
1650  *
1651  *      optional allocation flags:
1652  *      VM_ALLOC_NOBUSY         do not exclusive busy the page
1653  *      VM_ALLOC_NODUMP         do not include the page in a kernel core dump
1654  *      VM_ALLOC_NOOBJ          page is not associated with an object and
1655  *                              should not be exclusive busy
1656  *      VM_ALLOC_SBUSY          shared busy the allocated page
1657  *      VM_ALLOC_WIRED          wire the allocated page
1658  *      VM_ALLOC_ZERO           prefer a zeroed page
1659  *
1660  *      This routine may not sleep.
1661  */
1662 vm_page_t
1663 vm_page_alloc_contig(vm_object_t object, vm_pindex_t pindex, int req,
1664     u_long npages, vm_paddr_t low, vm_paddr_t high, u_long alignment,
1665     vm_paddr_t boundary, vm_memattr_t memattr)
1666 {
1667         vm_page_t m, m_tmp, m_ret;
1668         u_int flags;
1669         int req_class;
1670
1671         KASSERT((object != NULL) == ((req & VM_ALLOC_NOOBJ) == 0) &&
1672             (object != NULL || (req & VM_ALLOC_SBUSY) == 0) &&
1673             ((req & (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)) !=
1674             (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)),
1675             ("vm_page_alloc: inconsistent object(%p)/req(%x)", (void *)object,
1676             req));
1677         if (object != NULL) {
1678                 VM_OBJECT_ASSERT_WLOCKED(object);
1679                 KASSERT(object->type == OBJT_PHYS,
1680                     ("vm_page_alloc_contig: object %p isn't OBJT_PHYS",
1681                     object));
1682         }
1683         KASSERT(npages > 0, ("vm_page_alloc_contig: npages is zero"));
1684         req_class = req & VM_ALLOC_CLASS_MASK;
1685
1686         /*
1687          * The page daemon is allowed to dig deeper into the free page list.
1688          */
1689         if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
1690                 req_class = VM_ALLOC_SYSTEM;
1691
1692         mtx_lock(&vm_page_queue_free_mtx);
1693         if (vm_cnt.v_free_count + vm_cnt.v_cache_count >= npages +
1694             vm_cnt.v_free_reserved || (req_class == VM_ALLOC_SYSTEM &&
1695             vm_cnt.v_free_count + vm_cnt.v_cache_count >= npages +
1696             vm_cnt.v_interrupt_free_min) || (req_class == VM_ALLOC_INTERRUPT &&
1697             vm_cnt.v_free_count + vm_cnt.v_cache_count >= npages)) {
1698 #if VM_NRESERVLEVEL > 0
1699 retry:
1700                 if (object == NULL || (object->flags & OBJ_COLORED) == 0 ||
1701                     (m_ret = vm_reserv_alloc_contig(object, pindex, npages,
1702                     low, high, alignment, boundary)) == NULL)
1703 #endif
1704                         m_ret = vm_phys_alloc_contig(npages, low, high,
1705                             alignment, boundary);
1706         } else {
1707                 mtx_unlock(&vm_page_queue_free_mtx);
1708                 atomic_add_int(&vm_pageout_deficit, npages);
1709                 pagedaemon_wakeup();
1710                 return (NULL);
1711         }
1712         if (m_ret != NULL)
1713                 vm_phys_freecnt_adj(m_ret, -npages);
1714         else {
1715 #if VM_NRESERVLEVEL > 0
1716                 if (vm_reserv_reclaim_contig(npages, low, high, alignment,
1717                     boundary))
1718                         goto retry;
1719 #endif
1720         }
1721         mtx_unlock(&vm_page_queue_free_mtx);
1722         if (m_ret == NULL)
1723                 return (NULL);
1724         for (m = m_ret; m < &m_ret[npages]; m++)
1725                 vm_page_alloc_check(m);
1726
1727         /*
1728          * Initialize the pages.  Only the PG_ZERO flag is inherited.
1729          */
1730         flags = 0;
1731         if ((req & VM_ALLOC_ZERO) != 0)
1732                 flags = PG_ZERO;
1733         if ((req & VM_ALLOC_NODUMP) != 0)
1734                 flags |= PG_NODUMP;
1735         if ((req & VM_ALLOC_WIRED) != 0)
1736                 atomic_add_int(&vm_cnt.v_wire_count, npages);
1737         if (object != NULL) {
1738                 if (object->memattr != VM_MEMATTR_DEFAULT &&
1739                     memattr == VM_MEMATTR_DEFAULT)
1740                         memattr = object->memattr;
1741         }
1742         for (m = m_ret; m < &m_ret[npages]; m++) {
1743                 m->aflags = 0;
1744                 m->flags = (m->flags | PG_NODUMP) & flags;
1745                 m->busy_lock = VPB_UNBUSIED;
1746                 if (object != NULL) {
1747                         if ((req & (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)) == 0)
1748                                 m->busy_lock = VPB_SINGLE_EXCLUSIVER;
1749                         if ((req & VM_ALLOC_SBUSY) != 0)
1750                                 m->busy_lock = VPB_SHARERS_WORD(1);
1751                 }
1752                 if ((req & VM_ALLOC_WIRED) != 0)
1753                         m->wire_count = 1;
1754                 /* Unmanaged pages don't use "act_count". */
1755                 m->oflags = VPO_UNMANAGED;
1756                 if (object != NULL) {
1757                         if (vm_page_insert(m, object, pindex)) {
1758                                 if (vm_paging_needed())
1759                                         pagedaemon_wakeup();
1760                                 if ((req & VM_ALLOC_WIRED) != 0)
1761                                         atomic_subtract_int(&vm_cnt.v_wire_count,
1762                                             npages);
1763                                 for (m_tmp = m, m = m_ret;
1764                                     m < &m_ret[npages]; m++) {
1765                                         if ((req & VM_ALLOC_WIRED) != 0)
1766                                                 m->wire_count = 0;
1767                                         if (m >= m_tmp) {
1768                                                 m->object = NULL;
1769                                                 m->oflags |= VPO_UNMANAGED;
1770                                         }
1771                                         m->busy_lock = VPB_UNBUSIED;
1772                                         vm_page_free(m);
1773                                 }
1774                                 return (NULL);
1775                         }
1776                 } else
1777                         m->pindex = pindex;
1778                 if (memattr != VM_MEMATTR_DEFAULT)
1779                         pmap_page_set_memattr(m, memattr);
1780                 pindex++;
1781         }
1782         if (vm_paging_needed())
1783                 pagedaemon_wakeup();
1784         return (m_ret);
1785 }
1786
1787 /*
1788  * Check a page that has been freshly dequeued from a freelist.
1789  */
1790 static void
1791 vm_page_alloc_check(vm_page_t m)
1792 {
1793
1794         KASSERT(m->queue == PQ_NONE,
1795             ("page %p has unexpected queue %d", m, m->queue));
1796         KASSERT(m->wire_count == 0, ("page %p is wired", m));
1797         KASSERT(m->hold_count == 0, ("page %p is held", m));
1798         KASSERT(!vm_page_busied(m), ("page %p is busy", m));
1799         KASSERT(m->dirty == 0, ("page %p is dirty", m));
1800         KASSERT(pmap_page_get_memattr(m) == VM_MEMATTR_DEFAULT,
1801             ("page %p has unexpected memattr %d",
1802             m, pmap_page_get_memattr(m)));
1803         KASSERT(m->valid == 0, ("free page %p is valid", m));
1804 }
1805
1806 /*
1807  *      vm_page_alloc_freelist:
1808  *
1809  *      Allocate a physical page from the specified free page list.
1810  *
1811  *      The caller must always specify an allocation class.
1812  *
1813  *      allocation classes:
1814  *      VM_ALLOC_NORMAL         normal process request
1815  *      VM_ALLOC_SYSTEM         system *really* needs a page
1816  *      VM_ALLOC_INTERRUPT      interrupt time request
1817  *
1818  *      optional allocation flags:
1819  *      VM_ALLOC_COUNT(number)  the number of additional pages that the caller
1820  *                              intends to allocate
1821  *      VM_ALLOC_WIRED          wire the allocated page
1822  *      VM_ALLOC_ZERO           prefer a zeroed page
1823  *
1824  *      This routine may not sleep.
1825  */
1826 vm_page_t
1827 vm_page_alloc_freelist(int flind, int req)
1828 {
1829         vm_page_t m;
1830         u_int flags;
1831         int req_class;
1832
1833         req_class = req & VM_ALLOC_CLASS_MASK;
1834
1835         /*
1836          * The page daemon is allowed to dig deeper into the free page list.
1837          */
1838         if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
1839                 req_class = VM_ALLOC_SYSTEM;
1840
1841         /*
1842          * Do not allocate reserved pages unless the req has asked for it.
1843          */
1844         mtx_lock_flags(&vm_page_queue_free_mtx, MTX_RECURSE);
1845         if (vm_cnt.v_free_count + vm_cnt.v_cache_count > vm_cnt.v_free_reserved ||
1846             (req_class == VM_ALLOC_SYSTEM &&
1847             vm_cnt.v_free_count + vm_cnt.v_cache_count > vm_cnt.v_interrupt_free_min) ||
1848             (req_class == VM_ALLOC_INTERRUPT &&
1849             vm_cnt.v_free_count + vm_cnt.v_cache_count > 0))
1850                 m = vm_phys_alloc_freelist_pages(flind, VM_FREEPOOL_DIRECT, 0);
1851         else {
1852                 mtx_unlock(&vm_page_queue_free_mtx);
1853                 atomic_add_int(&vm_pageout_deficit,
1854                     max((u_int)req >> VM_ALLOC_COUNT_SHIFT, 1));
1855                 pagedaemon_wakeup();
1856                 return (NULL);
1857         }
1858         if (m == NULL) {
1859                 mtx_unlock(&vm_page_queue_free_mtx);
1860                 return (NULL);
1861         }
1862         vm_phys_freecnt_adj(m, -1);
1863         mtx_unlock(&vm_page_queue_free_mtx);
1864         vm_page_alloc_check(m);
1865
1866         /*
1867          * Initialize the page.  Only the PG_ZERO flag is inherited.
1868          */
1869         m->aflags = 0;
1870         flags = 0;
1871         if ((req & VM_ALLOC_ZERO) != 0)
1872                 flags = PG_ZERO;
1873         m->flags &= flags;
1874         if ((req & VM_ALLOC_WIRED) != 0) {
1875                 /*
1876                  * The page lock is not required for wiring a page that does
1877                  * not belong to an object.
1878                  */
1879                 atomic_add_int(&vm_cnt.v_wire_count, 1);
1880                 m->wire_count = 1;
1881         }
1882         /* Unmanaged pages don't use "act_count". */
1883         m->oflags = VPO_UNMANAGED;
1884         if (vm_paging_needed())
1885                 pagedaemon_wakeup();
1886         return (m);
1887 }
1888
1889 #define VPSC_ANY        0       /* No restrictions. */
1890 #define VPSC_NORESERV   1       /* Skip reservations; implies VPSC_NOSUPER. */
1891 #define VPSC_NOSUPER    2       /* Skip superpages. */
1892
1893 /*
1894  *      vm_page_scan_contig:
1895  *
1896  *      Scan vm_page_array[] between the specified entries "m_start" and
1897  *      "m_end" for a run of contiguous physical pages that satisfy the
1898  *      specified conditions, and return the lowest page in the run.  The
1899  *      specified "alignment" determines the alignment of the lowest physical
1900  *      page in the run.  If the specified "boundary" is non-zero, then the
1901  *      run of physical pages cannot span a physical address that is a
1902  *      multiple of "boundary".
1903  *
1904  *      "m_end" is never dereferenced, so it need not point to a vm_page
1905  *      structure within vm_page_array[].
1906  *
1907  *      "npages" must be greater than zero.  "m_start" and "m_end" must not
1908  *      span a hole (or discontiguity) in the physical address space.  Both
1909  *      "alignment" and "boundary" must be a power of two.
1910  */
1911 vm_page_t
1912 vm_page_scan_contig(u_long npages, vm_page_t m_start, vm_page_t m_end,
1913     u_long alignment, vm_paddr_t boundary, int options)
1914 {
1915         struct mtx *m_mtx, *new_mtx;
1916         vm_object_t object;
1917         vm_paddr_t pa;
1918         vm_page_t m, m_run;
1919 #if VM_NRESERVLEVEL > 0
1920         int level;
1921 #endif
1922         int m_inc, order, run_ext, run_len;
1923
1924         KASSERT(npages > 0, ("npages is 0"));
1925         KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
1926         KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
1927         m_run = NULL;
1928         run_len = 0;
1929         m_mtx = NULL;
1930         for (m = m_start; m < m_end && run_len < npages; m += m_inc) {
1931                 KASSERT((m->flags & (PG_FICTITIOUS | PG_MARKER)) == 0,
1932                     ("page %p is PG_FICTITIOUS or PG_MARKER", m));
1933
1934                 /*
1935                  * If the current page would be the start of a run, check its
1936                  * physical address against the end, alignment, and boundary
1937                  * conditions.  If it doesn't satisfy these conditions, either
1938                  * terminate the scan or advance to the next page that
1939                  * satisfies the failed condition.
1940                  */
1941                 if (run_len == 0) {
1942                         KASSERT(m_run == NULL, ("m_run != NULL"));
1943                         if (m + npages > m_end)
1944                                 break;
1945                         pa = VM_PAGE_TO_PHYS(m);
1946                         if ((pa & (alignment - 1)) != 0) {
1947                                 m_inc = atop(roundup2(pa, alignment) - pa);
1948                                 continue;
1949                         }
1950                         if (rounddown2(pa ^ (pa + ptoa(npages) - 1),
1951                             boundary) != 0) {
1952                                 m_inc = atop(roundup2(pa, boundary) - pa);
1953                                 continue;
1954                         }
1955                 } else
1956                         KASSERT(m_run != NULL, ("m_run == NULL"));
1957
1958                 /*
1959                  * Avoid releasing and reacquiring the same page lock.
1960                  */
1961                 new_mtx = vm_page_lockptr(m);
1962                 if (m_mtx != new_mtx) {
1963                         if (m_mtx != NULL)
1964                                 mtx_unlock(m_mtx);
1965                         m_mtx = new_mtx;
1966                         mtx_lock(m_mtx);
1967                 }
1968                 m_inc = 1;
1969 retry:
1970                 if (m->wire_count != 0 || m->hold_count != 0)
1971                         run_ext = 0;
1972 #if VM_NRESERVLEVEL > 0
1973                 else if ((level = vm_reserv_level(m)) >= 0 &&
1974                     (options & VPSC_NORESERV) != 0) {
1975                         run_ext = 0;
1976                         /* Advance to the end of the reservation. */
1977                         pa = VM_PAGE_TO_PHYS(m);
1978                         m_inc = atop(roundup2(pa + 1, vm_reserv_size(level)) -
1979                             pa);
1980                 }
1981 #endif
1982                 else if ((object = m->object) != NULL) {
1983                         /*
1984                          * The page is considered eligible for relocation if
1985                          * and only if it could be laundered or reclaimed by
1986                          * the page daemon.
1987                          */
1988                         if (!VM_OBJECT_TRYRLOCK(object)) {
1989                                 mtx_unlock(m_mtx);
1990                                 VM_OBJECT_RLOCK(object);
1991                                 mtx_lock(m_mtx);
1992                                 if (m->object != object) {
1993                                         /*
1994                                          * The page may have been freed.
1995                                          */
1996                                         VM_OBJECT_RUNLOCK(object);
1997                                         goto retry;
1998                                 } else if (m->wire_count != 0 ||
1999                                     m->hold_count != 0) {
2000                                         run_ext = 0;
2001                                         goto unlock;
2002                                 }
2003                         }
2004                         KASSERT((m->flags & PG_UNHOLDFREE) == 0,
2005                             ("page %p is PG_UNHOLDFREE", m));
2006                         /* Don't care: PG_NODUMP, PG_ZERO. */
2007                         if (object->type != OBJT_DEFAULT &&
2008                             object->type != OBJT_SWAP &&
2009                             object->type != OBJT_VNODE) {
2010                                 run_ext = 0;
2011 #if VM_NRESERVLEVEL > 0
2012                         } else if ((options & VPSC_NOSUPER) != 0 &&
2013                             (level = vm_reserv_level_iffullpop(m)) >= 0) {
2014                                 run_ext = 0;
2015                                 /* Advance to the end of the superpage. */
2016                                 pa = VM_PAGE_TO_PHYS(m);
2017                                 m_inc = atop(roundup2(pa + 1,
2018                                     vm_reserv_size(level)) - pa);
2019 #endif
2020                         } else if (object->memattr == VM_MEMATTR_DEFAULT &&
2021                             m->queue != PQ_NONE && !vm_page_busied(m)) {
2022                                 /*
2023                                  * The page is allocated but eligible for
2024                                  * relocation.  Extend the current run by one
2025                                  * page.
2026                                  */
2027                                 KASSERT(pmap_page_get_memattr(m) ==
2028                                     VM_MEMATTR_DEFAULT,
2029                                     ("page %p has an unexpected memattr", m));
2030                                 KASSERT((m->oflags & (VPO_SWAPINPROG |
2031                                     VPO_SWAPSLEEP | VPO_UNMANAGED)) == 0,
2032                                     ("page %p has unexpected oflags", m));
2033                                 /* Don't care: VPO_NOSYNC. */
2034                                 run_ext = 1;
2035                         } else
2036                                 run_ext = 0;
2037 unlock:
2038                         VM_OBJECT_RUNLOCK(object);
2039 #if VM_NRESERVLEVEL > 0
2040                 } else if (level >= 0) {
2041                         /*
2042                          * The page is reserved but not yet allocated.  In
2043                          * other words, it is still cached or free.  Extend
2044                          * the current run by one page.
2045                          */
2046                         run_ext = 1;
2047 #endif
2048                 } else if ((order = m->order) < VM_NFREEORDER) {
2049                         /*
2050                          * The page is enqueued in the physical memory
2051                          * allocator's cache/free page queues.  Moreover, it
2052                          * is the first page in a power-of-two-sized run of
2053                          * contiguous cache/free pages.  Add these pages to
2054                          * the end of the current run, and jump ahead.
2055                          */
2056                         run_ext = 1 << order;
2057                         m_inc = 1 << order;
2058                 } else {
2059                         /*
2060                          * Skip the page for one of the following reasons: (1)
2061                          * It is enqueued in the physical memory allocator's
2062                          * cache/free page queues.  However, it is not the
2063                          * first page in a run of contiguous cache/free pages.
2064                          * (This case rarely occurs because the scan is
2065                          * performed in ascending order.) (2) It is not
2066                          * reserved, and it is transitioning from free to
2067                          * allocated.  (Conversely, the transition from
2068                          * allocated to free for managed pages is blocked by
2069                          * the page lock.) (3) It is allocated but not
2070                          * contained by an object and not wired, e.g.,
2071                          * allocated by Xen's balloon driver.
2072                          */
2073                         run_ext = 0;
2074                 }
2075
2076                 /*
2077                  * Extend or reset the current run of pages.
2078                  */
2079                 if (run_ext > 0) {
2080                         if (run_len == 0)
2081                                 m_run = m;
2082                         run_len += run_ext;
2083                 } else {
2084                         if (run_len > 0) {
2085                                 m_run = NULL;
2086                                 run_len = 0;
2087                         }
2088                 }
2089         }
2090         if (m_mtx != NULL)
2091                 mtx_unlock(m_mtx);
2092         if (run_len >= npages)
2093                 return (m_run);
2094         return (NULL);
2095 }
2096
2097 /*
2098  *      vm_page_reclaim_run:
2099  *
2100  *      Try to relocate each of the allocated virtual pages within the
2101  *      specified run of physical pages to a new physical address.  Free the
2102  *      physical pages underlying the relocated virtual pages.  A virtual page
2103  *      is relocatable if and only if it could be laundered or reclaimed by
2104  *      the page daemon.  Whenever possible, a virtual page is relocated to a
2105  *      physical address above "high".
2106  *
2107  *      Returns 0 if every physical page within the run was already free or
2108  *      just freed by a successful relocation.  Otherwise, returns a non-zero
2109  *      value indicating why the last attempt to relocate a virtual page was
2110  *      unsuccessful.
2111  *
2112  *      "req_class" must be an allocation class.
2113  */
2114 static int
2115 vm_page_reclaim_run(int req_class, u_long npages, vm_page_t m_run,
2116     vm_paddr_t high)
2117 {
2118         struct mtx *m_mtx, *new_mtx;
2119         struct spglist free;
2120         vm_object_t object;
2121         vm_paddr_t pa;
2122         vm_page_t m, m_end, m_new;
2123         int error, order, req;
2124
2125         KASSERT((req_class & VM_ALLOC_CLASS_MASK) == req_class,
2126             ("req_class is not an allocation class"));
2127         SLIST_INIT(&free);
2128         error = 0;
2129         m = m_run;
2130         m_end = m_run + npages;
2131         m_mtx = NULL;
2132         for (; error == 0 && m < m_end; m++) {
2133                 KASSERT((m->flags & (PG_FICTITIOUS | PG_MARKER)) == 0,
2134                     ("page %p is PG_FICTITIOUS or PG_MARKER", m));
2135
2136                 /*
2137                  * Avoid releasing and reacquiring the same page lock.
2138                  */
2139                 new_mtx = vm_page_lockptr(m);
2140                 if (m_mtx != new_mtx) {
2141                         if (m_mtx != NULL)
2142                                 mtx_unlock(m_mtx);
2143                         m_mtx = new_mtx;
2144                         mtx_lock(m_mtx);
2145                 }
2146 retry:
2147                 if (m->wire_count != 0 || m->hold_count != 0)
2148                         error = EBUSY;
2149                 else if ((object = m->object) != NULL) {
2150                         /*
2151                          * The page is relocated if and only if it could be
2152                          * laundered or reclaimed by the page daemon.
2153                          */
2154                         if (!VM_OBJECT_TRYWLOCK(object)) {
2155                                 mtx_unlock(m_mtx);
2156                                 VM_OBJECT_WLOCK(object);
2157                                 mtx_lock(m_mtx);
2158                                 if (m->object != object) {
2159                                         /*
2160                                          * The page may have been freed.
2161                                          */
2162                                         VM_OBJECT_WUNLOCK(object);
2163                                         goto retry;
2164                                 } else if (m->wire_count != 0 ||
2165                                     m->hold_count != 0) {
2166                                         error = EBUSY;
2167                                         goto unlock;
2168                                 }
2169                         }
2170                         KASSERT((m->flags & PG_UNHOLDFREE) == 0,
2171                             ("page %p is PG_UNHOLDFREE", m));
2172                         /* Don't care: PG_NODUMP, PG_ZERO. */
2173                         if (object->type != OBJT_DEFAULT &&
2174                             object->type != OBJT_SWAP &&
2175                             object->type != OBJT_VNODE)
2176                                 error = EINVAL;
2177                         else if (object->memattr != VM_MEMATTR_DEFAULT)
2178                                 error = EINVAL;
2179                         else if (m->queue != PQ_NONE && !vm_page_busied(m)) {
2180                                 KASSERT(pmap_page_get_memattr(m) ==
2181                                     VM_MEMATTR_DEFAULT,
2182                                     ("page %p has an unexpected memattr", m));
2183                                 KASSERT((m->oflags & (VPO_SWAPINPROG |
2184                                     VPO_SWAPSLEEP | VPO_UNMANAGED)) == 0,
2185                                     ("page %p has unexpected oflags", m));
2186                                 /* Don't care: VPO_NOSYNC. */
2187                                 if (m->valid != 0) {
2188                                         /*
2189                                          * First, try to allocate a new page
2190                                          * that is above "high".  Failing
2191                                          * that, try to allocate a new page
2192                                          * that is below "m_run".  Allocate
2193                                          * the new page between the end of
2194                                          * "m_run" and "high" only as a last
2195                                          * resort.
2196                                          */
2197                                         req = req_class | VM_ALLOC_NOOBJ;
2198                                         if ((m->flags & PG_NODUMP) != 0)
2199                                                 req |= VM_ALLOC_NODUMP;
2200                                         if (trunc_page(high) !=
2201                                             ~(vm_paddr_t)PAGE_MASK) {
2202                                                 m_new = vm_page_alloc_contig(
2203                                                     NULL, 0, req, 1,
2204                                                     round_page(high),
2205                                                     ~(vm_paddr_t)0,
2206                                                     PAGE_SIZE, 0,
2207                                                     VM_MEMATTR_DEFAULT);
2208                                         } else
2209                                                 m_new = NULL;
2210                                         if (m_new == NULL) {
2211                                                 pa = VM_PAGE_TO_PHYS(m_run);
2212                                                 m_new = vm_page_alloc_contig(
2213                                                     NULL, 0, req, 1,
2214                                                     0, pa - 1, PAGE_SIZE, 0,
2215                                                     VM_MEMATTR_DEFAULT);
2216                                         }
2217                                         if (m_new == NULL) {
2218                                                 pa += ptoa(npages);
2219                                                 m_new = vm_page_alloc_contig(
2220                                                     NULL, 0, req, 1,
2221                                                     pa, high, PAGE_SIZE, 0,
2222                                                     VM_MEMATTR_DEFAULT);
2223                                         }
2224                                         if (m_new == NULL) {
2225                                                 error = ENOMEM;
2226                                                 goto unlock;
2227                                         }
2228                                         KASSERT(m_new->wire_count == 0,
2229                                             ("page %p is wired", m));
2230
2231                                         /*
2232                                          * Replace "m" with the new page.  For
2233                                          * vm_page_replace(), "m" must be busy
2234                                          * and dequeued.  Finally, change "m"
2235                                          * as if vm_page_free() was called.
2236                                          */
2237                                         if (object->ref_count != 0)
2238                                                 pmap_remove_all(m);
2239                                         m_new->aflags = m->aflags;
2240                                         KASSERT(m_new->oflags == VPO_UNMANAGED,
2241                                             ("page %p is managed", m));
2242                                         m_new->oflags = m->oflags & VPO_NOSYNC;
2243                                         pmap_copy_page(m, m_new);
2244                                         m_new->valid = m->valid;
2245                                         m_new->dirty = m->dirty;
2246                                         m->flags &= ~PG_ZERO;
2247                                         vm_page_xbusy(m);
2248                                         vm_page_remque(m);
2249                                         vm_page_replace_checked(m_new, object,
2250                                             m->pindex, m);
2251                                         m->valid = 0;
2252                                         vm_page_undirty(m);
2253
2254                                         /*
2255                                          * The new page must be deactivated
2256                                          * before the object is unlocked.
2257                                          */
2258                                         new_mtx = vm_page_lockptr(m_new);
2259                                         if (m_mtx != new_mtx) {
2260                                                 mtx_unlock(m_mtx);
2261                                                 m_mtx = new_mtx;
2262                                                 mtx_lock(m_mtx);
2263                                         }
2264                                         vm_page_deactivate(m_new);
2265                                 } else {
2266                                         m->flags &= ~PG_ZERO;
2267                                         vm_page_remque(m);
2268                                         vm_page_remove(m);
2269                                         KASSERT(m->dirty == 0,
2270                                             ("page %p is dirty", m));
2271                                 }
2272                                 SLIST_INSERT_HEAD(&free, m, plinks.s.ss);
2273                         } else
2274                                 error = EBUSY;
2275 unlock:
2276                         VM_OBJECT_WUNLOCK(object);
2277                 } else {
2278                         mtx_lock(&vm_page_queue_free_mtx);
2279                         order = m->order;
2280                         if (order < VM_NFREEORDER) {
2281                                 /*
2282                                  * The page is enqueued in the physical memory
2283                                  * allocator's cache/free page queues.
2284                                  * Moreover, it is the first page in a power-
2285                                  * of-two-sized run of contiguous cache/free
2286                                  * pages.  Jump ahead to the last page within
2287                                  * that run, and continue from there.
2288                                  */
2289                                 m += (1 << order) - 1;
2290                         }
2291 #if VM_NRESERVLEVEL > 0
2292                         else if (vm_reserv_is_page_free(m))
2293                                 order = 0;
2294 #endif
2295                         mtx_unlock(&vm_page_queue_free_mtx);
2296                         if (order == VM_NFREEORDER)
2297                                 error = EINVAL;
2298                 }
2299         }
2300         if (m_mtx != NULL)
2301                 mtx_unlock(m_mtx);
2302         if ((m = SLIST_FIRST(&free)) != NULL) {
2303                 mtx_lock(&vm_page_queue_free_mtx);
2304                 do {
2305                         SLIST_REMOVE_HEAD(&free, plinks.s.ss);
2306                         vm_phys_freecnt_adj(m, 1);
2307 #if VM_NRESERVLEVEL > 0
2308                         if (!vm_reserv_free_page(m))
2309 #else
2310                         if (true)
2311 #endif
2312                                 vm_phys_free_pages(m, 0);
2313                 } while ((m = SLIST_FIRST(&free)) != NULL);
2314                 vm_page_free_wakeup();
2315                 mtx_unlock(&vm_page_queue_free_mtx);
2316         }
2317         return (error);
2318 }
2319
2320 #define NRUNS   16
2321
2322 CTASSERT(powerof2(NRUNS));
2323
2324 #define RUN_INDEX(count)        ((count) & (NRUNS - 1))
2325
2326 #define MIN_RECLAIM     8
2327
2328 /*
2329  *      vm_page_reclaim_contig:
2330  *
2331  *      Reclaim allocated, contiguous physical memory satisfying the specified
2332  *      conditions by relocating the virtual pages using that physical memory.
2333  *      Returns true if reclamation is successful and false otherwise.  Since
2334  *      relocation requires the allocation of physical pages, reclamation may
2335  *      fail due to a shortage of cache/free pages.  When reclamation fails,
2336  *      callers are expected to perform VM_WAIT before retrying a failed
2337  *      allocation operation, e.g., vm_page_alloc_contig().
2338  *
2339  *      The caller must always specify an allocation class through "req".
2340  *
2341  *      allocation classes:
2342  *      VM_ALLOC_NORMAL         normal process request
2343  *      VM_ALLOC_SYSTEM         system *really* needs a page
2344  *      VM_ALLOC_INTERRUPT      interrupt time request
2345  *
2346  *      The optional allocation flags are ignored.
2347  *
2348  *      "npages" must be greater than zero.  Both "alignment" and "boundary"
2349  *      must be a power of two.
2350  */
2351 bool
2352 vm_page_reclaim_contig(int req, u_long npages, vm_paddr_t low, vm_paddr_t high,
2353     u_long alignment, vm_paddr_t boundary)
2354 {
2355         vm_paddr_t curr_low;
2356         vm_page_t m_run, m_runs[NRUNS];
2357         u_long count, reclaimed;
2358         int error, i, options, req_class;
2359
2360         KASSERT(npages > 0, ("npages is 0"));
2361         KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
2362         KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
2363         req_class = req & VM_ALLOC_CLASS_MASK;
2364
2365         /*
2366          * The page daemon is allowed to dig deeper into the free page list.
2367          */
2368         if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
2369                 req_class = VM_ALLOC_SYSTEM;
2370
2371         /*
2372          * Return if the number of cached and free pages cannot satisfy the
2373          * requested allocation.
2374          */
2375         count = vm_cnt.v_free_count + vm_cnt.v_cache_count;
2376         if (count < npages + vm_cnt.v_free_reserved || (count < npages +
2377             vm_cnt.v_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) ||
2378             (count < npages && req_class == VM_ALLOC_INTERRUPT))
2379                 return (false);
2380
2381         /*
2382          * Scan up to three times, relaxing the restrictions ("options") on
2383          * the reclamation of reservations and superpages each time.
2384          */
2385         for (options = VPSC_NORESERV;;) {
2386                 /*
2387                  * Find the highest runs that satisfy the given constraints
2388                  * and restrictions, and record them in "m_runs".
2389                  */
2390                 curr_low = low;
2391                 count = 0;
2392                 for (;;) {
2393                         m_run = vm_phys_scan_contig(npages, curr_low, high,
2394                             alignment, boundary, options);
2395                         if (m_run == NULL)
2396                                 break;
2397                         curr_low = VM_PAGE_TO_PHYS(m_run) + ptoa(npages);
2398                         m_runs[RUN_INDEX(count)] = m_run;
2399                         count++;
2400                 }
2401
2402                 /*
2403                  * Reclaim the highest runs in LIFO (descending) order until
2404                  * the number of reclaimed pages, "reclaimed", is at least
2405                  * MIN_RECLAIM.  Reset "reclaimed" each time because each
2406                  * reclamation is idempotent, and runs will (likely) recur
2407                  * from one scan to the next as restrictions are relaxed.
2408                  */
2409                 reclaimed = 0;
2410                 for (i = 0; count > 0 && i < NRUNS; i++) {
2411                         count--;
2412                         m_run = m_runs[RUN_INDEX(count)];
2413                         error = vm_page_reclaim_run(req_class, npages, m_run,
2414                             high);
2415                         if (error == 0) {
2416                                 reclaimed += npages;
2417                                 if (reclaimed >= MIN_RECLAIM)
2418                                         return (true);
2419                         }
2420                 }
2421
2422                 /*
2423                  * Either relax the restrictions on the next scan or return if
2424                  * the last scan had no restrictions.
2425                  */
2426                 if (options == VPSC_NORESERV)
2427                         options = VPSC_NOSUPER;
2428                 else if (options == VPSC_NOSUPER)
2429                         options = VPSC_ANY;
2430                 else if (options == VPSC_ANY)
2431                         return (reclaimed != 0);
2432         }
2433 }
2434
2435 /*
2436  *      vm_wait:        (also see VM_WAIT macro)
2437  *
2438  *      Sleep until free pages are available for allocation.
2439  *      - Called in various places before memory allocations.
2440  */
2441 void
2442 vm_wait(void)
2443 {
2444
2445         mtx_lock(&vm_page_queue_free_mtx);
2446         if (curproc == pageproc) {
2447                 vm_pageout_pages_needed = 1;
2448                 msleep(&vm_pageout_pages_needed, &vm_page_queue_free_mtx,
2449                     PDROP | PSWP, "VMWait", 0);
2450         } else {
2451                 if (__predict_false(pageproc == NULL))
2452                         panic("vm_wait in early boot");
2453                 if (!vm_pageout_wanted) {
2454                         vm_pageout_wanted = true;
2455                         wakeup(&vm_pageout_wanted);
2456                 }
2457                 vm_pages_needed = true;
2458                 msleep(&vm_cnt.v_free_count, &vm_page_queue_free_mtx, PDROP | PVM,
2459                     "vmwait", 0);
2460         }
2461 }
2462
2463 /*
2464  *      vm_waitpfault:  (also see VM_WAITPFAULT macro)
2465  *
2466  *      Sleep until free pages are available for allocation.
2467  *      - Called only in vm_fault so that processes page faulting
2468  *        can be easily tracked.
2469  *      - Sleeps at a lower priority than vm_wait() so that vm_wait()ing
2470  *        processes will be able to grab memory first.  Do not change
2471  *        this balance without careful testing first.
2472  */
2473 void
2474 vm_waitpfault(void)
2475 {
2476
2477         mtx_lock(&vm_page_queue_free_mtx);
2478         if (!vm_pageout_wanted) {
2479                 vm_pageout_wanted = true;
2480                 wakeup(&vm_pageout_wanted);
2481         }
2482         vm_pages_needed = true;
2483         msleep(&vm_cnt.v_free_count, &vm_page_queue_free_mtx, PDROP | PUSER,
2484             "pfault", 0);
2485 }
2486
2487 struct vm_pagequeue *
2488 vm_page_pagequeue(vm_page_t m)
2489 {
2490
2491         if (vm_page_in_laundry(m))
2492                 return (&vm_dom[0].vmd_pagequeues[m->queue]);
2493         else
2494                 return (&vm_phys_domain(m)->vmd_pagequeues[m->queue]);
2495 }
2496
2497 /*
2498  *      vm_page_dequeue:
2499  *
2500  *      Remove the given page from its current page queue.
2501  *
2502  *      The page must be locked.
2503  */
2504 void
2505 vm_page_dequeue(vm_page_t m)
2506 {
2507         struct vm_pagequeue *pq;
2508
2509         vm_page_assert_locked(m);
2510         KASSERT(m->queue < PQ_COUNT, ("vm_page_dequeue: page %p is not queued",
2511             m));
2512         pq = vm_page_pagequeue(m);
2513         vm_pagequeue_lock(pq);
2514         m->queue = PQ_NONE;
2515         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
2516         vm_pagequeue_cnt_dec(pq);
2517         vm_pagequeue_unlock(pq);
2518 }
2519
2520 /*
2521  *      vm_page_dequeue_locked:
2522  *
2523  *      Remove the given page from its current page queue.
2524  *
2525  *      The page and page queue must be locked.
2526  */
2527 void
2528 vm_page_dequeue_locked(vm_page_t m)
2529 {
2530         struct vm_pagequeue *pq;
2531
2532         vm_page_lock_assert(m, MA_OWNED);
2533         pq = vm_page_pagequeue(m);
2534         vm_pagequeue_assert_locked(pq);
2535         m->queue = PQ_NONE;
2536         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
2537         vm_pagequeue_cnt_dec(pq);
2538 }
2539
2540 /*
2541  *      vm_page_enqueue:
2542  *
2543  *      Add the given page to the specified page queue.
2544  *
2545  *      The page must be locked.
2546  */
2547 static void
2548 vm_page_enqueue(uint8_t queue, vm_page_t m)
2549 {
2550         struct vm_pagequeue *pq;
2551
2552         vm_page_lock_assert(m, MA_OWNED);
2553         KASSERT(queue < PQ_COUNT,
2554             ("vm_page_enqueue: invalid queue %u request for page %p",
2555             queue, m));
2556         if (queue == PQ_LAUNDRY)
2557                 pq = &vm_dom[0].vmd_pagequeues[queue];
2558         else
2559                 pq = &vm_phys_domain(m)->vmd_pagequeues[queue];
2560         vm_pagequeue_lock(pq);
2561         m->queue = queue;
2562         TAILQ_INSERT_TAIL(&pq->pq_pl, m, plinks.q);
2563         vm_pagequeue_cnt_inc(pq);
2564         vm_pagequeue_unlock(pq);
2565 }
2566
2567 /*
2568  *      vm_page_requeue:
2569  *
2570  *      Move the given page to the tail of its current page queue.
2571  *
2572  *      The page must be locked.
2573  */
2574 void
2575 vm_page_requeue(vm_page_t m)
2576 {
2577         struct vm_pagequeue *pq;
2578
2579         vm_page_lock_assert(m, MA_OWNED);
2580         KASSERT(m->queue != PQ_NONE,
2581             ("vm_page_requeue: page %p is not queued", m));
2582         pq = vm_page_pagequeue(m);
2583         vm_pagequeue_lock(pq);
2584         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
2585         TAILQ_INSERT_TAIL(&pq->pq_pl, m, plinks.q);
2586         vm_pagequeue_unlock(pq);
2587 }
2588
2589 /*
2590  *      vm_page_requeue_locked:
2591  *
2592  *      Move the given page to the tail of its current page queue.
2593  *
2594  *      The page queue must be locked.
2595  */
2596 void
2597 vm_page_requeue_locked(vm_page_t m)
2598 {
2599         struct vm_pagequeue *pq;
2600
2601         KASSERT(m->queue != PQ_NONE,
2602             ("vm_page_requeue_locked: page %p is not queued", m));
2603         pq = vm_page_pagequeue(m);
2604         vm_pagequeue_assert_locked(pq);
2605         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
2606         TAILQ_INSERT_TAIL(&pq->pq_pl, m, plinks.q);
2607 }
2608
2609 /*
2610  *      vm_page_activate:
2611  *
2612  *      Put the specified page on the active list (if appropriate).
2613  *      Ensure that act_count is at least ACT_INIT but do not otherwise
2614  *      mess with it.
2615  *
2616  *      The page must be locked.
2617  */
2618 void
2619 vm_page_activate(vm_page_t m)
2620 {
2621         int queue;
2622
2623         vm_page_lock_assert(m, MA_OWNED);
2624         if ((queue = m->queue) != PQ_ACTIVE) {
2625                 if (m->wire_count == 0 && (m->oflags & VPO_UNMANAGED) == 0) {
2626                         if (m->act_count < ACT_INIT)
2627                                 m->act_count = ACT_INIT;
2628                         if (queue != PQ_NONE)
2629                                 vm_page_dequeue(m);
2630                         vm_page_enqueue(PQ_ACTIVE, m);
2631                 } else
2632                         KASSERT(queue == PQ_NONE,
2633                             ("vm_page_activate: wired page %p is queued", m));
2634         } else {
2635                 if (m->act_count < ACT_INIT)
2636                         m->act_count = ACT_INIT;
2637         }
2638 }
2639
2640 /*
2641  *      vm_page_free_wakeup:
2642  *
2643  *      Helper routine for vm_page_free_toq() and vm_page_cache().  This
2644  *      routine is called when a page has been added to the cache or free
2645  *      queues.
2646  *
2647  *      The page queues must be locked.
2648  */
2649 static inline void
2650 vm_page_free_wakeup(void)
2651 {
2652
2653         mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
2654         /*
2655          * if pageout daemon needs pages, then tell it that there are
2656          * some free.
2657          */
2658         if (vm_pageout_pages_needed &&
2659             vm_cnt.v_cache_count + vm_cnt.v_free_count >= vm_cnt.v_pageout_free_min) {
2660                 wakeup(&vm_pageout_pages_needed);
2661                 vm_pageout_pages_needed = 0;
2662         }
2663         /*
2664          * wakeup processes that are waiting on memory if we hit a
2665          * high water mark. And wakeup scheduler process if we have
2666          * lots of memory. this process will swapin processes.
2667          */
2668         if (vm_pages_needed && !vm_page_count_min()) {
2669                 vm_pages_needed = false;
2670                 wakeup(&vm_cnt.v_free_count);
2671         }
2672 }
2673
2674 /*
2675  *      vm_page_free_toq:
2676  *
2677  *      Returns the given page to the free list,
2678  *      disassociating it with any VM object.
2679  *
2680  *      The object must be locked.  The page must be locked if it is managed.
2681  */
2682 void
2683 vm_page_free_toq(vm_page_t m)
2684 {
2685
2686         if ((m->oflags & VPO_UNMANAGED) == 0) {
2687                 vm_page_lock_assert(m, MA_OWNED);
2688                 KASSERT(!pmap_page_is_mapped(m),
2689                     ("vm_page_free_toq: freeing mapped page %p", m));
2690         } else
2691                 KASSERT(m->queue == PQ_NONE,
2692                     ("vm_page_free_toq: unmanaged page %p is queued", m));
2693         PCPU_INC(cnt.v_tfree);
2694
2695         if (vm_page_sbusied(m))
2696                 panic("vm_page_free: freeing busy page %p", m);
2697
2698         /*
2699          * Unqueue, then remove page.  Note that we cannot destroy
2700          * the page here because we do not want to call the pager's
2701          * callback routine until after we've put the page on the
2702          * appropriate free queue.
2703          */
2704         vm_page_remque(m);
2705         vm_page_remove(m);
2706
2707         /*
2708          * If fictitious remove object association and
2709          * return, otherwise delay object association removal.
2710          */
2711         if ((m->flags & PG_FICTITIOUS) != 0) {
2712                 return;
2713         }
2714
2715         m->valid = 0;
2716         vm_page_undirty(m);
2717
2718         if (m->wire_count != 0)
2719                 panic("vm_page_free: freeing wired page %p", m);
2720         if (m->hold_count != 0) {
2721                 m->flags &= ~PG_ZERO;
2722                 KASSERT((m->flags & PG_UNHOLDFREE) == 0,
2723                     ("vm_page_free: freeing PG_UNHOLDFREE page %p", m));
2724                 m->flags |= PG_UNHOLDFREE;
2725         } else {
2726                 /*
2727                  * Restore the default memory attribute to the page.
2728                  */
2729                 if (pmap_page_get_memattr(m) != VM_MEMATTR_DEFAULT)
2730                         pmap_page_set_memattr(m, VM_MEMATTR_DEFAULT);
2731
2732                 /*
2733                  * Insert the page into the physical memory allocator's
2734                  * cache/free page queues.
2735                  */
2736                 mtx_lock(&vm_page_queue_free_mtx);
2737                 vm_phys_freecnt_adj(m, 1);
2738 #if VM_NRESERVLEVEL > 0
2739                 if (!vm_reserv_free_page(m))
2740 #else
2741                 if (TRUE)
2742 #endif
2743                         vm_phys_free_pages(m, 0);
2744                 vm_page_free_wakeup();
2745                 mtx_unlock(&vm_page_queue_free_mtx);
2746         }
2747 }
2748
2749 /*
2750  *      vm_page_wire:
2751  *
2752  *      Mark this page as wired down by yet
2753  *      another map, removing it from paging queues
2754  *      as necessary.
2755  *
2756  *      If the page is fictitious, then its wire count must remain one.
2757  *
2758  *      The page must be locked.
2759  */
2760 void
2761 vm_page_wire(vm_page_t m)
2762 {
2763
2764         /*
2765          * Only bump the wire statistics if the page is not already wired,
2766          * and only unqueue the page if it is on some queue (if it is unmanaged
2767          * it is already off the queues).
2768          */
2769         vm_page_lock_assert(m, MA_OWNED);
2770         if ((m->flags & PG_FICTITIOUS) != 0) {
2771                 KASSERT(m->wire_count == 1,
2772                     ("vm_page_wire: fictitious page %p's wire count isn't one",
2773                     m));
2774                 return;
2775         }
2776         if (m->wire_count == 0) {
2777                 KASSERT((m->oflags & VPO_UNMANAGED) == 0 ||
2778                     m->queue == PQ_NONE,
2779                     ("vm_page_wire: unmanaged page %p is queued", m));
2780                 vm_page_remque(m);
2781                 atomic_add_int(&vm_cnt.v_wire_count, 1);
2782         }
2783         m->wire_count++;
2784         KASSERT(m->wire_count != 0, ("vm_page_wire: wire_count overflow m=%p", m));
2785 }
2786
2787 /*
2788  * vm_page_unwire:
2789  *
2790  * Release one wiring of the specified page, potentially allowing it to be
2791  * paged out.  Returns TRUE if the number of wirings transitions to zero and
2792  * FALSE otherwise.
2793  *
2794  * Only managed pages belonging to an object can be paged out.  If the number
2795  * of wirings transitions to zero and the page is eligible for page out, then
2796  * the page is added to the specified paging queue (unless PQ_NONE is
2797  * specified).
2798  *
2799  * If a page is fictitious, then its wire count must always be one.
2800  *
2801  * A managed page must be locked.
2802  */
2803 boolean_t
2804 vm_page_unwire(vm_page_t m, uint8_t queue)
2805 {
2806
2807         KASSERT(queue < PQ_COUNT || queue == PQ_NONE,
2808             ("vm_page_unwire: invalid queue %u request for page %p",
2809             queue, m));
2810         if ((m->oflags & VPO_UNMANAGED) == 0)
2811                 vm_page_assert_locked(m);
2812         if ((m->flags & PG_FICTITIOUS) != 0) {
2813                 KASSERT(m->wire_count == 1,
2814             ("vm_page_unwire: fictitious page %p's wire count isn't one", m));
2815                 return (FALSE);
2816         }
2817         if (m->wire_count > 0) {
2818                 m->wire_count--;
2819                 if (m->wire_count == 0) {
2820                         atomic_subtract_int(&vm_cnt.v_wire_count, 1);
2821                         if ((m->oflags & VPO_UNMANAGED) == 0 &&
2822                             m->object != NULL && queue != PQ_NONE)
2823                                 vm_page_enqueue(queue, m);
2824                         return (TRUE);
2825                 } else
2826                         return (FALSE);
2827         } else
2828                 panic("vm_page_unwire: page %p's wire count is zero", m);
2829 }
2830
2831 /*
2832  * Move the specified page to the inactive queue.
2833  *
2834  * Many pages placed on the inactive queue should actually go
2835  * into the cache, but it is difficult to figure out which.  What
2836  * we do instead, if the inactive target is well met, is to put
2837  * clean pages at the head of the inactive queue instead of the tail.
2838  * This will cause them to be moved to the cache more quickly and
2839  * if not actively re-referenced, reclaimed more quickly.  If we just
2840  * stick these pages at the end of the inactive queue, heavy filesystem
2841  * meta-data accesses can cause an unnecessary paging load on memory bound
2842  * processes.  This optimization causes one-time-use metadata to be
2843  * reused more quickly.
2844  *
2845  * Normally noreuse is FALSE, resulting in LRU operation.  noreuse is set
2846  * to TRUE if we want this page to be 'as if it were placed in the cache',
2847  * except without unmapping it from the process address space.  In
2848  * practice this is implemented by inserting the page at the head of the
2849  * queue, using a marker page to guide FIFO insertion ordering.
2850  *
2851  * The page must be locked.
2852  */
2853 static inline void
2854 _vm_page_deactivate(vm_page_t m, boolean_t noreuse)
2855 {
2856         struct vm_pagequeue *pq;
2857         int queue;
2858
2859         vm_page_assert_locked(m);
2860
2861         /*
2862          * Ignore if the page is already inactive, unless it is unlikely to be
2863          * reactivated.
2864          */
2865         if ((queue = m->queue) == PQ_INACTIVE && !noreuse)
2866                 return;
2867         if (m->wire_count == 0 && (m->oflags & VPO_UNMANAGED) == 0) {
2868                 pq = &vm_phys_domain(m)->vmd_pagequeues[PQ_INACTIVE];
2869                 /* Avoid multiple acquisitions of the inactive queue lock. */
2870                 if (queue == PQ_INACTIVE) {
2871                         vm_pagequeue_lock(pq);
2872                         vm_page_dequeue_locked(m);
2873                 } else {
2874                         if (queue != PQ_NONE)
2875                                 vm_page_dequeue(m);
2876                         vm_pagequeue_lock(pq);
2877                 }
2878                 m->queue = PQ_INACTIVE;
2879                 if (noreuse)
2880                         TAILQ_INSERT_BEFORE(&vm_phys_domain(m)->vmd_inacthead,
2881                             m, plinks.q);
2882                 else
2883                         TAILQ_INSERT_TAIL(&pq->pq_pl, m, plinks.q);
2884                 vm_pagequeue_cnt_inc(pq);
2885                 vm_pagequeue_unlock(pq);
2886         }
2887 }
2888
2889 /*
2890  * Move the specified page to the inactive queue.
2891  *
2892  * The page must be locked.
2893  */
2894 void
2895 vm_page_deactivate(vm_page_t m)
2896 {
2897
2898         _vm_page_deactivate(m, FALSE);
2899 }
2900
2901 /*
2902  * Move the specified page to the inactive queue with the expectation
2903  * that it is unlikely to be reused.
2904  *
2905  * The page must be locked.
2906  */
2907 void
2908 vm_page_deactivate_noreuse(vm_page_t m)
2909 {
2910
2911         _vm_page_deactivate(m, TRUE);
2912 }
2913
2914 /*
2915  * vm_page_launder
2916  *
2917  *      Put a page in the laundry.
2918  */
2919 void
2920 vm_page_launder(vm_page_t m)
2921 {
2922         int queue;
2923
2924         vm_page_assert_locked(m);
2925         if ((queue = m->queue) != PQ_LAUNDRY) {
2926                 if (m->wire_count == 0 && (m->oflags & VPO_UNMANAGED) == 0) {
2927                         if (queue != PQ_NONE)
2928                                 vm_page_dequeue(m);
2929                         vm_page_enqueue(PQ_LAUNDRY, m);
2930                 } else
2931                         KASSERT(queue == PQ_NONE,
2932                             ("wired page %p is queued", m));
2933         }
2934 }
2935
2936 /*
2937  * vm_page_try_to_free()
2938  *
2939  *      Attempt to free the page.  If we cannot free it, we do nothing.
2940  *      1 is returned on success, 0 on failure.
2941  */
2942 int
2943 vm_page_try_to_free(vm_page_t m)
2944 {
2945
2946         vm_page_lock_assert(m, MA_OWNED);
2947         if (m->object != NULL)
2948                 VM_OBJECT_ASSERT_WLOCKED(m->object);
2949         if (m->dirty || m->hold_count || m->wire_count ||
2950             (m->oflags & VPO_UNMANAGED) != 0 || vm_page_busied(m))
2951                 return (0);
2952         pmap_remove_all(m);
2953         if (m->dirty)
2954                 return (0);
2955         vm_page_free(m);
2956         return (1);
2957 }
2958
2959 /*
2960  * vm_page_advise
2961  *
2962  *      Deactivate or do nothing, as appropriate.
2963  *
2964  *      The object and page must be locked.
2965  */
2966 void
2967 vm_page_advise(vm_page_t m, int advice)
2968 {
2969
2970         vm_page_assert_locked(m);
2971         VM_OBJECT_ASSERT_WLOCKED(m->object);
2972         if (advice == MADV_FREE)
2973                 /*
2974                  * Mark the page clean.  This will allow the page to be freed
2975                  * up by the system.  However, such pages are often reused
2976                  * quickly by malloc() so we do not do anything that would
2977                  * cause a page fault if we can help it.
2978                  *
2979                  * Specifically, we do not try to actually free the page now
2980                  * nor do we try to put it in the cache (which would cause a
2981                  * page fault on reuse).
2982                  *
2983                  * But we do make the page as freeable as we can without
2984                  * actually taking the step of unmapping it.
2985                  */
2986                 vm_page_undirty(m);
2987         else if (advice != MADV_DONTNEED)
2988                 return;
2989
2990         /*
2991          * Clear any references to the page.  Otherwise, the page daemon will
2992          * immediately reactivate the page.
2993          */
2994         vm_page_aflag_clear(m, PGA_REFERENCED);
2995
2996         if (advice != MADV_FREE && m->dirty == 0 && pmap_is_modified(m))
2997                 vm_page_dirty(m);
2998
2999         /*
3000          * Place clean pages near the head of the inactive queue rather than
3001          * the tail, thus defeating the queue's LRU operation and ensuring that
3002          * the page will be reused quickly.  Dirty pages not already in the
3003          * laundry are moved there.
3004          */
3005         if (m->dirty == 0)
3006                 vm_page_deactivate_noreuse(m);
3007         else
3008                 vm_page_launder(m);
3009 }
3010
3011 /*
3012  * Grab a page, waiting until we are waken up due to the page
3013  * changing state.  We keep on waiting, if the page continues
3014  * to be in the object.  If the page doesn't exist, first allocate it
3015  * and then conditionally zero it.
3016  *
3017  * This routine may sleep.
3018  *
3019  * The object must be locked on entry.  The lock will, however, be released
3020  * and reacquired if the routine sleeps.
3021  */
3022 vm_page_t
3023 vm_page_grab(vm_object_t object, vm_pindex_t pindex, int allocflags)
3024 {
3025         vm_page_t m;
3026         int sleep;
3027
3028         VM_OBJECT_ASSERT_WLOCKED(object);
3029         KASSERT((allocflags & VM_ALLOC_SBUSY) == 0 ||
3030             (allocflags & VM_ALLOC_IGN_SBUSY) != 0,
3031             ("vm_page_grab: VM_ALLOC_SBUSY/VM_ALLOC_IGN_SBUSY mismatch"));
3032 retrylookup:
3033         if ((m = vm_page_lookup(object, pindex)) != NULL) {
3034                 sleep = (allocflags & VM_ALLOC_IGN_SBUSY) != 0 ?
3035                     vm_page_xbusied(m) : vm_page_busied(m);
3036                 if (sleep) {
3037                         if ((allocflags & VM_ALLOC_NOWAIT) != 0)
3038                                 return (NULL);
3039                         /*
3040                          * Reference the page before unlocking and
3041                          * sleeping so that the page daemon is less
3042                          * likely to reclaim it.
3043                          */
3044                         vm_page_aflag_set(m, PGA_REFERENCED);
3045                         vm_page_lock(m);
3046                         VM_OBJECT_WUNLOCK(object);
3047                         vm_page_busy_sleep(m, "pgrbwt", (allocflags &
3048                             VM_ALLOC_IGN_SBUSY) != 0);
3049                         VM_OBJECT_WLOCK(object);
3050                         goto retrylookup;
3051                 } else {
3052                         if ((allocflags & VM_ALLOC_WIRED) != 0) {
3053                                 vm_page_lock(m);
3054                                 vm_page_wire(m);
3055                                 vm_page_unlock(m);
3056                         }
3057                         if ((allocflags &
3058                             (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)) == 0)
3059                                 vm_page_xbusy(m);
3060                         if ((allocflags & VM_ALLOC_SBUSY) != 0)
3061                                 vm_page_sbusy(m);
3062                         return (m);
3063                 }
3064         }
3065         m = vm_page_alloc(object, pindex, allocflags);
3066         if (m == NULL) {
3067                 if ((allocflags & VM_ALLOC_NOWAIT) != 0)
3068                         return (NULL);
3069                 VM_OBJECT_WUNLOCK(object);
3070                 VM_WAIT;
3071                 VM_OBJECT_WLOCK(object);
3072                 goto retrylookup;
3073         }
3074         if (allocflags & VM_ALLOC_ZERO && (m->flags & PG_ZERO) == 0)
3075                 pmap_zero_page(m);
3076         return (m);
3077 }
3078
3079 /*
3080  * Mapping function for valid or dirty bits in a page.
3081  *
3082  * Inputs are required to range within a page.
3083  */
3084 vm_page_bits_t
3085 vm_page_bits(int base, int size)
3086 {
3087         int first_bit;
3088         int last_bit;
3089
3090         KASSERT(
3091             base + size <= PAGE_SIZE,
3092             ("vm_page_bits: illegal base/size %d/%d", base, size)
3093         );
3094
3095         if (size == 0)          /* handle degenerate case */
3096                 return (0);
3097
3098         first_bit = base >> DEV_BSHIFT;
3099         last_bit = (base + size - 1) >> DEV_BSHIFT;
3100
3101         return (((vm_page_bits_t)2 << last_bit) -
3102             ((vm_page_bits_t)1 << first_bit));
3103 }
3104
3105 /*
3106  *      vm_page_set_valid_range:
3107  *
3108  *      Sets portions of a page valid.  The arguments are expected
3109  *      to be DEV_BSIZE aligned but if they aren't the bitmap is inclusive
3110  *      of any partial chunks touched by the range.  The invalid portion of
3111  *      such chunks will be zeroed.
3112  *
3113  *      (base + size) must be less then or equal to PAGE_SIZE.
3114  */
3115 void
3116 vm_page_set_valid_range(vm_page_t m, int base, int size)
3117 {
3118         int endoff, frag;
3119
3120         VM_OBJECT_ASSERT_WLOCKED(m->object);
3121         if (size == 0)  /* handle degenerate case */
3122                 return;
3123
3124         /*
3125          * If the base is not DEV_BSIZE aligned and the valid
3126          * bit is clear, we have to zero out a portion of the
3127          * first block.
3128          */
3129         if ((frag = rounddown2(base, DEV_BSIZE)) != base &&
3130             (m->valid & (1 << (base >> DEV_BSHIFT))) == 0)
3131                 pmap_zero_page_area(m, frag, base - frag);
3132
3133         /*
3134          * If the ending offset is not DEV_BSIZE aligned and the
3135          * valid bit is clear, we have to zero out a portion of
3136          * the last block.
3137          */
3138         endoff = base + size;
3139         if ((frag = rounddown2(endoff, DEV_BSIZE)) != endoff &&
3140             (m->valid & (1 << (endoff >> DEV_BSHIFT))) == 0)
3141                 pmap_zero_page_area(m, endoff,
3142                     DEV_BSIZE - (endoff & (DEV_BSIZE - 1)));
3143
3144         /*
3145          * Assert that no previously invalid block that is now being validated
3146          * is already dirty.
3147          */
3148         KASSERT((~m->valid & vm_page_bits(base, size) & m->dirty) == 0,
3149             ("vm_page_set_valid_range: page %p is dirty", m));
3150
3151         /*
3152          * Set valid bits inclusive of any overlap.
3153          */
3154         m->valid |= vm_page_bits(base, size);
3155 }
3156
3157 /*
3158  * Clear the given bits from the specified page's dirty field.
3159  */
3160 static __inline void
3161 vm_page_clear_dirty_mask(vm_page_t m, vm_page_bits_t pagebits)
3162 {
3163         uintptr_t addr;
3164 #if PAGE_SIZE < 16384
3165         int shift;
3166 #endif
3167
3168         /*
3169          * If the object is locked and the page is neither exclusive busy nor
3170          * write mapped, then the page's dirty field cannot possibly be
3171          * set by a concurrent pmap operation.
3172          */
3173         VM_OBJECT_ASSERT_WLOCKED(m->object);
3174         if (!vm_page_xbusied(m) && !pmap_page_is_write_mapped(m))
3175                 m->dirty &= ~pagebits;
3176         else {
3177                 /*
3178                  * The pmap layer can call vm_page_dirty() without
3179                  * holding a distinguished lock.  The combination of
3180                  * the object's lock and an atomic operation suffice
3181                  * to guarantee consistency of the page dirty field.
3182                  *
3183                  * For PAGE_SIZE == 32768 case, compiler already
3184                  * properly aligns the dirty field, so no forcible
3185                  * alignment is needed. Only require existence of
3186                  * atomic_clear_64 when page size is 32768.
3187                  */
3188                 addr = (uintptr_t)&m->dirty;
3189 #if PAGE_SIZE == 32768
3190                 atomic_clear_64((uint64_t *)addr, pagebits);
3191 #elif PAGE_SIZE == 16384
3192                 atomic_clear_32((uint32_t *)addr, pagebits);
3193 #else           /* PAGE_SIZE <= 8192 */
3194                 /*
3195                  * Use a trick to perform a 32-bit atomic on the
3196                  * containing aligned word, to not depend on the existence
3197                  * of atomic_clear_{8, 16}.
3198                  */
3199                 shift = addr & (sizeof(uint32_t) - 1);
3200 #if BYTE_ORDER == BIG_ENDIAN
3201                 shift = (sizeof(uint32_t) - sizeof(m->dirty) - shift) * NBBY;
3202 #else
3203                 shift *= NBBY;
3204 #endif
3205                 addr &= ~(sizeof(uint32_t) - 1);
3206                 atomic_clear_32((uint32_t *)addr, pagebits << shift);
3207 #endif          /* PAGE_SIZE */
3208         }
3209 }
3210
3211 /*
3212  *      vm_page_set_validclean:
3213  *
3214  *      Sets portions of a page valid and clean.  The arguments are expected
3215  *      to be DEV_BSIZE aligned but if they aren't the bitmap is inclusive
3216  *      of any partial chunks touched by the range.  The invalid portion of
3217  *      such chunks will be zero'd.
3218  *
3219  *      (base + size) must be less then or equal to PAGE_SIZE.
3220  */
3221 void
3222 vm_page_set_validclean(vm_page_t m, int base, int size)
3223 {
3224         vm_page_bits_t oldvalid, pagebits;
3225         int endoff, frag;
3226
3227         VM_OBJECT_ASSERT_WLOCKED(m->object);
3228         if (size == 0)  /* handle degenerate case */
3229                 return;
3230
3231         /*
3232          * If the base is not DEV_BSIZE aligned and the valid
3233          * bit is clear, we have to zero out a portion of the
3234          * first block.
3235          */
3236         if ((frag = rounddown2(base, DEV_BSIZE)) != base &&
3237             (m->valid & ((vm_page_bits_t)1 << (base >> DEV_BSHIFT))) == 0)
3238                 pmap_zero_page_area(m, frag, base - frag);
3239
3240         /*
3241          * If the ending offset is not DEV_BSIZE aligned and the
3242          * valid bit is clear, we have to zero out a portion of
3243          * the last block.
3244          */
3245         endoff = base + size;
3246         if ((frag = rounddown2(endoff, DEV_BSIZE)) != endoff &&
3247             (m->valid & ((vm_page_bits_t)1 << (endoff >> DEV_BSHIFT))) == 0)
3248                 pmap_zero_page_area(m, endoff,
3249                     DEV_BSIZE - (endoff & (DEV_BSIZE - 1)));
3250
3251         /*
3252          * Set valid, clear dirty bits.  If validating the entire
3253          * page we can safely clear the pmap modify bit.  We also
3254          * use this opportunity to clear the VPO_NOSYNC flag.  If a process
3255          * takes a write fault on a MAP_NOSYNC memory area the flag will
3256          * be set again.
3257          *
3258          * We set valid bits inclusive of any overlap, but we can only
3259          * clear dirty bits for DEV_BSIZE chunks that are fully within
3260          * the range.
3261          */
3262         oldvalid = m->valid;
3263         pagebits = vm_page_bits(base, size);
3264         m->valid |= pagebits;
3265 #if 0   /* NOT YET */
3266         if ((frag = base & (DEV_BSIZE - 1)) != 0) {
3267                 frag = DEV_BSIZE - frag;
3268                 base += frag;
3269                 size -= frag;
3270                 if (size < 0)
3271                         size = 0;
3272         }
3273         pagebits = vm_page_bits(base, size & (DEV_BSIZE - 1));
3274 #endif
3275         if (base == 0 && size == PAGE_SIZE) {
3276                 /*
3277                  * The page can only be modified within the pmap if it is
3278                  * mapped, and it can only be mapped if it was previously
3279                  * fully valid.
3280                  */
3281                 if (oldvalid == VM_PAGE_BITS_ALL)
3282                         /*
3283                          * Perform the pmap_clear_modify() first.  Otherwise,
3284                          * a concurrent pmap operation, such as
3285                          * pmap_protect(), could clear a modification in the
3286                          * pmap and set the dirty field on the page before
3287                          * pmap_clear_modify() had begun and after the dirty
3288                          * field was cleared here.
3289                          */
3290                         pmap_clear_modify(m);
3291                 m->dirty = 0;
3292                 m->oflags &= ~VPO_NOSYNC;
3293         } else if (oldvalid != VM_PAGE_BITS_ALL)
3294                 m->dirty &= ~pagebits;
3295         else
3296                 vm_page_clear_dirty_mask(m, pagebits);
3297 }
3298
3299 void
3300 vm_page_clear_dirty(vm_page_t m, int base, int size)
3301 {
3302
3303         vm_page_clear_dirty_mask(m, vm_page_bits(base, size));
3304 }
3305
3306 /*
3307  *      vm_page_set_invalid:
3308  *
3309  *      Invalidates DEV_BSIZE'd chunks within a page.  Both the
3310  *      valid and dirty bits for the effected areas are cleared.
3311  */
3312 void
3313 vm_page_set_invalid(vm_page_t m, int base, int size)
3314 {
3315         vm_page_bits_t bits;
3316         vm_object_t object;
3317
3318         object = m->object;
3319         VM_OBJECT_ASSERT_WLOCKED(object);
3320         if (object->type == OBJT_VNODE && base == 0 && IDX_TO_OFF(m->pindex) +
3321             size >= object->un_pager.vnp.vnp_size)
3322                 bits = VM_PAGE_BITS_ALL;
3323         else
3324                 bits = vm_page_bits(base, size);
3325         if (object->ref_count != 0 && m->valid == VM_PAGE_BITS_ALL &&
3326             bits != 0)
3327                 pmap_remove_all(m);
3328         KASSERT((bits == 0 && m->valid == VM_PAGE_BITS_ALL) ||
3329             !pmap_page_is_mapped(m),
3330             ("vm_page_set_invalid: page %p is mapped", m));
3331         m->valid &= ~bits;
3332         m->dirty &= ~bits;
3333 }
3334
3335 /*
3336  * vm_page_zero_invalid()
3337  *
3338  *      The kernel assumes that the invalid portions of a page contain
3339  *      garbage, but such pages can be mapped into memory by user code.
3340  *      When this occurs, we must zero out the non-valid portions of the
3341  *      page so user code sees what it expects.
3342  *
3343  *      Pages are most often semi-valid when the end of a file is mapped
3344  *      into memory and the file's size is not page aligned.
3345  */
3346 void
3347 vm_page_zero_invalid(vm_page_t m, boolean_t setvalid)
3348 {
3349         int b;
3350         int i;
3351
3352         VM_OBJECT_ASSERT_WLOCKED(m->object);
3353         /*
3354          * Scan the valid bits looking for invalid sections that
3355          * must be zeroed.  Invalid sub-DEV_BSIZE'd areas ( where the
3356          * valid bit may be set ) have already been zeroed by
3357          * vm_page_set_validclean().
3358          */
3359         for (b = i = 0; i <= PAGE_SIZE / DEV_BSIZE; ++i) {
3360                 if (i == (PAGE_SIZE / DEV_BSIZE) ||
3361                     (m->valid & ((vm_page_bits_t)1 << i))) {
3362                         if (i > b) {
3363                                 pmap_zero_page_area(m,
3364                                     b << DEV_BSHIFT, (i - b) << DEV_BSHIFT);
3365                         }
3366                         b = i + 1;
3367                 }
3368         }
3369
3370         /*
3371          * setvalid is TRUE when we can safely set the zero'd areas
3372          * as being valid.  We can do this if there are no cache consistancy
3373          * issues.  e.g. it is ok to do with UFS, but not ok to do with NFS.
3374          */
3375         if (setvalid)
3376                 m->valid = VM_PAGE_BITS_ALL;
3377 }
3378
3379 /*
3380  *      vm_page_is_valid:
3381  *
3382  *      Is (partial) page valid?  Note that the case where size == 0
3383  *      will return FALSE in the degenerate case where the page is
3384  *      entirely invalid, and TRUE otherwise.
3385  */
3386 int
3387 vm_page_is_valid(vm_page_t m, int base, int size)
3388 {
3389         vm_page_bits_t bits;
3390
3391         VM_OBJECT_ASSERT_LOCKED(m->object);
3392         bits = vm_page_bits(base, size);
3393         return (m->valid != 0 && (m->valid & bits) == bits);
3394 }
3395
3396 /*
3397  *      vm_page_ps_is_valid:
3398  *
3399  *      Returns TRUE if the entire (super)page is valid and FALSE otherwise.
3400  */
3401 boolean_t
3402 vm_page_ps_is_valid(vm_page_t m)
3403 {
3404         int i, npages;
3405
3406         VM_OBJECT_ASSERT_LOCKED(m->object);
3407         npages = atop(pagesizes[m->psind]);
3408
3409         /*
3410          * The physically contiguous pages that make up a superpage, i.e., a
3411          * page with a page size index ("psind") greater than zero, will
3412          * occupy adjacent entries in vm_page_array[].
3413          */
3414         for (i = 0; i < npages; i++) {
3415                 if (m[i].valid != VM_PAGE_BITS_ALL)
3416                         return (FALSE);
3417         }
3418         return (TRUE);
3419 }
3420
3421 /*
3422  * Set the page's dirty bits if the page is modified.
3423  */
3424 void
3425 vm_page_test_dirty(vm_page_t m)
3426 {
3427
3428         VM_OBJECT_ASSERT_WLOCKED(m->object);
3429         if (m->dirty != VM_PAGE_BITS_ALL && pmap_is_modified(m))
3430                 vm_page_dirty(m);
3431 }
3432
3433 void
3434 vm_page_lock_KBI(vm_page_t m, const char *file, int line)
3435 {
3436
3437         mtx_lock_flags_(vm_page_lockptr(m), 0, file, line);
3438 }
3439
3440 void
3441 vm_page_unlock_KBI(vm_page_t m, const char *file, int line)
3442 {
3443
3444         mtx_unlock_flags_(vm_page_lockptr(m), 0, file, line);
3445 }
3446
3447 int
3448 vm_page_trylock_KBI(vm_page_t m, const char *file, int line)
3449 {
3450
3451         return (mtx_trylock_flags_(vm_page_lockptr(m), 0, file, line));
3452 }
3453
3454 #if defined(INVARIANTS) || defined(INVARIANT_SUPPORT)
3455 void
3456 vm_page_assert_locked_KBI(vm_page_t m, const char *file, int line)
3457 {
3458
3459         vm_page_lock_assert_KBI(m, MA_OWNED, file, line);
3460 }
3461
3462 void
3463 vm_page_lock_assert_KBI(vm_page_t m, int a, const char *file, int line)
3464 {
3465
3466         mtx_assert_(vm_page_lockptr(m), a, file, line);
3467 }
3468 #endif
3469
3470 #ifdef INVARIANTS
3471 void
3472 vm_page_object_lock_assert(vm_page_t m)
3473 {
3474
3475         /*
3476          * Certain of the page's fields may only be modified by the
3477          * holder of the containing object's lock or the exclusive busy.
3478          * holder.  Unfortunately, the holder of the write busy is
3479          * not recorded, and thus cannot be checked here.
3480          */
3481         if (m->object != NULL && !vm_page_xbusied(m))
3482                 VM_OBJECT_ASSERT_WLOCKED(m->object);
3483 }
3484
3485 void
3486 vm_page_assert_pga_writeable(vm_page_t m, uint8_t bits)
3487 {
3488
3489         if ((bits & PGA_WRITEABLE) == 0)
3490                 return;
3491
3492         /*
3493          * The PGA_WRITEABLE flag can only be set if the page is
3494          * managed, is exclusively busied or the object is locked.
3495          * Currently, this flag is only set by pmap_enter().
3496          */
3497         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
3498             ("PGA_WRITEABLE on unmanaged page"));
3499         if (!vm_page_xbusied(m))
3500                 VM_OBJECT_ASSERT_LOCKED(m->object);
3501 }
3502 #endif
3503
3504 #include "opt_ddb.h"
3505 #ifdef DDB
3506 #include <sys/kernel.h>
3507
3508 #include <ddb/ddb.h>
3509
3510 DB_SHOW_COMMAND(page, vm_page_print_page_info)
3511 {
3512         db_printf("vm_cnt.v_free_count: %d\n", vm_cnt.v_free_count);
3513         db_printf("vm_cnt.v_cache_count: %d\n", vm_cnt.v_cache_count);
3514         db_printf("vm_cnt.v_inactive_count: %d\n", vm_cnt.v_inactive_count);
3515         db_printf("vm_cnt.v_active_count: %d\n", vm_cnt.v_active_count);
3516         db_printf("vm_cnt.v_laundry_count: %d\n", vm_cnt.v_laundry_count);
3517         db_printf("vm_cnt.v_wire_count: %d\n", vm_cnt.v_wire_count);
3518         db_printf("vm_cnt.v_free_reserved: %d\n", vm_cnt.v_free_reserved);
3519         db_printf("vm_cnt.v_free_min: %d\n", vm_cnt.v_free_min);
3520         db_printf("vm_cnt.v_free_target: %d\n", vm_cnt.v_free_target);
3521         db_printf("vm_cnt.v_inactive_target: %d\n", vm_cnt.v_inactive_target);
3522 }
3523
3524 DB_SHOW_COMMAND(pageq, vm_page_print_pageq_info)
3525 {
3526         int dom;
3527
3528         db_printf("pq_free %d pq_cache %d\n",
3529             vm_cnt.v_free_count, vm_cnt.v_cache_count);
3530         for (dom = 0; dom < vm_ndomains; dom++) {
3531                 db_printf(
3532             "dom %d page_cnt %d free %d pq_act %d pq_inact %d pq_laund %d\n",
3533                     dom,
3534                     vm_dom[dom].vmd_page_count,
3535                     vm_dom[dom].vmd_free_count,
3536                     vm_dom[dom].vmd_pagequeues[PQ_ACTIVE].pq_cnt,
3537                     vm_dom[dom].vmd_pagequeues[PQ_INACTIVE].pq_cnt,
3538                     vm_dom[dom].vmd_pagequeues[PQ_LAUNDRY].pq_cnt);
3539         }
3540 }
3541
3542 DB_SHOW_COMMAND(pginfo, vm_page_print_pginfo)
3543 {
3544         vm_page_t m;
3545         boolean_t phys;
3546
3547         if (!have_addr) {
3548                 db_printf("show pginfo addr\n");
3549                 return;
3550         }
3551
3552         phys = strchr(modif, 'p') != NULL;
3553         if (phys)
3554                 m = PHYS_TO_VM_PAGE(addr);
3555         else
3556                 m = (vm_page_t)addr;
3557         db_printf(
3558     "page %p obj %p pidx 0x%jx phys 0x%jx q %d hold %d wire %d\n"
3559     "  af 0x%x of 0x%x f 0x%x act %d busy %x valid 0x%x dirty 0x%x\n",
3560             m, m->object, (uintmax_t)m->pindex, (uintmax_t)m->phys_addr,
3561             m->queue, m->hold_count, m->wire_count, m->aflags, m->oflags,
3562             m->flags, m->act_count, m->busy_lock, m->valid, m->dirty);
3563 }
3564 #endif /* DDB */