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