92b6a3df5e93164ff0c1016ae80980f72cea92c1
[dragonfly.git] / sys / vm / vm_page.c
1 /*
2  * (MPSAFE)
3  *
4  * Copyright (c) 1991 Regents of the University of California.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * The Mach Operating System project at Carnegie-Mellon University.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 4. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  *      from: @(#)vm_page.c     7.4 (Berkeley) 5/7/91
35  * $FreeBSD: src/sys/vm/vm_page.c,v 1.147.2.18 2002/03/10 05:03:19 alc Exp $
36  */
37
38 /*
39  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
40  * All rights reserved.
41  *
42  * Authors: Avadis Tevanian, Jr., Michael Wayne Young
43  *
44  * Permission to use, copy, modify and distribute this software and
45  * its documentation is hereby granted, provided that both the copyright
46  * notice and this permission notice appear in all copies of the
47  * software, derivative works or modified versions, and any portions
48  * thereof, and that both notices appear in supporting documentation.
49  *
50  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
51  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
52  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
53  *
54  * Carnegie Mellon requests users of this software to return to
55  *
56  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
57  *  School of Computer Science
58  *  Carnegie Mellon University
59  *  Pittsburgh PA 15213-3890
60  *
61  * any improvements or extensions that they make and grant Carnegie the
62  * rights to redistribute these changes.
63  */
64 /*
65  * Resident memory management module.  The module manipulates 'VM pages'.
66  * A VM page is the core building block for memory management.
67  */
68
69 #include <sys/param.h>
70 #include <sys/systm.h>
71 #include <sys/malloc.h>
72 #include <sys/proc.h>
73 #include <sys/vmmeter.h>
74 #include <sys/vnode.h>
75 #include <sys/kernel.h>
76
77 #include <vm/vm.h>
78 #include <vm/vm_param.h>
79 #include <sys/lock.h>
80 #include <vm/vm_kern.h>
81 #include <vm/pmap.h>
82 #include <vm/vm_map.h>
83 #include <vm/vm_object.h>
84 #include <vm/vm_page.h>
85 #include <vm/vm_pageout.h>
86 #include <vm/vm_pager.h>
87 #include <vm/vm_extern.h>
88 #include <vm/swap_pager.h>
89
90 #include <machine/md_var.h>
91
92 #include <vm/vm_page2.h>
93 #include <sys/spinlock2.h>
94
95 #define VMACTION_HSIZE  256
96 #define VMACTION_HMASK  (VMACTION_HSIZE - 1)
97
98 static void vm_page_queue_init(void);
99 static void vm_page_free_wakeup(void);
100 static vm_page_t vm_page_select_cache(vm_object_t, vm_pindex_t);
101 static vm_page_t _vm_page_list_find2(int basequeue, int index);
102 static void _vm_page_deactivate_locked(vm_page_t m, int athead);
103
104 /*
105  * Array of tailq lists
106  */
107 __cachealign struct vpgqueues vm_page_queues[PQ_COUNT];
108
109 LIST_HEAD(vm_page_action_list, vm_page_action);
110 struct vm_page_action_list      action_list[VMACTION_HSIZE];
111 static volatile int vm_pages_waiting;
112
113
114 RB_GENERATE2(vm_page_rb_tree, vm_page, rb_entry, rb_vm_page_compare,
115              vm_pindex_t, pindex);
116
117 static void
118 vm_page_queue_init(void) 
119 {
120         int i;
121
122         for (i = 0; i < PQ_L2_SIZE; i++)
123                 vm_page_queues[PQ_FREE+i].cnt = &vmstats.v_free_count;
124         for (i = 0; i < PQ_L2_SIZE; i++)
125                 vm_page_queues[PQ_CACHE+i].cnt = &vmstats.v_cache_count;
126
127         vm_page_queues[PQ_INACTIVE].cnt = &vmstats.v_inactive_count;
128         vm_page_queues[PQ_ACTIVE].cnt = &vmstats.v_active_count;
129         vm_page_queues[PQ_HOLD].cnt = &vmstats.v_active_count;
130         /* PQ_NONE has no queue */
131
132         for (i = 0; i < PQ_COUNT; i++) {
133                 TAILQ_INIT(&vm_page_queues[i].pl);
134                 spin_init(&vm_page_queues[i].spin);
135         }
136
137         for (i = 0; i < VMACTION_HSIZE; i++)
138                 LIST_INIT(&action_list[i]);
139 }
140
141 /*
142  * note: place in initialized data section?  Is this necessary?
143  */
144 long first_page = 0;
145 int vm_page_array_size = 0;
146 int vm_page_zero_count = 0;
147 vm_page_t vm_page_array = 0;
148
149 /*
150  * (low level boot)
151  *
152  * Sets the page size, perhaps based upon the memory size.
153  * Must be called before any use of page-size dependent functions.
154  */
155 void
156 vm_set_page_size(void)
157 {
158         if (vmstats.v_page_size == 0)
159                 vmstats.v_page_size = PAGE_SIZE;
160         if (((vmstats.v_page_size - 1) & vmstats.v_page_size) != 0)
161                 panic("vm_set_page_size: page size not a power of two");
162 }
163
164 /*
165  * (low level boot)
166  *
167  * Add a new page to the freelist for use by the system.  New pages
168  * are added to both the head and tail of the associated free page
169  * queue in a bottom-up fashion, so both zero'd and non-zero'd page
170  * requests pull 'recent' adds (higher physical addresses) first.
171  *
172  * Must be called in a critical section.
173  */
174 static vm_page_t
175 vm_add_new_page(vm_paddr_t pa)
176 {
177         struct vpgqueues *vpq;
178         vm_page_t m;
179
180         m = PHYS_TO_VM_PAGE(pa);
181         m->phys_addr = pa;
182         m->flags = 0;
183         m->pc = (pa >> PAGE_SHIFT) & PQ_L2_MASK;
184         m->queue = m->pc + PQ_FREE;
185         KKASSERT(m->dirty == 0);
186
187         atomic_add_int(&vmstats.v_page_count, 1);
188         atomic_add_int(&vmstats.v_free_count, 1);
189         vpq = &vm_page_queues[m->queue];
190         if (vpq->flipflop)
191                 TAILQ_INSERT_TAIL(&vpq->pl, m, pageq);
192         else
193                 TAILQ_INSERT_HEAD(&vpq->pl, m, pageq);
194         vpq->flipflop = 1 - vpq->flipflop;
195         ++vpq->lcnt;
196
197         return (m);
198 }
199
200 /*
201  * (low level boot)
202  *
203  * Initializes the resident memory module.
204  *
205  * Preallocates memory for critical VM structures and arrays prior to
206  * kernel_map becoming available.
207  *
208  * Memory is allocated from (virtual2_start, virtual2_end) if available,
209  * otherwise memory is allocated from (virtual_start, virtual_end).
210  *
211  * On x86-64 (virtual_start, virtual_end) is only 2GB and may not be
212  * large enough to hold vm_page_array & other structures for machines with
213  * large amounts of ram, so we want to use virtual2* when available.
214  */
215 void
216 vm_page_startup(void)
217 {
218         vm_offset_t vaddr = virtual2_start ? virtual2_start : virtual_start;
219         vm_offset_t mapped;
220         vm_size_t npages;
221         vm_paddr_t page_range;
222         vm_paddr_t new_end;
223         int i;
224         vm_paddr_t pa;
225         int nblocks;
226         vm_paddr_t last_pa;
227         vm_paddr_t end;
228         vm_paddr_t biggestone, biggestsize;
229         vm_paddr_t total;
230
231         total = 0;
232         biggestsize = 0;
233         biggestone = 0;
234         nblocks = 0;
235         vaddr = round_page(vaddr);
236
237         for (i = 0; phys_avail[i + 1]; i += 2) {
238                 phys_avail[i] = round_page64(phys_avail[i]);
239                 phys_avail[i + 1] = trunc_page64(phys_avail[i + 1]);
240         }
241
242         for (i = 0; phys_avail[i + 1]; i += 2) {
243                 vm_paddr_t size = phys_avail[i + 1] - phys_avail[i];
244
245                 if (size > biggestsize) {
246                         biggestone = i;
247                         biggestsize = size;
248                 }
249                 ++nblocks;
250                 total += size;
251         }
252
253         end = phys_avail[biggestone+1];
254         end = trunc_page(end);
255
256         /*
257          * Initialize the queue headers for the free queue, the active queue
258          * and the inactive queue.
259          */
260
261         vm_page_queue_init();
262
263 #if !defined(_KERNEL_VIRTUAL)
264         /*
265          * VKERNELs don't support minidumps and as such don't need
266          * vm_page_dump
267          *
268          * Allocate a bitmap to indicate that a random physical page
269          * needs to be included in a minidump.
270          *
271          * The amd64 port needs this to indicate which direct map pages
272          * need to be dumped, via calls to dump_add_page()/dump_drop_page().
273          *
274          * However, i386 still needs this workspace internally within the
275          * minidump code.  In theory, they are not needed on i386, but are
276          * included should the sf_buf code decide to use them.
277          */
278         page_range = phys_avail[(nblocks - 1) * 2 + 1] / PAGE_SIZE;
279         vm_page_dump_size = round_page(roundup2(page_range, NBBY) / NBBY);
280         end -= vm_page_dump_size;
281         vm_page_dump = (void *)pmap_map(&vaddr, end, end + vm_page_dump_size,
282             VM_PROT_READ | VM_PROT_WRITE);
283         bzero((void *)vm_page_dump, vm_page_dump_size);
284 #endif
285
286         /*
287          * Compute the number of pages of memory that will be available for
288          * use (taking into account the overhead of a page structure per
289          * page).
290          */
291         first_page = phys_avail[0] / PAGE_SIZE;
292         page_range = phys_avail[(nblocks - 1) * 2 + 1] / PAGE_SIZE - first_page;
293         npages = (total - (page_range * sizeof(struct vm_page))) / PAGE_SIZE;
294
295         /*
296          * Initialize the mem entry structures now, and put them in the free
297          * queue.
298          */
299         new_end = trunc_page(end - page_range * sizeof(struct vm_page));
300         mapped = pmap_map(&vaddr, new_end, end,
301             VM_PROT_READ | VM_PROT_WRITE);
302         vm_page_array = (vm_page_t)mapped;
303
304 #if defined(__x86_64__) && !defined(_KERNEL_VIRTUAL)
305         /*
306          * since pmap_map on amd64 returns stuff out of a direct-map region,
307          * we have to manually add these pages to the minidump tracking so
308          * that they can be dumped, including the vm_page_array.
309          */
310         for (pa = new_end; pa < phys_avail[biggestone + 1]; pa += PAGE_SIZE)
311                 dump_add_page(pa);
312 #endif
313
314         /*
315          * Clear all of the page structures
316          */
317         bzero((caddr_t) vm_page_array, page_range * sizeof(struct vm_page));
318         vm_page_array_size = page_range;
319
320         /*
321          * Construct the free queue(s) in ascending order (by physical
322          * address) so that the first 16MB of physical memory is allocated
323          * last rather than first.  On large-memory machines, this avoids
324          * the exhaustion of low physical memory before isa_dmainit has run.
325          */
326         vmstats.v_page_count = 0;
327         vmstats.v_free_count = 0;
328         for (i = 0; phys_avail[i + 1] && npages > 0; i += 2) {
329                 pa = phys_avail[i];
330                 if (i == biggestone)
331                         last_pa = new_end;
332                 else
333                         last_pa = phys_avail[i + 1];
334                 while (pa < last_pa && npages-- > 0) {
335                         vm_add_new_page(pa);
336                         pa += PAGE_SIZE;
337                 }
338         }
339         if (virtual2_start)
340                 virtual2_start = vaddr;
341         else
342                 virtual_start = vaddr;
343 }
344
345 /*
346  * Scan comparison function for Red-Black tree scans.  An inclusive
347  * (start,end) is expected.  Other fields are not used.
348  */
349 int
350 rb_vm_page_scancmp(struct vm_page *p, void *data)
351 {
352         struct rb_vm_page_scan_info *info = data;
353
354         if (p->pindex < info->start_pindex)
355                 return(-1);
356         if (p->pindex > info->end_pindex)
357                 return(1);
358         return(0);
359 }
360
361 int
362 rb_vm_page_compare(struct vm_page *p1, struct vm_page *p2)
363 {
364         if (p1->pindex < p2->pindex)
365                 return(-1);
366         if (p1->pindex > p2->pindex)
367                 return(1);
368         return(0);
369 }
370
371 /*
372  * Each page queue has its own spin lock, which is fairly optimal for
373  * allocating and freeing pages at least.
374  *
375  * The caller must hold the vm_page_spin_lock() before locking a vm_page's
376  * queue spinlock via this function.  Also note that m->queue cannot change
377  * unless both the page and queue are locked.
378  */
379 static __inline
380 void
381 _vm_page_queue_spin_lock(vm_page_t m)
382 {
383         u_short queue;
384
385         queue = m->queue;
386         if (queue != PQ_NONE) {
387                 spin_lock(&vm_page_queues[queue].spin);
388                 KKASSERT(queue == m->queue);
389         }
390 }
391
392 static __inline
393 void
394 _vm_page_queue_spin_unlock(vm_page_t m)
395 {
396         u_short queue;
397
398         queue = m->queue;
399         cpu_ccfence();
400         if (queue != PQ_NONE)
401                 spin_unlock(&vm_page_queues[queue].spin);
402 }
403
404 static __inline
405 void
406 _vm_page_queues_spin_lock(u_short queue)
407 {
408         cpu_ccfence();
409         if (queue != PQ_NONE)
410                 spin_lock(&vm_page_queues[queue].spin);
411 }
412
413
414 static __inline
415 void
416 _vm_page_queues_spin_unlock(u_short queue)
417 {
418         cpu_ccfence();
419         if (queue != PQ_NONE)
420                 spin_unlock(&vm_page_queues[queue].spin);
421 }
422
423 void
424 vm_page_queue_spin_lock(vm_page_t m)
425 {
426         _vm_page_queue_spin_lock(m);
427 }
428
429 void
430 vm_page_queues_spin_lock(u_short queue)
431 {
432         _vm_page_queues_spin_lock(queue);
433 }
434
435 void
436 vm_page_queue_spin_unlock(vm_page_t m)
437 {
438         _vm_page_queue_spin_unlock(m);
439 }
440
441 void
442 vm_page_queues_spin_unlock(u_short queue)
443 {
444         _vm_page_queues_spin_unlock(queue);
445 }
446
447 /*
448  * This locks the specified vm_page and its queue in the proper order
449  * (page first, then queue).  The queue may change so the caller must
450  * recheck on return.
451  */
452 static __inline
453 void
454 _vm_page_and_queue_spin_lock(vm_page_t m)
455 {
456         vm_page_spin_lock(m);
457         _vm_page_queue_spin_lock(m);
458 }
459
460 static __inline
461 void
462 _vm_page_and_queue_spin_unlock(vm_page_t m)
463 {
464         _vm_page_queues_spin_unlock(m->queue);
465         vm_page_spin_unlock(m);
466 }
467
468 void
469 vm_page_and_queue_spin_unlock(vm_page_t m)
470 {
471         _vm_page_and_queue_spin_unlock(m);
472 }
473
474 void
475 vm_page_and_queue_spin_lock(vm_page_t m)
476 {
477         _vm_page_and_queue_spin_lock(m);
478 }
479
480 /*
481  * Helper function removes vm_page from its current queue.
482  * Returns the base queue the page used to be on.
483  *
484  * The vm_page and the queue must be spinlocked.
485  * This function will unlock the queue but leave the page spinlocked.
486  */
487 static __inline u_short
488 _vm_page_rem_queue_spinlocked(vm_page_t m)
489 {
490         struct vpgqueues *pq;
491         u_short queue;
492
493         queue = m->queue;
494         if (queue != PQ_NONE) {
495                 pq = &vm_page_queues[queue];
496                 TAILQ_REMOVE(&pq->pl, m, pageq);
497                 atomic_add_int(pq->cnt, -1);
498                 pq->lcnt--;
499                 m->queue = PQ_NONE;
500                 if ((queue - m->pc) == PQ_FREE && (m->flags & PG_ZERO))
501                         atomic_subtract_int(&vm_page_zero_count, 1);
502                 vm_page_queues_spin_unlock(queue);
503                 if ((queue - m->pc) == PQ_CACHE || (queue - m->pc) == PQ_FREE)
504                         return (queue - m->pc);
505         }
506         return queue;
507 }
508
509 /*
510  * Helper function places the vm_page on the specified queue.
511  *
512  * The vm_page must be spinlocked.
513  * This function will return with both the page and the queue locked.
514  */
515 static __inline void
516 _vm_page_add_queue_spinlocked(vm_page_t m, u_short queue, int athead)
517 {
518         struct vpgqueues *pq;
519
520         KKASSERT(m->queue == PQ_NONE);
521
522         if (queue != PQ_NONE) {
523                 vm_page_queues_spin_lock(queue);
524                 pq = &vm_page_queues[queue];
525                 ++pq->lcnt;
526                 atomic_add_int(pq->cnt, 1);
527                 m->queue = queue;
528
529                 /*
530                  * Put zero'd pages on the end ( where we look for zero'd pages
531                  * first ) and non-zerod pages at the head.
532                  */
533                 if (queue - m->pc == PQ_FREE) {
534                         if (m->flags & PG_ZERO) {
535                                 TAILQ_INSERT_TAIL(&pq->pl, m, pageq);
536                                 atomic_add_int(&vm_page_zero_count, 1);
537                         } else {
538                                 TAILQ_INSERT_HEAD(&pq->pl, m, pageq);
539                         }
540                 } else if (athead) {
541                         TAILQ_INSERT_HEAD(&pq->pl, m, pageq);
542                 } else {
543                         TAILQ_INSERT_TAIL(&pq->pl, m, pageq);
544                 }
545                 /* leave the queue spinlocked */
546         }
547 }
548
549 /*
550  * Wait until page is no longer PG_BUSY or (if also_m_busy is TRUE)
551  * m->busy is zero.  Returns TRUE if it had to sleep, FALSE if we
552  * did not.  Only one sleep call will be made before returning.
553  *
554  * This function does NOT busy the page and on return the page is not
555  * guaranteed to be available.
556  */
557 void
558 vm_page_sleep_busy(vm_page_t m, int also_m_busy, const char *msg)
559 {
560         u_int32_t flags;
561
562         for (;;) {
563                 flags = m->flags;
564                 cpu_ccfence();
565
566                 if ((flags & PG_BUSY) == 0 &&
567                     (also_m_busy == 0 || (flags & PG_SBUSY) == 0)) {
568                         break;
569                 }
570                 tsleep_interlock(m, 0);
571                 if (atomic_cmpset_int(&m->flags, flags,
572                                       flags | PG_WANTED | PG_REFERENCED)) {
573                         tsleep(m, PINTERLOCKED, msg, 0);
574                         break;
575                 }
576         }
577 }
578
579 /*
580  * Wait until PG_BUSY can be set, then set it.  If also_m_busy is TRUE we
581  * also wait for m->busy to become 0 before setting PG_BUSY.
582  */
583 void
584 VM_PAGE_DEBUG_EXT(vm_page_busy_wait)(vm_page_t m,
585                                      int also_m_busy, const char *msg
586                                      VM_PAGE_DEBUG_ARGS)
587 {
588         u_int32_t flags;
589
590         for (;;) {
591                 flags = m->flags;
592                 cpu_ccfence();
593                 if (flags & PG_BUSY) {
594                         tsleep_interlock(m, 0);
595                         if (atomic_cmpset_int(&m->flags, flags,
596                                           flags | PG_WANTED | PG_REFERENCED)) {
597                                 tsleep(m, PINTERLOCKED, msg, 0);
598                         }
599                 } else if (also_m_busy && (flags & PG_SBUSY)) {
600                         tsleep_interlock(m, 0);
601                         if (atomic_cmpset_int(&m->flags, flags,
602                                           flags | PG_WANTED | PG_REFERENCED)) {
603                                 tsleep(m, PINTERLOCKED, msg, 0);
604                         }
605                 } else {
606                         if (atomic_cmpset_int(&m->flags, flags,
607                                               flags | PG_BUSY)) {
608 #ifdef VM_PAGE_DEBUG
609                                 m->busy_func = func;
610                                 m->busy_line = lineno;
611 #endif
612                                 break;
613                         }
614                 }
615         }
616 }
617
618 /*
619  * Attempt to set PG_BUSY.  If also_m_busy is TRUE we only succeed if m->busy
620  * is also 0.
621  *
622  * Returns non-zero on failure.
623  */
624 int
625 VM_PAGE_DEBUG_EXT(vm_page_busy_try)(vm_page_t m, int also_m_busy
626                                     VM_PAGE_DEBUG_ARGS)
627 {
628         u_int32_t flags;
629
630         for (;;) {
631                 flags = m->flags;
632                 cpu_ccfence();
633                 if (flags & PG_BUSY)
634                         return TRUE;
635                 if (also_m_busy && (flags & PG_SBUSY))
636                         return TRUE;
637                 if (atomic_cmpset_int(&m->flags, flags, flags | PG_BUSY)) {
638 #ifdef VM_PAGE_DEBUG
639                                 m->busy_func = func;
640                                 m->busy_line = lineno;
641 #endif
642                         return FALSE;
643                 }
644         }
645 }
646
647 /*
648  * Clear the PG_BUSY flag and return non-zero to indicate to the caller
649  * that a wakeup() should be performed.
650  *
651  * The vm_page must be spinlocked and will remain spinlocked on return.
652  * The related queue must NOT be spinlocked (which could deadlock us).
653  *
654  * (inline version)
655  */
656 static __inline
657 int
658 _vm_page_wakeup(vm_page_t m)
659 {
660         u_int32_t flags;
661
662         for (;;) {
663                 flags = m->flags;
664                 cpu_ccfence();
665                 if (atomic_cmpset_int(&m->flags, flags,
666                                       flags & ~(PG_BUSY | PG_WANTED))) {
667                         break;
668                 }
669         }
670         return(flags & PG_WANTED);
671 }
672
673 /*
674  * Clear the PG_BUSY flag and wakeup anyone waiting for the page.  This
675  * is typically the last call you make on a page before moving onto
676  * other things.
677  */
678 void
679 vm_page_wakeup(vm_page_t m)
680 {
681         KASSERT(m->flags & PG_BUSY, ("vm_page_wakeup: page not busy!!!"));
682         vm_page_spin_lock(m);
683         if (_vm_page_wakeup(m)) {
684                 vm_page_spin_unlock(m);
685                 wakeup(m);
686         } else {
687                 vm_page_spin_unlock(m);
688         }
689 }
690
691 /*
692  * Holding a page keeps it from being reused.  Other parts of the system
693  * can still disassociate the page from its current object and free it, or
694  * perform read or write I/O on it and/or otherwise manipulate the page,
695  * but if the page is held the VM system will leave the page and its data
696  * intact and not reuse the page for other purposes until the last hold
697  * reference is released.  (see vm_page_wire() if you want to prevent the
698  * page from being disassociated from its object too).
699  *
700  * The caller must still validate the contents of the page and, if necessary,
701  * wait for any pending I/O (e.g. vm_page_sleep_busy() loop) to complete
702  * before manipulating the page.
703  *
704  * XXX get vm_page_spin_lock() here and move FREE->HOLD if necessary
705  */
706 void
707 vm_page_hold(vm_page_t m)
708 {
709         vm_page_spin_lock(m);
710         atomic_add_int(&m->hold_count, 1);
711         if (m->queue - m->pc == PQ_FREE) {
712                 _vm_page_queue_spin_lock(m);
713                 _vm_page_rem_queue_spinlocked(m);
714                 _vm_page_add_queue_spinlocked(m, PQ_HOLD, 0);
715                 _vm_page_queue_spin_unlock(m);
716         }
717         vm_page_spin_unlock(m);
718 }
719
720 /*
721  * The opposite of vm_page_hold().  A page can be freed while being held,
722  * which places it on the PQ_HOLD queue.  If we are able to busy the page
723  * after the hold count drops to zero we will move the page to the
724  * appropriate PQ_FREE queue by calling vm_page_free_toq().
725  */
726 void
727 vm_page_unhold(vm_page_t m)
728 {
729         vm_page_spin_lock(m);
730         atomic_add_int(&m->hold_count, -1);
731         if (m->hold_count == 0 && m->queue == PQ_HOLD) {
732                 _vm_page_queue_spin_lock(m);
733                 _vm_page_rem_queue_spinlocked(m);
734                 _vm_page_add_queue_spinlocked(m, PQ_FREE + m->pc, 0);
735                 _vm_page_queue_spin_unlock(m);
736         }
737         vm_page_spin_unlock(m);
738 }
739
740 /*
741  * Inserts the given vm_page into the object and object list.
742  *
743  * The pagetables are not updated but will presumably fault the page
744  * in if necessary, or if a kernel page the caller will at some point
745  * enter the page into the kernel's pmap.  We are not allowed to block
746  * here so we *can't* do this anyway.
747  *
748  * This routine may not block.
749  * This routine must be called with the vm_object held.
750  * This routine must be called with a critical section held.
751  */
752 void
753 vm_page_insert(vm_page_t m, vm_object_t object, vm_pindex_t pindex)
754 {
755         ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
756         if (m->object != NULL)
757                 panic("vm_page_insert: already inserted");
758
759         object->generation++;
760         object->resident_page_count++;
761
762         /*
763          * Record the object/offset pair in this page and add the
764          * pv_list_count of the page to the object.
765          *
766          * The vm_page spin lock is required for interactions with the pmap.
767          */
768         vm_page_spin_lock(m);
769         m->object = object;
770         m->pindex = pindex;
771         vm_page_rb_tree_RB_INSERT(&object->rb_memq, m);
772         atomic_add_int(&object->agg_pv_list_count, m->md.pv_list_count);
773         vm_page_spin_unlock(m);
774
775         /*
776          * Since we are inserting a new and possibly dirty page,
777          * update the object's OBJ_WRITEABLE and OBJ_MIGHTBEDIRTY flags.
778          */
779         if ((m->valid & m->dirty) || (m->flags & PG_WRITEABLE))
780                 vm_object_set_writeable_dirty(object);
781
782         /*
783          * Checks for a swap assignment and sets PG_SWAPPED if appropriate.
784          */
785         swap_pager_page_inserted(m);
786 }
787
788 /*
789  * Removes the given vm_page_t from the (object,index) table
790  *
791  * The underlying pmap entry (if any) is NOT removed here.
792  * This routine may not block.
793  *
794  * The page must be BUSY and will remain BUSY on return.
795  * No other requirements.
796  *
797  * NOTE: FreeBSD side effect was to unbusy the page on return.  We leave
798  *       it busy.
799  */
800 void
801 vm_page_remove(vm_page_t m)
802 {
803         vm_object_t object;
804
805         if (m->object == NULL) {
806                 return;
807         }
808
809         if ((m->flags & PG_BUSY) == 0)
810                 panic("vm_page_remove: page not busy");
811
812         object = m->object;
813
814         vm_object_hold(object);
815
816         /*
817          * Remove the page from the object and update the object.
818          *
819          * The vm_page spin lock is required for interactions with the pmap.
820          */
821         vm_page_spin_lock(m);
822         vm_page_rb_tree_RB_REMOVE(&object->rb_memq, m);
823         object->resident_page_count--;
824         atomic_add_int(&object->agg_pv_list_count, -m->md.pv_list_count);
825         m->object = NULL;
826         vm_page_spin_unlock(m);
827
828         object->generation++;
829
830         vm_object_drop(object);
831 }
832
833 /*
834  * Locate and return the page at (object, pindex), or NULL if the
835  * page could not be found.
836  *
837  * The caller must hold the vm_object token.
838  */
839 vm_page_t
840 vm_page_lookup(vm_object_t object, vm_pindex_t pindex)
841 {
842         vm_page_t m;
843
844         /*
845          * Search the hash table for this object/offset pair
846          */
847         ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
848         m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq, pindex);
849         KKASSERT(m == NULL || (m->object == object && m->pindex == pindex));
850         return(m);
851 }
852
853 vm_page_t
854 VM_PAGE_DEBUG_EXT(vm_page_lookup_busy_wait)(struct vm_object *object,
855                                             vm_pindex_t pindex,
856                                             int also_m_busy, const char *msg
857                                             VM_PAGE_DEBUG_ARGS)
858 {
859         u_int32_t flags;
860         vm_page_t m;
861
862         ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
863         m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq, pindex);
864         while (m) {
865                 KKASSERT(m->object == object && m->pindex == pindex);
866                 flags = m->flags;
867                 cpu_ccfence();
868                 if (flags & PG_BUSY) {
869                         tsleep_interlock(m, 0);
870                         if (atomic_cmpset_int(&m->flags, flags,
871                                           flags | PG_WANTED | PG_REFERENCED)) {
872                                 tsleep(m, PINTERLOCKED, msg, 0);
873                                 m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq,
874                                                               pindex);
875                         }
876                 } else if (also_m_busy && (flags & PG_SBUSY)) {
877                         tsleep_interlock(m, 0);
878                         if (atomic_cmpset_int(&m->flags, flags,
879                                           flags | PG_WANTED | PG_REFERENCED)) {
880                                 tsleep(m, PINTERLOCKED, msg, 0);
881                                 m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq,
882                                                               pindex);
883                         }
884                 } else if (atomic_cmpset_int(&m->flags, flags,
885                                              flags | PG_BUSY)) {
886 #ifdef VM_PAGE_DEBUG
887                         m->busy_func = func;
888                         m->busy_line = lineno;
889 #endif
890                         break;
891                 }
892         }
893         return m;
894 }
895
896 /*
897  * Attempt to lookup and busy a page.
898  *
899  * Returns NULL if the page could not be found
900  *
901  * Returns a vm_page and error == TRUE if the page exists but could not
902  * be busied.
903  *
904  * Returns a vm_page and error == FALSE on success.
905  */
906 vm_page_t
907 VM_PAGE_DEBUG_EXT(vm_page_lookup_busy_try)(struct vm_object *object,
908                                            vm_pindex_t pindex,
909                                            int also_m_busy, int *errorp
910                                            VM_PAGE_DEBUG_ARGS)
911 {
912         u_int32_t flags;
913         vm_page_t m;
914
915         ASSERT_LWKT_TOKEN_HELD(vm_object_token(object));
916         m = vm_page_rb_tree_RB_LOOKUP(&object->rb_memq, pindex);
917         *errorp = FALSE;
918         while (m) {
919                 KKASSERT(m->object == object && m->pindex == pindex);
920                 flags = m->flags;
921                 cpu_ccfence();
922                 if (flags & PG_BUSY) {
923                         *errorp = TRUE;
924                         break;
925                 }
926                 if (also_m_busy && (flags & PG_SBUSY)) {
927                         *errorp = TRUE;
928                         break;
929                 }
930                 if (atomic_cmpset_int(&m->flags, flags, flags | PG_BUSY)) {
931 #ifdef VM_PAGE_DEBUG
932                         m->busy_func = func;
933                         m->busy_line = lineno;
934 #endif
935                         break;
936                 }
937         }
938         return m;
939 }
940
941 /*
942  * Caller must hold the related vm_object
943  */
944 vm_page_t
945 vm_page_next(vm_page_t m)
946 {
947         vm_page_t next;
948
949         next = vm_page_rb_tree_RB_NEXT(m);
950         if (next && next->pindex != m->pindex + 1)
951                 next = NULL;
952         return (next);
953 }
954
955 /*
956  * vm_page_rename()
957  *
958  * Move the given vm_page from its current object to the specified
959  * target object/offset.  The page must be busy and will remain so
960  * on return.
961  *
962  * new_object must be held.
963  * This routine might block. XXX ?
964  *
965  * NOTE: Swap associated with the page must be invalidated by the move.  We
966  *       have to do this for several reasons:  (1) we aren't freeing the
967  *       page, (2) we are dirtying the page, (3) the VM system is probably
968  *       moving the page from object A to B, and will then later move
969  *       the backing store from A to B and we can't have a conflict.
970  *
971  * NOTE: We *always* dirty the page.  It is necessary both for the
972  *       fact that we moved it, and because we may be invalidating
973  *       swap.  If the page is on the cache, we have to deactivate it
974  *       or vm_page_dirty() will panic.  Dirty pages are not allowed
975  *       on the cache.
976  */
977 void
978 vm_page_rename(vm_page_t m, vm_object_t new_object, vm_pindex_t new_pindex)
979 {
980         KKASSERT(m->flags & PG_BUSY);
981         ASSERT_LWKT_TOKEN_HELD(vm_object_token(new_object));
982         if (m->object) {
983                 ASSERT_LWKT_TOKEN_HELD(vm_object_token(m->object));
984                 vm_page_remove(m);
985         }
986         vm_page_insert(m, new_object, new_pindex);
987         if (m->queue - m->pc == PQ_CACHE)
988                 vm_page_deactivate(m);
989         vm_page_dirty(m);
990 }
991
992 /*
993  * vm_page_unqueue() without any wakeup.  This routine is used when a page
994  * is being moved between queues or otherwise is to remain BUSYied by the
995  * caller.
996  *
997  * This routine may not block.
998  */
999 void
1000 vm_page_unqueue_nowakeup(vm_page_t m)
1001 {
1002         vm_page_and_queue_spin_lock(m);
1003         (void)_vm_page_rem_queue_spinlocked(m);
1004         vm_page_spin_unlock(m);
1005 }
1006
1007 /*
1008  * vm_page_unqueue() - Remove a page from its queue, wakeup the pagedemon
1009  * if necessary.
1010  *
1011  * This routine may not block.
1012  */
1013 void
1014 vm_page_unqueue(vm_page_t m)
1015 {
1016         u_short queue;
1017
1018         vm_page_and_queue_spin_lock(m);
1019         queue = _vm_page_rem_queue_spinlocked(m);
1020         if (queue == PQ_FREE || queue == PQ_CACHE) {
1021                 vm_page_spin_unlock(m);
1022                 pagedaemon_wakeup();
1023         } else {
1024                 vm_page_spin_unlock(m);
1025         }
1026 }
1027
1028 /*
1029  * vm_page_list_find()
1030  *
1031  * Find a page on the specified queue with color optimization.
1032  *
1033  * The page coloring optimization attempts to locate a page that does
1034  * not overload other nearby pages in the object in the cpu's L1 or L2
1035  * caches.  We need this optimization because cpu caches tend to be
1036  * physical caches, while object spaces tend to be virtual.  This optimization
1037  * also gives us multiple queues and spinlocks to worth with on SMP systems.
1038  *
1039  * The page is returned spinlocked and removed from its queue (it will
1040  * be on PQ_NONE), or NULL. The page is not PG_BUSY'd.  The caller
1041  * is responsible for dealing with the busy-page case (usually by
1042  * deactivating the page and looping).
1043  *
1044  * NOTE:  This routine is carefully inlined.  A non-inlined version
1045  *        is available for outside callers but the only critical path is
1046  *        from within this source file.
1047  *
1048  * NOTE:  This routine assumes that the vm_pages found in PQ_CACHE and PQ_FREE
1049  *        represent stable storage, allowing us to order our locks vm_page
1050  *        first, then queue.
1051  */
1052 static __inline
1053 vm_page_t
1054 _vm_page_list_find(int basequeue, int index, boolean_t prefer_zero)
1055 {
1056         vm_page_t m;
1057
1058         for (;;) {
1059                 if (prefer_zero)
1060                         m = TAILQ_LAST(&vm_page_queues[basequeue+index].pl, pglist);
1061                 else
1062                         m = TAILQ_FIRST(&vm_page_queues[basequeue+index].pl);
1063                 if (m == NULL) {
1064                         m = _vm_page_list_find2(basequeue, index);
1065                         return(m);
1066                 }
1067                 vm_page_and_queue_spin_lock(m);
1068                 if (m->queue == basequeue + index) {
1069                         _vm_page_rem_queue_spinlocked(m);
1070                         /* vm_page_t spin held, no queue spin */
1071                         break;
1072                 }
1073                 vm_page_and_queue_spin_unlock(m);
1074         }
1075         return(m);
1076 }
1077
1078 static vm_page_t
1079 _vm_page_list_find2(int basequeue, int index)
1080 {
1081         int i;
1082         vm_page_t m = NULL;
1083         struct vpgqueues *pq;
1084
1085         pq = &vm_page_queues[basequeue];
1086
1087         /*
1088          * Note that for the first loop, index+i and index-i wind up at the
1089          * same place.  Even though this is not totally optimal, we've already
1090          * blown it by missing the cache case so we do not care.
1091          */
1092         for (i = PQ_L2_SIZE / 2; i > 0; --i) {
1093                 for (;;) {
1094                         m = TAILQ_FIRST(&pq[(index + i) & PQ_L2_MASK].pl);
1095                         if (m) {
1096                                 _vm_page_and_queue_spin_lock(m);
1097                                 if (m->queue ==
1098                                     basequeue + ((index + i) & PQ_L2_MASK)) {
1099                                         _vm_page_rem_queue_spinlocked(m);
1100                                         return(m);
1101                                 }
1102                                 _vm_page_and_queue_spin_unlock(m);
1103                                 continue;
1104                         }
1105                         m = TAILQ_FIRST(&pq[(index - i) & PQ_L2_MASK].pl);
1106                         if (m) {
1107                                 _vm_page_and_queue_spin_lock(m);
1108                                 if (m->queue ==
1109                                     basequeue + ((index - i) & PQ_L2_MASK)) {
1110                                         _vm_page_rem_queue_spinlocked(m);
1111                                         return(m);
1112                                 }
1113                                 _vm_page_and_queue_spin_unlock(m);
1114                                 continue;
1115                         }
1116                         break;  /* next i */
1117                 }
1118         }
1119         return(m);
1120 }
1121
1122 /*
1123  * Returns a vm_page candidate for allocation.  The page is not busied so
1124  * it can move around.  The caller must busy the page (and typically
1125  * deactivate it if it cannot be busied!)
1126  *
1127  * Returns a spinlocked vm_page that has been removed from its queue.
1128  */
1129 vm_page_t
1130 vm_page_list_find(int basequeue, int index, boolean_t prefer_zero)
1131 {
1132         return(_vm_page_list_find(basequeue, index, prefer_zero));
1133 }
1134
1135 /*
1136  * Find a page on the cache queue with color optimization, remove it
1137  * from the queue, and busy it.  The returned page will not be spinlocked.
1138  *
1139  * A candidate failure will be deactivated.  Candidates can fail due to
1140  * being busied by someone else, in which case they will be deactivated.
1141  *
1142  * This routine may not block.
1143  *
1144  */
1145 static vm_page_t
1146 vm_page_select_cache(vm_object_t object, vm_pindex_t pindex)
1147 {
1148         vm_page_t m;
1149
1150         for (;;) {
1151                 m = _vm_page_list_find(PQ_CACHE,
1152                                        (pindex + object->pg_color) & PQ_L2_MASK,
1153                                        FALSE);
1154                 if (m == NULL)
1155                         break;
1156                 /*
1157                  * (m) has been removed from its queue and spinlocked
1158                  */
1159                 if (vm_page_busy_try(m, TRUE)) {
1160                         _vm_page_deactivate_locked(m, 0);
1161                         vm_page_spin_unlock(m);
1162 #ifdef INVARIANTS
1163                         kprintf("Warning: busy page %p found in cache\n", m);
1164 #endif
1165                 } else {
1166                         /*
1167                          * We successfully busied the page
1168                          */
1169                         if ((m->flags & PG_UNMANAGED) == 0 &&
1170                             m->hold_count == 0 &&
1171                             m->wire_count == 0) {
1172                                 vm_page_spin_unlock(m);
1173                                 pagedaemon_wakeup();
1174                                 return(m);
1175                         }
1176                         _vm_page_deactivate_locked(m, 0);
1177                         if (_vm_page_wakeup(m)) {
1178                                 vm_page_spin_unlock(m);
1179                                 wakeup(m);
1180                         } else {
1181                                 vm_page_spin_unlock(m);
1182                         }
1183                 }
1184         }
1185         return (m);
1186 }
1187
1188 /*
1189  * Find a free or zero page, with specified preference.  We attempt to
1190  * inline the nominal case and fall back to _vm_page_select_free() 
1191  * otherwise.  A busied page is removed from the queue and returned.
1192  *
1193  * This routine may not block.
1194  */
1195 static __inline vm_page_t
1196 vm_page_select_free(vm_object_t object, vm_pindex_t pindex,
1197                     boolean_t prefer_zero)
1198 {
1199         vm_page_t m;
1200
1201         for (;;) {
1202                 m = _vm_page_list_find(PQ_FREE,
1203                                        (pindex + object->pg_color) & PQ_L2_MASK,
1204                                        prefer_zero);
1205                 if (m == NULL)
1206                         break;
1207                 if (vm_page_busy_try(m, TRUE)) {
1208                         _vm_page_deactivate_locked(m, 0);
1209                         vm_page_spin_unlock(m);
1210 #ifdef INVARIANTS
1211                         kprintf("Warning: busy page %p found in cache\n", m);
1212 #endif
1213                 } else {
1214                         KKASSERT((m->flags & PG_UNMANAGED) == 0);
1215                         KKASSERT(m->hold_count == 0);
1216                         KKASSERT(m->wire_count == 0);
1217                         vm_page_spin_unlock(m);
1218                         pagedaemon_wakeup();
1219
1220                         /* return busied and removed page */
1221                         return(m);
1222                 }
1223         }
1224         return(m);
1225 }
1226
1227 /*
1228  * vm_page_alloc()
1229  *
1230  * Allocate and return a memory cell associated with this VM object/offset
1231  * pair.
1232  *
1233  *      page_req classes:
1234  *
1235  *      VM_ALLOC_NORMAL         allow use of cache pages, nominal free drain
1236  *      VM_ALLOC_QUICK          like normal but cannot use cache
1237  *      VM_ALLOC_SYSTEM         greater free drain
1238  *      VM_ALLOC_INTERRUPT      allow free list to be completely drained
1239  *      VM_ALLOC_ZERO           advisory request for pre-zero'd page
1240  *
1241  * The object must be locked.
1242  * This routine may not block.
1243  * The returned page will be marked PG_BUSY
1244  *
1245  * Additional special handling is required when called from an interrupt
1246  * (VM_ALLOC_INTERRUPT).  We are not allowed to mess with the page cache
1247  * in this case.
1248  */
1249 vm_page_t
1250 vm_page_alloc(vm_object_t object, vm_pindex_t pindex, int page_req)
1251 {
1252         vm_page_t m = NULL;
1253
1254         KKASSERT(object != NULL);
1255         KASSERT(!vm_page_lookup(object, pindex),
1256                 ("vm_page_alloc: page already allocated"));
1257         KKASSERT(page_req & 
1258                 (VM_ALLOC_NORMAL|VM_ALLOC_QUICK|
1259                  VM_ALLOC_INTERRUPT|VM_ALLOC_SYSTEM));
1260
1261         /*
1262          * Certain system threads (pageout daemon, buf_daemon's) are
1263          * allowed to eat deeper into the free page list.
1264          */
1265         if (curthread->td_flags & TDF_SYSTHREAD)
1266                 page_req |= VM_ALLOC_SYSTEM;
1267
1268 loop:
1269         if (vmstats.v_free_count > vmstats.v_free_reserved ||
1270             ((page_req & VM_ALLOC_INTERRUPT) && vmstats.v_free_count > 0) ||
1271             ((page_req & VM_ALLOC_SYSTEM) && vmstats.v_cache_count == 0 &&
1272                 vmstats.v_free_count > vmstats.v_interrupt_free_min)
1273         ) {
1274                 /*
1275                  * The free queue has sufficient free pages to take one out.
1276                  */
1277                 if (page_req & VM_ALLOC_ZERO)
1278                         m = vm_page_select_free(object, pindex, TRUE);
1279                 else
1280                         m = vm_page_select_free(object, pindex, FALSE);
1281         } else if (page_req & VM_ALLOC_NORMAL) {
1282                 /*
1283                  * Allocatable from the cache (non-interrupt only).  On
1284                  * success, we must free the page and try again, thus
1285                  * ensuring that vmstats.v_*_free_min counters are replenished.
1286                  */
1287 #ifdef INVARIANTS
1288                 if (curthread->td_preempted) {
1289                         kprintf("vm_page_alloc(): warning, attempt to allocate"
1290                                 " cache page from preempting interrupt\n");
1291                         m = NULL;
1292                 } else {
1293                         m = vm_page_select_cache(object, pindex);
1294                 }
1295 #else
1296                 m = vm_page_select_cache(object, pindex);
1297 #endif
1298                 /*
1299                  * On success move the page into the free queue and loop.
1300                  */
1301                 if (m != NULL) {
1302                         KASSERT(m->dirty == 0,
1303                             ("Found dirty cache page %p", m));
1304                         vm_page_protect(m, VM_PROT_NONE);
1305                         vm_page_free(m);
1306                         goto loop;
1307                 }
1308
1309                 /*
1310                  * On failure return NULL
1311                  */
1312 #if defined(DIAGNOSTIC)
1313                 if (vmstats.v_cache_count > 0)
1314                         kprintf("vm_page_alloc(NORMAL): missing pages on cache queue: %d\n", vmstats.v_cache_count);
1315 #endif
1316                 vm_pageout_deficit++;
1317                 pagedaemon_wakeup();
1318                 return (NULL);
1319         } else {
1320                 /*
1321                  * No pages available, wakeup the pageout daemon and give up.
1322                  */
1323                 vm_pageout_deficit++;
1324                 pagedaemon_wakeup();
1325                 return (NULL);
1326         }
1327
1328         /*
1329          * Good page found.  The page has already been busied for us.
1330          *
1331          * v_free_count can race so loop if we don't find the expected
1332          * page.
1333          */
1334         if (m == NULL)
1335                 goto loop;
1336         KASSERT(m->dirty == 0, 
1337                 ("vm_page_alloc: free/cache page %p was dirty", m));
1338
1339         /*
1340          * NOTE: page has already been removed from its queue and busied.
1341          */
1342         KKASSERT(m->queue == PQ_NONE);
1343
1344         /*
1345          * Initialize structure.  Only the PG_ZERO flag is inherited.  Set
1346          * the page PG_BUSY
1347          */
1348         vm_page_flag_clear(m, ~(PG_ZERO | PG_BUSY));
1349         KKASSERT(m->wire_count == 0);
1350         KKASSERT(m->busy == 0);
1351         m->act_count = 0;
1352         m->valid = 0;
1353
1354         /*
1355          * Caller must be holding the object lock (asserted by
1356          * vm_page_insert()).
1357          *
1358          * NOTE: Inserting a page here does not insert it into any pmaps
1359          *       (which could cause us to block allocating memory).
1360          */
1361         vm_page_insert(m, object, pindex);
1362
1363         /*
1364          * Don't wakeup too often - wakeup the pageout daemon when
1365          * we would be nearly out of memory.
1366          */
1367         pagedaemon_wakeup();
1368
1369         /*
1370          * A PG_BUSY page is returned.
1371          */
1372         return (m);
1373 }
1374
1375 /*
1376  * Wait for sufficient free memory for nominal heavy memory use kernel
1377  * operations.
1378  */
1379 void
1380 vm_wait_nominal(void)
1381 {
1382         while (vm_page_count_min(0))
1383                 vm_wait(0);
1384 }
1385
1386 /*
1387  * Test if vm_wait_nominal() would block.
1388  */
1389 int
1390 vm_test_nominal(void)
1391 {
1392         if (vm_page_count_min(0))
1393                 return(1);
1394         return(0);
1395 }
1396
1397 /*
1398  * Block until free pages are available for allocation, called in various
1399  * places before memory allocations.
1400  *
1401  * The caller may loop if vm_page_count_min() == FALSE so we cannot be
1402  * more generous then that.
1403  */
1404 void
1405 vm_wait(int timo)
1406 {
1407         /*
1408          * never wait forever
1409          */
1410         if (timo == 0)
1411                 timo = hz;
1412         lwkt_gettoken(&vm_token);
1413
1414         if (curthread == pagethread) {
1415                 /*
1416                  * The pageout daemon itself needs pages, this is bad.
1417                  */
1418                 if (vm_page_count_min(0)) {
1419                         vm_pageout_pages_needed = 1;
1420                         tsleep(&vm_pageout_pages_needed, 0, "VMWait", timo);
1421                 }
1422         } else {
1423                 /*
1424                  * Wakeup the pageout daemon if necessary and wait.
1425                  */
1426                 if (vm_page_count_target()) {
1427                         if (vm_pages_needed == 0) {
1428                                 vm_pages_needed = 1;
1429                                 wakeup(&vm_pages_needed);
1430                         }
1431                         ++vm_pages_waiting;     /* SMP race ok */
1432                         tsleep(&vmstats.v_free_count, 0, "vmwait", timo);
1433                 }
1434         }
1435         lwkt_reltoken(&vm_token);
1436 }
1437
1438 /*
1439  * Block until free pages are available for allocation
1440  *
1441  * Called only from vm_fault so that processes page faulting can be
1442  * easily tracked.
1443  */
1444 void
1445 vm_waitpfault(void)
1446 {
1447         /*
1448          * Wakeup the pageout daemon if necessary and wait.
1449          */
1450         if (vm_page_count_target()) {
1451                 lwkt_gettoken(&vm_token);
1452                 if (vm_page_count_target()) {
1453                         if (vm_pages_needed == 0) {
1454                                 vm_pages_needed = 1;
1455                                 wakeup(&vm_pages_needed);
1456                         }
1457                         ++vm_pages_waiting;     /* SMP race ok */
1458                         tsleep(&vmstats.v_free_count, 0, "pfault", hz);
1459                 }
1460                 lwkt_reltoken(&vm_token);
1461         }
1462 }
1463
1464 /*
1465  * Put the specified page on the active list (if appropriate).  Ensure
1466  * that act_count is at least ACT_INIT but do not otherwise mess with it.
1467  *
1468  * The caller should be holding the page busied ? XXX
1469  * This routine may not block.
1470  */
1471 void
1472 vm_page_activate(vm_page_t m)
1473 {
1474         u_short oqueue;
1475
1476         vm_page_spin_lock(m);
1477         if (m->queue != PQ_ACTIVE) {
1478                 _vm_page_queue_spin_lock(m);
1479                 oqueue = _vm_page_rem_queue_spinlocked(m);
1480                 /* page is left spinlocked, queue is unlocked */
1481
1482                 if (oqueue == PQ_CACHE)
1483                         mycpu->gd_cnt.v_reactivated++;
1484                 if (m->wire_count == 0 && (m->flags & PG_UNMANAGED) == 0) {
1485                         if (m->act_count < ACT_INIT)
1486                                 m->act_count = ACT_INIT;
1487                         _vm_page_add_queue_spinlocked(m, PQ_ACTIVE, 0);
1488                 }
1489                 _vm_page_and_queue_spin_unlock(m);
1490                 if (oqueue == PQ_CACHE || oqueue == PQ_FREE)
1491                         pagedaemon_wakeup();
1492         } else {
1493                 if (m->act_count < ACT_INIT)
1494                         m->act_count = ACT_INIT;
1495                 vm_page_spin_unlock(m);
1496         }
1497 }
1498
1499 /*
1500  * Helper routine for vm_page_free_toq() and vm_page_cache().  This
1501  * routine is called when a page has been added to the cache or free
1502  * queues.
1503  *
1504  * This routine may not block.
1505  */
1506 static __inline void
1507 vm_page_free_wakeup(void)
1508 {
1509         /*
1510          * If the pageout daemon itself needs pages, then tell it that
1511          * there are some free.
1512          */
1513         if (vm_pageout_pages_needed &&
1514             vmstats.v_cache_count + vmstats.v_free_count >= 
1515             vmstats.v_pageout_free_min
1516         ) {
1517                 wakeup(&vm_pageout_pages_needed);
1518                 vm_pageout_pages_needed = 0;
1519         }
1520
1521         /*
1522          * Wakeup processes that are waiting on memory.
1523          *
1524          * NOTE: vm_paging_target() is the pageout daemon's target, while
1525          *       vm_page_count_target() is somewhere inbetween.  We want
1526          *       to wake processes up prior to the pageout daemon reaching
1527          *       its target to provide some hysteresis.
1528          */
1529         if (vm_pages_waiting) {
1530                 if (!vm_page_count_target()) {
1531                         /*
1532                          * Plenty of pages are free, wakeup everyone.
1533                          */
1534                         vm_pages_waiting = 0;
1535                         wakeup(&vmstats.v_free_count);
1536                         ++mycpu->gd_cnt.v_ppwakeups;
1537                 } else if (!vm_page_count_min(0)) {
1538                         /*
1539                          * Some pages are free, wakeup someone.
1540                          */
1541                         int wcount = vm_pages_waiting;
1542                         if (wcount > 0)
1543                                 --wcount;
1544                         vm_pages_waiting = wcount;
1545                         wakeup_one(&vmstats.v_free_count);
1546                         ++mycpu->gd_cnt.v_ppwakeups;
1547                 }
1548         }
1549 }
1550
1551 /*
1552  * Returns the given page to the PQ_FREE or PQ_HOLD list and disassociates
1553  * it from its VM object.
1554  *
1555  * The vm_page must be PG_BUSY on entry.  PG_BUSY will be released on
1556  * return (the page will have been freed).
1557  */
1558 void
1559 vm_page_free_toq(vm_page_t m)
1560 {
1561         mycpu->gd_cnt.v_tfree++;
1562         KKASSERT((m->flags & PG_MAPPED) == 0);
1563         KKASSERT(m->flags & PG_BUSY);
1564
1565         if (m->busy || ((m->queue - m->pc) == PQ_FREE)) {
1566                 kprintf(
1567                 "vm_page_free: pindex(%lu), busy(%d), PG_BUSY(%d), hold(%d)\n",
1568                     (u_long)m->pindex, m->busy, (m->flags & PG_BUSY) ? 1 : 0,
1569                     m->hold_count);
1570                 if ((m->queue - m->pc) == PQ_FREE)
1571                         panic("vm_page_free: freeing free page");
1572                 else
1573                         panic("vm_page_free: freeing busy page");
1574         }
1575
1576         /*
1577          * Remove from object, spinlock the page and its queues and
1578          * remove from any queue.  No queue spinlock will be held
1579          * after this section (because the page was removed from any
1580          * queue).
1581          */
1582         vm_page_remove(m);
1583         vm_page_and_queue_spin_lock(m);
1584         _vm_page_rem_queue_spinlocked(m);
1585
1586         /*
1587          * No further management of fictitious pages occurs beyond object
1588          * and queue removal.
1589          */
1590         if ((m->flags & PG_FICTITIOUS) != 0) {
1591                 vm_page_spin_unlock(m);
1592                 vm_page_wakeup(m);
1593                 return;
1594         }
1595
1596         m->valid = 0;
1597         vm_page_undirty(m);
1598
1599         if (m->wire_count != 0) {
1600                 if (m->wire_count > 1) {
1601                     panic(
1602                         "vm_page_free: invalid wire count (%d), pindex: 0x%lx",
1603                         m->wire_count, (long)m->pindex);
1604                 }
1605                 panic("vm_page_free: freeing wired page");
1606         }
1607
1608         /*
1609          * Clear the UNMANAGED flag when freeing an unmanaged page.
1610          */
1611         if (m->flags & PG_UNMANAGED) {
1612                 vm_page_flag_clear(m, PG_UNMANAGED);
1613         }
1614
1615         if (m->hold_count != 0) {
1616                 vm_page_flag_clear(m, PG_ZERO);
1617                 _vm_page_add_queue_spinlocked(m, PQ_HOLD, 0);
1618         } else {
1619                 _vm_page_add_queue_spinlocked(m, PQ_FREE + m->pc, 0);
1620         }
1621
1622         /*
1623          * This sequence allows us to clear PG_BUSY while still holding
1624          * its spin lock, which reduces contention vs allocators.  We
1625          * must not leave the queue locked or _vm_page_wakeup() may
1626          * deadlock.
1627          */
1628         _vm_page_queue_spin_unlock(m);
1629         if (_vm_page_wakeup(m)) {
1630                 vm_page_spin_unlock(m);
1631                 wakeup(m);
1632         } else {
1633                 vm_page_spin_unlock(m);
1634         }
1635         vm_page_free_wakeup();
1636 }
1637
1638 /*
1639  * vm_page_free_fromq_fast()
1640  *
1641  * Remove a non-zero page from one of the free queues; the page is removed for
1642  * zeroing, so do not issue a wakeup.
1643  */
1644 vm_page_t
1645 vm_page_free_fromq_fast(void)
1646 {
1647         static int qi;
1648         vm_page_t m;
1649         int i;
1650
1651         for (i = 0; i < PQ_L2_SIZE; ++i) {
1652                 m = vm_page_list_find(PQ_FREE, qi, FALSE);
1653                 /* page is returned spinlocked and removed from its queue */
1654                 if (m) {
1655                         if (vm_page_busy_try(m, TRUE)) {
1656                                 /*
1657                                  * We were unable to busy the page, deactivate
1658                                  * it and loop.
1659                                  */
1660                                 _vm_page_deactivate_locked(m, 0);
1661                                 vm_page_spin_unlock(m);
1662                         } else if ((m->flags & PG_ZERO) == 0) {
1663                                 /*
1664                                  * The page is not PG_ZERO'd so return it.
1665                                  */
1666                                 vm_page_spin_unlock(m);
1667                                 break;
1668                         } else {
1669                                 /*
1670                                  * The page is PG_ZERO, requeue it and loop
1671                                  */
1672                                 _vm_page_add_queue_spinlocked(m,
1673                                                               PQ_FREE + m->pc,
1674                                                               0);
1675                                 vm_page_queue_spin_unlock(m);
1676                                 if (_vm_page_wakeup(m)) {
1677                                         vm_page_spin_unlock(m);
1678                                         wakeup(m);
1679                                 } else {
1680                                         vm_page_spin_unlock(m);
1681                                 }
1682                         }
1683                         m = NULL;
1684                 }
1685                 qi = (qi + PQ_PRIME2) & PQ_L2_MASK;
1686         }
1687         return (m);
1688 }
1689
1690 /*
1691  * vm_page_unmanage()
1692  *
1693  * Prevent PV management from being done on the page.  The page is
1694  * removed from the paging queues as if it were wired, and as a 
1695  * consequence of no longer being managed the pageout daemon will not
1696  * touch it (since there is no way to locate the pte mappings for the
1697  * page).  madvise() calls that mess with the pmap will also no longer
1698  * operate on the page.
1699  *
1700  * Beyond that the page is still reasonably 'normal'.  Freeing the page
1701  * will clear the flag.
1702  *
1703  * This routine is used by OBJT_PHYS objects - objects using unswappable
1704  * physical memory as backing store rather then swap-backed memory and
1705  * will eventually be extended to support 4MB unmanaged physical 
1706  * mappings.
1707  *
1708  * Caller must be holding the page busy.
1709  */
1710 void
1711 vm_page_unmanage(vm_page_t m)
1712 {
1713         KKASSERT(m->flags & PG_BUSY);
1714         if ((m->flags & PG_UNMANAGED) == 0) {
1715                 if (m->wire_count == 0)
1716                         vm_page_unqueue(m);
1717         }
1718         vm_page_flag_set(m, PG_UNMANAGED);
1719 }
1720
1721 /*
1722  * Mark this page as wired down by yet another map, removing it from
1723  * paging queues as necessary.
1724  *
1725  * Caller must be holding the page busy.
1726  */
1727 void
1728 vm_page_wire(vm_page_t m)
1729 {
1730         /*
1731          * Only bump the wire statistics if the page is not already wired,
1732          * and only unqueue the page if it is on some queue (if it is unmanaged
1733          * it is already off the queues).  Don't do anything with fictitious
1734          * pages because they are always wired.
1735          */
1736         KKASSERT(m->flags & PG_BUSY);
1737         if ((m->flags & PG_FICTITIOUS) == 0) {
1738                 if (atomic_fetchadd_int(&m->wire_count, 1) == 0) {
1739                         if ((m->flags & PG_UNMANAGED) == 0)
1740                                 vm_page_unqueue(m);
1741                         atomic_add_int(&vmstats.v_wire_count, 1);
1742                 }
1743                 KASSERT(m->wire_count != 0,
1744                         ("vm_page_wire: wire_count overflow m=%p", m));
1745         }
1746 }
1747
1748 /*
1749  * Release one wiring of this page, potentially enabling it to be paged again.
1750  *
1751  * Many pages placed on the inactive queue should actually go
1752  * into the cache, but it is difficult to figure out which.  What
1753  * we do instead, if the inactive target is well met, is to put
1754  * clean pages at the head of the inactive queue instead of the tail.
1755  * This will cause them to be moved to the cache more quickly and
1756  * if not actively re-referenced, freed more quickly.  If we just
1757  * stick these pages at the end of the inactive queue, heavy filesystem
1758  * meta-data accesses can cause an unnecessary paging load on memory bound 
1759  * processes.  This optimization causes one-time-use metadata to be
1760  * reused more quickly.
1761  *
1762  * BUT, if we are in a low-memory situation we have no choice but to
1763  * put clean pages on the cache queue.
1764  *
1765  * A number of routines use vm_page_unwire() to guarantee that the page
1766  * will go into either the inactive or active queues, and will NEVER
1767  * be placed in the cache - for example, just after dirtying a page.
1768  * dirty pages in the cache are not allowed.
1769  *
1770  * The page queues must be locked.
1771  * This routine may not block.
1772  */
1773 void
1774 vm_page_unwire(vm_page_t m, int activate)
1775 {
1776         KKASSERT(m->flags & PG_BUSY);
1777         if (m->flags & PG_FICTITIOUS) {
1778                 /* do nothing */
1779         } else if (m->wire_count <= 0) {
1780                 panic("vm_page_unwire: invalid wire count: %d", m->wire_count);
1781         } else {
1782                 if (atomic_fetchadd_int(&m->wire_count, -1) == 1) {
1783                         atomic_add_int(&vmstats.v_wire_count, -1);
1784                         if (m->flags & PG_UNMANAGED) {
1785                                 ;
1786                         } else if (activate) {
1787                                 vm_page_spin_lock(m);
1788                                 _vm_page_add_queue_spinlocked(m, PQ_ACTIVE, 0);
1789                                 _vm_page_and_queue_spin_unlock(m);
1790                         } else {
1791                                 vm_page_spin_lock(m);
1792                                 vm_page_flag_clear(m, PG_WINATCFLS);
1793                                 _vm_page_add_queue_spinlocked(m, PQ_INACTIVE,
1794                                                               0);
1795                                 ++vm_swapcache_inactive_heuristic;
1796                                 _vm_page_and_queue_spin_unlock(m);
1797                         }
1798                 }
1799         }
1800 }
1801
1802 /*
1803  * Move the specified page to the inactive queue.  If the page has
1804  * any associated swap, the swap is deallocated.
1805  *
1806  * Normally athead is 0 resulting in LRU operation.  athead is set
1807  * to 1 if we want this page to be 'as if it were placed in the cache',
1808  * except without unmapping it from the process address space.
1809  *
1810  * vm_page's spinlock must be held on entry and will remain held on return.
1811  * This routine may not block.
1812  */
1813 static void
1814 _vm_page_deactivate_locked(vm_page_t m, int athead)
1815 {
1816         u_short oqueue;
1817
1818         /*
1819          * Ignore if already inactive.
1820          */
1821         if (m->queue == PQ_INACTIVE)
1822                 return;
1823         _vm_page_queue_spin_lock(m);
1824         oqueue = _vm_page_rem_queue_spinlocked(m);
1825
1826         if (m->wire_count == 0 && (m->flags & PG_UNMANAGED) == 0) {
1827                 if (oqueue == PQ_CACHE)
1828                         mycpu->gd_cnt.v_reactivated++;
1829                 vm_page_flag_clear(m, PG_WINATCFLS);
1830                 _vm_page_add_queue_spinlocked(m, PQ_INACTIVE, athead);
1831                 if (athead == 0)
1832                         ++vm_swapcache_inactive_heuristic;
1833         }
1834         _vm_page_queue_spin_unlock(m);
1835         /* leaves vm_page spinlocked */
1836 }
1837
1838 /*
1839  * Attempt to deactivate a page.
1840  *
1841  * No requirements.
1842  */
1843 void
1844 vm_page_deactivate(vm_page_t m)
1845 {
1846         vm_page_spin_lock(m);
1847         _vm_page_deactivate_locked(m, 0);
1848         vm_page_spin_unlock(m);
1849 }
1850
1851 void
1852 vm_page_deactivate_locked(vm_page_t m)
1853 {
1854         _vm_page_deactivate_locked(m, 0);
1855 }
1856
1857 /*
1858  * Attempt to move a page to PQ_CACHE.
1859  *
1860  * Returns 0 on failure, 1 on success
1861  *
1862  * The page should NOT be busied by the caller.  This function will validate
1863  * whether the page can be safely moved to the cache.
1864  */
1865 int
1866 vm_page_try_to_cache(vm_page_t m)
1867 {
1868         vm_page_spin_lock(m);
1869         if (vm_page_busy_try(m, TRUE)) {
1870                 vm_page_spin_unlock(m);
1871                 return(0);
1872         }
1873         if (m->dirty || m->hold_count || m->wire_count ||
1874             (m->flags & PG_UNMANAGED)) {
1875                 if (_vm_page_wakeup(m)) {
1876                         vm_page_spin_unlock(m);
1877                         wakeup(m);
1878                 } else {
1879                         vm_page_spin_unlock(m);
1880                 }
1881                 return(0);
1882         }
1883         vm_page_spin_unlock(m);
1884
1885         /*
1886          * Page busied by us and no longer spinlocked.  Dirty pages cannot
1887          * be moved to the cache.
1888          */
1889         vm_page_test_dirty(m);
1890         if (m->dirty) {
1891                 vm_page_wakeup(m);
1892                 return(0);
1893         }
1894         vm_page_cache(m);
1895         return(1);
1896 }
1897
1898 /*
1899  * Attempt to free the page.  If we cannot free it, we do nothing.
1900  * 1 is returned on success, 0 on failure.
1901  *
1902  * No requirements.
1903  */
1904 int
1905 vm_page_try_to_free(vm_page_t m)
1906 {
1907         vm_page_spin_lock(m);
1908         if (vm_page_busy_try(m, TRUE)) {
1909                 vm_page_spin_unlock(m);
1910                 return(0);
1911         }
1912         if (m->dirty || m->hold_count || m->wire_count ||
1913             (m->flags & PG_UNMANAGED)) {
1914                 if (_vm_page_wakeup(m)) {
1915                         vm_page_spin_unlock(m);
1916                         wakeup(m);
1917                 } else {
1918                         vm_page_spin_unlock(m);
1919                 }
1920                 return(0);
1921         }
1922         vm_page_spin_unlock(m);
1923
1924         /*
1925          * Page busied by us and no longer spinlocked.  Dirty pages will
1926          * not be freed by this function.    We have to re-test the
1927          * dirty bit after cleaning out the pmaps.
1928          */
1929         vm_page_test_dirty(m);
1930         if (m->dirty) {
1931                 vm_page_wakeup(m);
1932                 return(0);
1933         }
1934         vm_page_protect(m, VM_PROT_NONE);
1935         if (m->dirty) {
1936                 vm_page_wakeup(m);
1937                 return(0);
1938         }
1939         vm_page_free(m);
1940         return(1);
1941 }
1942
1943 /*
1944  * vm_page_cache
1945  *
1946  * Put the specified page onto the page cache queue (if appropriate).
1947  *
1948  * The page must be busy, and this routine will release the busy and
1949  * possibly even free the page.
1950  */
1951 void
1952 vm_page_cache(vm_page_t m)
1953 {
1954         if ((m->flags & PG_UNMANAGED) || m->busy ||
1955             m->wire_count || m->hold_count) {
1956                 kprintf("vm_page_cache: attempting to cache busy/held page\n");
1957                 vm_page_wakeup(m);
1958                 return;
1959         }
1960
1961         /*
1962          * Already in the cache (and thus not mapped)
1963          */
1964         if ((m->queue - m->pc) == PQ_CACHE) {
1965                 KKASSERT((m->flags & PG_MAPPED) == 0);
1966                 vm_page_wakeup(m);
1967                 return;
1968         }
1969
1970         /*
1971          * Caller is required to test m->dirty, but note that the act of
1972          * removing the page from its maps can cause it to become dirty
1973          * on an SMP system due to another cpu running in usermode.
1974          */
1975         if (m->dirty) {
1976                 panic("vm_page_cache: caching a dirty page, pindex: %ld",
1977                         (long)m->pindex);
1978         }
1979
1980         /*
1981          * Remove all pmaps and indicate that the page is not
1982          * writeable or mapped.  Our vm_page_protect() call may
1983          * have blocked (especially w/ VM_PROT_NONE), so recheck
1984          * everything.
1985          */
1986         vm_page_protect(m, VM_PROT_NONE);
1987         if ((m->flags & (PG_UNMANAGED|PG_MAPPED)) || m->busy ||
1988                         m->wire_count || m->hold_count) {
1989                 vm_page_wakeup(m);
1990         } else if (m->dirty) {
1991                 vm_page_deactivate(m);
1992                 vm_page_wakeup(m);
1993         } else {
1994                 _vm_page_and_queue_spin_lock(m);
1995                 _vm_page_rem_queue_spinlocked(m);
1996                 _vm_page_add_queue_spinlocked(m, PQ_CACHE + m->pc, 0);
1997                 _vm_page_queue_spin_unlock(m);
1998                 if (_vm_page_wakeup(m)) {
1999                         vm_page_spin_unlock(m);
2000                         wakeup(m);
2001                 } else {
2002                         vm_page_spin_unlock(m);
2003                 }
2004                 vm_page_free_wakeup();
2005         }
2006 }
2007
2008 /*
2009  * vm_page_dontneed()
2010  *
2011  * Cache, deactivate, or do nothing as appropriate.  This routine
2012  * is typically used by madvise() MADV_DONTNEED.
2013  *
2014  * Generally speaking we want to move the page into the cache so
2015  * it gets reused quickly.  However, this can result in a silly syndrome
2016  * due to the page recycling too quickly.  Small objects will not be
2017  * fully cached.  On the otherhand, if we move the page to the inactive
2018  * queue we wind up with a problem whereby very large objects 
2019  * unnecessarily blow away our inactive and cache queues.
2020  *
2021  * The solution is to move the pages based on a fixed weighting.  We
2022  * either leave them alone, deactivate them, or move them to the cache,
2023  * where moving them to the cache has the highest weighting.
2024  * By forcing some pages into other queues we eventually force the
2025  * system to balance the queues, potentially recovering other unrelated
2026  * space from active.  The idea is to not force this to happen too
2027  * often.
2028  *
2029  * The page must be busied.
2030  */
2031 void
2032 vm_page_dontneed(vm_page_t m)
2033 {
2034         static int dnweight;
2035         int dnw;
2036         int head;
2037
2038         dnw = ++dnweight;
2039
2040         /*
2041          * occassionally leave the page alone
2042          */
2043         if ((dnw & 0x01F0) == 0 ||
2044             m->queue == PQ_INACTIVE || 
2045             m->queue - m->pc == PQ_CACHE
2046         ) {
2047                 if (m->act_count >= ACT_INIT)
2048                         --m->act_count;
2049                 return;
2050         }
2051
2052         /*
2053          * If vm_page_dontneed() is inactivating a page, it must clear
2054          * the referenced flag; otherwise the pagedaemon will see references
2055          * on the page in the inactive queue and reactivate it. Until the 
2056          * page can move to the cache queue, madvise's job is not done.
2057          */
2058         vm_page_flag_clear(m, PG_REFERENCED);
2059         pmap_clear_reference(m);
2060
2061         if (m->dirty == 0)
2062                 vm_page_test_dirty(m);
2063
2064         if (m->dirty || (dnw & 0x0070) == 0) {
2065                 /*
2066                  * Deactivate the page 3 times out of 32.
2067                  */
2068                 head = 0;
2069         } else {
2070                 /*
2071                  * Cache the page 28 times out of every 32.  Note that
2072                  * the page is deactivated instead of cached, but placed
2073                  * at the head of the queue instead of the tail.
2074                  */
2075                 head = 1;
2076         }
2077         vm_page_spin_lock(m);
2078         _vm_page_deactivate_locked(m, head);
2079         vm_page_spin_unlock(m);
2080 }
2081
2082 /*
2083  * These routines manipulate the 'soft busy' count for a page.  A soft busy
2084  * is almost like PG_BUSY except that it allows certain compatible operations
2085  * to occur on the page while it is busy.  For example, a page undergoing a
2086  * write can still be mapped read-only.
2087  *
2088  * Because vm_pages can overlap buffers m->busy can be > 1.  m->busy is only
2089  * adjusted while the vm_page is PG_BUSY so the flash will occur when the
2090  * busy bit is cleared.
2091  */
2092 void
2093 vm_page_io_start(vm_page_t m)
2094 {
2095         KASSERT(m->flags & PG_BUSY, ("vm_page_io_start: page not busy!!!"));
2096         atomic_add_char(&m->busy, 1);
2097         vm_page_flag_set(m, PG_SBUSY);
2098 }
2099
2100 void
2101 vm_page_io_finish(vm_page_t m)
2102 {
2103         KASSERT(m->flags & PG_BUSY, ("vm_page_io_finish: page not busy!!!"));
2104         atomic_subtract_char(&m->busy, 1);
2105         if (m->busy == 0)
2106                 vm_page_flag_clear(m, PG_SBUSY);
2107 }
2108
2109 /*
2110  * Grab a page, blocking if it is busy and allocating a page if necessary.
2111  * A busy page is returned or NULL.
2112  *
2113  * The page is not removed from its queues. XXX?
2114  *
2115  * If VM_ALLOC_RETRY is specified VM_ALLOC_NORMAL must also be specified.
2116  * If VM_ALLOC_RETRY is not specified
2117  *
2118  * This routine may block, but if VM_ALLOC_RETRY is not set then NULL is
2119  * always returned if we had blocked.  
2120  * This routine will never return NULL if VM_ALLOC_RETRY is set.
2121  * This routine may not be called from an interrupt.
2122  * The returned page may not be entirely valid.
2123  *
2124  * This routine may be called from mainline code without spl protection and
2125  * be guarenteed a busied page associated with the object at the specified
2126  * index.
2127  *
2128  * No requirements.
2129  */
2130 vm_page_t
2131 vm_page_grab(vm_object_t object, vm_pindex_t pindex, int allocflags)
2132 {
2133         vm_page_t m;
2134         int error;
2135
2136         KKASSERT(allocflags &
2137                 (VM_ALLOC_NORMAL|VM_ALLOC_INTERRUPT|VM_ALLOC_SYSTEM));
2138         vm_object_hold(object);
2139         for (;;) {
2140                 m = vm_page_lookup_busy_try(object, pindex, TRUE, &error);
2141                 if (error) {
2142                         vm_page_sleep_busy(m, TRUE, "pgrbwt");
2143                         if ((allocflags & VM_ALLOC_RETRY) == 0) {
2144                                 m = NULL;
2145                                 break;
2146                         }
2147                 } else if (m == NULL) {
2148                         m = vm_page_alloc(object, pindex,
2149                                           allocflags & ~VM_ALLOC_RETRY);
2150                         if (m)
2151                                 break;
2152                         vm_wait(0);
2153                         if ((allocflags & VM_ALLOC_RETRY) == 0)
2154                                 break;
2155                 } else {
2156                         /* m found */
2157                         break;
2158                 }
2159         }
2160         vm_object_drop(object);
2161         return(m);
2162 }
2163
2164 /*
2165  * Mapping function for valid bits or for dirty bits in
2166  * a page.  May not block.
2167  *
2168  * Inputs are required to range within a page.
2169  *
2170  * No requirements.
2171  * Non blocking.
2172  */
2173 int
2174 vm_page_bits(int base, int size)
2175 {
2176         int first_bit;
2177         int last_bit;
2178
2179         KASSERT(
2180             base + size <= PAGE_SIZE,
2181             ("vm_page_bits: illegal base/size %d/%d", base, size)
2182         );
2183
2184         if (size == 0)          /* handle degenerate case */
2185                 return(0);
2186
2187         first_bit = base >> DEV_BSHIFT;
2188         last_bit = (base + size - 1) >> DEV_BSHIFT;
2189
2190         return ((2 << last_bit) - (1 << first_bit));
2191 }
2192
2193 /*
2194  * Sets portions of a page valid and clean.  The arguments are expected
2195  * to be DEV_BSIZE aligned but if they aren't the bitmap is inclusive
2196  * of any partial chunks touched by the range.  The invalid portion of
2197  * such chunks will be zero'd.
2198  *
2199  * NOTE: When truncating a buffer vnode_pager_setsize() will automatically
2200  *       align base to DEV_BSIZE so as not to mark clean a partially
2201  *       truncated device block.  Otherwise the dirty page status might be
2202  *       lost.
2203  *
2204  * This routine may not block.
2205  *
2206  * (base + size) must be less then or equal to PAGE_SIZE.
2207  */
2208 static void
2209 _vm_page_zero_valid(vm_page_t m, int base, int size)
2210 {
2211         int frag;
2212         int endoff;
2213
2214         if (size == 0)  /* handle degenerate case */
2215                 return;
2216
2217         /*
2218          * If the base is not DEV_BSIZE aligned and the valid
2219          * bit is clear, we have to zero out a portion of the
2220          * first block.
2221          */
2222
2223         if ((frag = base & ~(DEV_BSIZE - 1)) != base &&
2224             (m->valid & (1 << (base >> DEV_BSHIFT))) == 0
2225         ) {
2226                 pmap_zero_page_area(
2227                     VM_PAGE_TO_PHYS(m),
2228                     frag,
2229                     base - frag
2230                 );
2231         }
2232
2233         /*
2234          * If the ending offset is not DEV_BSIZE aligned and the 
2235          * valid bit is clear, we have to zero out a portion of
2236          * the last block.
2237          */
2238
2239         endoff = base + size;
2240
2241         if ((frag = endoff & ~(DEV_BSIZE - 1)) != endoff &&
2242             (m->valid & (1 << (endoff >> DEV_BSHIFT))) == 0
2243         ) {
2244                 pmap_zero_page_area(
2245                     VM_PAGE_TO_PHYS(m),
2246                     endoff,
2247                     DEV_BSIZE - (endoff & (DEV_BSIZE - 1))
2248                 );
2249         }
2250 }
2251
2252 /*
2253  * Set valid, clear dirty bits.  If validating the entire
2254  * page we can safely clear the pmap modify bit.  We also
2255  * use this opportunity to clear the PG_NOSYNC flag.  If a process
2256  * takes a write fault on a MAP_NOSYNC memory area the flag will
2257  * be set again.
2258  *
2259  * We set valid bits inclusive of any overlap, but we can only
2260  * clear dirty bits for DEV_BSIZE chunks that are fully within
2261  * the range.
2262  *
2263  * Page must be busied?
2264  * No other requirements.
2265  */
2266 void
2267 vm_page_set_valid(vm_page_t m, int base, int size)
2268 {
2269         _vm_page_zero_valid(m, base, size);
2270         m->valid |= vm_page_bits(base, size);
2271 }
2272
2273
2274 /*
2275  * Set valid bits and clear dirty bits.
2276  *
2277  * NOTE: This function does not clear the pmap modified bit.
2278  *       Also note that e.g. NFS may use a byte-granular base
2279  *       and size.
2280  *
2281  * WARNING: Page must be busied?  But vfs_clean_one_page() will call
2282  *          this without necessarily busying the page (via bdwrite()).
2283  *          So for now vm_token must also be held.
2284  *
2285  * No other requirements.
2286  */
2287 void
2288 vm_page_set_validclean(vm_page_t m, int base, int size)
2289 {
2290         int pagebits;
2291
2292         _vm_page_zero_valid(m, base, size);
2293         pagebits = vm_page_bits(base, size);
2294         m->valid |= pagebits;
2295         m->dirty &= ~pagebits;
2296         if (base == 0 && size == PAGE_SIZE) {
2297                 /*pmap_clear_modify(m);*/
2298                 vm_page_flag_clear(m, PG_NOSYNC);
2299         }
2300 }
2301
2302 /*
2303  * Set valid & dirty.  Used by buwrite()
2304  *
2305  * WARNING: Page must be busied?  But vfs_dirty_one_page() will
2306  *          call this function in buwrite() so for now vm_token must
2307  *          be held.
2308  *
2309  * No other requirements.
2310  */
2311 void
2312 vm_page_set_validdirty(vm_page_t m, int base, int size)
2313 {
2314         int pagebits;
2315
2316         pagebits = vm_page_bits(base, size);
2317         m->valid |= pagebits;
2318         m->dirty |= pagebits;
2319         if (m->object)
2320                 vm_object_set_writeable_dirty(m->object);
2321 }
2322
2323 /*
2324  * Clear dirty bits.
2325  *
2326  * NOTE: This function does not clear the pmap modified bit.
2327  *       Also note that e.g. NFS may use a byte-granular base
2328  *       and size.
2329  *
2330  * Page must be busied?
2331  * No other requirements.
2332  */
2333 void
2334 vm_page_clear_dirty(vm_page_t m, int base, int size)
2335 {
2336         m->dirty &= ~vm_page_bits(base, size);
2337         if (base == 0 && size == PAGE_SIZE) {
2338                 /*pmap_clear_modify(m);*/
2339                 vm_page_flag_clear(m, PG_NOSYNC);
2340         }
2341 }
2342
2343 /*
2344  * Make the page all-dirty.
2345  *
2346  * Also make sure the related object and vnode reflect the fact that the
2347  * object may now contain a dirty page.
2348  *
2349  * Page must be busied?
2350  * No other requirements.
2351  */
2352 void
2353 vm_page_dirty(vm_page_t m)
2354 {
2355 #ifdef INVARIANTS
2356         int pqtype = m->queue - m->pc;
2357 #endif
2358         KASSERT(pqtype != PQ_CACHE && pqtype != PQ_FREE,
2359                 ("vm_page_dirty: page in free/cache queue!"));
2360         if (m->dirty != VM_PAGE_BITS_ALL) {
2361                 m->dirty = VM_PAGE_BITS_ALL;
2362                 if (m->object)
2363                         vm_object_set_writeable_dirty(m->object);
2364         }
2365 }
2366
2367 /*
2368  * Invalidates DEV_BSIZE'd chunks within a page.  Both the
2369  * valid and dirty bits for the effected areas are cleared.
2370  *
2371  * Page must be busied?
2372  * Does not block.
2373  * No other requirements.
2374  */
2375 void
2376 vm_page_set_invalid(vm_page_t m, int base, int size)
2377 {
2378         int bits;
2379
2380         bits = vm_page_bits(base, size);
2381         m->valid &= ~bits;
2382         m->dirty &= ~bits;
2383         m->object->generation++;
2384 }
2385
2386 /*
2387  * The kernel assumes that the invalid portions of a page contain 
2388  * garbage, but such pages can be mapped into memory by user code.
2389  * When this occurs, we must zero out the non-valid portions of the
2390  * page so user code sees what it expects.
2391  *
2392  * Pages are most often semi-valid when the end of a file is mapped 
2393  * into memory and the file's size is not page aligned.
2394  *
2395  * Page must be busied?
2396  * No other requirements.
2397  */
2398 void
2399 vm_page_zero_invalid(vm_page_t m, boolean_t setvalid)
2400 {
2401         int b;
2402         int i;
2403
2404         /*
2405          * Scan the valid bits looking for invalid sections that
2406          * must be zerod.  Invalid sub-DEV_BSIZE'd areas ( where the
2407          * valid bit may be set ) have already been zerod by
2408          * vm_page_set_validclean().
2409          */
2410         for (b = i = 0; i <= PAGE_SIZE / DEV_BSIZE; ++i) {
2411                 if (i == (PAGE_SIZE / DEV_BSIZE) || 
2412                     (m->valid & (1 << i))
2413                 ) {
2414                         if (i > b) {
2415                                 pmap_zero_page_area(
2416                                     VM_PAGE_TO_PHYS(m), 
2417                                     b << DEV_BSHIFT,
2418                                     (i - b) << DEV_BSHIFT
2419                                 );
2420                         }
2421                         b = i + 1;
2422                 }
2423         }
2424
2425         /*
2426          * setvalid is TRUE when we can safely set the zero'd areas
2427          * as being valid.  We can do this if there are no cache consistency
2428          * issues.  e.g. it is ok to do with UFS, but not ok to do with NFS.
2429          */
2430         if (setvalid)
2431                 m->valid = VM_PAGE_BITS_ALL;
2432 }
2433
2434 /*
2435  * Is a (partial) page valid?  Note that the case where size == 0
2436  * will return FALSE in the degenerate case where the page is entirely
2437  * invalid, and TRUE otherwise.
2438  *
2439  * Does not block.
2440  * No other requirements.
2441  */
2442 int
2443 vm_page_is_valid(vm_page_t m, int base, int size)
2444 {
2445         int bits = vm_page_bits(base, size);
2446
2447         if (m->valid && ((m->valid & bits) == bits))
2448                 return 1;
2449         else
2450                 return 0;
2451 }
2452
2453 /*
2454  * update dirty bits from pmap/mmu.  May not block.
2455  *
2456  * Caller must hold the page busy
2457  */
2458 void
2459 vm_page_test_dirty(vm_page_t m)
2460 {
2461         if ((m->dirty != VM_PAGE_BITS_ALL) && pmap_is_modified(m)) {
2462                 vm_page_dirty(m);
2463         }
2464 }
2465
2466 /*
2467  * Register an action, associating it with its vm_page
2468  */
2469 void
2470 vm_page_register_action(vm_page_action_t action, vm_page_event_t event)
2471 {
2472         struct vm_page_action_list *list;
2473         int hv;
2474
2475         hv = (int)((intptr_t)action->m >> 8) & VMACTION_HMASK;
2476         list = &action_list[hv];
2477
2478         lwkt_gettoken(&vm_token);
2479         vm_page_flag_set(action->m, PG_ACTIONLIST);
2480         action->event = event;
2481         LIST_INSERT_HEAD(list, action, entry);
2482         lwkt_reltoken(&vm_token);
2483 }
2484
2485 /*
2486  * Unregister an action, disassociating it from its related vm_page
2487  */
2488 void
2489 vm_page_unregister_action(vm_page_action_t action)
2490 {
2491         struct vm_page_action_list *list;
2492         int hv;
2493
2494         lwkt_gettoken(&vm_token);
2495         if (action->event != VMEVENT_NONE) {
2496                 action->event = VMEVENT_NONE;
2497                 LIST_REMOVE(action, entry);
2498
2499                 hv = (int)((intptr_t)action->m >> 8) & VMACTION_HMASK;
2500                 list = &action_list[hv];
2501                 if (LIST_EMPTY(list))
2502                         vm_page_flag_clear(action->m, PG_ACTIONLIST);
2503         }
2504         lwkt_reltoken(&vm_token);
2505 }
2506
2507 /*
2508  * Issue an event on a VM page.  Corresponding action structures are
2509  * removed from the page's list and called.
2510  *
2511  * If the vm_page has no more pending action events we clear its
2512  * PG_ACTIONLIST flag.
2513  */
2514 void
2515 vm_page_event_internal(vm_page_t m, vm_page_event_t event)
2516 {
2517         struct vm_page_action_list *list;
2518         struct vm_page_action *scan;
2519         struct vm_page_action *next;
2520         int hv;
2521         int all;
2522
2523         hv = (int)((intptr_t)m >> 8) & VMACTION_HMASK;
2524         list = &action_list[hv];
2525         all = 1;
2526
2527         lwkt_gettoken(&vm_token);
2528         LIST_FOREACH_MUTABLE(scan, list, entry, next) {
2529                 if (scan->m == m) {
2530                         if (scan->event == event) {
2531                                 scan->event = VMEVENT_NONE;
2532                                 LIST_REMOVE(scan, entry);
2533                                 scan->func(m, scan);
2534                                 /* XXX */
2535                         } else {
2536                                 all = 0;
2537                         }
2538                 }
2539         }
2540         if (all)
2541                 vm_page_flag_clear(m, PG_ACTIONLIST);
2542         lwkt_reltoken(&vm_token);
2543 }
2544
2545 #include "opt_ddb.h"
2546 #ifdef DDB
2547 #include <sys/kernel.h>
2548
2549 #include <ddb/ddb.h>
2550
2551 DB_SHOW_COMMAND(page, vm_page_print_page_info)
2552 {
2553         db_printf("vmstats.v_free_count: %d\n", vmstats.v_free_count);
2554         db_printf("vmstats.v_cache_count: %d\n", vmstats.v_cache_count);
2555         db_printf("vmstats.v_inactive_count: %d\n", vmstats.v_inactive_count);
2556         db_printf("vmstats.v_active_count: %d\n", vmstats.v_active_count);
2557         db_printf("vmstats.v_wire_count: %d\n", vmstats.v_wire_count);
2558         db_printf("vmstats.v_free_reserved: %d\n", vmstats.v_free_reserved);
2559         db_printf("vmstats.v_free_min: %d\n", vmstats.v_free_min);
2560         db_printf("vmstats.v_free_target: %d\n", vmstats.v_free_target);
2561         db_printf("vmstats.v_cache_min: %d\n", vmstats.v_cache_min);
2562         db_printf("vmstats.v_inactive_target: %d\n", vmstats.v_inactive_target);
2563 }
2564
2565 DB_SHOW_COMMAND(pageq, vm_page_print_pageq_info)
2566 {
2567         int i;
2568         db_printf("PQ_FREE:");
2569         for(i=0;i<PQ_L2_SIZE;i++) {
2570                 db_printf(" %d", vm_page_queues[PQ_FREE + i].lcnt);
2571         }
2572         db_printf("\n");
2573                 
2574         db_printf("PQ_CACHE:");
2575         for(i=0;i<PQ_L2_SIZE;i++) {
2576                 db_printf(" %d", vm_page_queues[PQ_CACHE + i].lcnt);
2577         }
2578         db_printf("\n");
2579
2580         db_printf("PQ_ACTIVE: %d, PQ_INACTIVE: %d\n",
2581                 vm_page_queues[PQ_ACTIVE].lcnt,
2582                 vm_page_queues[PQ_INACTIVE].lcnt);
2583 }
2584 #endif /* DDB */