kernel - Remove object->agg_pv_list_count
[dragonfly.git] / sys / vm / vm_page.c
1 /*
2  * Copyright (c) 1991 Regents of the University of California.
3  * All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * The Mach Operating System project at Carnegie-Mellon University.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  *      from: @(#)vm_page.c     7.4 (Berkeley) 5/7/91
33  * $FreeBSD: src/sys/vm/vm_page.c,v 1.147.2.18 2002/03/10 05:03:19 alc Exp $
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  * Resident memory management module.  The module manipulates 'VM pages'.
64  * A VM page is the core building block for memory management.
65  */
66
67 #include <sys/param.h>
68 #include <sys/systm.h>
69 #include <sys/malloc.h>
70 #include <sys/proc.h>
71 #include <sys/vmmeter.h>
72 #include <sys/vnode.h>
73 #include <sys/kernel.h>
74 #include <sys/alist.h>
75 #include <sys/sysctl.h>
76 #include <sys/cpu_topology.h>
77
78 #include <vm/vm.h>
79 #include <vm/vm_param.h>
80 #include <sys/lock.h>
81 #include <vm/vm_kern.h>
82 #include <vm/pmap.h>
83 #include <vm/vm_map.h>
84 #include <vm/vm_object.h>
85 #include <vm/vm_page.h>
86 #include <vm/vm_pageout.h>
87 #include <vm/vm_pager.h>
88 #include <vm/vm_extern.h>
89 #include <vm/swap_pager.h>
90
91 #include <machine/inttypes.h>
92 #include <machine/md_var.h>
93 #include <machine/specialreg.h>
94
95 #include <vm/vm_page2.h>
96 #include <sys/spinlock2.h>
97
98 /*
99  * Action hash for user umtx support.
100  */
101 #define VMACTION_HSIZE          256
102 #define VMACTION_HMASK          (VMACTION_HSIZE - 1)
103
104 /*
105  * SET - Minimum required set associative size, must be a power of 2.  We
106  *       want this to match or exceed the set-associativeness of the cpu.
107  *
108  * GRP - A larger set that allows bleed-over into the domains of other
109  *       nearby cpus.  Also must be a power of 2.  Used by the page zeroing
110  *       code to smooth things out a bit.
111  */
112 #define PQ_SET_ASSOC            16
113 #define PQ_SET_ASSOC_MASK       (PQ_SET_ASSOC - 1)
114
115 #define PQ_GRP_ASSOC            (PQ_SET_ASSOC * 2)
116 #define PQ_GRP_ASSOC_MASK       (PQ_GRP_ASSOC - 1)
117
118 static void vm_page_queue_init(void);
119 static void vm_page_free_wakeup(void);
120 static vm_page_t vm_page_select_cache(u_short pg_color);
121 static vm_page_t _vm_page_list_find2(int basequeue, int index);
122 static void _vm_page_deactivate_locked(vm_page_t m, int athead);
123
124 /*
125  * Array of tailq lists
126  */
127 __cachealign struct vpgqueues vm_page_queues[PQ_COUNT];
128
129 LIST_HEAD(vm_page_action_list, vm_page_action);
130
131 struct vm_page_action_hash {
132         struct vm_page_action_list list;
133         struct lock     lk;
134 } __cachealign;
135
136 struct vm_page_action_hash      action_hash[VMACTION_HSIZE];
137 static volatile int vm_pages_waiting;
138
139 static struct alist vm_contig_alist;
140 static struct almeta vm_contig_ameta[ALIST_RECORDS_65536];
141 static struct spinlock vm_contig_spin = SPINLOCK_INITIALIZER(&vm_contig_spin, "vm_contig_spin");
142
143 static u_long vm_dma_reserved = 0;
144 TUNABLE_ULONG("vm.dma_reserved", &vm_dma_reserved);
145 SYSCTL_ULONG(_vm, OID_AUTO, dma_reserved, CTLFLAG_RD, &vm_dma_reserved, 0,
146             "Memory reserved for DMA");
147 SYSCTL_UINT(_vm, OID_AUTO, dma_free_pages, CTLFLAG_RD,
148             &vm_contig_alist.bl_free, 0, "Memory reserved for DMA");
149
150 static int vm_contig_verbose = 0;
151 TUNABLE_INT("vm.contig_verbose", &vm_contig_verbose);
152
153 RB_GENERATE2(vm_page_rb_tree, vm_page, rb_entry, rb_vm_page_compare,
154              vm_pindex_t, pindex);
155
156 static void
157 vm_page_queue_init(void) 
158 {
159         int i;
160
161         for (i = 0; i < PQ_L2_SIZE; i++)
162                 vm_page_queues[PQ_FREE+i].cnt_offset =
163                         offsetof(struct vmstats, v_free_count);
164         for (i = 0; i < PQ_L2_SIZE; i++)
165                 vm_page_queues[PQ_CACHE+i].cnt_offset =
166                         offsetof(struct vmstats, v_cache_count);
167         for (i = 0; i < PQ_L2_SIZE; i++)
168                 vm_page_queues[PQ_INACTIVE+i].cnt_offset =
169                         offsetof(struct vmstats, v_inactive_count);
170         for (i = 0; i < PQ_L2_SIZE; i++)
171                 vm_page_queues[PQ_ACTIVE+i].cnt_offset =
172                         offsetof(struct vmstats, v_active_count);
173         for (i = 0; i < PQ_L2_SIZE; i++)
174                 vm_page_queues[PQ_HOLD+i].cnt_offset =
175                         offsetof(struct vmstats, v_active_count);
176         /* PQ_NONE has no queue */
177
178         for (i = 0; i < PQ_COUNT; i++) {
179                 TAILQ_INIT(&vm_page_queues[i].pl);
180                 spin_init(&vm_page_queues[i].spin, "vm_page_queue_init");
181         }
182
183         /*
184          * NOTE: Action lock might recurse due to callback, so allow
185          *       recursion.
186          */
187         for (i = 0; i < VMACTION_HSIZE; i++) {
188                 LIST_INIT(&action_hash[i].list);
189                 lockinit(&action_hash[i].lk, "actlk", 0, LK_CANRECURSE);
190         }
191 }
192
193 /*
194  * note: place in initialized data section?  Is this necessary?
195  */
196 long first_page = 0;
197 int vm_page_array_size = 0;
198 vm_page_t vm_page_array = NULL;
199 vm_paddr_t vm_low_phys_reserved;
200
201 /*
202  * (low level boot)
203  *
204  * Sets the page size, perhaps based upon the memory size.
205  * Must be called before any use of page-size dependent functions.
206  */
207 void
208 vm_set_page_size(void)
209 {
210         if (vmstats.v_page_size == 0)
211                 vmstats.v_page_size = PAGE_SIZE;
212         if (((vmstats.v_page_size - 1) & vmstats.v_page_size) != 0)
213                 panic("vm_set_page_size: page size not a power of two");
214 }
215
216 /*
217  * (low level boot)
218  *
219  * Add a new page to the freelist for use by the system.  New pages
220  * are added to both the head and tail of the associated free page
221  * queue in a bottom-up fashion, so both zero'd and non-zero'd page
222  * requests pull 'recent' adds (higher physical addresses) first.
223  *
224  * Beware that the page zeroing daemon will also be running soon after
225  * boot, moving pages from the head to the tail of the PQ_FREE queues.
226  *
227  * Must be called in a critical section.
228  */
229 static void
230 vm_add_new_page(vm_paddr_t pa)
231 {
232         struct vpgqueues *vpq;
233         vm_page_t m;
234
235         m = PHYS_TO_VM_PAGE(pa);
236         m->phys_addr = pa;
237         m->flags = 0;
238         m->pat_mode = PAT_WRITE_BACK;
239         m->pc = (pa >> PAGE_SHIFT);
240
241         /*
242          * Twist for cpu localization in addition to page coloring, so
243          * different cpus selecting by m->queue get different page colors.
244          */
245         m->pc ^= ((pa >> PAGE_SHIFT) / PQ_L2_SIZE);
246         m->pc ^= ((pa >> PAGE_SHIFT) / (PQ_L2_SIZE * PQ_L2_SIZE));
247         m->pc &= PQ_L2_MASK;
248
249         /*
250          * Reserve a certain number of contiguous low memory pages for
251          * contigmalloc() to use.
252          */
253         if (pa < vm_low_phys_reserved) {
254                 atomic_add_int(&vmstats.v_page_count, 1);
255                 atomic_add_int(&vmstats.v_dma_pages, 1);
256                 m->queue = PQ_NONE;
257                 m->wire_count = 1;
258                 atomic_add_int(&vmstats.v_wire_count, 1);
259                 alist_free(&vm_contig_alist, pa >> PAGE_SHIFT, 1);
260                 return;
261         }
262
263         /*
264          * General page
265          */
266         m->queue = m->pc + PQ_FREE;
267         KKASSERT(m->dirty == 0);
268
269         atomic_add_int(&vmstats.v_page_count, 1);
270         atomic_add_int(&vmstats.v_free_count, 1);
271         vpq = &vm_page_queues[m->queue];
272         TAILQ_INSERT_HEAD(&vpq->pl, m, pageq);
273         ++vpq->lcnt;
274 }
275
276 /*
277  * (low level boot)
278  *
279  * Initializes the resident memory module.
280  *
281  * Preallocates memory for critical VM structures and arrays prior to
282  * kernel_map becoming available.
283  *
284  * Memory is allocated from (virtual2_start, virtual2_end) if available,
285  * otherwise memory is allocated from (virtual_start, virtual_end).
286  *
287  * On x86-64 (virtual_start, virtual_end) is only 2GB and may not be
288  * large enough to hold vm_page_array & other structures for machines with
289  * large amounts of ram, so we want to use virtual2* when available.
290  */
291 void
292 vm_page_startup(void)
293 {
294         vm_offset_t vaddr = virtual2_start ? virtual2_start : virtual_start;
295         vm_offset_t mapped;
296         vm_size_t npages;
297         vm_paddr_t page_range;
298         vm_paddr_t new_end;
299         int i;
300         vm_paddr_t pa;
301         vm_paddr_t last_pa;
302         vm_paddr_t end;
303         vm_paddr_t biggestone, biggestsize;
304         vm_paddr_t total;
305         vm_page_t m;
306
307         total = 0;
308         biggestsize = 0;
309         biggestone = 0;
310         vaddr = round_page(vaddr);
311
312         /*
313          * Make sure ranges are page-aligned.
314          */
315         for (i = 0; phys_avail[i].phys_end; ++i) {
316                 phys_avail[i].phys_beg = round_page64(phys_avail[i].phys_beg);
317                 phys_avail[i].phys_end = trunc_page64(phys_avail[i].phys_end);
318                 if (phys_avail[i].phys_end < phys_avail[i].phys_beg)
319                         phys_avail[i].phys_end = phys_avail[i].phys_beg;
320         }
321
322         /*
323          * Locate largest block
324          */
325         for (i = 0; phys_avail[i].phys_end; ++i) {
326                 vm_paddr_t size = phys_avail[i].phys_end -
327                                   phys_avail[i].phys_beg;
328
329                 if (size > biggestsize) {
330                         biggestone = i;
331                         biggestsize = size;
332                 }
333                 total += size;
334         }
335         --i;    /* adjust to last entry for use down below */
336
337         end = phys_avail[biggestone].phys_end;
338         end = trunc_page(end);
339
340         /*
341          * Initialize the queue headers for the free queue, the active queue
342          * and the inactive queue.
343          */
344         vm_page_queue_init();
345
346 #if !defined(_KERNEL_VIRTUAL)
347         /*
348          * VKERNELs don't support minidumps and as such don't need
349          * vm_page_dump
350          *
351          * Allocate a bitmap to indicate that a random physical page
352          * needs to be included in a minidump.
353          *
354          * The amd64 port needs this to indicate which direct map pages
355          * need to be dumped, via calls to dump_add_page()/dump_drop_page().
356          *
357          * However, i386 still needs this workspace internally within the
358          * minidump code.  In theory, they are not needed on i386, but are
359          * included should the sf_buf code decide to use them.
360          */
361         page_range = phys_avail[i].phys_end / PAGE_SIZE;
362         vm_page_dump_size = round_page(roundup2(page_range, NBBY) / NBBY);
363         end -= vm_page_dump_size;
364         vm_page_dump = (void *)pmap_map(&vaddr, end, end + vm_page_dump_size,
365                                         VM_PROT_READ | VM_PROT_WRITE);
366         bzero((void *)vm_page_dump, vm_page_dump_size);
367 #endif
368         /*
369          * Compute the number of pages of memory that will be available for
370          * use (taking into account the overhead of a page structure per
371          * page).
372          */
373         first_page = phys_avail[0].phys_beg / PAGE_SIZE;
374         page_range = phys_avail[i].phys_end / PAGE_SIZE - first_page;
375         npages = (total - (page_range * sizeof(struct vm_page))) / PAGE_SIZE;
376
377 #ifndef _KERNEL_VIRTUAL
378         /*
379          * (only applies to real kernels)
380          *
381          * Reserve a large amount of low memory for potential 32-bit DMA
382          * space allocations.  Once device initialization is complete we
383          * release most of it, but keep (vm_dma_reserved) memory reserved
384          * for later use.  Typically for X / graphics.  Through trial and
385          * error we find that GPUs usually requires ~60-100MB or so.
386          *
387          * By default, 128M is left in reserve on machines with 2G+ of ram.
388          */
389         vm_low_phys_reserved = (vm_paddr_t)65536 << PAGE_SHIFT;
390         if (vm_low_phys_reserved > total / 4)
391                 vm_low_phys_reserved = total / 4;
392         if (vm_dma_reserved == 0) {
393                 vm_dma_reserved = 128 * 1024 * 1024;    /* 128MB */
394                 if (vm_dma_reserved > total / 16)
395                         vm_dma_reserved = total / 16;
396         }
397 #endif
398         alist_init(&vm_contig_alist, 65536, vm_contig_ameta,
399                    ALIST_RECORDS_65536);
400
401         /*
402          * Initialize the mem entry structures now, and put them in the free
403          * queue.
404          */
405         new_end = trunc_page(end - page_range * sizeof(struct vm_page));
406         mapped = pmap_map(&vaddr, new_end, end, VM_PROT_READ | VM_PROT_WRITE);
407         vm_page_array = (vm_page_t)mapped;
408
409 #if defined(__x86_64__) && !defined(_KERNEL_VIRTUAL)
410         /*
411          * since pmap_map on amd64 returns stuff out of a direct-map region,
412          * we have to manually add these pages to the minidump tracking so
413          * that they can be dumped, including the vm_page_array.
414          */
415         for (pa = new_end;
416              pa < phys_avail[biggestone].phys_end;
417              pa += PAGE_SIZE) {
418                 dump_add_page(pa);
419         }
420 #endif
421
422         /*
423          * Clear all of the page structures, run basic initialization so
424          * PHYS_TO_VM_PAGE() operates properly even on pages not in the
425          * map.
426          */
427         bzero((caddr_t) vm_page_array, page_range * sizeof(struct vm_page));
428         vm_page_array_size = page_range;
429
430         m = &vm_page_array[0];
431         pa = ptoa(first_page);
432         for (i = 0; i < page_range; ++i) {
433                 spin_init(&m->spin, "vm_page");
434                 m->phys_addr = pa;
435                 pa += PAGE_SIZE;
436                 ++m;
437         }
438
439         /*
440          * Construct the free queue(s) in ascending order (by physical
441          * address) so that the first 16MB of physical memory is allocated
442          * last rather than first.  On large-memory machines, this avoids
443          * the exhaustion of low physical memory before isa_dmainit has run.
444          */
445         vmstats.v_page_count = 0;
446         vmstats.v_free_count = 0;
447         for (i = 0; phys_avail[i].phys_end && npages > 0; ++i) {
448                 pa = phys_avail[i].phys_beg;
449                 if (i == biggestone)
450                         last_pa = new_end;
451                 else
452                         last_pa = phys_avail[i].phys_end;
453                 while (pa < last_pa && npages-- > 0) {
454                         vm_add_new_page(pa);
455                         pa += PAGE_SIZE;
456                 }
457         }
458         if (virtual2_start)
459                 virtual2_start = vaddr;
460         else
461                 virtual_start = vaddr;
462         mycpu->gd_vmstats = vmstats;
463 }
464
465 /*
466  * Reorganize VM pages based on numa data.  May be called as many times as
467  * necessary.  Will reorganize the vm_page_t page color and related queue(s)
468  * to allow vm_page_alloc() to choose pages based on socket affinity.
469  *
470  * NOTE: This function is only called while we are still in UP mode, so
471  *       we only need a critical section to protect the queues (which
472  *       saves a lot of time, there are likely a ton of pages).
473  */
474 void
475 vm_numa_organize(vm_paddr_t ran_beg, vm_paddr_t bytes, int physid)
476 {
477         vm_paddr_t scan_beg;
478         vm_paddr_t scan_end;
479         vm_paddr_t ran_end;
480         struct vpgqueues *vpq;
481         vm_page_t m;
482         vm_page_t mend;
483         int i;
484         int socket_mod;
485         int socket_value;
486
487         /*
488          * Check if no physical information, or there was only one socket
489          * (so don't waste time doing nothing!).
490          */
491         if (cpu_topology_phys_ids <= 1 ||
492             cpu_topology_core_ids == 0) {
493                 return;
494         }
495
496         /*
497          * Setup for our iteration.  Note that ACPI may iterate CPU
498          * sockets starting at 0 or 1 or some other number.  The
499          * cpu_topology code mod's it against the socket count.
500          */
501         ran_end = ran_beg + bytes;
502         physid %= cpu_topology_phys_ids;
503
504         socket_mod = PQ_L2_SIZE / cpu_topology_phys_ids;
505         socket_value = physid * socket_mod;
506         mend = &vm_page_array[vm_page_array_size];
507
508         crit_enter();
509
510         /*
511          * Adjust vm_page->pc and requeue all affected pages.  The
512          * allocator will then be able to localize memory allocations
513          * to some degree.
514          */
515         for (i = 0; phys_avail[i].phys_end; ++i) {
516                 scan_beg = phys_avail[i].phys_beg;
517                 scan_end = phys_avail[i].phys_end;
518                 if (scan_end <= ran_beg)
519                         continue;
520                 if (scan_beg >= ran_end)
521                         continue;
522                 if (scan_beg < ran_beg)
523                         scan_beg = ran_beg;
524                 if (scan_end > ran_end)
525                         scan_end = ran_end;
526                 if (atop(scan_end) > first_page + vm_page_array_size)
527                         scan_end = ptoa(first_page + vm_page_array_size);
528
529                 m = PHYS_TO_VM_PAGE(scan_beg);
530                 while (scan_beg < scan_end) {
531                         KKASSERT(m < mend);
532                         if (m->queue != PQ_NONE) {
533                                 vpq = &vm_page_queues[m->queue];
534                                 TAILQ_REMOVE(&vpq->pl, m, pageq);
535                                 --vpq->lcnt;
536                                 /* queue doesn't change, no need to adj cnt */
537                                 m->queue -= m->pc;
538                                 m->pc %= socket_mod;
539                                 m->pc += socket_value;
540                                 m->pc &= PQ_L2_MASK;
541                                 m->queue += m->pc;
542                                 vpq = &vm_page_queues[m->queue];
543                                 TAILQ_INSERT_HEAD(&vpq->pl, m, pageq);
544                                 ++vpq->lcnt;
545                                 /* queue doesn't change, no need to adj cnt */
546                         } else {
547                                 m->pc %= socket_mod;
548                                 m->pc += socket_value;
549                                 m->pc &= PQ_L2_MASK;
550                         }
551                         scan_beg += PAGE_SIZE;
552                         ++m;
553                 }
554         }
555         crit_exit();
556 }
557
558 /*
559  * We tended to reserve a ton of memory for contigmalloc().  Now that most
560  * drivers have initialized we want to return most the remaining free
561  * reserve back to the VM page queues so they can be used for normal
562  * allocations.
563  *
564  * We leave vm_dma_reserved bytes worth of free pages in the reserve pool.
565  */
566 static void
567 vm_page_startup_finish(void *dummy __unused)
568 {
569         alist_blk_t blk;
570         alist_blk_t rblk;
571         alist_blk_t count;
572         alist_blk_t xcount;
573         alist_blk_t bfree;
574         vm_page_t m;
575
576         spin_lock(&vm_contig_spin);
577         for (;;) {
578                 bfree = alist_free_info(&vm_contig_alist, &blk, &count);
579                 if (bfree <= vm_dma_reserved / PAGE_SIZE)
580                         break;
581                 if (count == 0)
582                         break;
583
584                 /*
585                  * Figure out how much of the initial reserve we have to
586                  * free in order to reach our target.
587                  */
588                 bfree -= vm_dma_reserved / PAGE_SIZE;
589                 if (count > bfree) {
590                         blk += count - bfree;
591                         count = bfree;
592                 }
593
594                 /*
595                  * Calculate the nearest power of 2 <= count.
596                  */
597                 for (xcount = 1; xcount <= count; xcount <<= 1)
598                         ;
599                 xcount >>= 1;
600                 blk += count - xcount;
601                 count = xcount;
602
603                 /*
604                  * Allocate the pages from the alist, then free them to
605                  * the normal VM page queues.
606                  *
607                  * Pages allocated from the alist are wired.  We have to
608                  * busy, unwire, and free them.  We must also adjust
609                  * vm_low_phys_reserved before freeing any pages to prevent
610                  * confusion.
611                  */
612                 rblk = alist_alloc(&vm_contig_alist, blk, count);
613                 if (rblk != blk) {
614                         kprintf("vm_page_startup_finish: Unable to return "
615                                 "dma space @0x%08x/%d -> 0x%08x\n",
616                                 blk, count, rblk);
617                         break;
618                 }
619                 atomic_add_int(&vmstats.v_dma_pages, -count);
620                 spin_unlock(&vm_contig_spin);
621
622                 m = PHYS_TO_VM_PAGE((vm_paddr_t)blk << PAGE_SHIFT);
623                 vm_low_phys_reserved = VM_PAGE_TO_PHYS(m);
624                 while (count) {
625                         vm_page_busy_wait(m, FALSE, "cpgfr");
626                         vm_page_unwire(m, 0);
627                         vm_page_free(m);
628                         --count;
629                         ++m;
630                 }
631                 spin_lock(&vm_contig_spin);
632         }
633         spin_unlock(&vm_contig_spin);
634
635         /*
636          * Print out how much DMA space drivers have already allocated and
637          * how much is left over.
638          */
639         kprintf("DMA space used: %jdk, remaining available: %jdk\n",
640                 (intmax_t)(vmstats.v_dma_pages - vm_contig_alist.bl_free) *
641                 (PAGE_SIZE / 1024),
642                 (intmax_t)vm_contig_alist.bl_free * (PAGE_SIZE / 1024));
643 }
644 SYSINIT(vm_pgend, SI_SUB_PROC0_POST, SI_ORDER_ANY,
645         vm_page_startup_finish, NULL);
646
647
648 /*
649  * Scan comparison function for Red-Black tree scans.  An inclusive
650  * (start,end) is expected.  Other fields are not used.
651  */
652 int
653 rb_vm_page_scancmp(struct vm_page *p, void *data)
654 {
655         struct rb_vm_page_scan_info *info = data;
656
657         if (p->pindex < info->start_pindex)
658                 return(-1);
659         if (p->pindex > info->end_pindex)
660                 return(1);
661         return(0);
662 }
663
664 int
665 rb_vm_page_compare(struct vm_page *p1, struct vm_page *p2)
666 {
667         if (p1->pindex < p2->pindex)
668                 return(-1);
669         if (p1->pindex > p2->pindex)
670                 return(1);
671         return(0);
672 }
673
674 void
675 vm_page_init(vm_page_t m)
676 {
677         /* do nothing for now.  Called from pmap_page_init() */
678 }
679
680 /*
681  * Each page queue has its own spin lock, which is fairly optimal for
682  * allocating and freeing pages at least.
683  *
684  * The caller must hold the vm_page_spin_lock() before locking a vm_page's
685  * queue spinlock via this function.  Also note that m->queue cannot change
686  * unless both the page and queue are locked.
687  */
688 static __inline
689 void
690 _vm_page_queue_spin_lock(vm_page_t m)
691 {
692         u_short queue;
693
694         queue = m->queue;
695         if (queue != PQ_NONE) {
696                 spin_lock(&vm_page_queues[queue].spin);
697                 KKASSERT(queue == m->queue);
698         }
699 }
700
701 static __inline
702 void
703 _vm_page_queue_spin_unlock(vm_page_t m)
704 {
705         u_short queue;
706
707         queue = m->queue;
708         cpu_ccfence();
709         if (queue != PQ_NONE)
710                 spin_unlock(&vm_page_queues[queue].spin);
711 }
712
713 static __inline
714 void
715 _vm_page_queues_spin_lock(u_short queue)
716 {
717         cpu_ccfence();
718         if (queue != PQ_NONE)
719                 spin_lock(&vm_page_queues[queue].spin);
720 }
721
722
723 static __inline
724 void
725 _vm_page_queues_spin_unlock(u_short queue)
726 {
727         cpu_ccfence();
728         if (queue != PQ_NONE)
729                 spin_unlock(&vm_page_queues[queue].spin);
730 }
731
732 void
733 vm_page_queue_spin_lock(vm_page_t m)
734 {
735         _vm_page_queue_spin_lock(m);
736 }
737
738 void
739 vm_page_queues_spin_lock(u_short queue)
740 {
741         _vm_page_queues_spin_lock(queue);
742 }
743
744 void
745 vm_page_queue_spin_unlock(vm_page_t m)
746 {
747         _vm_page_queue_spin_unlock(m);
748 }
749
750 void
751 vm_page_queues_spin_unlock(u_short queue)
752 {
753         _vm_page_queues_spin_unlock(queue);
754 }
755
756 /*
757  * This locks the specified vm_page and its queue in the proper order
758  * (page first, then queue).  The queue may change so the caller must
759  * recheck on return.
760  */
761 static __inline
762 void
763 _vm_page_and_queue_spin_lock(vm_page_t m)
764 {
765         vm_page_spin_lock(m);
766         _vm_page_queue_spin_lock(m);
767 }
768
769 static __inline
770 void
771 _vm_page_and_queue_spin_unlock(vm_page_t m)
772 {
773         _vm_page_queues_spin_unlock(m->queue);
774         vm_page_spin_unlock(m);
775 }
776
777 void
778 vm_page_and_queue_spin_unlock(vm_page_t m)
779 {
780         _vm_page_and_queue_spin_unlock(m);
781 }
782
783 void
784 vm_page_and_queue_spin_lock(vm_page_t m)
785 {
786         _vm_page_and_queue_spin_lock(m);
787 }
788
789 /*
790  * Helper function removes vm_page from its current queue.
791  * Returns the base queue the page used to be on.
792  *
793  * The vm_page and the queue must be spinlocked.
794  * This function will unlock the queue but leave the page spinlocked.
795  */
796 static __inline u_short
797 _vm_page_rem_queue_spinlocked(vm_page_t m)
798 {
799         struct vpgqueues *pq;
800         u_short queue;
801         u_short oqueue;
802         int *cnt;
803
804         queue = m->queue;
805         if (queue != PQ_NONE) {
806                 pq = &vm_page_queues[queue];
807                 TAILQ_REMOVE(&pq->pl, m, pageq);
808
809                 /*
810                  * Adjust our pcpu stats.  In order for the nominal low-memory
811                  * algorithms to work properly we don't let any pcpu stat get
812                  * too negative before we force it to be rolled-up into the
813                  * global stats.  Otherwise our pageout and vm_wait tests
814                  * will fail badly.
815                  *
816                  * The idea here is to reduce unnecessary SMP cache
817                  * mastership changes in the global vmstats, which can be
818                  * particularly bad in multi-socket systems.
819                  */
820                 cnt = (int *)((char *)&mycpu->gd_vmstats_adj + pq->cnt_offset);
821                 atomic_add_int(cnt, -1);
822                 if (*cnt < -VMMETER_SLOP_COUNT) {
823                         u_int copy = atomic_swap_int(cnt, 0);
824                         cnt = (int *)((char *)&vmstats + pq->cnt_offset);
825                         atomic_add_int(cnt, copy);
826                         cnt = (int *)((char *)&mycpu->gd_vmstats +
827                                       pq->cnt_offset);
828                         atomic_add_int(cnt, copy);
829                 }
830                 pq->lcnt--;
831                 m->queue = PQ_NONE;
832                 oqueue = queue;
833                 queue -= m->pc;
834                 vm_page_queues_spin_unlock(oqueue);     /* intended */
835         }
836         return queue;
837 }
838
839 /*
840  * Helper function places the vm_page on the specified queue.
841  *
842  * The vm_page must be spinlocked.
843  * This function will return with both the page and the queue locked.
844  */
845 static __inline void
846 _vm_page_add_queue_spinlocked(vm_page_t m, u_short queue, int athead)
847 {
848         struct vpgqueues *pq;
849         u_int *cnt;
850
851         KKASSERT(m->queue == PQ_NONE);
852
853         if (queue != PQ_NONE) {
854                 vm_page_queues_spin_lock(queue);
855                 pq = &vm_page_queues[queue];
856                 ++pq->lcnt;
857
858                 /*
859                  * Adjust our pcpu stats.  If a system entity really needs
860                  * to incorporate the count it will call vmstats_rollup()
861                  * to roll it all up into the global vmstats strufture.
862                  */
863                 cnt = (int *)((char *)&mycpu->gd_vmstats_adj + pq->cnt_offset);
864                 atomic_add_int(cnt, 1);
865
866                 /*
867                  * PQ_FREE is always handled LIFO style to try to provide
868                  * cache-hot pages to programs.
869                  */
870                 m->queue = queue;
871                 if (queue - m->pc == PQ_FREE) {
872                         TAILQ_INSERT_HEAD(&pq->pl, m, pageq);
873                 } else if (athead) {
874                         TAILQ_INSERT_HEAD(&pq->pl, m, pageq);
875                 } else {
876                         TAILQ_INSERT_TAIL(&pq->pl, m, pageq);
877                 }
878                 /* leave the queue spinlocked */
879         }
880 }
881
882 /*
883  * Wait until page is no longer PG_BUSY or (if also_m_busy is TRUE)
884  * m->busy is zero.  Returns TRUE if it had to sleep, FALSE if we
885  * did not.  Only one sleep call will be made before returning.
886  *
887  * This function does NOT busy the page and on return the page is not
888  * guaranteed to be available.
889  */
890 void
891 vm_page_sleep_busy(vm_page_t m, int also_m_busy, const char *msg)
892 {
893         u_int32_t flags;
894
895         for (;;) {
896                 flags = m->flags;
897                 cpu_ccfence();
898
899                 if ((flags & PG_BUSY) == 0 &&
900                     (also_m_busy == 0 || (flags & PG_SBUSY) == 0)) {
901                         break;
902                 }
903                 tsleep_interlock(m, 0);
904                 if (atomic_cmpset_int(&m->flags, flags,
905                                       flags | PG_WANTED | PG_REFERENCED)) {
906                         tsleep(m, PINTERLOCKED, msg, 0);
907                         break;
908                 }
909         }
910 }
911
912 /*
913  * This calculates and returns a page color given an optional VM object and
914  * either a pindex or an iterator.  We attempt to return a cpu-localized
915  * pg_color that is still roughly 16-way set-associative.  The CPU topology
916  * is used if it was probed.
917  *
918  * The caller may use the returned value to index into e.g. PQ_FREE when
919  * allocating a page in order to nominally obtain pages that are hopefully
920  * already localized to the requesting cpu.  This function is not able to
921  * provide any sort of guarantee of this, but does its best to improve
922  * hardware cache management performance.
923  *
924  * WARNING! The caller must mask the returned value with PQ_L2_MASK.
925  */
926 u_short
927 vm_get_pg_color(int cpuid, vm_object_t object, vm_pindex_t pindex)
928 {
929         u_short pg_color;
930         int phys_id;
931         int core_id;
932         int object_pg_color;
933
934         phys_id = get_cpu_phys_id(cpuid);
935         core_id = get_cpu_core_id(cpuid);
936         object_pg_color = object ? object->pg_color : 0;
937
938         if (cpu_topology_phys_ids && cpu_topology_core_ids) {
939                 int grpsize;
940
941                 /*
942                  * Break us down by socket and cpu
943                  */
944                 pg_color = phys_id * PQ_L2_SIZE / cpu_topology_phys_ids;
945                 pg_color += core_id * PQ_L2_SIZE /
946                             (cpu_topology_core_ids * cpu_topology_phys_ids);
947
948                 /*
949                  * Calculate remaining component for object/queue color
950                  */
951                 grpsize = PQ_L2_SIZE / (cpu_topology_core_ids *
952                                         cpu_topology_phys_ids);
953                 if (grpsize >= 8) {
954                         pg_color += (pindex + object_pg_color) % grpsize;
955                 } else {
956                         if (grpsize <= 2) {
957                                 grpsize = 8;
958                         } else {
959                                 /* 3->9, 4->8, 5->10, 6->12, 7->14 */
960                                 grpsize += grpsize;
961                                 if (grpsize < 8)
962                                         grpsize += grpsize;
963                         }
964                         pg_color += (pindex + object_pg_color) % grpsize;
965                 }
966         } else {
967                 /*
968                  * Unknown topology, distribute things evenly.
969                  */
970                 pg_color = cpuid * PQ_L2_SIZE / ncpus;
971                 pg_color += pindex + object_pg_color;
972         }
973         return (pg_color & PQ_L2_MASK);
974 }
975
976 /*
977  * Wait until PG_BUSY can be set, then set it.  If also_m_busy is TRUE we
978  * also wait for m->busy to become 0 before setting PG_BUSY.
979  */
980 void
981 VM_PAGE_DEBUG_EXT(vm_page_busy_wait)(vm_page_t m,
982                                      int also_m_busy, const char *msg
983                                      VM_PAGE_DEBUG_ARGS)
984 {
985         u_int32_t flags;
986
987         for (;;) {
988                 flags = m->flags;
989                 cpu_ccfence();
990                 if (flags & PG_BUSY) {
991                         tsleep_interlock(m, 0);
992                         if (atomic_cmpset_int(&m->flags, flags,
993                                           flags | PG_WANTED | PG_REFERENCED)) {
994                                 tsleep(m, PINTERLOCKED, msg, 0);
995                         }
996                 } else if (also_m_busy && (flags & PG_SBUSY)) {
997                         tsleep_interlock(m, 0);
998                         if (atomic_cmpset_int(&m->flags, flags,
999                                           flags | PG_WANTED | PG_REFERENCED)) {
1000                                 tsleep(m, PINTERLOCKED, msg, 0);
1001                         }
1002                 } else {
1003                         if (atomic_cmpset_int(&m->flags, flags,
1004                                               flags | PG_BUSY)) {
1005 #ifdef VM_PAGE_DEBUG
1006                                 m->busy_func = func;
1007                                 m->busy_line = lineno;
1008 #endif
1009                                 break;
1010                         }
1011                 }
1012         }
1013 }
1014
1015 /*
1016  * Attempt to set PG_BUSY.  If also_m_busy is TRUE we only succeed if m->busy
1017  * is also 0.
1018  *
1019  * Returns non-zero on failure.
1020  */
1021 int
1022 VM_PAGE_DEBUG_EXT(vm_page_busy_try)(vm_page_t m, int also_m_busy
1023                                     VM_PAGE_DEBUG_ARGS)
1024 {
1025         u_int32_t flags;
1026
1027         for (;;) {
1028                 flags = m->flags;
1029                 cpu_ccfence();
1030                 if (flags & PG_BUSY)
1031                         return TRUE;
1032                 if (also_m_busy && (flags & PG_SBUSY))
1033                         return TRUE;
1034                 if (atomic_cmpset_int(&m->flags, flags, flags | PG_BUSY)) {
1035 #ifdef VM_PAGE_DEBUG
1036                                 m->busy_func = func;
1037                                 m->busy_line = lineno;
1038 #endif
1039                         return FALSE;
1040                 }
1041         }
1042 }
1043
1044 /*
1045  * Clear the PG_BUSY flag and return non-zero to indicate to the caller
1046  * that a wakeup() should be performed.
1047  *
1048  * The vm_page must be spinlocked and will remain spinlocked on return.
1049  * The related queue must NOT be spinlocked (which could deadlock us).
1050  *
1051  * (inline version)
1052  */
1053 static __inline
1054 int
1055 _vm_page_wakeup(vm_page_t m)
1056 {
1057         u_int32_t flags;
1058
1059         for (;;) {
1060                 flags = m->flags;
1061                 cpu_ccfence();
1062                 if (atomic_cmpset_int(&m->flags, flags,
1063                                       flags & ~(PG_BUSY | PG_WANTED))) {
1064                         break;
1065                 }
1066         }
1067         return(flags & PG_WANTED);
1068 }
1069
1070 /*
1071  * Clear the PG_BUSY flag and wakeup anyone waiting for the page.  This
1072  * is typically the last call you make on a page before moving onto
1073  * other things.
1074  */
1075 void
1076 vm_page_wakeup(vm_page_t m)
1077 {
1078         KASSERT(m->flags & PG_BUSY, ("vm_page_wakeup: page not busy!!!"));
1079         vm_page_spin_lock(m);
1080         if (_vm_page_wakeup(m)) {
1081                 vm_page_spin_unlock(m);
1082                 wakeup(m);
1083         } else {
1084                 vm_page_spin_unlock(m);
1085         }
1086 }
1087
1088 /*
1089  * Holding a page keeps it from being reused.  Other parts of the system
1090  * can still disassociate the page from its current object and free it, or
1091  * perform read or write I/O on it and/or otherwise manipulate the page,
1092  * but if the page is held the VM system will leave the page and its data
1093  * intact and not reuse the page for other purposes until the last hold
1094  * reference is released.  (see vm_page_wire() if you want to prevent the
1095  * page from being disassociated from its object too).
1096  *
1097  * The caller must still validate the contents of the page and, if necessary,
1098  * wait for any pending I/O (e.g. vm_page_sleep_busy() loop) to complete
1099  * before manipulating the page.
1100  *
1101  * XXX get vm_page_spin_lock() here and move FREE->HOLD if necessary
1102  */
1103 void
1104 vm_page_hold(vm_page_t m)
1105 {
1106         vm_page_spin_lock(m);
1107         atomic_add_int(&m->hold_count, 1);
1108         if (m->queue - m->pc == PQ_FREE) {
1109                 _vm_page_queue_spin_lock(m);
1110                 _vm_page_rem_queue_spinlocked(m);
1111                 _vm_page_add_queue_spinlocked(m, PQ_HOLD + m->pc, 0);
1112                 _vm_page_queue_spin_unlock(m);
1113         }
1114         vm_page_spin_unlock(m);
1115 }
1116
1117 /*
1118  * The opposite of vm_page_hold().  If the page is on the HOLD queue
1119  * it was freed while held and must be moved back to the FREE queue.
1120  */
1121 void
1122 vm_page_unhold(vm_page_t m)
1123 {
1124         KASSERT(m->hold_count > 0 && m->queue - m->pc != PQ_FREE,
1125                 ("vm_page_unhold: pg %p illegal hold_count (%d) or on FREE queue (%d)",
1126                  m, m->hold_count, m->queue - m->pc));
1127         vm_page_spin_lock(m);
1128         atomic_add_int(&m->hold_count, -1);
1129         if (m->hold_count == 0 && m->queue - m->pc == PQ_HOLD) {
1130                 _vm_page_queue_spin_lock(m);
1131                 _vm_page_rem_queue_spinlocked(m);
1132                 _vm_page_add_queue_spinlocked(m, PQ_FREE + m->pc, 0);
1133                 _vm_page_queue_spin_unlock(m);
1134         }
1135         vm_page_spin_unlock(m);
1136 }
1137
1138 /*
1139  *      vm_page_getfake:
1140  *
1141  *      Create a fictitious page with the specified physical address and
1142  *      memory attribute.  The memory attribute is the only the machine-
1143  *      dependent aspect of a fictitious page that must be initialized.
1144  */
1145
1146 void
1147 vm_page_initfake(vm_page_t m, vm_paddr_t paddr, vm_memattr_t memattr)
1148 {
1149
1150         if ((m->flags & PG_FICTITIOUS) != 0) {
1151                 /*
1152                  * The page's memattr might have changed since the
1153                  * previous initialization.  Update the pmap to the
1154                  * new memattr.
1155                  */
1156                 goto memattr;
1157         }
1158         m->phys_addr = paddr;
1159         m->queue = PQ_NONE;
1160         /* Fictitious pages don't use "segind". */
1161         /* Fictitious pages don't use "order" or "pool". */
1162         m->flags = PG_FICTITIOUS | PG_UNMANAGED | PG_BUSY;
1163         m->wire_count = 1;
1164         spin_init(&m->spin, "fake_page");
1165         pmap_page_init(m);
1166 memattr:
1167         pmap_page_set_memattr(m, memattr);
1168 }
1169
1170 /*
1171  * Inserts the given vm_page into the object and object list.
1172  *
1173  * The pagetables are not updated but will presumably fault the page
1174  * in if necessary, or if a kernel page the caller will at some point
1175  * enter the page into the kernel's pmap.  We are not allowed to block
1176  * here so we *can't* do this anyway.
1177  *
1178  * This routine may not block.
1179  * This routine must be called with the vm_object held.
1180  * This routine must be called with a critical section held.
1181  *
1182  * This routine returns TRUE if the page was inserted into the object
1183  * successfully, and FALSE if the page already exists in the object.
1184  */
1185 int
1186 vm_page_insert(vm_page_t m, vm_object_t object, vm_pindex_t pindex)
1187 {
1188         ASSERT_LWKT_TOKEN_HELD_EXCL(vm_object_token(object));
1189         if (m->object != NULL)
1190                 panic("vm_page_insert: already inserted");
1191
1192         object->generation++;
1193
1194         /*
1195          * Record the object/offset pair in this page and add the
1196          * pv_list_count of the page to the object.
1197          *
1198          * The vm_page spin lock is required for interactions with the pmap.
1199          */
1200         vm_page_spin_lock(m);
1201         m->object = object;
1202         m->pindex = pindex;
1203         if (vm_page_rb_tree_RB_INSERT(&object->rb_memq, m)) {
1204                 m->object = NULL;
1205                 m->pindex = 0;
1206                 vm_page_spin_unlock(m);
1207                 return FALSE;
1208         }
1209         ++object->resident_page_count;
1210         ++mycpu->gd_vmtotal.t_rm;
1211         vm_page_spin_unlock(m);
1212
1213         /*
1214          * Since we are inserting a new and possibly dirty page,
1215          * update the object's OBJ_WRITEABLE and OBJ_MIGHTBEDIRTY flags.
1216          */
1217         if ((m->valid & m->dirty) ||
1218             (m->flags & (PG_WRITEABLE | PG_NEED_COMMIT)))
1219                 vm_object_set_writeable_dirty(object);
1220
1221         /*
1222          * Checks for a swap assignment and sets PG_SWAPPED if appropriate.
1223          */
1224         swap_pager_page_inserted(m);
1225         return TRUE;
1226 }
1227
1228 /*
1229  * Removes the given vm_page_t from the (object,index) table
1230  *
1231  * The underlying pmap entry (if any) is NOT removed here.
1232  * This routine may not block.
1233  *
1234  * The page must be BUSY and will remain BUSY on return.
1235  * No other requirements.
1236  *
1237  * NOTE: FreeBSD side effect was to unbusy the page on return.  We leave
1238  *       it busy.
1239  */
1240 void
1241 vm_page_remove(vm_page_t m)
1242 {
1243         vm_object_t object;
1244
1245         if (m->object == NULL) {
1246                 return;
1247         }
1248
1249         if ((m->flags & PG_BUSY) == 0)
1250                 panic("vm_page_remove: page not busy");
1251
1252         object = m->object;
1253
1254         vm_object_hold(object);
1255
1256         /*
1257          * Remove the page from the object and update the object.
1258          *
1259          * The vm_page spin lock is required for interactions with the pmap.
1260          */
1261         vm_page_spin_lock(m);
1262         vm_page_rb_tree_RB_REMOVE(&object->rb_memq, m);
1263         --object->resident_page_count;
1264         --mycpu->gd_vmtotal.t_rm;
1265         m->object = NULL;
1266         vm_page_spin_unlock(m);
1267
1268         object->generation++;
1269
1270         vm_object_drop(object);
1271 }
1272
1273 /*
1274  * Locate and return the page at (object, pindex), or NULL if the
1275  * page could not be found.
1276  *
1277  * The caller must hold the vm_object token.
1278  */
1279 vm_page_t
1280 vm_page_lookup(vm_object_t object, vm_pindex_t pindex)
1281 {
1282         vm_page_t m;
1283
1284         /*
1285          * Search the hash table for this object/offset pair
1286          */
1287         ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
1288         m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq, pindex);
1289         KKASSERT(m == NULL || (m->object == object && m->pindex == pindex));
1290         return(m);
1291 }
1292
1293 vm_page_t
1294 VM_PAGE_DEBUG_EXT(vm_page_lookup_busy_wait)(struct vm_object *object,
1295                                             vm_pindex_t pindex,
1296                                             int also_m_busy, const char *msg
1297                                             VM_PAGE_DEBUG_ARGS)
1298 {
1299         u_int32_t flags;
1300         vm_page_t m;
1301
1302         ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
1303         m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq, pindex);
1304         while (m) {
1305                 KKASSERT(m->object == object && m->pindex == pindex);
1306                 flags = m->flags;
1307                 cpu_ccfence();
1308                 if (flags & PG_BUSY) {
1309                         tsleep_interlock(m, 0);
1310                         if (atomic_cmpset_int(&m->flags, flags,
1311                                           flags | PG_WANTED | PG_REFERENCED)) {
1312                                 tsleep(m, PINTERLOCKED, msg, 0);
1313                                 m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq,
1314                                                               pindex);
1315                         }
1316                 } else if (also_m_busy && (flags & PG_SBUSY)) {
1317                         tsleep_interlock(m, 0);
1318                         if (atomic_cmpset_int(&m->flags, flags,
1319                                           flags | PG_WANTED | PG_REFERENCED)) {
1320                                 tsleep(m, PINTERLOCKED, msg, 0);
1321                                 m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq,
1322                                                               pindex);
1323                         }
1324                 } else if (atomic_cmpset_int(&m->flags, flags,
1325                                              flags | PG_BUSY)) {
1326 #ifdef VM_PAGE_DEBUG
1327                         m->busy_func = func;
1328                         m->busy_line = lineno;
1329 #endif
1330                         break;
1331                 }
1332         }
1333         return m;
1334 }
1335
1336 /*
1337  * Attempt to lookup and busy a page.
1338  *
1339  * Returns NULL if the page could not be found
1340  *
1341  * Returns a vm_page and error == TRUE if the page exists but could not
1342  * be busied.
1343  *
1344  * Returns a vm_page and error == FALSE on success.
1345  */
1346 vm_page_t
1347 VM_PAGE_DEBUG_EXT(vm_page_lookup_busy_try)(struct vm_object *object,
1348                                            vm_pindex_t pindex,
1349                                            int also_m_busy, int *errorp
1350                                            VM_PAGE_DEBUG_ARGS)
1351 {
1352         u_int32_t flags;
1353         vm_page_t m;
1354
1355         ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
1356         m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq, pindex);
1357         *errorp = FALSE;
1358         while (m) {
1359                 KKASSERT(m->object == object && m->pindex == pindex);
1360                 flags = m->flags;
1361                 cpu_ccfence();
1362                 if (flags & PG_BUSY) {
1363                         *errorp = TRUE;
1364                         break;
1365                 }
1366                 if (also_m_busy && (flags & PG_SBUSY)) {
1367                         *errorp = TRUE;
1368                         break;
1369                 }
1370                 if (atomic_cmpset_int(&m->flags, flags, flags | PG_BUSY)) {
1371 #ifdef VM_PAGE_DEBUG
1372                         m->busy_func = func;
1373                         m->busy_line = lineno;
1374 #endif
1375                         break;
1376                 }
1377         }
1378         return m;
1379 }
1380
1381 /*
1382  * Attempt to repurpose the passed-in page.  If the passed-in page cannot
1383  * be repurposed it will be released, *must_reenter will be set to 1, and
1384  * this function will fall-through to vm_page_lookup_busy_try().
1385  *
1386  * The passed-in page must be wired and not busy.  The returned page will
1387  * be busied and not wired.
1388  *
1389  * A different page may be returned.  The returned page will be busied and
1390  * not wired.
1391  *
1392  * NULL can be returned.  If so, the required page could not be busied.
1393  * The passed-in page will be unwired.
1394  */
1395 vm_page_t
1396 vm_page_repurpose(struct vm_object *object, vm_pindex_t pindex,
1397                   int also_m_busy, int *errorp, vm_page_t m,
1398                   int *must_reenter, int *iswired)
1399 {
1400         if (m) {
1401                 /*
1402                  * Do not mess with pages in a complex state, such as pages
1403                  * which are mapped, as repurposing such pages can be more
1404                  * expensive than simply allocatin a new one.
1405                  *
1406                  * NOTE: Soft-busying can deadlock against putpages or I/O
1407                  *       so we only allow hard-busying here.
1408                  */
1409                 KKASSERT(also_m_busy == FALSE);
1410                 vm_page_busy_wait(m, also_m_busy, "biodep");
1411
1412                 if ((m->flags & (PG_UNMANAGED | PG_MAPPED |
1413                                  PG_FICTITIOUS | PG_SBUSY)) ||
1414                     m->busy || m->wire_count != 1 || m->hold_count) {
1415                         vm_page_unwire(m, 0);
1416                         vm_page_wakeup(m);
1417                         /* fall through to normal lookup */
1418                 } else if (m->dirty || (m->flags & PG_NEED_COMMIT)) {
1419                         vm_page_unwire(m, 0);
1420                         vm_page_deactivate(m);
1421                         vm_page_wakeup(m);
1422                         /* fall through to normal lookup */
1423                 } else {
1424                         /*
1425                          * We can safely repurpose the page.  It should
1426                          * already be unqueued.
1427                          */
1428                         KKASSERT(m->queue == PQ_NONE && m->dirty == 0);
1429                         vm_page_remove(m);
1430                         m->valid = 0;
1431                         m->act_count = 0;
1432                         if (vm_page_insert(m, object, pindex)) {
1433                                 *errorp = 0;
1434                                 *iswired = 1;
1435
1436                                 return m;
1437                         }
1438                         vm_page_unwire(m, 0);
1439                         vm_page_free(m);
1440                         /* fall through to normal lookup */
1441                 }
1442         }
1443
1444         /*
1445          * Cannot repurpose page, attempt to locate the desired page.  May
1446          * return NULL.
1447          */
1448         *must_reenter = 1;
1449         *iswired = 0;
1450         m = vm_page_lookup_busy_try(object, pindex, also_m_busy, errorp);
1451
1452         return m;
1453 }
1454
1455 /*
1456  * Caller must hold the related vm_object
1457  */
1458 vm_page_t
1459 vm_page_next(vm_page_t m)
1460 {
1461         vm_page_t next;
1462
1463         next = vm_page_rb_tree_RB_NEXT(m);
1464         if (next && next->pindex != m->pindex + 1)
1465                 next = NULL;
1466         return (next);
1467 }
1468
1469 /*
1470  * vm_page_rename()
1471  *
1472  * Move the given vm_page from its current object to the specified
1473  * target object/offset.  The page must be busy and will remain so
1474  * on return.
1475  *
1476  * new_object must be held.
1477  * This routine might block. XXX ?
1478  *
1479  * NOTE: Swap associated with the page must be invalidated by the move.  We
1480  *       have to do this for several reasons:  (1) we aren't freeing the
1481  *       page, (2) we are dirtying the page, (3) the VM system is probably
1482  *       moving the page from object A to B, and will then later move
1483  *       the backing store from A to B and we can't have a conflict.
1484  *
1485  * NOTE: We *always* dirty the page.  It is necessary both for the
1486  *       fact that we moved it, and because we may be invalidating
1487  *       swap.  If the page is on the cache, we have to deactivate it
1488  *       or vm_page_dirty() will panic.  Dirty pages are not allowed
1489  *       on the cache.
1490  */
1491 void
1492 vm_page_rename(vm_page_t m, vm_object_t new_object, vm_pindex_t new_pindex)
1493 {
1494         KKASSERT(m->flags & PG_BUSY);
1495         ASSERT_LWKT_TOKEN_HELD_EXCL(vm_object_token(new_object));
1496         if (m->object) {
1497                 ASSERT_LWKT_TOKEN_HELD_EXCL(vm_object_token(m->object));
1498                 vm_page_remove(m);
1499         }
1500         if (vm_page_insert(m, new_object, new_pindex) == FALSE) {
1501                 panic("vm_page_rename: target exists (%p,%"PRIu64")",
1502                       new_object, new_pindex);
1503         }
1504         if (m->queue - m->pc == PQ_CACHE)
1505                 vm_page_deactivate(m);
1506         vm_page_dirty(m);
1507 }
1508
1509 /*
1510  * vm_page_unqueue() without any wakeup.  This routine is used when a page
1511  * is to remain BUSYied by the caller.
1512  *
1513  * This routine may not block.
1514  */
1515 void
1516 vm_page_unqueue_nowakeup(vm_page_t m)
1517 {
1518         vm_page_and_queue_spin_lock(m);
1519         (void)_vm_page_rem_queue_spinlocked(m);
1520         vm_page_spin_unlock(m);
1521 }
1522
1523 /*
1524  * vm_page_unqueue() - Remove a page from its queue, wakeup the pagedemon
1525  * if necessary.
1526  *
1527  * This routine may not block.
1528  */
1529 void
1530 vm_page_unqueue(vm_page_t m)
1531 {
1532         u_short queue;
1533
1534         vm_page_and_queue_spin_lock(m);
1535         queue = _vm_page_rem_queue_spinlocked(m);
1536         if (queue == PQ_FREE || queue == PQ_CACHE) {
1537                 vm_page_spin_unlock(m);
1538                 pagedaemon_wakeup();
1539         } else {
1540                 vm_page_spin_unlock(m);
1541         }
1542 }
1543
1544 /*
1545  * vm_page_list_find()
1546  *
1547  * Find a page on the specified queue with color optimization.
1548  *
1549  * The page coloring optimization attempts to locate a page that does
1550  * not overload other nearby pages in the object in the cpu's L1 or L2
1551  * caches.  We need this optimization because cpu caches tend to be
1552  * physical caches, while object spaces tend to be virtual.
1553  *
1554  * The page coloring optimization also, very importantly, tries to localize
1555  * memory to cpus and physical sockets.
1556  *
1557  * On MP systems each PQ_FREE and PQ_CACHE color queue has its own spinlock
1558  * and the algorithm is adjusted to localize allocations on a per-core basis.
1559  * This is done by 'twisting' the colors.
1560  *
1561  * The page is returned spinlocked and removed from its queue (it will
1562  * be on PQ_NONE), or NULL. The page is not PG_BUSY'd.  The caller
1563  * is responsible for dealing with the busy-page case (usually by
1564  * deactivating the page and looping).
1565  *
1566  * NOTE:  This routine is carefully inlined.  A non-inlined version
1567  *        is available for outside callers but the only critical path is
1568  *        from within this source file.
1569  *
1570  * NOTE:  This routine assumes that the vm_pages found in PQ_CACHE and PQ_FREE
1571  *        represent stable storage, allowing us to order our locks vm_page
1572  *        first, then queue.
1573  */
1574 static __inline
1575 vm_page_t
1576 _vm_page_list_find(int basequeue, int index, boolean_t prefer_zero)
1577 {
1578         vm_page_t m;
1579
1580         for (;;) {
1581                 if (prefer_zero) {
1582                         m = TAILQ_LAST(&vm_page_queues[basequeue+index].pl,
1583                                        pglist);
1584                 } else {
1585                         m = TAILQ_FIRST(&vm_page_queues[basequeue+index].pl);
1586                 }
1587                 if (m == NULL) {
1588                         m = _vm_page_list_find2(basequeue, index);
1589                         return(m);
1590                 }
1591                 vm_page_and_queue_spin_lock(m);
1592                 if (m->queue == basequeue + index) {
1593                         _vm_page_rem_queue_spinlocked(m);
1594                         /* vm_page_t spin held, no queue spin */
1595                         break;
1596                 }
1597                 vm_page_and_queue_spin_unlock(m);
1598         }
1599         return(m);
1600 }
1601
1602 /*
1603  * If we could not find the page in the desired queue try to find it in
1604  * a nearby queue.
1605  */
1606 static vm_page_t
1607 _vm_page_list_find2(int basequeue, int index)
1608 {
1609         struct vpgqueues *pq;
1610         vm_page_t m = NULL;
1611         int pqmask = PQ_SET_ASSOC_MASK >> 1;
1612         int pqi;
1613         int i;
1614
1615         index &= PQ_L2_MASK;
1616         pq = &vm_page_queues[basequeue];
1617
1618         /*
1619          * Run local sets of 16, 32, 64, 128, and the whole queue if all
1620          * else fails (PQ_L2_MASK which is 255).
1621          */
1622         do {
1623                 pqmask = (pqmask << 1) | 1;
1624                 for (i = 0; i <= pqmask; ++i) {
1625                         pqi = (index & ~pqmask) | ((index + i) & pqmask);
1626                         m = TAILQ_FIRST(&pq[pqi].pl);
1627                         if (m) {
1628                                 _vm_page_and_queue_spin_lock(m);
1629                                 if (m->queue == basequeue + pqi) {
1630                                         _vm_page_rem_queue_spinlocked(m);
1631                                         return(m);
1632                                 }
1633                                 _vm_page_and_queue_spin_unlock(m);
1634                                 --i;
1635                                 continue;
1636                         }
1637                 }
1638         } while (pqmask != PQ_L2_MASK);
1639
1640         return(m);
1641 }
1642
1643 /*
1644  * Returns a vm_page candidate for allocation.  The page is not busied so
1645  * it can move around.  The caller must busy the page (and typically
1646  * deactivate it if it cannot be busied!)
1647  *
1648  * Returns a spinlocked vm_page that has been removed from its queue.
1649  */
1650 vm_page_t
1651 vm_page_list_find(int basequeue, int index, boolean_t prefer_zero)
1652 {
1653         return(_vm_page_list_find(basequeue, index, prefer_zero));
1654 }
1655
1656 /*
1657  * Find a page on the cache queue with color optimization, remove it
1658  * from the queue, and busy it.  The returned page will not be spinlocked.
1659  *
1660  * A candidate failure will be deactivated.  Candidates can fail due to
1661  * being busied by someone else, in which case they will be deactivated.
1662  *
1663  * This routine may not block.
1664  *
1665  */
1666 static vm_page_t
1667 vm_page_select_cache(u_short pg_color)
1668 {
1669         vm_page_t m;
1670
1671         for (;;) {
1672                 m = _vm_page_list_find(PQ_CACHE, pg_color & PQ_L2_MASK, FALSE);
1673                 if (m == NULL)
1674                         break;
1675                 /*
1676                  * (m) has been removed from its queue and spinlocked
1677                  */
1678                 if (vm_page_busy_try(m, TRUE)) {
1679                         _vm_page_deactivate_locked(m, 0);
1680                         vm_page_spin_unlock(m);
1681                 } else {
1682                         /*
1683                          * We successfully busied the page
1684                          */
1685                         if ((m->flags & (PG_UNMANAGED | PG_NEED_COMMIT)) == 0 &&
1686                             m->hold_count == 0 &&
1687                             m->wire_count == 0 &&
1688                             (m->dirty & m->valid) == 0) {
1689                                 vm_page_spin_unlock(m);
1690                                 pagedaemon_wakeup();
1691                                 return(m);
1692                         }
1693
1694                         /*
1695                          * The page cannot be recycled, deactivate it.
1696                          */
1697                         _vm_page_deactivate_locked(m, 0);
1698                         if (_vm_page_wakeup(m)) {
1699                                 vm_page_spin_unlock(m);
1700                                 wakeup(m);
1701                         } else {
1702                                 vm_page_spin_unlock(m);
1703                         }
1704                 }
1705         }
1706         return (m);
1707 }
1708
1709 /*
1710  * Find a free or zero page, with specified preference.  We attempt to
1711  * inline the nominal case and fall back to _vm_page_select_free() 
1712  * otherwise.  A busied page is removed from the queue and returned.
1713  *
1714  * This routine may not block.
1715  */
1716 static __inline vm_page_t
1717 vm_page_select_free(u_short pg_color, boolean_t prefer_zero)
1718 {
1719         vm_page_t m;
1720
1721         for (;;) {
1722                 m = _vm_page_list_find(PQ_FREE, pg_color & PQ_L2_MASK,
1723                                        prefer_zero);
1724                 if (m == NULL)
1725                         break;
1726                 if (vm_page_busy_try(m, TRUE)) {
1727                         /*
1728                          * Various mechanisms such as a pmap_collect can
1729                          * result in a busy page on the free queue.  We
1730                          * have to move the page out of the way so we can
1731                          * retry the allocation.  If the other thread is not
1732                          * allocating the page then m->valid will remain 0 and
1733                          * the pageout daemon will free the page later on.
1734                          *
1735                          * Since we could not busy the page, however, we
1736                          * cannot make assumptions as to whether the page
1737                          * will be allocated by the other thread or not,
1738                          * so all we can do is deactivate it to move it out
1739                          * of the way.  In particular, if the other thread
1740                          * wires the page it may wind up on the inactive
1741                          * queue and the pageout daemon will have to deal
1742                          * with that case too.
1743                          */
1744                         _vm_page_deactivate_locked(m, 0);
1745                         vm_page_spin_unlock(m);
1746                 } else {
1747                         /*
1748                          * Theoretically if we are able to busy the page
1749                          * atomic with the queue removal (using the vm_page
1750                          * lock) nobody else should be able to mess with the
1751                          * page before us.
1752                          */
1753                         KKASSERT((m->flags & (PG_UNMANAGED |
1754                                               PG_NEED_COMMIT)) == 0);
1755                         KASSERT(m->hold_count == 0, ("m->hold_count is not zero "
1756                                                      "pg %p q=%d flags=%08x hold=%d wire=%d",
1757                                                      m, m->queue, m->flags, m->hold_count, m->wire_count));
1758                         KKASSERT(m->wire_count == 0);
1759                         vm_page_spin_unlock(m);
1760                         pagedaemon_wakeup();
1761
1762                         /* return busied and removed page */
1763                         return(m);
1764                 }
1765         }
1766         return(m);
1767 }
1768
1769 /*
1770  * vm_page_alloc()
1771  *
1772  * Allocate and return a memory cell associated with this VM object/offset
1773  * pair.  If object is NULL an unassociated page will be allocated.
1774  *
1775  * The returned page will be busied and removed from its queues.  This
1776  * routine can block and may return NULL if a race occurs and the page
1777  * is found to already exist at the specified (object, pindex).
1778  *
1779  *      VM_ALLOC_NORMAL         allow use of cache pages, nominal free drain
1780  *      VM_ALLOC_QUICK          like normal but cannot use cache
1781  *      VM_ALLOC_SYSTEM         greater free drain
1782  *      VM_ALLOC_INTERRUPT      allow free list to be completely drained
1783  *      VM_ALLOC_ZERO           advisory request for pre-zero'd page only
1784  *      VM_ALLOC_FORCE_ZERO     advisory request for pre-zero'd page only
1785  *      VM_ALLOC_NULL_OK        ok to return NULL on insertion collision
1786  *                              (see vm_page_grab())
1787  *      VM_ALLOC_USE_GD         ok to use per-gd cache
1788  *
1789  *      VM_ALLOC_CPU(n)         allocate using specified cpu localization
1790  *
1791  * The object must be held if not NULL
1792  * This routine may not block
1793  *
1794  * Additional special handling is required when called from an interrupt
1795  * (VM_ALLOC_INTERRUPT).  We are not allowed to mess with the page cache
1796  * in this case.
1797  */
1798 vm_page_t
1799 vm_page_alloc(vm_object_t object, vm_pindex_t pindex, int page_req)
1800 {
1801         globaldata_t gd;
1802         vm_object_t obj;
1803         vm_page_t m;
1804         u_short pg_color;
1805         int cpuid_local;
1806
1807 #if 0
1808         /*
1809          * Special per-cpu free VM page cache.  The pages are pre-busied
1810          * and pre-zerod for us.
1811          */
1812         if (gd->gd_vmpg_count && (page_req & VM_ALLOC_USE_GD)) {
1813                 crit_enter_gd(gd);
1814                 if (gd->gd_vmpg_count) {
1815                         m = gd->gd_vmpg_array[--gd->gd_vmpg_count];
1816                         crit_exit_gd(gd);
1817                         goto done;
1818                 }
1819                 crit_exit_gd(gd);
1820         }
1821 #endif
1822         m = NULL;
1823
1824         /*
1825          * CPU LOCALIZATION
1826          *
1827          * CPU localization algorithm.  Break the page queues up by physical
1828          * id and core id (note that two cpu threads will have the same core
1829          * id, and core_id != gd_cpuid).
1830          *
1831          * This is nowhere near perfect, for example the last pindex in a
1832          * subgroup will overflow into the next cpu or package.  But this
1833          * should get us good page reuse locality in heavy mixed loads.
1834          *
1835          * (may be executed before the APs are started, so other GDs might
1836          *  not exist!)
1837          */
1838         if (page_req & VM_ALLOC_CPU_SPEC)
1839                 cpuid_local = VM_ALLOC_GETCPU(page_req);
1840         else
1841                 cpuid_local = mycpu->gd_cpuid;
1842
1843         pg_color = vm_get_pg_color(cpuid_local, object, pindex);
1844
1845         KKASSERT(page_req & 
1846                 (VM_ALLOC_NORMAL|VM_ALLOC_QUICK|
1847                  VM_ALLOC_INTERRUPT|VM_ALLOC_SYSTEM));
1848
1849         /*
1850          * Certain system threads (pageout daemon, buf_daemon's) are
1851          * allowed to eat deeper into the free page list.
1852          */
1853         if (curthread->td_flags & TDF_SYSTHREAD)
1854                 page_req |= VM_ALLOC_SYSTEM;
1855
1856         /*
1857          * Impose various limitations.  Note that the v_free_reserved test
1858          * must match the opposite of vm_page_count_target() to avoid
1859          * livelocks, be careful.
1860          */
1861 loop:
1862         gd = mycpu;
1863         if (gd->gd_vmstats.v_free_count >= gd->gd_vmstats.v_free_reserved ||
1864             ((page_req & VM_ALLOC_INTERRUPT) &&
1865              gd->gd_vmstats.v_free_count > 0) ||
1866             ((page_req & VM_ALLOC_SYSTEM) &&
1867              gd->gd_vmstats.v_cache_count == 0 &&
1868                 gd->gd_vmstats.v_free_count >
1869                 gd->gd_vmstats.v_interrupt_free_min)
1870         ) {
1871                 /*
1872                  * The free queue has sufficient free pages to take one out.
1873                  */
1874                 if (page_req & (VM_ALLOC_ZERO | VM_ALLOC_FORCE_ZERO))
1875                         m = vm_page_select_free(pg_color, TRUE);
1876                 else
1877                         m = vm_page_select_free(pg_color, FALSE);
1878         } else if (page_req & VM_ALLOC_NORMAL) {
1879                 /*
1880                  * Allocatable from the cache (non-interrupt only).  On
1881                  * success, we must free the page and try again, thus
1882                  * ensuring that vmstats.v_*_free_min counters are replenished.
1883                  */
1884 #ifdef INVARIANTS
1885                 if (curthread->td_preempted) {
1886                         kprintf("vm_page_alloc(): warning, attempt to allocate"
1887                                 " cache page from preempting interrupt\n");
1888                         m = NULL;
1889                 } else {
1890                         m = vm_page_select_cache(pg_color);
1891                 }
1892 #else
1893                 m = vm_page_select_cache(pg_color);
1894 #endif
1895                 /*
1896                  * On success move the page into the free queue and loop.
1897                  *
1898                  * Only do this if we can safely acquire the vm_object lock,
1899                  * because this is effectively a random page and the caller
1900                  * might be holding the lock shared, we don't want to
1901                  * deadlock.
1902                  */
1903                 if (m != NULL) {
1904                         KASSERT(m->dirty == 0,
1905                                 ("Found dirty cache page %p", m));
1906                         if ((obj = m->object) != NULL) {
1907                                 if (vm_object_hold_try(obj)) {
1908                                         vm_page_protect(m, VM_PROT_NONE);
1909                                         vm_page_free(m);
1910                                         /* m->object NULL here */
1911                                         vm_object_drop(obj);
1912                                 } else {
1913                                         vm_page_deactivate(m);
1914                                         vm_page_wakeup(m);
1915                                 }
1916                         } else {
1917                                 vm_page_protect(m, VM_PROT_NONE);
1918                                 vm_page_free(m);
1919                         }
1920                         goto loop;
1921                 }
1922
1923                 /*
1924                  * On failure return NULL
1925                  */
1926                 atomic_add_int(&vm_pageout_deficit, 1);
1927                 pagedaemon_wakeup();
1928                 return (NULL);
1929         } else {
1930                 /*
1931                  * No pages available, wakeup the pageout daemon and give up.
1932                  */
1933                 atomic_add_int(&vm_pageout_deficit, 1);
1934                 pagedaemon_wakeup();
1935                 return (NULL);
1936         }
1937
1938         /*
1939          * v_free_count can race so loop if we don't find the expected
1940          * page.
1941          */
1942         if (m == NULL) {
1943                 vmstats_rollup();
1944                 goto loop;
1945         }
1946
1947         /*
1948          * Good page found.  The page has already been busied for us and
1949          * removed from its queues.
1950          */
1951         KASSERT(m->dirty == 0,
1952                 ("vm_page_alloc: free/cache page %p was dirty", m));
1953         KKASSERT(m->queue == PQ_NONE);
1954
1955 #if 0
1956 done:
1957 #endif
1958         /*
1959          * Initialize the structure, inheriting some flags but clearing
1960          * all the rest.  The page has already been busied for us.
1961          */
1962         vm_page_flag_clear(m, ~(PG_BUSY | PG_SBUSY));
1963         KKASSERT(m->wire_count == 0);
1964         KKASSERT(m->busy == 0);
1965         m->act_count = 0;
1966         m->valid = 0;
1967
1968         /*
1969          * Caller must be holding the object lock (asserted by
1970          * vm_page_insert()).
1971          *
1972          * NOTE: Inserting a page here does not insert it into any pmaps
1973          *       (which could cause us to block allocating memory).
1974          *
1975          * NOTE: If no object an unassociated page is allocated, m->pindex
1976          *       can be used by the caller for any purpose.
1977          */
1978         if (object) {
1979                 if (vm_page_insert(m, object, pindex) == FALSE) {
1980                         vm_page_free(m);
1981                         if ((page_req & VM_ALLOC_NULL_OK) == 0)
1982                                 panic("PAGE RACE %p[%ld]/%p",
1983                                       object, (long)pindex, m);
1984                         m = NULL;
1985                 }
1986         } else {
1987                 m->pindex = pindex;
1988         }
1989
1990         /*
1991          * Don't wakeup too often - wakeup the pageout daemon when
1992          * we would be nearly out of memory.
1993          */
1994         pagedaemon_wakeup();
1995
1996         /*
1997          * A PG_BUSY page is returned.
1998          */
1999         return (m);
2000 }
2001
2002 /*
2003  * Returns number of pages available in our DMA memory reserve
2004  * (adjusted with vm.dma_reserved=<value>m in /boot/loader.conf)
2005  */
2006 vm_size_t
2007 vm_contig_avail_pages(void)
2008 {
2009         alist_blk_t blk;
2010         alist_blk_t count;
2011         alist_blk_t bfree;
2012         spin_lock(&vm_contig_spin);
2013         bfree = alist_free_info(&vm_contig_alist, &blk, &count);
2014         spin_unlock(&vm_contig_spin);
2015
2016         return bfree;
2017 }
2018
2019 /*
2020  * Attempt to allocate contiguous physical memory with the specified
2021  * requirements.
2022  */
2023 vm_page_t
2024 vm_page_alloc_contig(vm_paddr_t low, vm_paddr_t high,
2025                      unsigned long alignment, unsigned long boundary,
2026                      unsigned long size, vm_memattr_t memattr)
2027 {
2028         alist_blk_t blk;
2029         vm_page_t m;
2030         int i;
2031
2032         alignment >>= PAGE_SHIFT;
2033         if (alignment == 0)
2034                 alignment = 1;
2035         boundary >>= PAGE_SHIFT;
2036         if (boundary == 0)
2037                 boundary = 1;
2038         size = (size + PAGE_MASK) >> PAGE_SHIFT;
2039
2040         spin_lock(&vm_contig_spin);
2041         blk = alist_alloc(&vm_contig_alist, 0, size);
2042         if (blk == ALIST_BLOCK_NONE) {
2043                 spin_unlock(&vm_contig_spin);
2044                 if (bootverbose) {
2045                         kprintf("vm_page_alloc_contig: %ldk nospace\n",
2046                                 (size + PAGE_MASK) * (PAGE_SIZE / 1024));
2047                 }
2048                 return(NULL);
2049         }
2050         if (high && ((vm_paddr_t)(blk + size) << PAGE_SHIFT) > high) {
2051                 alist_free(&vm_contig_alist, blk, size);
2052                 spin_unlock(&vm_contig_spin);
2053                 if (bootverbose) {
2054                         kprintf("vm_page_alloc_contig: %ldk high "
2055                                 "%016jx failed\n",
2056                                 (size + PAGE_MASK) * (PAGE_SIZE / 1024),
2057                                 (intmax_t)high);
2058                 }
2059                 return(NULL);
2060         }
2061         spin_unlock(&vm_contig_spin);
2062         if (vm_contig_verbose) {
2063                 kprintf("vm_page_alloc_contig: %016jx/%ldk\n",
2064                         (intmax_t)(vm_paddr_t)blk << PAGE_SHIFT,
2065                         (size + PAGE_MASK) * (PAGE_SIZE / 1024));
2066         }
2067
2068         m = PHYS_TO_VM_PAGE((vm_paddr_t)blk << PAGE_SHIFT);
2069         if (memattr != VM_MEMATTR_DEFAULT)
2070                 for (i = 0;i < size;i++)
2071                         pmap_page_set_memattr(&m[i], memattr);
2072         return m;
2073 }
2074
2075 /*
2076  * Free contiguously allocated pages.  The pages will be wired but not busy.
2077  * When freeing to the alist we leave them wired and not busy.
2078  */
2079 void
2080 vm_page_free_contig(vm_page_t m, unsigned long size)
2081 {
2082         vm_paddr_t pa = VM_PAGE_TO_PHYS(m);
2083         vm_pindex_t start = pa >> PAGE_SHIFT;
2084         vm_pindex_t pages = (size + PAGE_MASK) >> PAGE_SHIFT;
2085
2086         if (vm_contig_verbose) {
2087                 kprintf("vm_page_free_contig:  %016jx/%ldk\n",
2088                         (intmax_t)pa, size / 1024);
2089         }
2090         if (pa < vm_low_phys_reserved) {
2091                 KKASSERT(pa + size <= vm_low_phys_reserved);
2092                 spin_lock(&vm_contig_spin);
2093                 alist_free(&vm_contig_alist, start, pages);
2094                 spin_unlock(&vm_contig_spin);
2095         } else {
2096                 while (pages) {
2097                         vm_page_busy_wait(m, FALSE, "cpgfr");
2098                         vm_page_unwire(m, 0);
2099                         vm_page_free(m);
2100                         --pages;
2101                         ++m;
2102                 }
2103
2104         }
2105 }
2106
2107
2108 /*
2109  * Wait for sufficient free memory for nominal heavy memory use kernel
2110  * operations.
2111  *
2112  * WARNING!  Be sure never to call this in any vm_pageout code path, which
2113  *           will trivially deadlock the system.
2114  */
2115 void
2116 vm_wait_nominal(void)
2117 {
2118         while (vm_page_count_min(0))
2119                 vm_wait(0);
2120 }
2121
2122 /*
2123  * Test if vm_wait_nominal() would block.
2124  */
2125 int
2126 vm_test_nominal(void)
2127 {
2128         if (vm_page_count_min(0))
2129                 return(1);
2130         return(0);
2131 }
2132
2133 /*
2134  * Block until free pages are available for allocation, called in various
2135  * places before memory allocations.
2136  *
2137  * The caller may loop if vm_page_count_min() == FALSE so we cannot be
2138  * more generous then that.
2139  */
2140 void
2141 vm_wait(int timo)
2142 {
2143         /*
2144          * never wait forever
2145          */
2146         if (timo == 0)
2147                 timo = hz;
2148         lwkt_gettoken(&vm_token);
2149
2150         if (curthread == pagethread) {
2151                 /*
2152                  * The pageout daemon itself needs pages, this is bad.
2153                  */
2154                 if (vm_page_count_min(0)) {
2155                         vm_pageout_pages_needed = 1;
2156                         tsleep(&vm_pageout_pages_needed, 0, "VMWait", timo);
2157                 }
2158         } else {
2159                 /*
2160                  * Wakeup the pageout daemon if necessary and wait.
2161                  *
2162                  * Do not wait indefinitely for the target to be reached,
2163                  * as load might prevent it from being reached any time soon.
2164                  * But wait a little to try to slow down page allocations
2165                  * and to give more important threads (the pagedaemon)
2166                  * allocation priority.
2167                  */
2168                 if (vm_page_count_target()) {
2169                         if (vm_pages_needed == 0) {
2170                                 vm_pages_needed = 1;
2171                                 wakeup(&vm_pages_needed);
2172                         }
2173                         ++vm_pages_waiting;     /* SMP race ok */
2174                         tsleep(&vmstats.v_free_count, 0, "vmwait", timo);
2175                 }
2176         }
2177         lwkt_reltoken(&vm_token);
2178 }
2179
2180 /*
2181  * Block until free pages are available for allocation
2182  *
2183  * Called only from vm_fault so that processes page faulting can be
2184  * easily tracked.
2185  */
2186 void
2187 vm_wait_pfault(void)
2188 {
2189         /*
2190          * Wakeup the pageout daemon if necessary and wait.
2191          *
2192          * Do not wait indefinitely for the target to be reached,
2193          * as load might prevent it from being reached any time soon.
2194          * But wait a little to try to slow down page allocations
2195          * and to give more important threads (the pagedaemon)
2196          * allocation priority.
2197          */
2198         if (vm_page_count_min(0)) {
2199                 lwkt_gettoken(&vm_token);
2200                 while (vm_page_count_severe()) {
2201                         if (vm_page_count_target()) {
2202                                 thread_t td;
2203
2204                                 if (vm_pages_needed == 0) {
2205                                         vm_pages_needed = 1;
2206                                         wakeup(&vm_pages_needed);
2207                                 }
2208                                 ++vm_pages_waiting;     /* SMP race ok */
2209                                 tsleep(&vmstats.v_free_count, 0, "pfault", hz);
2210
2211                                 /*
2212                                  * Do not stay stuck in the loop if the system is trying
2213                                  * to kill the process.
2214                                  */
2215                                 td = curthread;
2216                                 if (td->td_proc && (td->td_proc->p_flags & P_LOWMEMKILL))
2217                                         break;
2218                         }
2219                 }
2220                 lwkt_reltoken(&vm_token);
2221         }
2222 }
2223
2224 /*
2225  * Put the specified page on the active list (if appropriate).  Ensure
2226  * that act_count is at least ACT_INIT but do not otherwise mess with it.
2227  *
2228  * The caller should be holding the page busied ? XXX
2229  * This routine may not block.
2230  */
2231 void
2232 vm_page_activate(vm_page_t m)
2233 {
2234         u_short oqueue;
2235
2236         vm_page_spin_lock(m);
2237         if (m->queue - m->pc != PQ_ACTIVE) {
2238                 _vm_page_queue_spin_lock(m);
2239                 oqueue = _vm_page_rem_queue_spinlocked(m);
2240                 /* page is left spinlocked, queue is unlocked */
2241
2242                 if (oqueue == PQ_CACHE)
2243                         mycpu->gd_cnt.v_reactivated++;
2244                 if (m->wire_count == 0 && (m->flags & PG_UNMANAGED) == 0) {
2245                         if (m->act_count < ACT_INIT)
2246                                 m->act_count = ACT_INIT;
2247                         _vm_page_add_queue_spinlocked(m, PQ_ACTIVE + m->pc, 0);
2248                 }
2249                 _vm_page_and_queue_spin_unlock(m);
2250                 if (oqueue == PQ_CACHE || oqueue == PQ_FREE)
2251                         pagedaemon_wakeup();
2252         } else {
2253                 if (m->act_count < ACT_INIT)
2254                         m->act_count = ACT_INIT;
2255                 vm_page_spin_unlock(m);
2256         }
2257 }
2258
2259 /*
2260  * Helper routine for vm_page_free_toq() and vm_page_cache().  This
2261  * routine is called when a page has been added to the cache or free
2262  * queues.
2263  *
2264  * This routine may not block.
2265  */
2266 static __inline void
2267 vm_page_free_wakeup(void)
2268 {
2269         globaldata_t gd = mycpu;
2270
2271         /*
2272          * If the pageout daemon itself needs pages, then tell it that
2273          * there are some free.
2274          */
2275         if (vm_pageout_pages_needed &&
2276             gd->gd_vmstats.v_cache_count + gd->gd_vmstats.v_free_count >=
2277             gd->gd_vmstats.v_pageout_free_min
2278         ) {
2279                 vm_pageout_pages_needed = 0;
2280                 wakeup(&vm_pageout_pages_needed);
2281         }
2282
2283         /*
2284          * Wakeup processes that are waiting on memory.
2285          *
2286          * Generally speaking we want to wakeup stuck processes as soon as
2287          * possible.  !vm_page_count_min(0) is the absolute minimum point
2288          * where we can do this.  Wait a bit longer to reduce degenerate
2289          * re-blocking (vm_page_free_hysteresis).  The target check is just
2290          * to make sure the min-check w/hysteresis does not exceed the
2291          * normal target.
2292          */
2293         if (vm_pages_waiting) {
2294                 if (!vm_page_count_min(vm_page_free_hysteresis) ||
2295                     !vm_page_count_target()) {
2296                         vm_pages_waiting = 0;
2297                         wakeup(&vmstats.v_free_count);
2298                         ++mycpu->gd_cnt.v_ppwakeups;
2299                 }
2300 #if 0
2301                 if (!vm_page_count_target()) {
2302                         /*
2303                          * Plenty of pages are free, wakeup everyone.
2304                          */
2305                         vm_pages_waiting = 0;
2306                         wakeup(&vmstats.v_free_count);
2307                         ++mycpu->gd_cnt.v_ppwakeups;
2308                 } else if (!vm_page_count_min(0)) {
2309                         /*
2310                          * Some pages are free, wakeup someone.
2311                          */
2312                         int wcount = vm_pages_waiting;
2313                         if (wcount > 0)
2314                                 --wcount;
2315                         vm_pages_waiting = wcount;
2316                         wakeup_one(&vmstats.v_free_count);
2317                         ++mycpu->gd_cnt.v_ppwakeups;
2318                 }
2319 #endif
2320         }
2321 }
2322
2323 /*
2324  * Returns the given page to the PQ_FREE or PQ_HOLD list and disassociates
2325  * it from its VM object.
2326  *
2327  * The vm_page must be PG_BUSY on entry.  PG_BUSY will be released on
2328  * return (the page will have been freed).
2329  */
2330 void
2331 vm_page_free_toq(vm_page_t m)
2332 {
2333         mycpu->gd_cnt.v_tfree++;
2334         KKASSERT((m->flags & PG_MAPPED) == 0);
2335         KKASSERT(m->flags & PG_BUSY);
2336
2337         if (m->busy || ((m->queue - m->pc) == PQ_FREE)) {
2338                 kprintf("vm_page_free: pindex(%lu), busy(%d), "
2339                         "PG_BUSY(%d), hold(%d)\n",
2340                         (u_long)m->pindex, m->busy,
2341                         ((m->flags & PG_BUSY) ? 1 : 0), m->hold_count);
2342                 if ((m->queue - m->pc) == PQ_FREE)
2343                         panic("vm_page_free: freeing free page");
2344                 else
2345                         panic("vm_page_free: freeing busy page");
2346         }
2347
2348         /*
2349          * Remove from object, spinlock the page and its queues and
2350          * remove from any queue.  No queue spinlock will be held
2351          * after this section (because the page was removed from any
2352          * queue).
2353          */
2354         vm_page_remove(m);
2355         vm_page_and_queue_spin_lock(m);
2356         _vm_page_rem_queue_spinlocked(m);
2357
2358         /*
2359          * No further management of fictitious pages occurs beyond object
2360          * and queue removal.
2361          */
2362         if ((m->flags & PG_FICTITIOUS) != 0) {
2363                 vm_page_spin_unlock(m);
2364                 vm_page_wakeup(m);
2365                 return;
2366         }
2367
2368         m->valid = 0;
2369         vm_page_undirty(m);
2370
2371         if (m->wire_count != 0) {
2372                 if (m->wire_count > 1) {
2373                     panic(
2374                         "vm_page_free: invalid wire count (%d), pindex: 0x%lx",
2375                         m->wire_count, (long)m->pindex);
2376                 }
2377                 panic("vm_page_free: freeing wired page");
2378         }
2379
2380         /*
2381          * Clear the UNMANAGED flag when freeing an unmanaged page.
2382          * Clear the NEED_COMMIT flag
2383          */
2384         if (m->flags & PG_UNMANAGED)
2385                 vm_page_flag_clear(m, PG_UNMANAGED);
2386         if (m->flags & PG_NEED_COMMIT)
2387                 vm_page_flag_clear(m, PG_NEED_COMMIT);
2388
2389         if (m->hold_count != 0) {
2390                 _vm_page_add_queue_spinlocked(m, PQ_HOLD + m->pc, 0);
2391         } else {
2392                 _vm_page_add_queue_spinlocked(m, PQ_FREE + m->pc, 0);
2393         }
2394
2395         /*
2396          * This sequence allows us to clear PG_BUSY while still holding
2397          * its spin lock, which reduces contention vs allocators.  We
2398          * must not leave the queue locked or _vm_page_wakeup() may
2399          * deadlock.
2400          */
2401         _vm_page_queue_spin_unlock(m);
2402         if (_vm_page_wakeup(m)) {
2403                 vm_page_spin_unlock(m);
2404                 wakeup(m);
2405         } else {
2406                 vm_page_spin_unlock(m);
2407         }
2408         vm_page_free_wakeup();
2409 }
2410
2411 /*
2412  * vm_page_unmanage()
2413  *
2414  * Prevent PV management from being done on the page.  The page is
2415  * removed from the paging queues as if it were wired, and as a 
2416  * consequence of no longer being managed the pageout daemon will not
2417  * touch it (since there is no way to locate the pte mappings for the
2418  * page).  madvise() calls that mess with the pmap will also no longer
2419  * operate on the page.
2420  *
2421  * Beyond that the page is still reasonably 'normal'.  Freeing the page
2422  * will clear the flag.
2423  *
2424  * This routine is used by OBJT_PHYS objects - objects using unswappable
2425  * physical memory as backing store rather then swap-backed memory and
2426  * will eventually be extended to support 4MB unmanaged physical 
2427  * mappings.
2428  *
2429  * Caller must be holding the page busy.
2430  */
2431 void
2432 vm_page_unmanage(vm_page_t m)
2433 {
2434         KKASSERT(m->flags & PG_BUSY);
2435         if ((m->flags & PG_UNMANAGED) == 0) {
2436                 if (m->wire_count == 0)
2437                         vm_page_unqueue(m);
2438         }
2439         vm_page_flag_set(m, PG_UNMANAGED);
2440 }
2441
2442 /*
2443  * Mark this page as wired down by yet another map, removing it from
2444  * paging queues as necessary.
2445  *
2446  * Caller must be holding the page busy.
2447  */
2448 void
2449 vm_page_wire(vm_page_t m)
2450 {
2451         /*
2452          * Only bump the wire statistics if the page is not already wired,
2453          * and only unqueue the page if it is on some queue (if it is unmanaged
2454          * it is already off the queues).  Don't do anything with fictitious
2455          * pages because they are always wired.
2456          */
2457         KKASSERT(m->flags & PG_BUSY);
2458         if ((m->flags & PG_FICTITIOUS) == 0) {
2459                 if (atomic_fetchadd_int(&m->wire_count, 1) == 0) {
2460                         if ((m->flags & PG_UNMANAGED) == 0)
2461                                 vm_page_unqueue(m);
2462                         atomic_add_int(&mycpu->gd_vmstats_adj.v_wire_count, 1);
2463                 }
2464                 KASSERT(m->wire_count != 0,
2465                         ("vm_page_wire: wire_count overflow m=%p", m));
2466         }
2467 }
2468
2469 /*
2470  * Release one wiring of this page, potentially enabling it to be paged again.
2471  *
2472  * Many pages placed on the inactive queue should actually go
2473  * into the cache, but it is difficult to figure out which.  What
2474  * we do instead, if the inactive target is well met, is to put
2475  * clean pages at the head of the inactive queue instead of the tail.
2476  * This will cause them to be moved to the cache more quickly and
2477  * if not actively re-referenced, freed more quickly.  If we just
2478  * stick these pages at the end of the inactive queue, heavy filesystem
2479  * meta-data accesses can cause an unnecessary paging load on memory bound 
2480  * processes.  This optimization causes one-time-use metadata to be
2481  * reused more quickly.
2482  *
2483  * Pages marked PG_NEED_COMMIT are always activated and never placed on
2484  * the inactive queue.  This helps the pageout daemon determine memory
2485  * pressure and act on out-of-memory situations more quickly.
2486  *
2487  * BUT, if we are in a low-memory situation we have no choice but to
2488  * put clean pages on the cache queue.
2489  *
2490  * A number of routines use vm_page_unwire() to guarantee that the page
2491  * will go into either the inactive or active queues, and will NEVER
2492  * be placed in the cache - for example, just after dirtying a page.
2493  * dirty pages in the cache are not allowed.
2494  *
2495  * This routine may not block.
2496  */
2497 void
2498 vm_page_unwire(vm_page_t m, int activate)
2499 {
2500         KKASSERT(m->flags & PG_BUSY);
2501         if (m->flags & PG_FICTITIOUS) {
2502                 /* do nothing */
2503         } else if (m->wire_count <= 0) {
2504                 panic("vm_page_unwire: invalid wire count: %d", m->wire_count);
2505         } else {
2506                 if (atomic_fetchadd_int(&m->wire_count, -1) == 1) {
2507                         atomic_add_int(&mycpu->gd_vmstats_adj.v_wire_count, -1);
2508                         if (m->flags & PG_UNMANAGED) {
2509                                 ;
2510                         } else if (activate || (m->flags & PG_NEED_COMMIT)) {
2511                                 vm_page_spin_lock(m);
2512                                 _vm_page_add_queue_spinlocked(m,
2513                                                         PQ_ACTIVE + m->pc, 0);
2514                                 _vm_page_and_queue_spin_unlock(m);
2515                         } else {
2516                                 vm_page_spin_lock(m);
2517                                 vm_page_flag_clear(m, PG_WINATCFLS);
2518                                 _vm_page_add_queue_spinlocked(m,
2519                                                         PQ_INACTIVE + m->pc, 0);
2520                                 ++vm_swapcache_inactive_heuristic;
2521                                 _vm_page_and_queue_spin_unlock(m);
2522                         }
2523                 }
2524         }
2525 }
2526
2527 /*
2528  * Move the specified page to the inactive queue.  If the page has
2529  * any associated swap, the swap is deallocated.
2530  *
2531  * Normally athead is 0 resulting in LRU operation.  athead is set
2532  * to 1 if we want this page to be 'as if it were placed in the cache',
2533  * except without unmapping it from the process address space.
2534  *
2535  * vm_page's spinlock must be held on entry and will remain held on return.
2536  * This routine may not block.
2537  */
2538 static void
2539 _vm_page_deactivate_locked(vm_page_t m, int athead)
2540 {
2541         u_short oqueue;
2542
2543         /*
2544          * Ignore if already inactive.
2545          */
2546         if (m->queue - m->pc == PQ_INACTIVE)
2547                 return;
2548         _vm_page_queue_spin_lock(m);
2549         oqueue = _vm_page_rem_queue_spinlocked(m);
2550
2551         if (m->wire_count == 0 && (m->flags & PG_UNMANAGED) == 0) {
2552                 if (oqueue == PQ_CACHE)
2553                         mycpu->gd_cnt.v_reactivated++;
2554                 vm_page_flag_clear(m, PG_WINATCFLS);
2555                 _vm_page_add_queue_spinlocked(m, PQ_INACTIVE + m->pc, athead);
2556                 if (athead == 0)
2557                         ++vm_swapcache_inactive_heuristic;
2558         }
2559         /* NOTE: PQ_NONE if condition not taken */
2560         _vm_page_queue_spin_unlock(m);
2561         /* leaves vm_page spinlocked */
2562 }
2563
2564 /*
2565  * Attempt to deactivate a page.
2566  *
2567  * No requirements.
2568  */
2569 void
2570 vm_page_deactivate(vm_page_t m)
2571 {
2572         vm_page_spin_lock(m);
2573         _vm_page_deactivate_locked(m, 0);
2574         vm_page_spin_unlock(m);
2575 }
2576
2577 void
2578 vm_page_deactivate_locked(vm_page_t m)
2579 {
2580         _vm_page_deactivate_locked(m, 0);
2581 }
2582
2583 /*
2584  * Attempt to move a busied page to PQ_CACHE, then unconditionally unbusy it.
2585  *
2586  * This function returns non-zero if it successfully moved the page to
2587  * PQ_CACHE.
2588  *
2589  * This function unconditionally unbusies the page on return.
2590  */
2591 int
2592 vm_page_try_to_cache(vm_page_t m)
2593 {
2594         vm_page_spin_lock(m);
2595         if (m->dirty || m->hold_count || m->wire_count ||
2596             (m->flags & (PG_UNMANAGED | PG_NEED_COMMIT))) {
2597                 if (_vm_page_wakeup(m)) {
2598                         vm_page_spin_unlock(m);
2599                         wakeup(m);
2600                 } else {
2601                         vm_page_spin_unlock(m);
2602                 }
2603                 return(0);
2604         }
2605         vm_page_spin_unlock(m);
2606
2607         /*
2608          * Page busied by us and no longer spinlocked.  Dirty pages cannot
2609          * be moved to the cache.
2610          */
2611         vm_page_test_dirty(m);
2612         if (m->dirty || (m->flags & PG_NEED_COMMIT)) {
2613                 vm_page_wakeup(m);
2614                 return(0);
2615         }
2616         vm_page_cache(m);
2617         return(1);
2618 }
2619
2620 /*
2621  * Attempt to free the page.  If we cannot free it, we do nothing.
2622  * 1 is returned on success, 0 on failure.
2623  *
2624  * No requirements.
2625  */
2626 int
2627 vm_page_try_to_free(vm_page_t m)
2628 {
2629         vm_page_spin_lock(m);
2630         if (vm_page_busy_try(m, TRUE)) {
2631                 vm_page_spin_unlock(m);
2632                 return(0);
2633         }
2634
2635         /*
2636          * The page can be in any state, including already being on the free
2637          * queue.  Check to see if it really can be freed.
2638          */
2639         if (m->dirty ||                         /* can't free if it is dirty */
2640             m->hold_count ||                    /* or held (XXX may be wrong) */
2641             m->wire_count ||                    /* or wired */
2642             (m->flags & (PG_UNMANAGED |         /* or unmanaged */
2643                          PG_NEED_COMMIT)) ||    /* or needs a commit */
2644             m->queue - m->pc == PQ_FREE ||      /* already on PQ_FREE */
2645             m->queue - m->pc == PQ_HOLD) {      /* already on PQ_HOLD */
2646                 if (_vm_page_wakeup(m)) {
2647                         vm_page_spin_unlock(m);
2648                         wakeup(m);
2649                 } else {
2650                         vm_page_spin_unlock(m);
2651                 }
2652                 return(0);
2653         }
2654         vm_page_spin_unlock(m);
2655
2656         /*
2657          * We can probably free the page.
2658          *
2659          * Page busied by us and no longer spinlocked.  Dirty pages will
2660          * not be freed by this function.    We have to re-test the
2661          * dirty bit after cleaning out the pmaps.
2662          */
2663         vm_page_test_dirty(m);
2664         if (m->dirty || (m->flags & PG_NEED_COMMIT)) {
2665                 vm_page_wakeup(m);
2666                 return(0);
2667         }
2668         vm_page_protect(m, VM_PROT_NONE);
2669         if (m->dirty || (m->flags & PG_NEED_COMMIT)) {
2670                 vm_page_wakeup(m);
2671                 return(0);
2672         }
2673         vm_page_free(m);
2674         return(1);
2675 }
2676
2677 /*
2678  * vm_page_cache
2679  *
2680  * Put the specified page onto the page cache queue (if appropriate).
2681  *
2682  * The page must be busy, and this routine will release the busy and
2683  * possibly even free the page.
2684  */
2685 void
2686 vm_page_cache(vm_page_t m)
2687 {
2688         /*
2689          * Not suitable for the cache
2690          */
2691         if ((m->flags & (PG_UNMANAGED | PG_NEED_COMMIT)) ||
2692             m->busy || m->wire_count || m->hold_count) {
2693                 vm_page_wakeup(m);
2694                 return;
2695         }
2696
2697         /*
2698          * Already in the cache (and thus not mapped)
2699          */
2700         if ((m->queue - m->pc) == PQ_CACHE) {
2701                 KKASSERT((m->flags & PG_MAPPED) == 0);
2702                 vm_page_wakeup(m);
2703                 return;
2704         }
2705
2706         /*
2707          * Caller is required to test m->dirty, but note that the act of
2708          * removing the page from its maps can cause it to become dirty
2709          * on an SMP system due to another cpu running in usermode.
2710          */
2711         if (m->dirty) {
2712                 panic("vm_page_cache: caching a dirty page, pindex: %ld",
2713                         (long)m->pindex);
2714         }
2715
2716         /*
2717          * Remove all pmaps and indicate that the page is not
2718          * writeable or mapped.  Our vm_page_protect() call may
2719          * have blocked (especially w/ VM_PROT_NONE), so recheck
2720          * everything.
2721          */
2722         vm_page_protect(m, VM_PROT_NONE);
2723         if ((m->flags & (PG_UNMANAGED | PG_MAPPED)) ||
2724             m->busy || m->wire_count || m->hold_count) {
2725                 vm_page_wakeup(m);
2726         } else if (m->dirty || (m->flags & PG_NEED_COMMIT)) {
2727                 vm_page_deactivate(m);
2728                 vm_page_wakeup(m);
2729         } else {
2730                 _vm_page_and_queue_spin_lock(m);
2731                 _vm_page_rem_queue_spinlocked(m);
2732                 _vm_page_add_queue_spinlocked(m, PQ_CACHE + m->pc, 0);
2733                 _vm_page_queue_spin_unlock(m);
2734                 if (_vm_page_wakeup(m)) {
2735                         vm_page_spin_unlock(m);
2736                         wakeup(m);
2737                 } else {
2738                         vm_page_spin_unlock(m);
2739                 }
2740                 vm_page_free_wakeup();
2741         }
2742 }
2743
2744 /*
2745  * vm_page_dontneed()
2746  *
2747  * Cache, deactivate, or do nothing as appropriate.  This routine
2748  * is typically used by madvise() MADV_DONTNEED.
2749  *
2750  * Generally speaking we want to move the page into the cache so
2751  * it gets reused quickly.  However, this can result in a silly syndrome
2752  * due to the page recycling too quickly.  Small objects will not be
2753  * fully cached.  On the otherhand, if we move the page to the inactive
2754  * queue we wind up with a problem whereby very large objects 
2755  * unnecessarily blow away our inactive and cache queues.
2756  *
2757  * The solution is to move the pages based on a fixed weighting.  We
2758  * either leave them alone, deactivate them, or move them to the cache,
2759  * where moving them to the cache has the highest weighting.
2760  * By forcing some pages into other queues we eventually force the
2761  * system to balance the queues, potentially recovering other unrelated
2762  * space from active.  The idea is to not force this to happen too
2763  * often.
2764  *
2765  * The page must be busied.
2766  */
2767 void
2768 vm_page_dontneed(vm_page_t m)
2769 {
2770         static int dnweight;
2771         int dnw;
2772         int head;
2773
2774         dnw = ++dnweight;
2775
2776         /*
2777          * occassionally leave the page alone
2778          */
2779         if ((dnw & 0x01F0) == 0 ||
2780             m->queue - m->pc == PQ_INACTIVE ||
2781             m->queue - m->pc == PQ_CACHE
2782         ) {
2783                 if (m->act_count >= ACT_INIT)
2784                         --m->act_count;
2785                 return;
2786         }
2787
2788         /*
2789          * If vm_page_dontneed() is inactivating a page, it must clear
2790          * the referenced flag; otherwise the pagedaemon will see references
2791          * on the page in the inactive queue and reactivate it. Until the 
2792          * page can move to the cache queue, madvise's job is not done.
2793          */
2794         vm_page_flag_clear(m, PG_REFERENCED);
2795         pmap_clear_reference(m);
2796
2797         if (m->dirty == 0)
2798                 vm_page_test_dirty(m);
2799
2800         if (m->dirty || (dnw & 0x0070) == 0) {
2801                 /*
2802                  * Deactivate the page 3 times out of 32.
2803                  */
2804                 head = 0;
2805         } else {
2806                 /*
2807                  * Cache the page 28 times out of every 32.  Note that
2808                  * the page is deactivated instead of cached, but placed
2809                  * at the head of the queue instead of the tail.
2810                  */
2811                 head = 1;
2812         }
2813         vm_page_spin_lock(m);
2814         _vm_page_deactivate_locked(m, head);
2815         vm_page_spin_unlock(m);
2816 }
2817
2818 /*
2819  * These routines manipulate the 'soft busy' count for a page.  A soft busy
2820  * is almost like PG_BUSY except that it allows certain compatible operations
2821  * to occur on the page while it is busy.  For example, a page undergoing a
2822  * write can still be mapped read-only.
2823  *
2824  * Because vm_pages can overlap buffers m->busy can be > 1.  m->busy is only
2825  * adjusted while the vm_page is PG_BUSY so the flash will occur when the
2826  * busy bit is cleared.
2827  */
2828 void
2829 vm_page_io_start(vm_page_t m)
2830 {
2831         KASSERT(m->flags & PG_BUSY, ("vm_page_io_start: page not busy!!!"));
2832         atomic_add_char(&m->busy, 1);
2833         vm_page_flag_set(m, PG_SBUSY);
2834 }
2835
2836 void
2837 vm_page_io_finish(vm_page_t m)
2838 {
2839         KASSERT(m->flags & PG_BUSY, ("vm_page_io_finish: page not busy!!!"));
2840         atomic_subtract_char(&m->busy, 1);
2841         if (m->busy == 0)
2842                 vm_page_flag_clear(m, PG_SBUSY);
2843 }
2844
2845 /*
2846  * Indicate that a clean VM page requires a filesystem commit and cannot
2847  * be reused.  Used by tmpfs.
2848  */
2849 void
2850 vm_page_need_commit(vm_page_t m)
2851 {
2852         vm_page_flag_set(m, PG_NEED_COMMIT);
2853         vm_object_set_writeable_dirty(m->object);
2854 }
2855
2856 void
2857 vm_page_clear_commit(vm_page_t m)
2858 {
2859         vm_page_flag_clear(m, PG_NEED_COMMIT);
2860 }
2861
2862 /*
2863  * Grab a page, blocking if it is busy and allocating a page if necessary.
2864  * A busy page is returned or NULL.  The page may or may not be valid and
2865  * might not be on a queue (the caller is responsible for the disposition of
2866  * the page).
2867  *
2868  * If VM_ALLOC_ZERO is specified and the grab must allocate a new page, the
2869  * page will be zero'd and marked valid.
2870  *
2871  * If VM_ALLOC_FORCE_ZERO is specified the page will be zero'd and marked
2872  * valid even if it already exists.
2873  *
2874  * If VM_ALLOC_RETRY is specified this routine will never return NULL.  Also
2875  * note that VM_ALLOC_NORMAL must be specified if VM_ALLOC_RETRY is specified.
2876  * VM_ALLOC_NULL_OK is implied when VM_ALLOC_RETRY is specified.
2877  *
2878  * This routine may block, but if VM_ALLOC_RETRY is not set then NULL is
2879  * always returned if we had blocked.  
2880  *
2881  * This routine may not be called from an interrupt.
2882  *
2883  * No other requirements.
2884  */
2885 vm_page_t
2886 vm_page_grab(vm_object_t object, vm_pindex_t pindex, int allocflags)
2887 {
2888         vm_page_t m;
2889         int error;
2890         int shared = 1;
2891
2892         KKASSERT(allocflags &
2893                 (VM_ALLOC_NORMAL|VM_ALLOC_INTERRUPT|VM_ALLOC_SYSTEM));
2894         vm_object_hold_shared(object);
2895         for (;;) {
2896                 m = vm_page_lookup_busy_try(object, pindex, TRUE, &error);
2897                 if (error) {
2898                         vm_page_sleep_busy(m, TRUE, "pgrbwt");
2899                         if ((allocflags & VM_ALLOC_RETRY) == 0) {
2900                                 m = NULL;
2901                                 break;
2902                         }
2903                         /* retry */
2904                 } else if (m == NULL) {
2905                         if (shared) {
2906                                 vm_object_upgrade(object);
2907                                 shared = 0;
2908                         }
2909                         if (allocflags & VM_ALLOC_RETRY)
2910                                 allocflags |= VM_ALLOC_NULL_OK;
2911                         m = vm_page_alloc(object, pindex,
2912                                           allocflags & ~VM_ALLOC_RETRY);
2913                         if (m)
2914                                 break;
2915                         vm_wait(0);
2916                         if ((allocflags & VM_ALLOC_RETRY) == 0)
2917                                 goto failed;
2918                 } else {
2919                         /* m found */
2920                         break;
2921                 }
2922         }
2923
2924         /*
2925          * If VM_ALLOC_ZERO an invalid page will be zero'd and set valid.
2926          *
2927          * If VM_ALLOC_FORCE_ZERO the page is unconditionally zero'd and set
2928          * valid even if already valid.
2929          *
2930          * NOTE!  We have removed all of the PG_ZERO optimizations and also
2931          *        removed the idle zeroing code.  These optimizations actually
2932          *        slow things down on modern cpus because the zerod area is
2933          *        likely uncached, placing a memory-access burden on the
2934          *        accesors taking the fault.
2935          *
2936          *        By always zeroing the page in-line with the fault, no
2937          *        dynamic ram reads are needed and the caches are hot, ready
2938          *        for userland to access the memory.
2939          */
2940         if (m->valid == 0) {
2941                 if (allocflags & (VM_ALLOC_ZERO | VM_ALLOC_FORCE_ZERO)) {
2942                         pmap_zero_page(VM_PAGE_TO_PHYS(m));
2943                         m->valid = VM_PAGE_BITS_ALL;
2944                 }
2945         } else if (allocflags & VM_ALLOC_FORCE_ZERO) {
2946                 pmap_zero_page(VM_PAGE_TO_PHYS(m));
2947                 m->valid = VM_PAGE_BITS_ALL;
2948         }
2949 failed:
2950         vm_object_drop(object);
2951         return(m);
2952 }
2953
2954 /*
2955  * Mapping function for valid bits or for dirty bits in
2956  * a page.  May not block.
2957  *
2958  * Inputs are required to range within a page.
2959  *
2960  * No requirements.
2961  * Non blocking.
2962  */
2963 int
2964 vm_page_bits(int base, int size)
2965 {
2966         int first_bit;
2967         int last_bit;
2968
2969         KASSERT(
2970             base + size <= PAGE_SIZE,
2971             ("vm_page_bits: illegal base/size %d/%d", base, size)
2972         );
2973
2974         if (size == 0)          /* handle degenerate case */
2975                 return(0);
2976
2977         first_bit = base >> DEV_BSHIFT;
2978         last_bit = (base + size - 1) >> DEV_BSHIFT;
2979
2980         return ((2 << last_bit) - (1 << first_bit));
2981 }
2982
2983 /*
2984  * Sets portions of a page valid and clean.  The arguments are expected
2985  * to be DEV_BSIZE aligned but if they aren't the bitmap is inclusive
2986  * of any partial chunks touched by the range.  The invalid portion of
2987  * such chunks will be zero'd.
2988  *
2989  * NOTE: When truncating a buffer vnode_pager_setsize() will automatically
2990  *       align base to DEV_BSIZE so as not to mark clean a partially
2991  *       truncated device block.  Otherwise the dirty page status might be
2992  *       lost.
2993  *
2994  * This routine may not block.
2995  *
2996  * (base + size) must be less then or equal to PAGE_SIZE.
2997  */
2998 static void
2999 _vm_page_zero_valid(vm_page_t m, int base, int size)
3000 {
3001         int frag;
3002         int endoff;
3003
3004         if (size == 0)  /* handle degenerate case */
3005                 return;
3006
3007         /*
3008          * If the base is not DEV_BSIZE aligned and the valid
3009          * bit is clear, we have to zero out a portion of the
3010          * first block.
3011          */
3012
3013         if ((frag = base & ~(DEV_BSIZE - 1)) != base &&
3014             (m->valid & (1 << (base >> DEV_BSHIFT))) == 0
3015         ) {
3016                 pmap_zero_page_area(
3017                     VM_PAGE_TO_PHYS(m),
3018                     frag,
3019                     base - frag
3020                 );
3021         }
3022
3023         /*
3024          * If the ending offset is not DEV_BSIZE aligned and the 
3025          * valid bit is clear, we have to zero out a portion of
3026          * the last block.
3027          */
3028
3029         endoff = base + size;
3030
3031         if ((frag = endoff & ~(DEV_BSIZE - 1)) != endoff &&
3032             (m->valid & (1 << (endoff >> DEV_BSHIFT))) == 0
3033         ) {
3034                 pmap_zero_page_area(
3035                     VM_PAGE_TO_PHYS(m),
3036                     endoff,
3037                     DEV_BSIZE - (endoff & (DEV_BSIZE - 1))
3038                 );
3039         }
3040 }
3041
3042 /*
3043  * Set valid, clear dirty bits.  If validating the entire
3044  * page we can safely clear the pmap modify bit.  We also
3045  * use this opportunity to clear the PG_NOSYNC flag.  If a process
3046  * takes a write fault on a MAP_NOSYNC memory area the flag will
3047  * be set again.
3048  *
3049  * We set valid bits inclusive of any overlap, but we can only
3050  * clear dirty bits for DEV_BSIZE chunks that are fully within
3051  * the range.
3052  *
3053  * Page must be busied?
3054  * No other requirements.
3055  */
3056 void
3057 vm_page_set_valid(vm_page_t m, int base, int size)
3058 {
3059         _vm_page_zero_valid(m, base, size);
3060         m->valid |= vm_page_bits(base, size);
3061 }
3062
3063
3064 /*
3065  * Set valid bits and clear dirty bits.
3066  *
3067  * Page must be busied by caller.
3068  *
3069  * NOTE: This function does not clear the pmap modified bit.
3070  *       Also note that e.g. NFS may use a byte-granular base
3071  *       and size.
3072  *
3073  * No other requirements.
3074  */
3075 void
3076 vm_page_set_validclean(vm_page_t m, int base, int size)
3077 {
3078         int pagebits;
3079
3080         _vm_page_zero_valid(m, base, size);
3081         pagebits = vm_page_bits(base, size);
3082         m->valid |= pagebits;
3083         m->dirty &= ~pagebits;
3084         if (base == 0 && size == PAGE_SIZE) {
3085                 /*pmap_clear_modify(m);*/
3086                 vm_page_flag_clear(m, PG_NOSYNC);
3087         }
3088 }
3089
3090 /*
3091  * Set valid & dirty.  Used by buwrite()
3092  *
3093  * Page must be busied by caller.
3094  */
3095 void
3096 vm_page_set_validdirty(vm_page_t m, int base, int size)
3097 {
3098         int pagebits;
3099
3100         pagebits = vm_page_bits(base, size);
3101         m->valid |= pagebits;
3102         m->dirty |= pagebits;
3103         if (m->object)
3104                vm_object_set_writeable_dirty(m->object);
3105 }
3106
3107 /*
3108  * Clear dirty bits.
3109  *
3110  * NOTE: This function does not clear the pmap modified bit.
3111  *       Also note that e.g. NFS may use a byte-granular base
3112  *       and size.
3113  *
3114  * Page must be busied?
3115  * No other requirements.
3116  */
3117 void
3118 vm_page_clear_dirty(vm_page_t m, int base, int size)
3119 {
3120         m->dirty &= ~vm_page_bits(base, size);
3121         if (base == 0 && size == PAGE_SIZE) {
3122                 /*pmap_clear_modify(m);*/
3123                 vm_page_flag_clear(m, PG_NOSYNC);
3124         }
3125 }
3126
3127 /*
3128  * Make the page all-dirty.
3129  *
3130  * Also make sure the related object and vnode reflect the fact that the
3131  * object may now contain a dirty page.
3132  *
3133  * Page must be busied?
3134  * No other requirements.
3135  */
3136 void
3137 vm_page_dirty(vm_page_t m)
3138 {
3139 #ifdef INVARIANTS
3140         int pqtype = m->queue - m->pc;
3141 #endif
3142         KASSERT(pqtype != PQ_CACHE && pqtype != PQ_FREE,
3143                 ("vm_page_dirty: page in free/cache queue!"));
3144         if (m->dirty != VM_PAGE_BITS_ALL) {
3145                 m->dirty = VM_PAGE_BITS_ALL;
3146                 if (m->object)
3147                         vm_object_set_writeable_dirty(m->object);
3148         }
3149 }
3150
3151 /*
3152  * Invalidates DEV_BSIZE'd chunks within a page.  Both the
3153  * valid and dirty bits for the effected areas are cleared.
3154  *
3155  * Page must be busied?
3156  * Does not block.
3157  * No other requirements.
3158  */
3159 void
3160 vm_page_set_invalid(vm_page_t m, int base, int size)
3161 {
3162         int bits;
3163
3164         bits = vm_page_bits(base, size);
3165         m->valid &= ~bits;
3166         m->dirty &= ~bits;
3167         m->object->generation++;
3168 }
3169
3170 /*
3171  * The kernel assumes that the invalid portions of a page contain 
3172  * garbage, but such pages can be mapped into memory by user code.
3173  * When this occurs, we must zero out the non-valid portions of the
3174  * page so user code sees what it expects.
3175  *
3176  * Pages are most often semi-valid when the end of a file is mapped 
3177  * into memory and the file's size is not page aligned.
3178  *
3179  * Page must be busied?
3180  * No other requirements.
3181  */
3182 void
3183 vm_page_zero_invalid(vm_page_t m, boolean_t setvalid)
3184 {
3185         int b;
3186         int i;
3187
3188         /*
3189          * Scan the valid bits looking for invalid sections that
3190          * must be zerod.  Invalid sub-DEV_BSIZE'd areas ( where the
3191          * valid bit may be set ) have already been zerod by
3192          * vm_page_set_validclean().
3193          */
3194         for (b = i = 0; i <= PAGE_SIZE / DEV_BSIZE; ++i) {
3195                 if (i == (PAGE_SIZE / DEV_BSIZE) || 
3196                     (m->valid & (1 << i))
3197                 ) {
3198                         if (i > b) {
3199                                 pmap_zero_page_area(
3200                                     VM_PAGE_TO_PHYS(m), 
3201                                     b << DEV_BSHIFT,
3202                                     (i - b) << DEV_BSHIFT
3203                                 );
3204                         }
3205                         b = i + 1;
3206                 }
3207         }
3208
3209         /*
3210          * setvalid is TRUE when we can safely set the zero'd areas
3211          * as being valid.  We can do this if there are no cache consistency
3212          * issues.  e.g. it is ok to do with UFS, but not ok to do with NFS.
3213          */
3214         if (setvalid)
3215                 m->valid = VM_PAGE_BITS_ALL;
3216 }
3217
3218 /*
3219  * Is a (partial) page valid?  Note that the case where size == 0
3220  * will return FALSE in the degenerate case where the page is entirely
3221  * invalid, and TRUE otherwise.
3222  *
3223  * Does not block.
3224  * No other requirements.
3225  */
3226 int
3227 vm_page_is_valid(vm_page_t m, int base, int size)
3228 {
3229         int bits = vm_page_bits(base, size);
3230
3231         if (m->valid && ((m->valid & bits) == bits))
3232                 return 1;
3233         else
3234                 return 0;
3235 }
3236
3237 /*
3238  * update dirty bits from pmap/mmu.  May not block.
3239  *
3240  * Caller must hold the page busy
3241  */
3242 void
3243 vm_page_test_dirty(vm_page_t m)
3244 {
3245         if ((m->dirty != VM_PAGE_BITS_ALL) && pmap_is_modified(m)) {
3246                 vm_page_dirty(m);
3247         }
3248 }
3249
3250 /*
3251  * Register an action, associating it with its vm_page
3252  */
3253 void
3254 vm_page_register_action(vm_page_action_t action, vm_page_event_t event)
3255 {
3256         struct vm_page_action_hash *hash;
3257         int hv;
3258
3259         hv = (int)((intptr_t)action->m >> 8) & VMACTION_HMASK;
3260         hash = &action_hash[hv];
3261
3262         lockmgr(&hash->lk, LK_EXCLUSIVE);
3263         vm_page_flag_set(action->m, PG_ACTIONLIST);
3264         action->event = event;
3265         LIST_INSERT_HEAD(&hash->list, action, entry);
3266         lockmgr(&hash->lk, LK_RELEASE);
3267 }
3268
3269 /*
3270  * Unregister an action, disassociating it from its related vm_page
3271  */
3272 void
3273 vm_page_unregister_action(vm_page_action_t action)
3274 {
3275         struct vm_page_action_hash *hash;
3276         int hv;
3277
3278         hv = (int)((intptr_t)action->m >> 8) & VMACTION_HMASK;
3279         hash = &action_hash[hv];
3280         lockmgr(&hash->lk, LK_EXCLUSIVE);
3281         if (action->event != VMEVENT_NONE) {
3282                 action->event = VMEVENT_NONE;
3283                 LIST_REMOVE(action, entry);
3284
3285                 if (LIST_EMPTY(&hash->list))
3286                         vm_page_flag_clear(action->m, PG_ACTIONLIST);
3287         }
3288         lockmgr(&hash->lk, LK_RELEASE);
3289 }
3290
3291 /*
3292  * Issue an event on a VM page.  Corresponding action structures are
3293  * removed from the page's list and called.
3294  *
3295  * If the vm_page has no more pending action events we clear its
3296  * PG_ACTIONLIST flag.
3297  */
3298 void
3299 vm_page_event_internal(vm_page_t m, vm_page_event_t event)
3300 {
3301         struct vm_page_action_hash *hash;
3302         struct vm_page_action *scan;
3303         struct vm_page_action *next;
3304         int hv;
3305         int all;
3306
3307         hv = (int)((intptr_t)m >> 8) & VMACTION_HMASK;
3308         hash = &action_hash[hv];
3309         all = 1;
3310
3311         lockmgr(&hash->lk, LK_EXCLUSIVE);
3312         LIST_FOREACH_MUTABLE(scan, &hash->list, entry, next) {
3313                 if (scan->m == m) {
3314                         if (scan->event == event) {
3315                                 scan->event = VMEVENT_NONE;
3316                                 LIST_REMOVE(scan, entry);
3317                                 scan->func(m, scan);
3318                                 /* XXX */
3319                         } else {
3320                                 all = 0;
3321                         }
3322                 }
3323         }
3324         if (all)
3325                 vm_page_flag_clear(m, PG_ACTIONLIST);
3326         lockmgr(&hash->lk, LK_RELEASE);
3327 }
3328
3329 #include "opt_ddb.h"
3330 #ifdef DDB
3331 #include <sys/kernel.h>
3332
3333 #include <ddb/ddb.h>
3334
3335 DB_SHOW_COMMAND(page, vm_page_print_page_info)
3336 {
3337         db_printf("vmstats.v_free_count: %d\n", vmstats.v_free_count);
3338         db_printf("vmstats.v_cache_count: %d\n", vmstats.v_cache_count);
3339         db_printf("vmstats.v_inactive_count: %d\n", vmstats.v_inactive_count);
3340         db_printf("vmstats.v_active_count: %d\n", vmstats.v_active_count);
3341         db_printf("vmstats.v_wire_count: %d\n", vmstats.v_wire_count);
3342         db_printf("vmstats.v_free_reserved: %d\n", vmstats.v_free_reserved);
3343         db_printf("vmstats.v_free_min: %d\n", vmstats.v_free_min);
3344         db_printf("vmstats.v_free_target: %d\n", vmstats.v_free_target);
3345         db_printf("vmstats.v_cache_min: %d\n", vmstats.v_cache_min);
3346         db_printf("vmstats.v_inactive_target: %d\n", vmstats.v_inactive_target);
3347 }
3348
3349 DB_SHOW_COMMAND(pageq, vm_page_print_pageq_info)
3350 {
3351         int i;
3352         db_printf("PQ_FREE:");
3353         for (i = 0; i < PQ_L2_SIZE; i++) {
3354                 db_printf(" %d", vm_page_queues[PQ_FREE + i].lcnt);
3355         }
3356         db_printf("\n");
3357                 
3358         db_printf("PQ_CACHE:");
3359         for(i = 0; i < PQ_L2_SIZE; i++) {
3360                 db_printf(" %d", vm_page_queues[PQ_CACHE + i].lcnt);
3361         }
3362         db_printf("\n");
3363
3364         db_printf("PQ_ACTIVE:");
3365         for(i = 0; i < PQ_L2_SIZE; i++) {
3366                 db_printf(" %d", vm_page_queues[PQ_ACTIVE + i].lcnt);
3367         }
3368         db_printf("\n");
3369
3370         db_printf("PQ_INACTIVE:");
3371         for(i = 0; i < PQ_L2_SIZE; i++) {
3372                 db_printf(" %d", vm_page_queues[PQ_INACTIVE + i].lcnt);
3373         }
3374         db_printf("\n");
3375 }
3376 #endif /* DDB */