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          * Allocate a page if the number of free pages exceeds the minimum
1516          * for the request class.
1517          */
1518         mtx_lock(&vm_page_queue_free_mtx);
1519         if (vm_cnt.v_free_count > vm_cnt.v_free_reserved ||
1520             (req_class == VM_ALLOC_SYSTEM &&
1521             vm_cnt.v_free_count > vm_cnt.v_interrupt_free_min) ||
1522             (req_class == VM_ALLOC_INTERRUPT &&
1523             vm_cnt.v_free_count > 0)) {
1524                 /*
1525                  * Can we allocate the page from a reservation?
1526                  */
1527 #if VM_NRESERVLEVEL > 0
1528                 if (object == NULL || (object->flags & (OBJ_COLORED |
1529                     OBJ_FICTITIOUS)) != OBJ_COLORED || (m =
1530                     vm_reserv_alloc_page(object, pindex, mpred)) == NULL)
1531 #endif
1532                 {
1533                         /*
1534                          * If not, allocate it from the free page queues.
1535                          */
1536                         m = vm_phys_alloc_pages(object != NULL ?
1537                             VM_FREEPOOL_DEFAULT : VM_FREEPOOL_DIRECT, 0);
1538 #if VM_NRESERVLEVEL > 0
1539                         if (m == NULL && vm_reserv_reclaim_inactive()) {
1540                                 m = vm_phys_alloc_pages(object != NULL ?
1541                                     VM_FREEPOOL_DEFAULT : VM_FREEPOOL_DIRECT,
1542                                     0);
1543                         }
1544 #endif
1545                 }
1546         } else {
1547                 /*
1548                  * Not allocatable, give up.
1549                  */
1550                 mtx_unlock(&vm_page_queue_free_mtx);
1551                 atomic_add_int(&vm_pageout_deficit,
1552                     max((u_int)req >> VM_ALLOC_COUNT_SHIFT, 1));
1553                 pagedaemon_wakeup();
1554                 return (NULL);
1555         }
1556
1557         /*
1558          *  At this point we had better have found a good page.
1559          */
1560         KASSERT(m != NULL, ("vm_page_alloc: missing page"));
1561         vm_phys_freecnt_adj(m, -1);
1562         mtx_unlock(&vm_page_queue_free_mtx);
1563         vm_page_alloc_check(m);
1564
1565         /*
1566          * Initialize the page.  Only the PG_ZERO flag is inherited.
1567          */
1568         flags = 0;
1569         if ((req & VM_ALLOC_ZERO) != 0)
1570                 flags = PG_ZERO;
1571         flags &= m->flags;
1572         if ((req & VM_ALLOC_NODUMP) != 0)
1573                 flags |= PG_NODUMP;
1574         m->flags = flags;
1575         m->aflags = 0;
1576         m->oflags = object == NULL || (object->flags & OBJ_UNMANAGED) != 0 ?
1577             VPO_UNMANAGED : 0;
1578         m->busy_lock = VPB_UNBUSIED;
1579         if ((req & (VM_ALLOC_NOBUSY | VM_ALLOC_NOOBJ | VM_ALLOC_SBUSY)) == 0)
1580                 m->busy_lock = VPB_SINGLE_EXCLUSIVER;
1581         if ((req & VM_ALLOC_SBUSY) != 0)
1582                 m->busy_lock = VPB_SHARERS_WORD(1);
1583         if (req & VM_ALLOC_WIRED) {
1584                 /*
1585                  * The page lock is not required for wiring a page until that
1586                  * page is inserted into the object.
1587                  */
1588                 atomic_add_int(&vm_cnt.v_wire_count, 1);
1589                 m->wire_count = 1;
1590         }
1591         m->act_count = 0;
1592
1593         if (object != NULL) {
1594                 if (vm_page_insert_after(m, object, pindex, mpred)) {
1595                         pagedaemon_wakeup();
1596                         if (req & VM_ALLOC_WIRED) {
1597                                 atomic_subtract_int(&vm_cnt.v_wire_count, 1);
1598                                 m->wire_count = 0;
1599                         }
1600                         m->object = NULL;
1601                         m->oflags = VPO_UNMANAGED;
1602                         m->busy_lock = VPB_UNBUSIED;
1603                         vm_page_free(m);
1604                         return (NULL);
1605                 }
1606
1607                 /* Ignore device objects; the pager sets "memattr" for them. */
1608                 if (object->memattr != VM_MEMATTR_DEFAULT &&
1609                     (object->flags & OBJ_FICTITIOUS) == 0)
1610                         pmap_page_set_memattr(m, object->memattr);
1611         } else
1612                 m->pindex = pindex;
1613
1614         /*
1615          * Don't wakeup too often - wakeup the pageout daemon when
1616          * we would be nearly out of memory.
1617          */
1618         if (vm_paging_needed())
1619                 pagedaemon_wakeup();
1620
1621         return (m);
1622 }
1623
1624 /*
1625  *      vm_page_alloc_contig:
1626  *
1627  *      Allocate a contiguous set of physical pages of the given size "npages"
1628  *      from the free lists.  All of the physical pages must be at or above
1629  *      the given physical address "low" and below the given physical address
1630  *      "high".  The given value "alignment" determines the alignment of the
1631  *      first physical page in the set.  If the given value "boundary" is
1632  *      non-zero, then the set of physical pages cannot cross any physical
1633  *      address boundary that is a multiple of that value.  Both "alignment"
1634  *      and "boundary" must be a power of two.
1635  *
1636  *      If the specified memory attribute, "memattr", is VM_MEMATTR_DEFAULT,
1637  *      then the memory attribute setting for the physical pages is configured
1638  *      to the object's memory attribute setting.  Otherwise, the memory
1639  *      attribute setting for the physical pages is configured to "memattr",
1640  *      overriding the object's memory attribute setting.  However, if the
1641  *      object's memory attribute setting is not VM_MEMATTR_DEFAULT, then the
1642  *      memory attribute setting for the physical pages cannot be configured
1643  *      to VM_MEMATTR_DEFAULT.
1644  *
1645  *      The caller must always specify an allocation class.
1646  *
1647  *      allocation classes:
1648  *      VM_ALLOC_NORMAL         normal process request
1649  *      VM_ALLOC_SYSTEM         system *really* needs a page
1650  *      VM_ALLOC_INTERRUPT      interrupt time request
1651  *
1652  *      optional allocation flags:
1653  *      VM_ALLOC_NOBUSY         do not exclusive busy the page
1654  *      VM_ALLOC_NODUMP         do not include the page in a kernel core dump
1655  *      VM_ALLOC_NOOBJ          page is not associated with an object and
1656  *                              should not be exclusive busy
1657  *      VM_ALLOC_SBUSY          shared busy the allocated page
1658  *      VM_ALLOC_WIRED          wire the allocated page
1659  *      VM_ALLOC_ZERO           prefer a zeroed page
1660  *
1661  *      This routine may not sleep.
1662  */
1663 vm_page_t
1664 vm_page_alloc_contig(vm_object_t object, vm_pindex_t pindex, int req,
1665     u_long npages, vm_paddr_t low, vm_paddr_t high, u_long alignment,
1666     vm_paddr_t boundary, vm_memattr_t memattr)
1667 {
1668         vm_page_t m, m_tmp, m_ret;
1669         u_int flags;
1670         int req_class;
1671
1672         KASSERT((object != NULL) == ((req & VM_ALLOC_NOOBJ) == 0) &&
1673             (object != NULL || (req & VM_ALLOC_SBUSY) == 0) &&
1674             ((req & (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)) !=
1675             (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)),
1676             ("vm_page_alloc: inconsistent object(%p)/req(%x)", (void *)object,
1677             req));
1678         if (object != NULL) {
1679                 VM_OBJECT_ASSERT_WLOCKED(object);
1680                 KASSERT(object->type == OBJT_PHYS,
1681                     ("vm_page_alloc_contig: object %p isn't OBJT_PHYS",
1682                     object));
1683         }
1684         KASSERT(npages > 0, ("vm_page_alloc_contig: npages is zero"));
1685         req_class = req & VM_ALLOC_CLASS_MASK;
1686
1687         /*
1688          * The page daemon is allowed to dig deeper into the free page list.
1689          */
1690         if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
1691                 req_class = VM_ALLOC_SYSTEM;
1692
1693         mtx_lock(&vm_page_queue_free_mtx);
1694         if (vm_cnt.v_free_count >= npages + vm_cnt.v_free_reserved ||
1695             (req_class == VM_ALLOC_SYSTEM &&
1696             vm_cnt.v_free_count >= npages + vm_cnt.v_interrupt_free_min) ||
1697             (req_class == VM_ALLOC_INTERRUPT &&
1698             vm_cnt.v_free_count >= npages)) {
1699 #if VM_NRESERVLEVEL > 0
1700 retry:
1701                 if (object == NULL || (object->flags & OBJ_COLORED) == 0 ||
1702                     (m_ret = vm_reserv_alloc_contig(object, pindex, npages,
1703                     low, high, alignment, boundary)) == NULL)
1704 #endif
1705                         m_ret = vm_phys_alloc_contig(npages, low, high,
1706                             alignment, boundary);
1707         } else {
1708                 mtx_unlock(&vm_page_queue_free_mtx);
1709                 atomic_add_int(&vm_pageout_deficit, npages);
1710                 pagedaemon_wakeup();
1711                 return (NULL);
1712         }
1713         if (m_ret != NULL)
1714                 vm_phys_freecnt_adj(m_ret, -npages);
1715         else {
1716 #if VM_NRESERVLEVEL > 0
1717                 if (vm_reserv_reclaim_contig(npages, low, high, alignment,
1718                     boundary))
1719                         goto retry;
1720 #endif
1721         }
1722         mtx_unlock(&vm_page_queue_free_mtx);
1723         if (m_ret == NULL)
1724                 return (NULL);
1725         for (m = m_ret; m < &m_ret[npages]; m++)
1726                 vm_page_alloc_check(m);
1727
1728         /*
1729          * Initialize the pages.  Only the PG_ZERO flag is inherited.
1730          */
1731         flags = 0;
1732         if ((req & VM_ALLOC_ZERO) != 0)
1733                 flags = PG_ZERO;
1734         if ((req & VM_ALLOC_NODUMP) != 0)
1735                 flags |= PG_NODUMP;
1736         if ((req & VM_ALLOC_WIRED) != 0)
1737                 atomic_add_int(&vm_cnt.v_wire_count, npages);
1738         if (object != NULL) {
1739                 if (object->memattr != VM_MEMATTR_DEFAULT &&
1740                     memattr == VM_MEMATTR_DEFAULT)
1741                         memattr = object->memattr;
1742         }
1743         for (m = m_ret; m < &m_ret[npages]; m++) {
1744                 m->aflags = 0;
1745                 m->flags = (m->flags | PG_NODUMP) & flags;
1746                 m->busy_lock = VPB_UNBUSIED;
1747                 if (object != NULL) {
1748                         if ((req & (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)) == 0)
1749                                 m->busy_lock = VPB_SINGLE_EXCLUSIVER;
1750                         if ((req & VM_ALLOC_SBUSY) != 0)
1751                                 m->busy_lock = VPB_SHARERS_WORD(1);
1752                 }
1753                 if ((req & VM_ALLOC_WIRED) != 0)
1754                         m->wire_count = 1;
1755                 /* Unmanaged pages don't use "act_count". */
1756                 m->oflags = VPO_UNMANAGED;
1757                 if (object != NULL) {
1758                         if (vm_page_insert(m, object, pindex)) {
1759                                 if (vm_paging_needed())
1760                                         pagedaemon_wakeup();
1761                                 if ((req & VM_ALLOC_WIRED) != 0)
1762                                         atomic_subtract_int(&vm_cnt.v_wire_count,
1763                                             npages);
1764                                 for (m_tmp = m, m = m_ret;
1765                                     m < &m_ret[npages]; m++) {
1766                                         if ((req & VM_ALLOC_WIRED) != 0)
1767                                                 m->wire_count = 0;
1768                                         if (m >= m_tmp) {
1769                                                 m->object = NULL;
1770                                                 m->oflags |= VPO_UNMANAGED;
1771                                         }
1772                                         m->busy_lock = VPB_UNBUSIED;
1773                                         vm_page_free(m);
1774                                 }
1775                                 return (NULL);
1776                         }
1777                 } else
1778                         m->pindex = pindex;
1779                 if (memattr != VM_MEMATTR_DEFAULT)
1780                         pmap_page_set_memattr(m, memattr);
1781                 pindex++;
1782         }
1783         if (vm_paging_needed())
1784                 pagedaemon_wakeup();
1785         return (m_ret);
1786 }
1787
1788 /*
1789  * Check a page that has been freshly dequeued from a freelist.
1790  */
1791 static void
1792 vm_page_alloc_check(vm_page_t m)
1793 {
1794
1795         KASSERT(m->queue == PQ_NONE,
1796             ("page %p has unexpected queue %d", m, m->queue));
1797         KASSERT(m->wire_count == 0, ("page %p is wired", m));
1798         KASSERT(m->hold_count == 0, ("page %p is held", m));
1799         KASSERT(!vm_page_busied(m), ("page %p is busy", m));
1800         KASSERT(m->dirty == 0, ("page %p is dirty", m));
1801         KASSERT(pmap_page_get_memattr(m) == VM_MEMATTR_DEFAULT,
1802             ("page %p has unexpected memattr %d",
1803             m, pmap_page_get_memattr(m)));
1804         KASSERT(m->valid == 0, ("free page %p is valid", m));
1805 }
1806
1807 /*
1808  *      vm_page_alloc_freelist:
1809  *
1810  *      Allocate a physical page from the specified free page list.
1811  *
1812  *      The caller must always specify an allocation class.
1813  *
1814  *      allocation classes:
1815  *      VM_ALLOC_NORMAL         normal process request
1816  *      VM_ALLOC_SYSTEM         system *really* needs a page
1817  *      VM_ALLOC_INTERRUPT      interrupt time request
1818  *
1819  *      optional allocation flags:
1820  *      VM_ALLOC_COUNT(number)  the number of additional pages that the caller
1821  *                              intends to allocate
1822  *      VM_ALLOC_WIRED          wire the allocated page
1823  *      VM_ALLOC_ZERO           prefer a zeroed page
1824  *
1825  *      This routine may not sleep.
1826  */
1827 vm_page_t
1828 vm_page_alloc_freelist(int flind, int req)
1829 {
1830         vm_page_t m;
1831         u_int flags;
1832         int req_class;
1833
1834         req_class = req & VM_ALLOC_CLASS_MASK;
1835
1836         /*
1837          * The page daemon is allowed to dig deeper into the free page list.
1838          */
1839         if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
1840                 req_class = VM_ALLOC_SYSTEM;
1841
1842         /*
1843          * Do not allocate reserved pages unless the req has asked for it.
1844          */
1845         mtx_lock(&vm_page_queue_free_mtx);
1846         if (vm_cnt.v_free_count > vm_cnt.v_free_reserved ||
1847             (req_class == VM_ALLOC_SYSTEM &&
1848             vm_cnt.v_free_count > vm_cnt.v_interrupt_free_min) ||
1849             (req_class == VM_ALLOC_INTERRUPT &&
1850             vm_cnt.v_free_count > 0))
1851                 m = vm_phys_alloc_freelist_pages(flind, VM_FREEPOOL_DIRECT, 0);
1852         else {
1853                 mtx_unlock(&vm_page_queue_free_mtx);
1854                 atomic_add_int(&vm_pageout_deficit,
1855                     max((u_int)req >> VM_ALLOC_COUNT_SHIFT, 1));
1856                 pagedaemon_wakeup();
1857                 return (NULL);
1858         }
1859         if (m == NULL) {
1860                 mtx_unlock(&vm_page_queue_free_mtx);
1861                 return (NULL);
1862         }
1863         vm_phys_freecnt_adj(m, -1);
1864         mtx_unlock(&vm_page_queue_free_mtx);
1865         vm_page_alloc_check(m);
1866
1867         /*
1868          * Initialize the page.  Only the PG_ZERO flag is inherited.
1869          */
1870         m->aflags = 0;
1871         flags = 0;
1872         if ((req & VM_ALLOC_ZERO) != 0)
1873                 flags = PG_ZERO;
1874         m->flags &= flags;
1875         if ((req & VM_ALLOC_WIRED) != 0) {
1876                 /*
1877                  * The page lock is not required for wiring a page that does
1878                  * not belong to an object.
1879                  */
1880                 atomic_add_int(&vm_cnt.v_wire_count, 1);
1881                 m->wire_count = 1;
1882         }
1883         /* Unmanaged pages don't use "act_count". */
1884         m->oflags = VPO_UNMANAGED;
1885         if (vm_paging_needed())
1886                 pagedaemon_wakeup();
1887         return (m);
1888 }
1889
1890 #define VPSC_ANY        0       /* No restrictions. */
1891 #define VPSC_NORESERV   1       /* Skip reservations; implies VPSC_NOSUPER. */
1892 #define VPSC_NOSUPER    2       /* Skip superpages. */
1893
1894 /*
1895  *      vm_page_scan_contig:
1896  *
1897  *      Scan vm_page_array[] between the specified entries "m_start" and
1898  *      "m_end" for a run of contiguous physical pages that satisfy the
1899  *      specified conditions, and return the lowest page in the run.  The
1900  *      specified "alignment" determines the alignment of the lowest physical
1901  *      page in the run.  If the specified "boundary" is non-zero, then the
1902  *      run of physical pages cannot span a physical address that is a
1903  *      multiple of "boundary".
1904  *
1905  *      "m_end" is never dereferenced, so it need not point to a vm_page
1906  *      structure within vm_page_array[].
1907  *
1908  *      "npages" must be greater than zero.  "m_start" and "m_end" must not
1909  *      span a hole (or discontiguity) in the physical address space.  Both
1910  *      "alignment" and "boundary" must be a power of two.
1911  */
1912 vm_page_t
1913 vm_page_scan_contig(u_long npages, vm_page_t m_start, vm_page_t m_end,
1914     u_long alignment, vm_paddr_t boundary, int options)
1915 {
1916         struct mtx *m_mtx, *new_mtx;
1917         vm_object_t object;
1918         vm_paddr_t pa;
1919         vm_page_t m, m_run;
1920 #if VM_NRESERVLEVEL > 0
1921         int level;
1922 #endif
1923         int m_inc, order, run_ext, run_len;
1924
1925         KASSERT(npages > 0, ("npages is 0"));
1926         KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
1927         KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
1928         m_run = NULL;
1929         run_len = 0;
1930         m_mtx = NULL;
1931         for (m = m_start; m < m_end && run_len < npages; m += m_inc) {
1932                 KASSERT((m->flags & (PG_FICTITIOUS | PG_MARKER)) == 0,
1933                     ("page %p is PG_FICTITIOUS or PG_MARKER", m));
1934
1935                 /*
1936                  * If the current page would be the start of a run, check its
1937                  * physical address against the end, alignment, and boundary
1938                  * conditions.  If it doesn't satisfy these conditions, either
1939                  * terminate the scan or advance to the next page that
1940                  * satisfies the failed condition.
1941                  */
1942                 if (run_len == 0) {
1943                         KASSERT(m_run == NULL, ("m_run != NULL"));
1944                         if (m + npages > m_end)
1945                                 break;
1946                         pa = VM_PAGE_TO_PHYS(m);
1947                         if ((pa & (alignment - 1)) != 0) {
1948                                 m_inc = atop(roundup2(pa, alignment) - pa);
1949                                 continue;
1950                         }
1951                         if (rounddown2(pa ^ (pa + ptoa(npages) - 1),
1952                             boundary) != 0) {
1953                                 m_inc = atop(roundup2(pa, boundary) - pa);
1954                                 continue;
1955                         }
1956                 } else
1957                         KASSERT(m_run != NULL, ("m_run == NULL"));
1958
1959                 /*
1960                  * Avoid releasing and reacquiring the same page lock.
1961                  */
1962                 new_mtx = vm_page_lockptr(m);
1963                 if (m_mtx != new_mtx) {
1964                         if (m_mtx != NULL)
1965                                 mtx_unlock(m_mtx);
1966                         m_mtx = new_mtx;
1967                         mtx_lock(m_mtx);
1968                 }
1969                 m_inc = 1;
1970 retry:
1971                 if (m->wire_count != 0 || m->hold_count != 0)
1972                         run_ext = 0;
1973 #if VM_NRESERVLEVEL > 0
1974                 else if ((level = vm_reserv_level(m)) >= 0 &&
1975                     (options & VPSC_NORESERV) != 0) {
1976                         run_ext = 0;
1977                         /* Advance to the end of the reservation. */
1978                         pa = VM_PAGE_TO_PHYS(m);
1979                         m_inc = atop(roundup2(pa + 1, vm_reserv_size(level)) -
1980                             pa);
1981                 }
1982 #endif
1983                 else if ((object = m->object) != NULL) {
1984                         /*
1985                          * The page is considered eligible for relocation if
1986                          * and only if it could be laundered or reclaimed by
1987                          * the page daemon.
1988                          */
1989                         if (!VM_OBJECT_TRYRLOCK(object)) {
1990                                 mtx_unlock(m_mtx);
1991                                 VM_OBJECT_RLOCK(object);
1992                                 mtx_lock(m_mtx);
1993                                 if (m->object != object) {
1994                                         /*
1995                                          * The page may have been freed.
1996                                          */
1997                                         VM_OBJECT_RUNLOCK(object);
1998                                         goto retry;
1999                                 } else if (m->wire_count != 0 ||
2000                                     m->hold_count != 0) {
2001                                         run_ext = 0;
2002                                         goto unlock;
2003                                 }
2004                         }
2005                         KASSERT((m->flags & PG_UNHOLDFREE) == 0,
2006                             ("page %p is PG_UNHOLDFREE", m));
2007                         /* Don't care: PG_NODUMP, PG_ZERO. */
2008                         if (object->type != OBJT_DEFAULT &&
2009                             object->type != OBJT_SWAP &&
2010                             object->type != OBJT_VNODE) {
2011                                 run_ext = 0;
2012 #if VM_NRESERVLEVEL > 0
2013                         } else if ((options & VPSC_NOSUPER) != 0 &&
2014                             (level = vm_reserv_level_iffullpop(m)) >= 0) {
2015                                 run_ext = 0;
2016                                 /* Advance to the end of the superpage. */
2017                                 pa = VM_PAGE_TO_PHYS(m);
2018                                 m_inc = atop(roundup2(pa + 1,
2019                                     vm_reserv_size(level)) - pa);
2020 #endif
2021                         } else if (object->memattr == VM_MEMATTR_DEFAULT &&
2022                             m->queue != PQ_NONE && !vm_page_busied(m)) {
2023                                 /*
2024                                  * The page is allocated but eligible for
2025                                  * relocation.  Extend the current run by one
2026                                  * page.
2027                                  */
2028                                 KASSERT(pmap_page_get_memattr(m) ==
2029                                     VM_MEMATTR_DEFAULT,
2030                                     ("page %p has an unexpected memattr", m));
2031                                 KASSERT((m->oflags & (VPO_SWAPINPROG |
2032                                     VPO_SWAPSLEEP | VPO_UNMANAGED)) == 0,
2033                                     ("page %p has unexpected oflags", m));
2034                                 /* Don't care: VPO_NOSYNC. */
2035                                 run_ext = 1;
2036                         } else
2037                                 run_ext = 0;
2038 unlock:
2039                         VM_OBJECT_RUNLOCK(object);
2040 #if VM_NRESERVLEVEL > 0
2041                 } else if (level >= 0) {
2042                         /*
2043                          * The page is reserved but not yet allocated.  In
2044                          * other words, it is still cached or free.  Extend
2045                          * the current run by one page.
2046                          */
2047                         run_ext = 1;
2048 #endif
2049                 } else if ((order = m->order) < VM_NFREEORDER) {
2050                         /*
2051                          * The page is enqueued in the physical memory
2052                          * allocator's cache/free page queues.  Moreover, it
2053                          * is the first page in a power-of-two-sized run of
2054                          * contiguous cache/free pages.  Add these pages to
2055                          * the end of the current run, and jump ahead.
2056                          */
2057                         run_ext = 1 << order;
2058                         m_inc = 1 << order;
2059                 } else {
2060                         /*
2061                          * Skip the page for one of the following reasons: (1)
2062                          * It is enqueued in the physical memory allocator's
2063                          * cache/free page queues.  However, it is not the
2064                          * first page in a run of contiguous cache/free pages.
2065                          * (This case rarely occurs because the scan is
2066                          * performed in ascending order.) (2) It is not
2067                          * reserved, and it is transitioning from free to
2068                          * allocated.  (Conversely, the transition from
2069                          * allocated to free for managed pages is blocked by
2070                          * the page lock.) (3) It is allocated but not
2071                          * contained by an object and not wired, e.g.,
2072                          * allocated by Xen's balloon driver.
2073                          */
2074                         run_ext = 0;
2075                 }
2076
2077                 /*
2078                  * Extend or reset the current run of pages.
2079                  */
2080                 if (run_ext > 0) {
2081                         if (run_len == 0)
2082                                 m_run = m;
2083                         run_len += run_ext;
2084                 } else {
2085                         if (run_len > 0) {
2086                                 m_run = NULL;
2087                                 run_len = 0;
2088                         }
2089                 }
2090         }
2091         if (m_mtx != NULL)
2092                 mtx_unlock(m_mtx);
2093         if (run_len >= npages)
2094                 return (m_run);
2095         return (NULL);
2096 }
2097
2098 /*
2099  *      vm_page_reclaim_run:
2100  *
2101  *      Try to relocate each of the allocated virtual pages within the
2102  *      specified run of physical pages to a new physical address.  Free the
2103  *      physical pages underlying the relocated virtual pages.  A virtual page
2104  *      is relocatable if and only if it could be laundered or reclaimed by
2105  *      the page daemon.  Whenever possible, a virtual page is relocated to a
2106  *      physical address above "high".
2107  *
2108  *      Returns 0 if every physical page within the run was already free or
2109  *      just freed by a successful relocation.  Otherwise, returns a non-zero
2110  *      value indicating why the last attempt to relocate a virtual page was
2111  *      unsuccessful.
2112  *
2113  *      "req_class" must be an allocation class.
2114  */
2115 static int
2116 vm_page_reclaim_run(int req_class, u_long npages, vm_page_t m_run,
2117     vm_paddr_t high)
2118 {
2119         struct mtx *m_mtx, *new_mtx;
2120         struct spglist free;
2121         vm_object_t object;
2122         vm_paddr_t pa;
2123         vm_page_t m, m_end, m_new;
2124         int error, order, req;
2125
2126         KASSERT((req_class & VM_ALLOC_CLASS_MASK) == req_class,
2127             ("req_class is not an allocation class"));
2128         SLIST_INIT(&free);
2129         error = 0;
2130         m = m_run;
2131         m_end = m_run + npages;
2132         m_mtx = NULL;
2133         for (; error == 0 && m < m_end; m++) {
2134                 KASSERT((m->flags & (PG_FICTITIOUS | PG_MARKER)) == 0,
2135                     ("page %p is PG_FICTITIOUS or PG_MARKER", m));
2136
2137                 /*
2138                  * Avoid releasing and reacquiring the same page lock.
2139                  */
2140                 new_mtx = vm_page_lockptr(m);
2141                 if (m_mtx != new_mtx) {
2142                         if (m_mtx != NULL)
2143                                 mtx_unlock(m_mtx);
2144                         m_mtx = new_mtx;
2145                         mtx_lock(m_mtx);
2146                 }
2147 retry:
2148                 if (m->wire_count != 0 || m->hold_count != 0)
2149                         error = EBUSY;
2150                 else if ((object = m->object) != NULL) {
2151                         /*
2152                          * The page is relocated if and only if it could be
2153                          * laundered or reclaimed by the page daemon.
2154                          */
2155                         if (!VM_OBJECT_TRYWLOCK(object)) {
2156                                 mtx_unlock(m_mtx);
2157                                 VM_OBJECT_WLOCK(object);
2158                                 mtx_lock(m_mtx);
2159                                 if (m->object != object) {
2160                                         /*
2161                                          * The page may have been freed.
2162                                          */
2163                                         VM_OBJECT_WUNLOCK(object);
2164                                         goto retry;
2165                                 } else if (m->wire_count != 0 ||
2166                                     m->hold_count != 0) {
2167                                         error = EBUSY;
2168                                         goto unlock;
2169                                 }
2170                         }
2171                         KASSERT((m->flags & PG_UNHOLDFREE) == 0,
2172                             ("page %p is PG_UNHOLDFREE", m));
2173                         /* Don't care: PG_NODUMP, PG_ZERO. */
2174                         if (object->type != OBJT_DEFAULT &&
2175                             object->type != OBJT_SWAP &&
2176                             object->type != OBJT_VNODE)
2177                                 error = EINVAL;
2178                         else if (object->memattr != VM_MEMATTR_DEFAULT)
2179                                 error = EINVAL;
2180                         else if (m->queue != PQ_NONE && !vm_page_busied(m)) {
2181                                 KASSERT(pmap_page_get_memattr(m) ==
2182                                     VM_MEMATTR_DEFAULT,
2183                                     ("page %p has an unexpected memattr", m));
2184                                 KASSERT((m->oflags & (VPO_SWAPINPROG |
2185                                     VPO_SWAPSLEEP | VPO_UNMANAGED)) == 0,
2186                                     ("page %p has unexpected oflags", m));
2187                                 /* Don't care: VPO_NOSYNC. */
2188                                 if (m->valid != 0) {
2189                                         /*
2190                                          * First, try to allocate a new page
2191                                          * that is above "high".  Failing
2192                                          * that, try to allocate a new page
2193                                          * that is below "m_run".  Allocate
2194                                          * the new page between the end of
2195                                          * "m_run" and "high" only as a last
2196                                          * resort.
2197                                          */
2198                                         req = req_class | VM_ALLOC_NOOBJ;
2199                                         if ((m->flags & PG_NODUMP) != 0)
2200                                                 req |= VM_ALLOC_NODUMP;
2201                                         if (trunc_page(high) !=
2202                                             ~(vm_paddr_t)PAGE_MASK) {
2203                                                 m_new = vm_page_alloc_contig(
2204                                                     NULL, 0, req, 1,
2205                                                     round_page(high),
2206                                                     ~(vm_paddr_t)0,
2207                                                     PAGE_SIZE, 0,
2208                                                     VM_MEMATTR_DEFAULT);
2209                                         } else
2210                                                 m_new = NULL;
2211                                         if (m_new == NULL) {
2212                                                 pa = VM_PAGE_TO_PHYS(m_run);
2213                                                 m_new = vm_page_alloc_contig(
2214                                                     NULL, 0, req, 1,
2215                                                     0, pa - 1, PAGE_SIZE, 0,
2216                                                     VM_MEMATTR_DEFAULT);
2217                                         }
2218                                         if (m_new == NULL) {
2219                                                 pa += ptoa(npages);
2220                                                 m_new = vm_page_alloc_contig(
2221                                                     NULL, 0, req, 1,
2222                                                     pa, high, PAGE_SIZE, 0,
2223                                                     VM_MEMATTR_DEFAULT);
2224                                         }
2225                                         if (m_new == NULL) {
2226                                                 error = ENOMEM;
2227                                                 goto unlock;
2228                                         }
2229                                         KASSERT(m_new->wire_count == 0,
2230                                             ("page %p is wired", m));
2231
2232                                         /*
2233                                          * Replace "m" with the new page.  For
2234                                          * vm_page_replace(), "m" must be busy
2235                                          * and dequeued.  Finally, change "m"
2236                                          * as if vm_page_free() was called.
2237                                          */
2238                                         if (object->ref_count != 0)
2239                                                 pmap_remove_all(m);
2240                                         m_new->aflags = m->aflags;
2241                                         KASSERT(m_new->oflags == VPO_UNMANAGED,
2242                                             ("page %p is managed", m));
2243                                         m_new->oflags = m->oflags & VPO_NOSYNC;
2244                                         pmap_copy_page(m, m_new);
2245                                         m_new->valid = m->valid;
2246                                         m_new->dirty = m->dirty;
2247                                         m->flags &= ~PG_ZERO;
2248                                         vm_page_xbusy(m);
2249                                         vm_page_remque(m);
2250                                         vm_page_replace_checked(m_new, object,
2251                                             m->pindex, m);
2252                                         m->valid = 0;
2253                                         vm_page_undirty(m);
2254
2255                                         /*
2256                                          * The new page must be deactivated
2257                                          * before the object is unlocked.
2258                                          */
2259                                         new_mtx = vm_page_lockptr(m_new);
2260                                         if (m_mtx != new_mtx) {
2261                                                 mtx_unlock(m_mtx);
2262                                                 m_mtx = new_mtx;
2263                                                 mtx_lock(m_mtx);
2264                                         }
2265                                         vm_page_deactivate(m_new);
2266                                 } else {
2267                                         m->flags &= ~PG_ZERO;
2268                                         vm_page_remque(m);
2269                                         vm_page_remove(m);
2270                                         KASSERT(m->dirty == 0,
2271                                             ("page %p is dirty", m));
2272                                 }
2273                                 SLIST_INSERT_HEAD(&free, m, plinks.s.ss);
2274                         } else
2275                                 error = EBUSY;
2276 unlock:
2277                         VM_OBJECT_WUNLOCK(object);
2278                 } else {
2279                         mtx_lock(&vm_page_queue_free_mtx);
2280                         order = m->order;
2281                         if (order < VM_NFREEORDER) {
2282                                 /*
2283                                  * The page is enqueued in the physical memory
2284                                  * allocator's cache/free page queues.
2285                                  * Moreover, it is the first page in a power-
2286                                  * of-two-sized run of contiguous cache/free
2287                                  * pages.  Jump ahead to the last page within
2288                                  * that run, and continue from there.
2289                                  */
2290                                 m += (1 << order) - 1;
2291                         }
2292 #if VM_NRESERVLEVEL > 0
2293                         else if (vm_reserv_is_page_free(m))
2294                                 order = 0;
2295 #endif
2296                         mtx_unlock(&vm_page_queue_free_mtx);
2297                         if (order == VM_NFREEORDER)
2298                                 error = EINVAL;
2299                 }
2300         }
2301         if (m_mtx != NULL)
2302                 mtx_unlock(m_mtx);
2303         if ((m = SLIST_FIRST(&free)) != NULL) {
2304                 mtx_lock(&vm_page_queue_free_mtx);
2305                 do {
2306                         SLIST_REMOVE_HEAD(&free, plinks.s.ss);
2307                         vm_phys_freecnt_adj(m, 1);
2308 #if VM_NRESERVLEVEL > 0
2309                         if (!vm_reserv_free_page(m))
2310 #else
2311                         if (true)
2312 #endif
2313                                 vm_phys_free_pages(m, 0);
2314                 } while ((m = SLIST_FIRST(&free)) != NULL);
2315                 vm_page_free_wakeup();
2316                 mtx_unlock(&vm_page_queue_free_mtx);
2317         }
2318         return (error);
2319 }
2320
2321 #define NRUNS   16
2322
2323 CTASSERT(powerof2(NRUNS));
2324
2325 #define RUN_INDEX(count)        ((count) & (NRUNS - 1))
2326
2327 #define MIN_RECLAIM     8
2328
2329 /*
2330  *      vm_page_reclaim_contig:
2331  *
2332  *      Reclaim allocated, contiguous physical memory satisfying the specified
2333  *      conditions by relocating the virtual pages using that physical memory.
2334  *      Returns true if reclamation is successful and false otherwise.  Since
2335  *      relocation requires the allocation of physical pages, reclamation may
2336  *      fail due to a shortage of cache/free pages.  When reclamation fails,
2337  *      callers are expected to perform VM_WAIT before retrying a failed
2338  *      allocation operation, e.g., vm_page_alloc_contig().
2339  *
2340  *      The caller must always specify an allocation class through "req".
2341  *
2342  *      allocation classes:
2343  *      VM_ALLOC_NORMAL         normal process request
2344  *      VM_ALLOC_SYSTEM         system *really* needs a page
2345  *      VM_ALLOC_INTERRUPT      interrupt time request
2346  *
2347  *      The optional allocation flags are ignored.
2348  *
2349  *      "npages" must be greater than zero.  Both "alignment" and "boundary"
2350  *      must be a power of two.
2351  */
2352 bool
2353 vm_page_reclaim_contig(int req, u_long npages, vm_paddr_t low, vm_paddr_t high,
2354     u_long alignment, vm_paddr_t boundary)
2355 {
2356         vm_paddr_t curr_low;
2357         vm_page_t m_run, m_runs[NRUNS];
2358         u_long count, reclaimed;
2359         int error, i, options, req_class;
2360
2361         KASSERT(npages > 0, ("npages is 0"));
2362         KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
2363         KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
2364         req_class = req & VM_ALLOC_CLASS_MASK;
2365
2366         /*
2367          * The page daemon is allowed to dig deeper into the free page list.
2368          */
2369         if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
2370                 req_class = VM_ALLOC_SYSTEM;
2371
2372         /*
2373          * Return if the number of cached and free pages cannot satisfy the
2374          * requested allocation.
2375          */
2376         count = vm_cnt.v_free_count;
2377         if (count < npages + vm_cnt.v_free_reserved || (count < npages +
2378             vm_cnt.v_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) ||
2379             (count < npages && req_class == VM_ALLOC_INTERRUPT))
2380                 return (false);
2381
2382         /*
2383          * Scan up to three times, relaxing the restrictions ("options") on
2384          * the reclamation of reservations and superpages each time.
2385          */
2386         for (options = VPSC_NORESERV;;) {
2387                 /*
2388                  * Find the highest runs that satisfy the given constraints
2389                  * and restrictions, and record them in "m_runs".
2390                  */
2391                 curr_low = low;
2392                 count = 0;
2393                 for (;;) {
2394                         m_run = vm_phys_scan_contig(npages, curr_low, high,
2395                             alignment, boundary, options);
2396                         if (m_run == NULL)
2397                                 break;
2398                         curr_low = VM_PAGE_TO_PHYS(m_run) + ptoa(npages);
2399                         m_runs[RUN_INDEX(count)] = m_run;
2400                         count++;
2401                 }
2402
2403                 /*
2404                  * Reclaim the highest runs in LIFO (descending) order until
2405                  * the number of reclaimed pages, "reclaimed", is at least
2406                  * MIN_RECLAIM.  Reset "reclaimed" each time because each
2407                  * reclamation is idempotent, and runs will (likely) recur
2408                  * from one scan to the next as restrictions are relaxed.
2409                  */
2410                 reclaimed = 0;
2411                 for (i = 0; count > 0 && i < NRUNS; i++) {
2412                         count--;
2413                         m_run = m_runs[RUN_INDEX(count)];
2414                         error = vm_page_reclaim_run(req_class, npages, m_run,
2415                             high);
2416                         if (error == 0) {
2417                                 reclaimed += npages;
2418                                 if (reclaimed >= MIN_RECLAIM)
2419                                         return (true);
2420                         }
2421                 }
2422
2423                 /*
2424                  * Either relax the restrictions on the next scan or return if
2425                  * the last scan had no restrictions.
2426                  */
2427                 if (options == VPSC_NORESERV)
2428                         options = VPSC_NOSUPER;
2429                 else if (options == VPSC_NOSUPER)
2430                         options = VPSC_ANY;
2431                 else if (options == VPSC_ANY)
2432                         return (reclaimed != 0);
2433         }
2434 }
2435
2436 /*
2437  *      vm_wait:        (also see VM_WAIT macro)
2438  *
2439  *      Sleep until free pages are available for allocation.
2440  *      - Called in various places before memory allocations.
2441  */
2442 void
2443 vm_wait(void)
2444 {
2445
2446         mtx_lock(&vm_page_queue_free_mtx);
2447         if (curproc == pageproc) {
2448                 vm_pageout_pages_needed = 1;
2449                 msleep(&vm_pageout_pages_needed, &vm_page_queue_free_mtx,
2450                     PDROP | PSWP, "VMWait", 0);
2451         } else {
2452                 if (__predict_false(pageproc == NULL))
2453                         panic("vm_wait in early boot");
2454                 if (!vm_pageout_wanted) {
2455                         vm_pageout_wanted = true;
2456                         wakeup(&vm_pageout_wanted);
2457                 }
2458                 vm_pages_needed = true;
2459                 msleep(&vm_cnt.v_free_count, &vm_page_queue_free_mtx, PDROP | PVM,
2460                     "vmwait", 0);
2461         }
2462 }
2463
2464 /*
2465  *      vm_waitpfault:  (also see VM_WAITPFAULT macro)
2466  *
2467  *      Sleep until free pages are available for allocation.
2468  *      - Called only in vm_fault so that processes page faulting
2469  *        can be easily tracked.
2470  *      - Sleeps at a lower priority than vm_wait() so that vm_wait()ing
2471  *        processes will be able to grab memory first.  Do not change
2472  *        this balance without careful testing first.
2473  */
2474 void
2475 vm_waitpfault(void)
2476 {
2477
2478         mtx_lock(&vm_page_queue_free_mtx);
2479         if (!vm_pageout_wanted) {
2480                 vm_pageout_wanted = true;
2481                 wakeup(&vm_pageout_wanted);
2482         }
2483         vm_pages_needed = true;
2484         msleep(&vm_cnt.v_free_count, &vm_page_queue_free_mtx, PDROP | PUSER,
2485             "pfault", 0);
2486 }
2487
2488 struct vm_pagequeue *
2489 vm_page_pagequeue(vm_page_t m)
2490 {
2491
2492         if (vm_page_in_laundry(m))
2493                 return (&vm_dom[0].vmd_pagequeues[m->queue]);
2494         else
2495                 return (&vm_phys_domain(m)->vmd_pagequeues[m->queue]);
2496 }
2497
2498 /*
2499  *      vm_page_dequeue:
2500  *
2501  *      Remove the given page from its current page queue.
2502  *
2503  *      The page must be locked.
2504  */
2505 void
2506 vm_page_dequeue(vm_page_t m)
2507 {
2508         struct vm_pagequeue *pq;
2509
2510         vm_page_assert_locked(m);
2511         KASSERT(m->queue < PQ_COUNT, ("vm_page_dequeue: page %p is not queued",
2512             m));
2513         pq = vm_page_pagequeue(m);
2514         vm_pagequeue_lock(pq);
2515         m->queue = PQ_NONE;
2516         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
2517         vm_pagequeue_cnt_dec(pq);
2518         vm_pagequeue_unlock(pq);
2519 }
2520
2521 /*
2522  *      vm_page_dequeue_locked:
2523  *
2524  *      Remove the given page from its current page queue.
2525  *
2526  *      The page and page queue must be locked.
2527  */
2528 void
2529 vm_page_dequeue_locked(vm_page_t m)
2530 {
2531         struct vm_pagequeue *pq;
2532
2533         vm_page_lock_assert(m, MA_OWNED);
2534         pq = vm_page_pagequeue(m);
2535         vm_pagequeue_assert_locked(pq);
2536         m->queue = PQ_NONE;
2537         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
2538         vm_pagequeue_cnt_dec(pq);
2539 }
2540
2541 /*
2542  *      vm_page_enqueue:
2543  *
2544  *      Add the given page to the specified page queue.
2545  *
2546  *      The page must be locked.
2547  */
2548 static void
2549 vm_page_enqueue(uint8_t queue, vm_page_t m)
2550 {
2551         struct vm_pagequeue *pq;
2552
2553         vm_page_lock_assert(m, MA_OWNED);
2554         KASSERT(queue < PQ_COUNT,
2555             ("vm_page_enqueue: invalid queue %u request for page %p",
2556             queue, m));
2557         if (queue == PQ_LAUNDRY)
2558                 pq = &vm_dom[0].vmd_pagequeues[queue];
2559         else
2560                 pq = &vm_phys_domain(m)->vmd_pagequeues[queue];
2561         vm_pagequeue_lock(pq);
2562         m->queue = queue;
2563         TAILQ_INSERT_TAIL(&pq->pq_pl, m, plinks.q);
2564         vm_pagequeue_cnt_inc(pq);
2565         vm_pagequeue_unlock(pq);
2566 }
2567
2568 /*
2569  *      vm_page_requeue:
2570  *
2571  *      Move the given page to the tail of its current page queue.
2572  *
2573  *      The page must be locked.
2574  */
2575 void
2576 vm_page_requeue(vm_page_t m)
2577 {
2578         struct vm_pagequeue *pq;
2579
2580         vm_page_lock_assert(m, MA_OWNED);
2581         KASSERT(m->queue != PQ_NONE,
2582             ("vm_page_requeue: page %p is not queued", m));
2583         pq = vm_page_pagequeue(m);
2584         vm_pagequeue_lock(pq);
2585         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
2586         TAILQ_INSERT_TAIL(&pq->pq_pl, m, plinks.q);
2587         vm_pagequeue_unlock(pq);
2588 }
2589
2590 /*
2591  *      vm_page_requeue_locked:
2592  *
2593  *      Move the given page to the tail of its current page queue.
2594  *
2595  *      The page queue must be locked.
2596  */
2597 void
2598 vm_page_requeue_locked(vm_page_t m)
2599 {
2600         struct vm_pagequeue *pq;
2601
2602         KASSERT(m->queue != PQ_NONE,
2603             ("vm_page_requeue_locked: page %p is not queued", m));
2604         pq = vm_page_pagequeue(m);
2605         vm_pagequeue_assert_locked(pq);
2606         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
2607         TAILQ_INSERT_TAIL(&pq->pq_pl, m, plinks.q);
2608 }
2609
2610 /*
2611  *      vm_page_activate:
2612  *
2613  *      Put the specified page on the active list (if appropriate).
2614  *      Ensure that act_count is at least ACT_INIT but do not otherwise
2615  *      mess with it.
2616  *
2617  *      The page must be locked.
2618  */
2619 void
2620 vm_page_activate(vm_page_t m)
2621 {
2622         int queue;
2623
2624         vm_page_lock_assert(m, MA_OWNED);
2625         if ((queue = m->queue) != PQ_ACTIVE) {
2626                 if (m->wire_count == 0 && (m->oflags & VPO_UNMANAGED) == 0) {
2627                         if (m->act_count < ACT_INIT)
2628                                 m->act_count = ACT_INIT;
2629                         if (queue != PQ_NONE)
2630                                 vm_page_dequeue(m);
2631                         vm_page_enqueue(PQ_ACTIVE, m);
2632                 } else
2633                         KASSERT(queue == PQ_NONE,
2634                             ("vm_page_activate: wired page %p is queued", m));
2635         } else {
2636                 if (m->act_count < ACT_INIT)
2637                         m->act_count = ACT_INIT;
2638         }
2639 }
2640
2641 /*
2642  *      vm_page_free_wakeup:
2643  *
2644  *      Helper routine for vm_page_free_toq() and vm_page_cache().  This
2645  *      routine is called when a page has been added to the cache or free
2646  *      queues.
2647  *
2648  *      The page queues must be locked.
2649  */
2650 static inline void
2651 vm_page_free_wakeup(void)
2652 {
2653
2654         mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
2655         /*
2656          * if pageout daemon needs pages, then tell it that there are
2657          * some free.
2658          */
2659         if (vm_pageout_pages_needed &&
2660             vm_cnt.v_free_count >= vm_cnt.v_pageout_free_min) {
2661                 wakeup(&vm_pageout_pages_needed);
2662                 vm_pageout_pages_needed = 0;
2663         }
2664         /*
2665          * wakeup processes that are waiting on memory if we hit a
2666          * high water mark. And wakeup scheduler process if we have
2667          * lots of memory. this process will swapin processes.
2668          */
2669         if (vm_pages_needed && !vm_page_count_min()) {
2670                 vm_pages_needed = false;
2671                 wakeup(&vm_cnt.v_free_count);
2672         }
2673 }
2674
2675 /*
2676  *      vm_page_free_toq:
2677  *
2678  *      Returns the given page to the free list,
2679  *      disassociating it with any VM object.
2680  *
2681  *      The object must be locked.  The page must be locked if it is managed.
2682  */
2683 void
2684 vm_page_free_toq(vm_page_t m)
2685 {
2686
2687         if ((m->oflags & VPO_UNMANAGED) == 0) {
2688                 vm_page_lock_assert(m, MA_OWNED);
2689                 KASSERT(!pmap_page_is_mapped(m),
2690                     ("vm_page_free_toq: freeing mapped page %p", m));
2691         } else
2692                 KASSERT(m->queue == PQ_NONE,
2693                     ("vm_page_free_toq: unmanaged page %p is queued", m));
2694         PCPU_INC(cnt.v_tfree);
2695
2696         if (vm_page_sbusied(m))
2697                 panic("vm_page_free: freeing busy page %p", m);
2698
2699         /*
2700          * Unqueue, then remove page.  Note that we cannot destroy
2701          * the page here because we do not want to call the pager's
2702          * callback routine until after we've put the page on the
2703          * appropriate free queue.
2704          */
2705         vm_page_remque(m);
2706         vm_page_remove(m);
2707
2708         /*
2709          * If fictitious remove object association and
2710          * return, otherwise delay object association removal.
2711          */
2712         if ((m->flags & PG_FICTITIOUS) != 0) {
2713                 return;
2714         }
2715
2716         m->valid = 0;
2717         vm_page_undirty(m);
2718
2719         if (m->wire_count != 0)
2720                 panic("vm_page_free: freeing wired page %p", m);
2721         if (m->hold_count != 0) {
2722                 m->flags &= ~PG_ZERO;
2723                 KASSERT((m->flags & PG_UNHOLDFREE) == 0,
2724                     ("vm_page_free: freeing PG_UNHOLDFREE page %p", m));
2725                 m->flags |= PG_UNHOLDFREE;
2726         } else {
2727                 /*
2728                  * Restore the default memory attribute to the page.
2729                  */
2730                 if (pmap_page_get_memattr(m) != VM_MEMATTR_DEFAULT)
2731                         pmap_page_set_memattr(m, VM_MEMATTR_DEFAULT);
2732
2733                 /*
2734                  * Insert the page into the physical memory allocator's
2735                  * cache/free page queues.
2736                  */
2737                 mtx_lock(&vm_page_queue_free_mtx);
2738                 vm_phys_freecnt_adj(m, 1);
2739 #if VM_NRESERVLEVEL > 0
2740                 if (!vm_reserv_free_page(m))
2741 #else
2742                 if (TRUE)
2743 #endif
2744                         vm_phys_free_pages(m, 0);
2745                 vm_page_free_wakeup();
2746                 mtx_unlock(&vm_page_queue_free_mtx);
2747         }
2748 }
2749
2750 /*
2751  *      vm_page_wire:
2752  *
2753  *      Mark this page as wired down by yet
2754  *      another map, removing it from paging queues
2755  *      as necessary.
2756  *
2757  *      If the page is fictitious, then its wire count must remain one.
2758  *
2759  *      The page must be locked.
2760  */
2761 void
2762 vm_page_wire(vm_page_t m)
2763 {
2764
2765         /*
2766          * Only bump the wire statistics if the page is not already wired,
2767          * and only unqueue the page if it is on some queue (if it is unmanaged
2768          * it is already off the queues).
2769          */
2770         vm_page_lock_assert(m, MA_OWNED);
2771         if ((m->flags & PG_FICTITIOUS) != 0) {
2772                 KASSERT(m->wire_count == 1,
2773                     ("vm_page_wire: fictitious page %p's wire count isn't one",
2774                     m));
2775                 return;
2776         }
2777         if (m->wire_count == 0) {
2778                 KASSERT((m->oflags & VPO_UNMANAGED) == 0 ||
2779                     m->queue == PQ_NONE,
2780                     ("vm_page_wire: unmanaged page %p is queued", m));
2781                 vm_page_remque(m);
2782                 atomic_add_int(&vm_cnt.v_wire_count, 1);
2783         }
2784         m->wire_count++;
2785         KASSERT(m->wire_count != 0, ("vm_page_wire: wire_count overflow m=%p", m));
2786 }
2787
2788 /*
2789  * vm_page_unwire:
2790  *
2791  * Release one wiring of the specified page, potentially allowing it to be
2792  * paged out.  Returns TRUE if the number of wirings transitions to zero and
2793  * FALSE otherwise.
2794  *
2795  * Only managed pages belonging to an object can be paged out.  If the number
2796  * of wirings transitions to zero and the page is eligible for page out, then
2797  * the page is added to the specified paging queue (unless PQ_NONE is
2798  * specified).
2799  *
2800  * If a page is fictitious, then its wire count must always be one.
2801  *
2802  * A managed page must be locked.
2803  */
2804 boolean_t
2805 vm_page_unwire(vm_page_t m, uint8_t queue)
2806 {
2807
2808         KASSERT(queue < PQ_COUNT || queue == PQ_NONE,
2809             ("vm_page_unwire: invalid queue %u request for page %p",
2810             queue, m));
2811         if ((m->oflags & VPO_UNMANAGED) == 0)
2812                 vm_page_assert_locked(m);
2813         if ((m->flags & PG_FICTITIOUS) != 0) {
2814                 KASSERT(m->wire_count == 1,
2815             ("vm_page_unwire: fictitious page %p's wire count isn't one", m));
2816                 return (FALSE);
2817         }
2818         if (m->wire_count > 0) {
2819                 m->wire_count--;
2820                 if (m->wire_count == 0) {
2821                         atomic_subtract_int(&vm_cnt.v_wire_count, 1);
2822                         if ((m->oflags & VPO_UNMANAGED) == 0 &&
2823                             m->object != NULL && queue != PQ_NONE)
2824                                 vm_page_enqueue(queue, m);
2825                         return (TRUE);
2826                 } else
2827                         return (FALSE);
2828         } else
2829                 panic("vm_page_unwire: page %p's wire count is zero", m);
2830 }
2831
2832 /*
2833  * Move the specified page to the inactive queue.
2834  *
2835  * Many pages placed on the inactive queue should actually go
2836  * into the cache, but it is difficult to figure out which.  What
2837  * we do instead, if the inactive target is well met, is to put
2838  * clean pages at the head of the inactive queue instead of the tail.
2839  * This will cause them to be moved to the cache more quickly and
2840  * if not actively re-referenced, reclaimed more quickly.  If we just
2841  * stick these pages at the end of the inactive queue, heavy filesystem
2842  * meta-data accesses can cause an unnecessary paging load on memory bound
2843  * processes.  This optimization causes one-time-use metadata to be
2844  * reused more quickly.
2845  *
2846  * Normally noreuse is FALSE, resulting in LRU operation.  noreuse is set
2847  * to TRUE if we want this page to be 'as if it were placed in the cache',
2848  * except without unmapping it from the process address space.  In
2849  * practice this is implemented by inserting the page at the head of the
2850  * queue, using a marker page to guide FIFO insertion ordering.
2851  *
2852  * The page must be locked.
2853  */
2854 static inline void
2855 _vm_page_deactivate(vm_page_t m, boolean_t noreuse)
2856 {
2857         struct vm_pagequeue *pq;
2858         int queue;
2859
2860         vm_page_assert_locked(m);
2861
2862         /*
2863          * Ignore if the page is already inactive, unless it is unlikely to be
2864          * reactivated.
2865          */
2866         if ((queue = m->queue) == PQ_INACTIVE && !noreuse)
2867                 return;
2868         if (m->wire_count == 0 && (m->oflags & VPO_UNMANAGED) == 0) {
2869                 pq = &vm_phys_domain(m)->vmd_pagequeues[PQ_INACTIVE];
2870                 /* Avoid multiple acquisitions of the inactive queue lock. */
2871                 if (queue == PQ_INACTIVE) {
2872                         vm_pagequeue_lock(pq);
2873                         vm_page_dequeue_locked(m);
2874                 } else {
2875                         if (queue != PQ_NONE)
2876                                 vm_page_dequeue(m);
2877                         vm_pagequeue_lock(pq);
2878                 }
2879                 m->queue = PQ_INACTIVE;
2880                 if (noreuse)
2881                         TAILQ_INSERT_BEFORE(&vm_phys_domain(m)->vmd_inacthead,
2882                             m, plinks.q);
2883                 else
2884                         TAILQ_INSERT_TAIL(&pq->pq_pl, m, plinks.q);
2885                 vm_pagequeue_cnt_inc(pq);
2886                 vm_pagequeue_unlock(pq);
2887         }
2888 }
2889
2890 /*
2891  * Move the specified page to the inactive queue.
2892  *
2893  * The page must be locked.
2894  */
2895 void
2896 vm_page_deactivate(vm_page_t m)
2897 {
2898
2899         _vm_page_deactivate(m, FALSE);
2900 }
2901
2902 /*
2903  * Move the specified page to the inactive queue with the expectation
2904  * that it is unlikely to be reused.
2905  *
2906  * The page must be locked.
2907  */
2908 void
2909 vm_page_deactivate_noreuse(vm_page_t m)
2910 {
2911
2912         _vm_page_deactivate(m, TRUE);
2913 }
2914
2915 /*
2916  * vm_page_launder
2917  *
2918  *      Put a page in the laundry.
2919  */
2920 void
2921 vm_page_launder(vm_page_t m)
2922 {
2923         int queue;
2924
2925         vm_page_assert_locked(m);
2926         if ((queue = m->queue) != PQ_LAUNDRY) {
2927                 if (m->wire_count == 0 && (m->oflags & VPO_UNMANAGED) == 0) {
2928                         if (queue != PQ_NONE)
2929                                 vm_page_dequeue(m);
2930                         vm_page_enqueue(PQ_LAUNDRY, m);
2931                 } else
2932                         KASSERT(queue == PQ_NONE,
2933                             ("wired page %p is queued", m));
2934         }
2935 }
2936
2937 /*
2938  * vm_page_try_to_free()
2939  *
2940  *      Attempt to free the page.  If we cannot free it, we do nothing.
2941  *      1 is returned on success, 0 on failure.
2942  */
2943 int
2944 vm_page_try_to_free(vm_page_t m)
2945 {
2946
2947         vm_page_lock_assert(m, MA_OWNED);
2948         if (m->object != NULL)
2949                 VM_OBJECT_ASSERT_WLOCKED(m->object);
2950         if (m->dirty || m->hold_count || m->wire_count ||
2951             (m->oflags & VPO_UNMANAGED) != 0 || vm_page_busied(m))
2952                 return (0);
2953         pmap_remove_all(m);
2954         if (m->dirty)
2955                 return (0);
2956         vm_page_free(m);
2957         return (1);
2958 }
2959
2960 /*
2961  * vm_page_advise
2962  *
2963  *      Deactivate or do nothing, as appropriate.
2964  *
2965  *      The object and page must be locked.
2966  */
2967 void
2968 vm_page_advise(vm_page_t m, int advice)
2969 {
2970
2971         vm_page_assert_locked(m);
2972         VM_OBJECT_ASSERT_WLOCKED(m->object);
2973         if (advice == MADV_FREE)
2974                 /*
2975                  * Mark the page clean.  This will allow the page to be freed
2976                  * up by the system.  However, such pages are often reused
2977                  * quickly by malloc() so we do not do anything that would
2978                  * cause a page fault if we can help it.
2979                  *
2980                  * Specifically, we do not try to actually free the page now
2981                  * nor do we try to put it in the cache (which would cause a
2982                  * page fault on reuse).
2983                  *
2984                  * But we do make the page as freeable as we can without
2985                  * actually taking the step of unmapping it.
2986                  */
2987                 vm_page_undirty(m);
2988         else if (advice != MADV_DONTNEED)
2989                 return;
2990
2991         /*
2992          * Clear any references to the page.  Otherwise, the page daemon will
2993          * immediately reactivate the page.
2994          */
2995         vm_page_aflag_clear(m, PGA_REFERENCED);
2996
2997         if (advice != MADV_FREE && m->dirty == 0 && pmap_is_modified(m))
2998                 vm_page_dirty(m);
2999
3000         /*
3001          * Place clean pages near the head of the inactive queue rather than
3002          * the tail, thus defeating the queue's LRU operation and ensuring that
3003          * the page will be reused quickly.  Dirty pages not already in the
3004          * laundry are moved there.
3005          */
3006         if (m->dirty == 0)
3007                 vm_page_deactivate_noreuse(m);
3008         else
3009                 vm_page_launder(m);
3010 }
3011
3012 /*
3013  * Grab a page, waiting until we are waken up due to the page
3014  * changing state.  We keep on waiting, if the page continues
3015  * to be in the object.  If the page doesn't exist, first allocate it
3016  * and then conditionally zero it.
3017  *
3018  * This routine may sleep.
3019  *
3020  * The object must be locked on entry.  The lock will, however, be released
3021  * and reacquired if the routine sleeps.
3022  */
3023 vm_page_t
3024 vm_page_grab(vm_object_t object, vm_pindex_t pindex, int allocflags)
3025 {
3026         vm_page_t m;
3027         int sleep;
3028
3029         VM_OBJECT_ASSERT_WLOCKED(object);
3030         KASSERT((allocflags & VM_ALLOC_SBUSY) == 0 ||
3031             (allocflags & VM_ALLOC_IGN_SBUSY) != 0,
3032             ("vm_page_grab: VM_ALLOC_SBUSY/VM_ALLOC_IGN_SBUSY mismatch"));
3033 retrylookup:
3034         if ((m = vm_page_lookup(object, pindex)) != NULL) {
3035                 sleep = (allocflags & VM_ALLOC_IGN_SBUSY) != 0 ?
3036                     vm_page_xbusied(m) : vm_page_busied(m);
3037                 if (sleep) {
3038                         if ((allocflags & VM_ALLOC_NOWAIT) != 0)
3039                                 return (NULL);
3040                         /*
3041                          * Reference the page before unlocking and
3042                          * sleeping so that the page daemon is less
3043                          * likely to reclaim it.
3044                          */
3045                         vm_page_aflag_set(m, PGA_REFERENCED);
3046                         vm_page_lock(m);
3047                         VM_OBJECT_WUNLOCK(object);
3048                         vm_page_busy_sleep(m, "pgrbwt", (allocflags &
3049                             VM_ALLOC_IGN_SBUSY) != 0);
3050                         VM_OBJECT_WLOCK(object);
3051                         goto retrylookup;
3052                 } else {
3053                         if ((allocflags & VM_ALLOC_WIRED) != 0) {
3054                                 vm_page_lock(m);
3055                                 vm_page_wire(m);
3056                                 vm_page_unlock(m);
3057                         }
3058                         if ((allocflags &
3059                             (VM_ALLOC_NOBUSY | VM_ALLOC_SBUSY)) == 0)
3060                                 vm_page_xbusy(m);
3061                         if ((allocflags & VM_ALLOC_SBUSY) != 0)
3062                                 vm_page_sbusy(m);
3063                         return (m);
3064                 }
3065         }
3066         m = vm_page_alloc(object, pindex, allocflags);
3067         if (m == NULL) {
3068                 if ((allocflags & VM_ALLOC_NOWAIT) != 0)
3069                         return (NULL);
3070                 VM_OBJECT_WUNLOCK(object);
3071                 VM_WAIT;
3072                 VM_OBJECT_WLOCK(object);
3073                 goto retrylookup;
3074         }
3075         if (allocflags & VM_ALLOC_ZERO && (m->flags & PG_ZERO) == 0)
3076                 pmap_zero_page(m);
3077         return (m);
3078 }
3079
3080 /*
3081  * Mapping function for valid or dirty bits in a page.
3082  *
3083  * Inputs are required to range within a page.
3084  */
3085 vm_page_bits_t
3086 vm_page_bits(int base, int size)
3087 {
3088         int first_bit;
3089         int last_bit;
3090
3091         KASSERT(
3092             base + size <= PAGE_SIZE,
3093             ("vm_page_bits: illegal base/size %d/%d", base, size)
3094         );
3095
3096         if (size == 0)          /* handle degenerate case */
3097                 return (0);
3098
3099         first_bit = base >> DEV_BSHIFT;
3100         last_bit = (base + size - 1) >> DEV_BSHIFT;
3101
3102         return (((vm_page_bits_t)2 << last_bit) -
3103             ((vm_page_bits_t)1 << first_bit));
3104 }
3105
3106 /*
3107  *      vm_page_set_valid_range:
3108  *
3109  *      Sets portions of a page valid.  The arguments are expected
3110  *      to be DEV_BSIZE aligned but if they aren't the bitmap is inclusive
3111  *      of any partial chunks touched by the range.  The invalid portion of
3112  *      such chunks will be zeroed.
3113  *
3114  *      (base + size) must be less then or equal to PAGE_SIZE.
3115  */
3116 void
3117 vm_page_set_valid_range(vm_page_t m, int base, int size)
3118 {
3119         int endoff, frag;
3120
3121         VM_OBJECT_ASSERT_WLOCKED(m->object);
3122         if (size == 0)  /* handle degenerate case */
3123                 return;
3124
3125         /*
3126          * If the base is not DEV_BSIZE aligned and the valid
3127          * bit is clear, we have to zero out a portion of the
3128          * first block.
3129          */
3130         if ((frag = rounddown2(base, DEV_BSIZE)) != base &&
3131             (m->valid & (1 << (base >> DEV_BSHIFT))) == 0)
3132                 pmap_zero_page_area(m, frag, base - frag);
3133
3134         /*
3135          * If the ending offset is not DEV_BSIZE aligned and the
3136          * valid bit is clear, we have to zero out a portion of
3137          * the last block.
3138          */
3139         endoff = base + size;
3140         if ((frag = rounddown2(endoff, DEV_BSIZE)) != endoff &&
3141             (m->valid & (1 << (endoff >> DEV_BSHIFT))) == 0)
3142                 pmap_zero_page_area(m, endoff,
3143                     DEV_BSIZE - (endoff & (DEV_BSIZE - 1)));
3144
3145         /*
3146          * Assert that no previously invalid block that is now being validated
3147          * is already dirty.
3148          */
3149         KASSERT((~m->valid & vm_page_bits(base, size) & m->dirty) == 0,
3150             ("vm_page_set_valid_range: page %p is dirty", m));
3151
3152         /*
3153          * Set valid bits inclusive of any overlap.
3154          */
3155         m->valid |= vm_page_bits(base, size);
3156 }
3157
3158 /*
3159  * Clear the given bits from the specified page's dirty field.
3160  */
3161 static __inline void
3162 vm_page_clear_dirty_mask(vm_page_t m, vm_page_bits_t pagebits)
3163 {
3164         uintptr_t addr;
3165 #if PAGE_SIZE < 16384
3166         int shift;
3167 #endif
3168
3169         /*
3170          * If the object is locked and the page is neither exclusive busy nor
3171          * write mapped, then the page's dirty field cannot possibly be
3172          * set by a concurrent pmap operation.
3173          */
3174         VM_OBJECT_ASSERT_WLOCKED(m->object);
3175         if (!vm_page_xbusied(m) && !pmap_page_is_write_mapped(m))
3176                 m->dirty &= ~pagebits;
3177         else {
3178                 /*
3179                  * The pmap layer can call vm_page_dirty() without
3180                  * holding a distinguished lock.  The combination of
3181                  * the object's lock and an atomic operation suffice
3182                  * to guarantee consistency of the page dirty field.
3183                  *
3184                  * For PAGE_SIZE == 32768 case, compiler already
3185                  * properly aligns the dirty field, so no forcible
3186                  * alignment is needed. Only require existence of
3187                  * atomic_clear_64 when page size is 32768.
3188                  */
3189                 addr = (uintptr_t)&m->dirty;
3190 #if PAGE_SIZE == 32768
3191                 atomic_clear_64((uint64_t *)addr, pagebits);
3192 #elif PAGE_SIZE == 16384
3193                 atomic_clear_32((uint32_t *)addr, pagebits);
3194 #else           /* PAGE_SIZE <= 8192 */
3195                 /*
3196                  * Use a trick to perform a 32-bit atomic on the
3197                  * containing aligned word, to not depend on the existence
3198                  * of atomic_clear_{8, 16}.
3199                  */
3200                 shift = addr & (sizeof(uint32_t) - 1);
3201 #if BYTE_ORDER == BIG_ENDIAN
3202                 shift = (sizeof(uint32_t) - sizeof(m->dirty) - shift) * NBBY;
3203 #else
3204                 shift *= NBBY;
3205 #endif
3206                 addr &= ~(sizeof(uint32_t) - 1);
3207                 atomic_clear_32((uint32_t *)addr, pagebits << shift);
3208 #endif          /* PAGE_SIZE */
3209         }
3210 }
3211
3212 /*
3213  *      vm_page_set_validclean:
3214  *
3215  *      Sets portions of a page valid and clean.  The arguments are expected
3216  *      to be DEV_BSIZE aligned but if they aren't the bitmap is inclusive
3217  *      of any partial chunks touched by the range.  The invalid portion of
3218  *      such chunks will be zero'd.
3219  *
3220  *      (base + size) must be less then or equal to PAGE_SIZE.
3221  */
3222 void
3223 vm_page_set_validclean(vm_page_t m, int base, int size)
3224 {
3225         vm_page_bits_t oldvalid, pagebits;
3226         int endoff, frag;
3227
3228         VM_OBJECT_ASSERT_WLOCKED(m->object);
3229         if (size == 0)  /* handle degenerate case */
3230                 return;
3231
3232         /*
3233          * If the base is not DEV_BSIZE aligned and the valid
3234          * bit is clear, we have to zero out a portion of the
3235          * first block.
3236          */
3237         if ((frag = rounddown2(base, DEV_BSIZE)) != base &&
3238             (m->valid & ((vm_page_bits_t)1 << (base >> DEV_BSHIFT))) == 0)
3239                 pmap_zero_page_area(m, frag, base - frag);
3240
3241         /*
3242          * If the ending offset is not DEV_BSIZE aligned and the
3243          * valid bit is clear, we have to zero out a portion of
3244          * the last block.
3245          */
3246         endoff = base + size;
3247         if ((frag = rounddown2(endoff, DEV_BSIZE)) != endoff &&
3248             (m->valid & ((vm_page_bits_t)1 << (endoff >> DEV_BSHIFT))) == 0)
3249                 pmap_zero_page_area(m, endoff,
3250                     DEV_BSIZE - (endoff & (DEV_BSIZE - 1)));
3251
3252         /*
3253          * Set valid, clear dirty bits.  If validating the entire
3254          * page we can safely clear the pmap modify bit.  We also
3255          * use this opportunity to clear the VPO_NOSYNC flag.  If a process
3256          * takes a write fault on a MAP_NOSYNC memory area the flag will
3257          * be set again.
3258          *
3259          * We set valid bits inclusive of any overlap, but we can only
3260          * clear dirty bits for DEV_BSIZE chunks that are fully within
3261          * the range.
3262          */
3263         oldvalid = m->valid;
3264         pagebits = vm_page_bits(base, size);
3265         m->valid |= pagebits;
3266 #if 0   /* NOT YET */
3267         if ((frag = base & (DEV_BSIZE - 1)) != 0) {
3268                 frag = DEV_BSIZE - frag;
3269                 base += frag;
3270                 size -= frag;
3271                 if (size < 0)
3272                         size = 0;
3273         }
3274         pagebits = vm_page_bits(base, size & (DEV_BSIZE - 1));
3275 #endif
3276         if (base == 0 && size == PAGE_SIZE) {
3277                 /*
3278                  * The page can only be modified within the pmap if it is
3279                  * mapped, and it can only be mapped if it was previously
3280                  * fully valid.
3281                  */
3282                 if (oldvalid == VM_PAGE_BITS_ALL)
3283                         /*
3284                          * Perform the pmap_clear_modify() first.  Otherwise,
3285                          * a concurrent pmap operation, such as
3286                          * pmap_protect(), could clear a modification in the
3287                          * pmap and set the dirty field on the page before
3288                          * pmap_clear_modify() had begun and after the dirty
3289                          * field was cleared here.
3290                          */
3291                         pmap_clear_modify(m);
3292                 m->dirty = 0;
3293                 m->oflags &= ~VPO_NOSYNC;
3294         } else if (oldvalid != VM_PAGE_BITS_ALL)
3295                 m->dirty &= ~pagebits;
3296         else
3297                 vm_page_clear_dirty_mask(m, pagebits);
3298 }
3299
3300 void
3301 vm_page_clear_dirty(vm_page_t m, int base, int size)
3302 {
3303
3304         vm_page_clear_dirty_mask(m, vm_page_bits(base, size));
3305 }
3306
3307 /*
3308  *      vm_page_set_invalid:
3309  *
3310  *      Invalidates DEV_BSIZE'd chunks within a page.  Both the
3311  *      valid and dirty bits for the effected areas are cleared.
3312  */
3313 void
3314 vm_page_set_invalid(vm_page_t m, int base, int size)
3315 {
3316         vm_page_bits_t bits;
3317         vm_object_t object;
3318
3319         object = m->object;
3320         VM_OBJECT_ASSERT_WLOCKED(object);
3321         if (object->type == OBJT_VNODE && base == 0 && IDX_TO_OFF(m->pindex) +
3322             size >= object->un_pager.vnp.vnp_size)
3323                 bits = VM_PAGE_BITS_ALL;
3324         else
3325                 bits = vm_page_bits(base, size);
3326         if (object->ref_count != 0 && m->valid == VM_PAGE_BITS_ALL &&
3327             bits != 0)
3328                 pmap_remove_all(m);
3329         KASSERT((bits == 0 && m->valid == VM_PAGE_BITS_ALL) ||
3330             !pmap_page_is_mapped(m),
3331             ("vm_page_set_invalid: page %p is mapped", m));
3332         m->valid &= ~bits;
3333         m->dirty &= ~bits;
3334 }
3335
3336 /*
3337  * vm_page_zero_invalid()
3338  *
3339  *      The kernel assumes that the invalid portions of a page contain
3340  *      garbage, but such pages can be mapped into memory by user code.
3341  *      When this occurs, we must zero out the non-valid portions of the
3342  *      page so user code sees what it expects.
3343  *
3344  *      Pages are most often semi-valid when the end of a file is mapped
3345  *      into memory and the file's size is not page aligned.
3346  */
3347 void
3348 vm_page_zero_invalid(vm_page_t m, boolean_t setvalid)
3349 {
3350         int b;
3351         int i;
3352
3353         VM_OBJECT_ASSERT_WLOCKED(m->object);
3354         /*
3355          * Scan the valid bits looking for invalid sections that
3356          * must be zeroed.  Invalid sub-DEV_BSIZE'd areas ( where the
3357          * valid bit may be set ) have already been zeroed by
3358          * vm_page_set_validclean().
3359          */
3360         for (b = i = 0; i <= PAGE_SIZE / DEV_BSIZE; ++i) {
3361                 if (i == (PAGE_SIZE / DEV_BSIZE) ||
3362                     (m->valid & ((vm_page_bits_t)1 << i))) {
3363                         if (i > b) {
3364                                 pmap_zero_page_area(m,
3365                                     b << DEV_BSHIFT, (i - b) << DEV_BSHIFT);
3366                         }
3367                         b = i + 1;
3368                 }
3369         }
3370
3371         /*
3372          * setvalid is TRUE when we can safely set the zero'd areas
3373          * as being valid.  We can do this if there are no cache consistancy
3374          * issues.  e.g. it is ok to do with UFS, but not ok to do with NFS.
3375          */
3376         if (setvalid)
3377                 m->valid = VM_PAGE_BITS_ALL;
3378 }
3379
3380 /*
3381  *      vm_page_is_valid:
3382  *
3383  *      Is (partial) page valid?  Note that the case where size == 0
3384  *      will return FALSE in the degenerate case where the page is
3385  *      entirely invalid, and TRUE otherwise.
3386  */
3387 int
3388 vm_page_is_valid(vm_page_t m, int base, int size)
3389 {
3390         vm_page_bits_t bits;
3391
3392         VM_OBJECT_ASSERT_LOCKED(m->object);
3393         bits = vm_page_bits(base, size);
3394         return (m->valid != 0 && (m->valid & bits) == bits);
3395 }
3396
3397 /*
3398  *      vm_page_ps_is_valid:
3399  *
3400  *      Returns TRUE if the entire (super)page is valid and FALSE otherwise.
3401  */
3402 boolean_t
3403 vm_page_ps_is_valid(vm_page_t m)
3404 {
3405         int i, npages;
3406
3407         VM_OBJECT_ASSERT_LOCKED(m->object);
3408         npages = atop(pagesizes[m->psind]);
3409
3410         /*
3411          * The physically contiguous pages that make up a superpage, i.e., a
3412          * page with a page size index ("psind") greater than zero, will
3413          * occupy adjacent entries in vm_page_array[].
3414          */
3415         for (i = 0; i < npages; i++) {
3416                 if (m[i].valid != VM_PAGE_BITS_ALL)
3417                         return (FALSE);
3418         }
3419         return (TRUE);
3420 }
3421
3422 /*
3423  * Set the page's dirty bits if the page is modified.
3424  */
3425 void
3426 vm_page_test_dirty(vm_page_t m)
3427 {
3428
3429         VM_OBJECT_ASSERT_WLOCKED(m->object);
3430         if (m->dirty != VM_PAGE_BITS_ALL && pmap_is_modified(m))
3431                 vm_page_dirty(m);
3432 }
3433
3434 void
3435 vm_page_lock_KBI(vm_page_t m, const char *file, int line)
3436 {
3437
3438         mtx_lock_flags_(vm_page_lockptr(m), 0, file, line);
3439 }
3440
3441 void
3442 vm_page_unlock_KBI(vm_page_t m, const char *file, int line)
3443 {
3444
3445         mtx_unlock_flags_(vm_page_lockptr(m), 0, file, line);
3446 }
3447
3448 int
3449 vm_page_trylock_KBI(vm_page_t m, const char *file, int line)
3450 {
3451
3452         return (mtx_trylock_flags_(vm_page_lockptr(m), 0, file, line));
3453 }
3454
3455 #if defined(INVARIANTS) || defined(INVARIANT_SUPPORT)
3456 void
3457 vm_page_assert_locked_KBI(vm_page_t m, const char *file, int line)
3458 {
3459
3460         vm_page_lock_assert_KBI(m, MA_OWNED, file, line);
3461 }
3462
3463 void
3464 vm_page_lock_assert_KBI(vm_page_t m, int a, const char *file, int line)
3465 {
3466
3467         mtx_assert_(vm_page_lockptr(m), a, file, line);
3468 }
3469 #endif
3470
3471 #ifdef INVARIANTS
3472 void
3473 vm_page_object_lock_assert(vm_page_t m)
3474 {
3475
3476         /*
3477          * Certain of the page's fields may only be modified by the
3478          * holder of the containing object's lock or the exclusive busy.
3479          * holder.  Unfortunately, the holder of the write busy is
3480          * not recorded, and thus cannot be checked here.
3481          */
3482         if (m->object != NULL && !vm_page_xbusied(m))
3483                 VM_OBJECT_ASSERT_WLOCKED(m->object);
3484 }
3485
3486 void
3487 vm_page_assert_pga_writeable(vm_page_t m, uint8_t bits)
3488 {
3489
3490         if ((bits & PGA_WRITEABLE) == 0)
3491                 return;
3492
3493         /*
3494          * The PGA_WRITEABLE flag can only be set if the page is
3495          * managed, is exclusively busied or the object is locked.
3496          * Currently, this flag is only set by pmap_enter().
3497          */
3498         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
3499             ("PGA_WRITEABLE on unmanaged page"));
3500         if (!vm_page_xbusied(m))
3501                 VM_OBJECT_ASSERT_LOCKED(m->object);
3502 }
3503 #endif
3504
3505 #include "opt_ddb.h"
3506 #ifdef DDB
3507 #include <sys/kernel.h>
3508
3509 #include <ddb/ddb.h>
3510
3511 DB_SHOW_COMMAND(page, vm_page_print_page_info)
3512 {
3513
3514         db_printf("vm_cnt.v_free_count: %d\n", vm_cnt.v_free_count);
3515         db_printf("vm_cnt.v_inactive_count: %d\n", vm_cnt.v_inactive_count);
3516         db_printf("vm_cnt.v_active_count: %d\n", vm_cnt.v_active_count);
3517         db_printf("vm_cnt.v_laundry_count: %d\n", vm_cnt.v_laundry_count);
3518         db_printf("vm_cnt.v_wire_count: %d\n", vm_cnt.v_wire_count);
3519         db_printf("vm_cnt.v_free_reserved: %d\n", vm_cnt.v_free_reserved);
3520         db_printf("vm_cnt.v_free_min: %d\n", vm_cnt.v_free_min);
3521         db_printf("vm_cnt.v_free_target: %d\n", vm_cnt.v_free_target);
3522         db_printf("vm_cnt.v_inactive_target: %d\n", vm_cnt.v_inactive_target);
3523 }
3524
3525 DB_SHOW_COMMAND(pageq, vm_page_print_pageq_info)
3526 {
3527         int dom;
3528
3529         db_printf("pq_free %d\n", vm_cnt.v_free_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 */