AMD64 - Fix many compile-time warnings. int/ptr type mismatches, %llx, etc.
[dragonfly.git] / sys / vm / swap_pager.c
1 /*
2  * Copyright (c) 1998,2004 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * Copyright (c) 1994 John S. Dyson
35  * Copyright (c) 1990 University of Utah.
36  * Copyright (c) 1991, 1993
37  *      The Regents of the University of California.  All rights reserved.
38  *
39  * This code is derived from software contributed to Berkeley by
40  * the Systems Programming Group of the University of Utah Computer
41  * Science Department.
42  *
43  * Redistribution and use in source and binary forms, with or without
44  * modification, are permitted provided that the following conditions
45  * are met:
46  * 1. Redistributions of source code must retain the above copyright
47  *    notice, this list of conditions and the following disclaimer.
48  * 2. Redistributions in binary form must reproduce the above copyright
49  *    notice, this list of conditions and the following disclaimer in the
50  *    documentation and/or other materials provided with the distribution.
51  * 3. All advertising materials mentioning features or use of this software
52  *    must display the following acknowledgement:
53  *      This product includes software developed by the University of
54  *      California, Berkeley and its contributors.
55  * 4. Neither the name of the University nor the names of its contributors
56  *    may be used to endorse or promote products derived from this software
57  *    without specific prior written permission.
58  *
59  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69  * SUCH DAMAGE.
70  *
71  *                              New Swap System
72  *                              Matthew Dillon
73  *
74  * Radix Bitmap 'blists'.
75  *
76  *      - The new swapper uses the new radix bitmap code.  This should scale
77  *        to arbitrarily small or arbitrarily large swap spaces and an almost
78  *        arbitrary degree of fragmentation.
79  *
80  * Features:
81  *
82  *      - on the fly reallocation of swap during putpages.  The new system
83  *        does not try to keep previously allocated swap blocks for dirty
84  *        pages.  
85  *
86  *      - on the fly deallocation of swap
87  *
88  *      - No more garbage collection required.  Unnecessarily allocated swap
89  *        blocks only exist for dirty vm_page_t's now and these are already
90  *        cycled (in a high-load system) by the pager.  We also do on-the-fly
91  *        removal of invalidated swap blocks when a page is destroyed
92  *        or renamed.
93  *
94  * from: Utah $Hdr: swap_pager.c 1.4 91/04/30$
95  *
96  *      @(#)swap_pager.c        8.9 (Berkeley) 3/21/94
97  *
98  * $FreeBSD: src/sys/vm/swap_pager.c,v 1.130.2.12 2002/08/31 21:15:55 dillon Exp $
99  * $DragonFly: src/sys/vm/swap_pager.c,v 1.32 2008/07/01 02:02:56 dillon Exp $
100  */
101
102 #include <sys/param.h>
103 #include <sys/systm.h>
104 #include <sys/conf.h>
105 #include <sys/kernel.h>
106 #include <sys/proc.h>
107 #include <sys/buf.h>
108 #include <sys/vnode.h>
109 #include <sys/malloc.h>
110 #include <sys/vmmeter.h>
111 #include <sys/sysctl.h>
112 #include <sys/blist.h>
113 #include <sys/lock.h>
114 #include <sys/thread2.h>
115
116 #ifndef MAX_PAGEOUT_CLUSTER
117 #define MAX_PAGEOUT_CLUSTER 16
118 #endif
119
120 #define SWB_NPAGES      MAX_PAGEOUT_CLUSTER
121
122 #include "opt_swap.h"
123 #include <vm/vm.h>
124 #include <vm/vm_object.h>
125 #include <vm/vm_page.h>
126 #include <vm/vm_pager.h>
127 #include <vm/vm_pageout.h>
128 #include <vm/swap_pager.h>
129 #include <vm/vm_extern.h>
130 #include <vm/vm_zone.h>
131
132 #include <sys/buf2.h>
133 #include <vm/vm_page2.h>
134
135 #define SWM_FREE        0x02    /* free, period                 */
136 #define SWM_POP         0x04    /* pop out                      */
137
138 #define AUTOCHAINDONE   ((struct buf *)(intptr_t)-1)
139
140 /*
141  * vm_swap_size is in page-sized chunks now.  It was DEV_BSIZE'd chunks
142  * in the old system.
143  */
144
145 extern int vm_swap_size;        /* number of free swap blocks, in pages */
146
147 int swap_pager_full;            /* swap space exhaustion (task killing) */
148 static int swap_pager_almost_full; /* swap space exhaustion (w/ hysteresis)*/
149 static int nsw_rcount;          /* free read buffers                    */
150 static int nsw_wcount_sync;     /* limit write buffers / synchronous    */
151 static int nsw_wcount_async;    /* limit write buffers / asynchronous   */
152 static int nsw_wcount_async_max;/* assigned maximum                     */
153 static int nsw_cluster_max;     /* maximum VOP I/O allowed              */
154 static int sw_alloc_interlock;  /* swap pager allocation interlock      */
155
156 struct blist *swapblist;
157 static struct swblock **swhash;
158 static int swhash_mask;
159 static int swap_async_max = 4;  /* maximum in-progress async I/O's      */
160
161 extern struct vnode *swapdev_vp;        /* from vm_swap.c */
162
163 SYSCTL_INT(_vm, OID_AUTO, swap_async_max,
164         CTLFLAG_RW, &swap_async_max, 0, "Maximum running async swap ops");
165
166 /*
167  * "named" and "unnamed" anon region objects.  Try to reduce the overhead
168  * of searching a named list by hashing it just a little.
169  */
170
171 #define NOBJLISTS               8
172
173 #define NOBJLIST(handle)        \
174         (&swap_pager_object_list[((int)(intptr_t)handle >> 4) & (NOBJLISTS-1)])
175
176 static struct pagerlst  swap_pager_object_list[NOBJLISTS];
177 struct pagerlst         swap_pager_un_object_list;
178 vm_zone_t               swap_zone;
179
180 /*
181  * pagerops for OBJT_SWAP - "swap pager".  Some ops are also global procedure
182  * calls hooked from other parts of the VM system and do not appear here.
183  * (see vm/swap_pager.h).
184  */
185
186 static vm_object_t
187                 swap_pager_alloc (void *handle, off_t size,
188                                   vm_prot_t prot, off_t offset);
189 static void     swap_pager_dealloc (vm_object_t object);
190 static int      swap_pager_getpages (vm_object_t, vm_page_t *, int, int);
191 static void     swap_pager_init (void);
192 static void     swap_pager_unswapped (vm_page_t);
193 static void     swap_pager_strategy (vm_object_t, struct bio *);
194 static void     swap_chain_iodone(struct bio *biox);
195
196 struct pagerops swappagerops = {
197         swap_pager_init,        /* early system initialization of pager */
198         swap_pager_alloc,       /* allocate an OBJT_SWAP object         */
199         swap_pager_dealloc,     /* deallocate an OBJT_SWAP object       */
200         swap_pager_getpages,    /* pagein                               */
201         swap_pager_putpages,    /* pageout                              */
202         swap_pager_haspage,     /* get backing store status for page    */
203         swap_pager_unswapped,   /* remove swap related to page          */
204         swap_pager_strategy     /* pager strategy call                  */
205 };
206
207 /*
208  * dmmax is in page-sized chunks with the new swap system.  It was
209  * dev-bsized chunks in the old.  dmmax is always a power of 2.
210  *
211  * swap_*() routines are externally accessible.  swp_*() routines are
212  * internal.
213  */
214
215 int dmmax;
216 static int dmmax_mask;
217 int nswap_lowat = 128;          /* in pages, swap_pager_almost_full warn */
218 int nswap_hiwat = 512;          /* in pages, swap_pager_almost_full warn */
219
220 static __inline void    swp_sizecheck (void);
221 static void     swp_pager_sync_iodone (struct bio *bio);
222 static void     swp_pager_async_iodone (struct bio *bio);
223
224 /*
225  * Swap bitmap functions
226  */
227
228 static __inline void    swp_pager_freeswapspace (daddr_t blk, int npages);
229 static __inline daddr_t swp_pager_getswapspace (int npages);
230
231 /*
232  * Metadata functions
233  */
234
235 static void swp_pager_meta_build (vm_object_t, vm_pindex_t, daddr_t);
236 static void swp_pager_meta_free (vm_object_t, vm_pindex_t, daddr_t);
237 static void swp_pager_meta_free_all (vm_object_t);
238 static daddr_t swp_pager_meta_ctl (vm_object_t, vm_pindex_t, int);
239
240 /*
241  * SWP_SIZECHECK() -    update swap_pager_full indication
242  *      
243  *      update the swap_pager_almost_full indication and warn when we are
244  *      about to run out of swap space, using lowat/hiwat hysteresis.
245  *
246  *      Clear swap_pager_full ( task killing ) indication when lowat is met.
247  *
248  *      No restrictions on call
249  *      This routine may not block.
250  *      This routine must be called at splvm()
251  */
252
253 static __inline void
254 swp_sizecheck(void)
255 {
256         if (vm_swap_size < nswap_lowat) {
257                 if (swap_pager_almost_full == 0) {
258                         kprintf("swap_pager: out of swap space\n");
259                         swap_pager_almost_full = 1;
260                 }
261         } else {
262                 swap_pager_full = 0;
263                 if (vm_swap_size > nswap_hiwat)
264                         swap_pager_almost_full = 0;
265         }
266 }
267
268 /*
269  * SWAP_PAGER_INIT() -  initialize the swap pager!
270  *
271  *      Expected to be started from system init.  NOTE:  This code is run 
272  *      before much else so be careful what you depend on.  Most of the VM
273  *      system has yet to be initialized at this point.
274  */
275
276 static void
277 swap_pager_init(void)
278 {
279         /*
280          * Initialize object lists
281          */
282         int i;
283
284         for (i = 0; i < NOBJLISTS; ++i)
285                 TAILQ_INIT(&swap_pager_object_list[i]);
286         TAILQ_INIT(&swap_pager_un_object_list);
287
288         /*
289          * Device Stripe, in PAGE_SIZE'd blocks
290          */
291
292         dmmax = SWB_NPAGES * 2;
293         dmmax_mask = ~(dmmax - 1);
294 }
295
296 /*
297  * SWAP_PAGER_SWAP_INIT() - swap pager initialization from pageout process
298  *
299  *      Expected to be started from pageout process once, prior to entering
300  *      its main loop.
301  */
302
303 void
304 swap_pager_swap_init(void)
305 {
306         int n, n2;
307
308         /*
309          * Number of in-transit swap bp operations.  Don't
310          * exhaust the pbufs completely.  Make sure we
311          * initialize workable values (0 will work for hysteresis
312          * but it isn't very efficient).
313          *
314          * The nsw_cluster_max is constrained by the number of pages an XIO
315          * holds, i.e., (MAXPHYS/PAGE_SIZE) and our locally defined
316          * MAX_PAGEOUT_CLUSTER.   Also be aware that swap ops are
317          * constrained by the swap device interleave stripe size.
318          *
319          * Currently we hardwire nsw_wcount_async to 4.  This limit is 
320          * designed to prevent other I/O from having high latencies due to
321          * our pageout I/O.  The value 4 works well for one or two active swap
322          * devices but is probably a little low if you have more.  Even so,
323          * a higher value would probably generate only a limited improvement
324          * with three or four active swap devices since the system does not
325          * typically have to pageout at extreme bandwidths.   We will want
326          * at least 2 per swap devices, and 4 is a pretty good value if you
327          * have one NFS swap device due to the command/ack latency over NFS.
328          * So it all works out pretty well.
329          */
330
331         nsw_cluster_max = min((MAXPHYS/PAGE_SIZE), MAX_PAGEOUT_CLUSTER);
332
333         nsw_rcount = (nswbuf + 1) / 2;
334         nsw_wcount_sync = (nswbuf + 3) / 4;
335         nsw_wcount_async = 4;
336         nsw_wcount_async_max = nsw_wcount_async;
337
338         /*
339          * Initialize our zone.  Right now I'm just guessing on the number
340          * we need based on the number of pages in the system.  Each swblock
341          * can hold 16 pages, so this is probably overkill.  This reservation
342          * is typically limited to around 32MB by default.
343          */
344         n = vmstats.v_page_count / 2;
345         if (maxswzone && n > maxswzone / sizeof(struct swblock))
346                 n = maxswzone / sizeof(struct swblock);
347         n2 = n;
348
349         do {
350                 swap_zone = zinit(
351                         "SWAPMETA", 
352                         sizeof(struct swblock), 
353                         n,
354                         ZONE_INTERRUPT, 
355                         1);
356                 if (swap_zone != NULL)
357                         break;
358                 /*
359                  * if the allocation failed, try a zone two thirds the
360                  * size of the previous attempt.
361                  */
362                 n -= ((n + 2) / 3);
363         } while (n > 0);
364
365         if (swap_zone == NULL)
366                 panic("swap_pager_swap_init: swap_zone == NULL");
367         if (n2 != n)
368                 kprintf("Swap zone entries reduced from %d to %d.\n", n2, n);
369         n2 = n;
370
371         /*
372          * Initialize our meta-data hash table.  The swapper does not need to
373          * be quite as efficient as the VM system, so we do not use an 
374          * oversized hash table.
375          *
376          *      n:              size of hash table, must be power of 2
377          *      swhash_mask:    hash table index mask
378          */
379
380         for (n = 1; n < n2 / 8; n *= 2)
381                 ;
382
383         swhash = kmalloc(sizeof(struct swblock *) * n, M_VMPGDATA,
384             M_WAITOK | M_ZERO);
385
386         swhash_mask = n - 1;
387 }
388
389 /*
390  * SWAP_PAGER_ALLOC() - allocate a new OBJT_SWAP VM object and instantiate
391  *                      its metadata structures.
392  *
393  *      This routine is called from the mmap and fork code to create a new
394  *      OBJT_SWAP object.  We do this by creating an OBJT_DEFAULT object
395  *      and then converting it with swp_pager_meta_build().
396  *
397  *      This routine may block in vm_object_allocate() and create a named
398  *      object lookup race, so we must interlock.   We must also run at
399  *      splvm() for the object lookup to handle races with interrupts, but
400  *      we do not have to maintain splvm() in between the lookup and the
401  *      add because (I believe) it is not possible to attempt to create
402  *      a new swap object w/handle when a default object with that handle
403  *      already exists.
404  */
405
406 static vm_object_t
407 swap_pager_alloc(void *handle, off_t size, vm_prot_t prot, off_t offset)
408 {
409         vm_object_t object;
410
411         if (handle) {
412                 /*
413                  * Reference existing named region or allocate new one.  There
414                  * should not be a race here against swp_pager_meta_build()
415                  * as called from vm_page_remove() in regards to the lookup
416                  * of the handle.
417                  */
418
419                 while (sw_alloc_interlock) {
420                         sw_alloc_interlock = -1;
421                         tsleep(&sw_alloc_interlock, 0, "swpalc", 0);
422                 }
423                 sw_alloc_interlock = 1;
424
425                 object = vm_pager_object_lookup(NOBJLIST(handle), handle);
426
427                 if (object != NULL) {
428                         vm_object_reference(object);
429                 } else {
430                         object = vm_object_allocate(OBJT_DEFAULT,
431                                 OFF_TO_IDX(offset + PAGE_MASK + size));
432                         object->handle = handle;
433
434                         swp_pager_meta_build(object, 0, SWAPBLK_NONE);
435                 }
436
437                 if (sw_alloc_interlock < 0)
438                         wakeup(&sw_alloc_interlock);
439
440                 sw_alloc_interlock = 0;
441         } else {
442                 object = vm_object_allocate(OBJT_DEFAULT,
443                         OFF_TO_IDX(offset + PAGE_MASK + size));
444
445                 swp_pager_meta_build(object, 0, SWAPBLK_NONE);
446         }
447
448         return (object);
449 }
450
451 /*
452  * SWAP_PAGER_DEALLOC() -       remove swap metadata from object
453  *
454  *      The swap backing for the object is destroyed.  The code is 
455  *      designed such that we can reinstantiate it later, but this
456  *      routine is typically called only when the entire object is
457  *      about to be destroyed.
458  *
459  *      This routine may block, but no longer does. 
460  *
461  *      The object must be locked or unreferenceable.
462  */
463
464 static void
465 swap_pager_dealloc(vm_object_t object)
466 {
467         /*
468          * Remove from list right away so lookups will fail if we block for
469          * pageout completion.
470          */
471
472         if (object->handle == NULL) {
473                 TAILQ_REMOVE(&swap_pager_un_object_list, object, pager_object_list);
474         } else {
475                 TAILQ_REMOVE(NOBJLIST(object->handle), object, pager_object_list);
476         }
477
478         vm_object_pip_wait(object, "swpdea");
479
480         /*
481          * Free all remaining metadata.  We only bother to free it from 
482          * the swap meta data.  We do not attempt to free swapblk's still
483          * associated with vm_page_t's for this object.  We do not care
484          * if paging is still in progress on some objects.
485          */
486         crit_enter();
487         swp_pager_meta_free_all(object);
488         crit_exit();
489 }
490
491 /************************************************************************
492  *                      SWAP PAGER BITMAP ROUTINES                      *
493  ************************************************************************/
494
495 /*
496  * SWP_PAGER_GETSWAPSPACE() -   allocate raw swap space
497  *
498  *      Allocate swap for the requested number of pages.  The starting
499  *      swap block number (a page index) is returned or SWAPBLK_NONE
500  *      if the allocation failed.
501  *
502  *      Also has the side effect of advising that somebody made a mistake
503  *      when they configured swap and didn't configure enough.
504  *
505  *      Must be called at splvm() to avoid races with bitmap frees from
506  *      vm_page_remove() aka swap_pager_page_removed().
507  *
508  *      This routine may not block
509  *      This routine must be called at splvm().
510  */
511
512 static __inline daddr_t
513 swp_pager_getswapspace(int npages)
514 {
515         daddr_t blk;
516
517         if ((blk = blist_alloc(swapblist, npages)) == SWAPBLK_NONE) {
518                 if (swap_pager_full != 2) {
519                         kprintf("swap_pager_getswapspace: failed\n");
520                         swap_pager_full = 2;
521                         swap_pager_almost_full = 1;
522                 }
523         } else {
524                 vm_swap_size -= npages;
525                 swp_sizecheck();
526         }
527         return(blk);
528 }
529
530 /*
531  * SWP_PAGER_FREESWAPSPACE() -  free raw swap space 
532  *
533  *      This routine returns the specified swap blocks back to the bitmap.
534  *
535  *      Note:  This routine may not block (it could in the old swap code),
536  *      and through the use of the new blist routines it does not block.
537  *
538  *      We must be called at splvm() to avoid races with bitmap frees from
539  *      vm_page_remove() aka swap_pager_page_removed().
540  *
541  *      This routine may not block
542  *      This routine must be called at splvm().
543  */
544
545 static __inline void
546 swp_pager_freeswapspace(daddr_t blk, int npages)
547 {
548         blist_free(swapblist, blk, npages);
549         vm_swap_size += npages;
550         swp_sizecheck();
551 }
552
553 /*
554  * SWAP_PAGER_FREESPACE() -     frees swap blocks associated with a page
555  *                              range within an object.
556  *
557  *      This is a globally accessible routine.
558  *
559  *      This routine removes swapblk assignments from swap metadata.
560  *
561  *      The external callers of this routine typically have already destroyed 
562  *      or renamed vm_page_t's associated with this range in the object so 
563  *      we should be ok.
564  *
565  *      This routine may be called at any spl.  We up our spl to splvm temporarily
566  *      in order to perform the metadata removal.
567  */
568
569 void
570 swap_pager_freespace(vm_object_t object, vm_pindex_t start, vm_size_t size)
571 {
572         crit_enter();
573         swp_pager_meta_free(object, start, size);
574         crit_exit();
575 }
576
577 /*
578  * SWAP_PAGER_RESERVE() - reserve swap blocks in object
579  *
580  *      Assigns swap blocks to the specified range within the object.  The 
581  *      swap blocks are not zerod.  Any previous swap assignment is destroyed.
582  *
583  *      Returns 0 on success, -1 on failure.
584  */
585
586 int
587 swap_pager_reserve(vm_object_t object, vm_pindex_t start, vm_size_t size)
588 {
589         int n = 0;
590         daddr_t blk = SWAPBLK_NONE;
591         vm_pindex_t beg = start;        /* save start index */
592
593         crit_enter();
594         while (size) {
595                 if (n == 0) {
596                         n = BLIST_MAX_ALLOC;
597                         while ((blk = swp_pager_getswapspace(n)) == SWAPBLK_NONE) {
598                                 n >>= 1;
599                                 if (n == 0) {
600                                         swp_pager_meta_free(object, beg, start - beg);
601                                         crit_exit();
602                                         return(-1);
603                                 }
604                         }
605                 }
606                 swp_pager_meta_build(object, start, blk);
607                 --size;
608                 ++start;
609                 ++blk;
610                 --n;
611         }
612         swp_pager_meta_free(object, start, n);
613         crit_exit();
614         return(0);
615 }
616
617 /*
618  * SWAP_PAGER_COPY() -  copy blocks from source pager to destination pager
619  *                      and destroy the source.
620  *
621  *      Copy any valid swapblks from the source to the destination.  In
622  *      cases where both the source and destination have a valid swapblk,
623  *      we keep the destination's.
624  *
625  *      This routine is allowed to block.  It may block allocating metadata
626  *      indirectly through swp_pager_meta_build() or if paging is still in
627  *      progress on the source. 
628  *
629  *      This routine can be called at any spl
630  *
631  *      XXX vm_page_collapse() kinda expects us not to block because we 
632  *      supposedly do not need to allocate memory, but for the moment we
633  *      *may* have to get a little memory from the zone allocator, but
634  *      it is taken from the interrupt memory.  We should be ok. 
635  *
636  *      The source object contains no vm_page_t's (which is just as well)
637  *
638  *      The source object is of type OBJT_SWAP.
639  *
640  *      The source and destination objects must be locked or 
641  *      inaccessible (XXX are they ?)
642  */
643
644 void
645 swap_pager_copy(vm_object_t srcobject, vm_object_t dstobject,
646     vm_pindex_t offset, int destroysource)
647 {
648         vm_pindex_t i;
649
650         crit_enter();
651
652         /*
653          * If destroysource is set, we remove the source object from the 
654          * swap_pager internal queue now. 
655          */
656
657         if (destroysource) {
658                 if (srcobject->handle == NULL) {
659                         TAILQ_REMOVE(
660                             &swap_pager_un_object_list, 
661                             srcobject, 
662                             pager_object_list
663                         );
664                 } else {
665                         TAILQ_REMOVE(
666                             NOBJLIST(srcobject->handle),
667                             srcobject,
668                             pager_object_list
669                         );
670                 }
671         }
672
673         /*
674          * transfer source to destination.
675          */
676
677         for (i = 0; i < dstobject->size; ++i) {
678                 daddr_t dstaddr;
679
680                 /*
681                  * Locate (without changing) the swapblk on the destination,
682                  * unless it is invalid in which case free it silently, or
683                  * if the destination is a resident page, in which case the
684                  * source is thrown away.
685                  */
686
687                 dstaddr = swp_pager_meta_ctl(dstobject, i, 0);
688
689                 if (dstaddr == SWAPBLK_NONE) {
690                         /*
691                          * Destination has no swapblk and is not resident,
692                          * copy source.
693                          */
694                         daddr_t srcaddr;
695
696                         srcaddr = swp_pager_meta_ctl(
697                             srcobject, 
698                             i + offset,
699                             SWM_POP
700                         );
701
702                         if (srcaddr != SWAPBLK_NONE)
703                                 swp_pager_meta_build(dstobject, i, srcaddr);
704                 } else {
705                         /*
706                          * Destination has valid swapblk or it is represented
707                          * by a resident page.  We destroy the sourceblock.
708                          */
709                         
710                         swp_pager_meta_ctl(srcobject, i + offset, SWM_FREE);
711                 }
712         }
713
714         /*
715          * Free left over swap blocks in source.
716          *
717          * We have to revert the type to OBJT_DEFAULT so we do not accidently
718          * double-remove the object from the swap queues.
719          */
720
721         if (destroysource) {
722                 swp_pager_meta_free_all(srcobject);
723                 /*
724                  * Reverting the type is not necessary, the caller is going
725                  * to destroy srcobject directly, but I'm doing it here
726                  * for consistency since we've removed the object from its
727                  * queues.
728                  */
729                 srcobject->type = OBJT_DEFAULT;
730         }
731         crit_exit();
732 }
733
734 /*
735  * SWAP_PAGER_HASPAGE() -       determine if we have good backing store for
736  *                              the requested page.
737  *
738  *      We determine whether good backing store exists for the requested
739  *      page and return TRUE if it does, FALSE if it doesn't.
740  *
741  *      If TRUE, we also try to determine how much valid, contiguous backing
742  *      store exists before and after the requested page within a reasonable
743  *      distance.  We do not try to restrict it to the swap device stripe
744  *      (that is handled in getpages/putpages).  It probably isn't worth
745  *      doing here.
746  */
747
748 boolean_t
749 swap_pager_haspage(vm_object_t object, vm_pindex_t pindex, int *before,
750     int *after)
751 {
752         daddr_t blk0;
753
754         /*
755          * do we have good backing store at the requested index ?
756          */
757
758         crit_enter();
759         blk0 = swp_pager_meta_ctl(object, pindex, 0);
760
761         if (blk0 == SWAPBLK_NONE) {
762                 crit_exit();
763                 if (before)
764                         *before = 0;
765                 if (after)
766                         *after = 0;
767                 return (FALSE);
768         }
769
770         /*
771          * find backwards-looking contiguous good backing store
772          */
773
774         if (before != NULL) {
775                 int i;
776
777                 for (i = 1; i < (SWB_NPAGES/2); ++i) {
778                         daddr_t blk;
779
780                         if (i > pindex)
781                                 break;
782                         blk = swp_pager_meta_ctl(object, pindex - i, 0);
783                         if (blk != blk0 - i)
784                                 break;
785                 }
786                 *before = (i - 1);
787         }
788
789         /*
790          * find forward-looking contiguous good backing store
791          */
792
793         if (after != NULL) {
794                 int i;
795
796                 for (i = 1; i < (SWB_NPAGES/2); ++i) {
797                         daddr_t blk;
798
799                         blk = swp_pager_meta_ctl(object, pindex + i, 0);
800                         if (blk != blk0 + i)
801                                 break;
802                 }
803                 *after = (i - 1);
804         }
805         crit_exit();
806         return (TRUE);
807 }
808
809 /*
810  * SWAP_PAGER_PAGE_UNSWAPPED() - remove swap backing store related to page
811  *
812  *      This removes any associated swap backing store, whether valid or
813  *      not, from the page.  
814  *
815  *      This routine is typically called when a page is made dirty, at
816  *      which point any associated swap can be freed.  MADV_FREE also
817  *      calls us in a special-case situation
818  *
819  *      NOTE!!!  If the page is clean and the swap was valid, the caller
820  *      should make the page dirty before calling this routine.  This routine
821  *      does NOT change the m->dirty status of the page.  Also: MADV_FREE
822  *      depends on it.
823  *
824  *      This routine may not block
825  *      This routine must be called at splvm()
826  */
827
828 static void
829 swap_pager_unswapped(vm_page_t m)
830 {
831         swp_pager_meta_ctl(m->object, m->pindex, SWM_FREE);
832 }
833
834 /*
835  * SWAP_PAGER_STRATEGY() - read, write, free blocks
836  *
837  *      This implements the vm_pager_strategy() interface to swap and allows
838  *      other parts of the system to directly access swap as backing store
839  *      through vm_objects of type OBJT_SWAP.  This is intended to be a 
840  *      cacheless interface ( i.e. caching occurs at higher levels ).
841  *      Therefore we do not maintain any resident pages.  All I/O goes
842  *      directly to and from the swap device.
843  *      
844  *      We currently attempt to run I/O synchronously or asynchronously as
845  *      the caller requests.  This isn't perfect because we loose error
846  *      sequencing when we run multiple ops in parallel to satisfy a request.
847  *      But this is swap, so we let it all hang out.
848  */
849
850 static void     
851 swap_pager_strategy(vm_object_t object, struct bio *bio)
852 {
853         struct buf *bp = bio->bio_buf;
854         struct bio *nbio;
855         vm_pindex_t start;
856         vm_pindex_t biox_blkno = 0;
857         int count;
858         char *data;
859         struct bio *biox = NULL;
860         struct buf *bufx = NULL;
861         struct bio_track *track;
862
863         /*
864          * tracking for swapdev vnode I/Os
865          */
866         if (bp->b_cmd == BUF_CMD_READ)
867                 track = &swapdev_vp->v_track_read;
868         else
869                 track = &swapdev_vp->v_track_write;
870
871         if (bp->b_bcount & PAGE_MASK) {
872                 bp->b_error = EINVAL;
873                 bp->b_flags |= B_ERROR | B_INVAL;
874                 biodone(bio);
875                 kprintf("swap_pager_strategy: bp %p offset %lld size %d, "
876                         "not page bounded\n",
877                         bp, (long long)bio->bio_offset, (int)bp->b_bcount);
878                 return;
879         }
880
881         /*
882          * Clear error indication, initialize page index, count, data pointer.
883          */
884         bp->b_error = 0;
885         bp->b_flags &= ~B_ERROR;
886         bp->b_resid = bp->b_bcount;
887
888         start = (vm_pindex_t)(bio->bio_offset >> PAGE_SHIFT);
889         count = howmany(bp->b_bcount, PAGE_SIZE);
890         data = bp->b_data;
891
892         crit_enter();
893
894         /*
895          * Deal with BUF_CMD_FREEBLKS
896          */
897         if (bp->b_cmd == BUF_CMD_FREEBLKS) {
898                 /*
899                  * FREE PAGE(s) - destroy underlying swap that is no longer
900                  *                needed.
901                  */
902                 swp_pager_meta_free(object, start, count);
903                 crit_exit();
904                 bp->b_resid = 0;
905                 biodone(bio);
906                 return;
907         }
908
909         /*
910          * We need to be able to create a new cluster of I/O's.  We cannot
911          * use the caller fields of the passed bio so push a new one.
912          *
913          * Because nbio is just a placeholder for the cluster links,
914          * we can biodone() the original bio instead of nbio to make
915          * things a bit more efficient.
916          */
917         nbio = push_bio(bio);
918         nbio->bio_offset = bio->bio_offset;
919         nbio->bio_caller_info1.cluster_head = NULL;
920         nbio->bio_caller_info2.cluster_tail = NULL;
921
922         /*
923          * Execute read or write
924          */
925
926         while (count > 0) {
927                 daddr_t blk;
928
929                 /*
930                  * Obtain block.  If block not found and writing, allocate a
931                  * new block and build it into the object.
932                  */
933
934                 blk = swp_pager_meta_ctl(object, start, 0);
935                 if ((blk == SWAPBLK_NONE) && bp->b_cmd != BUF_CMD_READ) {
936                         blk = swp_pager_getswapspace(1);
937                         if (blk == SWAPBLK_NONE) {
938                                 bp->b_error = ENOMEM;
939                                 bp->b_flags |= B_ERROR;
940                                 break;
941                         }
942                         swp_pager_meta_build(object, start, blk);
943                 }
944                         
945                 /*
946                  * Do we have to flush our current collection?  Yes if:
947                  *
948                  *      - no swap block at this index
949                  *      - swap block is not contiguous
950                  *      - we cross a physical disk boundry in the
951                  *        stripe.
952                  */
953
954                 if (
955                     biox && (biox_blkno + btoc(bufx->b_bcount) != blk ||
956                      ((biox_blkno ^ blk) & dmmax_mask)
957                     )
958                 ) {
959                         crit_exit();
960                         if (bp->b_cmd == BUF_CMD_READ) {
961                                 ++mycpu->gd_cnt.v_swapin;
962                                 mycpu->gd_cnt.v_swappgsin += btoc(bufx->b_bcount);
963                         } else {
964                                 ++mycpu->gd_cnt.v_swapout;
965                                 mycpu->gd_cnt.v_swappgsout += btoc(bufx->b_bcount);
966                                 bufx->b_dirtyend = bufx->b_bcount;
967                         }
968
969                         /*
970                          * Flush the biox to the swap device.
971                          */
972                         if (bufx->b_bcount) {
973                                 if (bufx->b_cmd != BUF_CMD_READ)
974                                         bufx->b_dirtyend = bufx->b_bcount;
975                                 BUF_KERNPROC(bufx);
976                                 vn_strategy(swapdev_vp, biox);
977                         } else {
978                                 biodone(biox);
979                         }
980                         crit_enter();
981                         biox = NULL;
982                         bufx = NULL;
983                 }
984
985                 /*
986                  * Add new swapblk to biox, instantiating biox if necessary.
987                  * Zero-fill reads are able to take a shortcut.
988                  */
989                 if (blk == SWAPBLK_NONE) {
990                         /*
991                          * We can only get here if we are reading.  Since
992                          * we are at splvm() we can safely modify b_resid,
993                          * even if chain ops are in progress.
994                          */
995                         bzero(data, PAGE_SIZE);
996                         bp->b_resid -= PAGE_SIZE;
997                 } else {
998                         if (biox == NULL) {
999                                 /* XXX chain count > 4, wait to <= 4 */
1000
1001                                 bufx = getpbuf(NULL);
1002                                 biox = &bufx->b_bio1;
1003                                 cluster_append(nbio, bufx);
1004                                 bufx->b_flags |= (bufx->b_flags & B_ORDERED) |
1005                                                 B_ASYNC;
1006                                 bufx->b_cmd = bp->b_cmd;
1007                                 biox->bio_done = swap_chain_iodone;
1008                                 biox->bio_offset = (off_t)blk << PAGE_SHIFT;
1009                                 biox->bio_caller_info1.cluster_parent = nbio;
1010                                 biox_blkno = blk;
1011                                 bufx->b_bcount = 0;
1012                                 bufx->b_data = data;
1013                         }
1014                         bufx->b_bcount += PAGE_SIZE;
1015                 }
1016                 --count;
1017                 ++start;
1018                 data += PAGE_SIZE;
1019         }
1020
1021         /*
1022          *  Flush out last buffer
1023          */
1024         crit_exit();
1025
1026         if (biox) {
1027                 if ((bp->b_flags & B_ASYNC) == 0)
1028                         bufx->b_flags &= ~B_ASYNC;
1029                 if (bufx->b_cmd == BUF_CMD_READ) {
1030                         ++mycpu->gd_cnt.v_swapin;
1031                         mycpu->gd_cnt.v_swappgsin += btoc(bufx->b_bcount);
1032                 } else {
1033                         ++mycpu->gd_cnt.v_swapout;
1034                         mycpu->gd_cnt.v_swappgsout += btoc(bufx->b_bcount);
1035                         bufx->b_dirtyend = bufx->b_bcount;
1036                 }
1037                 if (bufx->b_bcount) {
1038                         if (bufx->b_cmd != BUF_CMD_READ)
1039                                 bufx->b_dirtyend = bufx->b_bcount;
1040                         BUF_KERNPROC(bufx);
1041                         vn_strategy(swapdev_vp, biox);
1042                 } else {
1043                         biodone(biox);
1044                 }
1045                 /* biox, bufx = NULL */
1046         }
1047
1048         /*
1049          * Wait for completion.  Now that we are no longer using
1050          * cluster_append, use the cluster_tail field to indicate
1051          * auto-completion if there are still I/O's in progress.
1052          */
1053         if (bp->b_flags & B_ASYNC) {
1054                 crit_enter();
1055                 if (nbio->bio_caller_info1.cluster_head == NULL) {
1056                         biodone(bio);
1057                 } else {
1058                         nbio->bio_caller_info2.cluster_tail = AUTOCHAINDONE;
1059                 }
1060                 crit_exit();
1061         } else {
1062                 crit_enter();
1063                 while (nbio->bio_caller_info1.cluster_head != NULL) {
1064                         bp->b_flags |= B_WANT;
1065                         tsleep(bp, 0, "bpchain", 0);
1066                 }
1067                 if (bp->b_resid != 0 && !(bp->b_flags & B_ERROR)) {
1068                         bp->b_flags |= B_ERROR;
1069                         bp->b_error = EINVAL;
1070                 }
1071                 biodone(bio);
1072                 crit_exit();
1073         }
1074 }
1075
1076 static void
1077 swap_chain_iodone(struct bio *biox)
1078 {
1079         struct buf **nextp;
1080         struct buf *bufx;       /* chained sub-buffer */
1081         struct bio *nbio;       /* parent nbio with chain glue */
1082         struct buf *bp;         /* original bp associated with nbio */
1083
1084         bufx = biox->bio_buf;
1085         nbio = biox->bio_caller_info1.cluster_parent;
1086         bp = nbio->bio_buf;
1087
1088         /*
1089          * Update the original buffer
1090          */
1091         KKASSERT(bp != NULL);
1092         if (bufx->b_flags & B_ERROR) {
1093                 bp->b_flags |= B_ERROR;
1094                 bp->b_error = bufx->b_error;
1095         } else if (bufx->b_resid != 0) {
1096                 bp->b_flags |= B_ERROR;
1097                 bp->b_error = EINVAL;
1098         } else {
1099                 bp->b_resid -= bufx->b_bcount;
1100         }
1101
1102         /*
1103          * Remove us from the chain.  It is sufficient to clean up 
1104          * cluster_head.  Once the chain is operational cluster_tail
1105          * may be used to indicate AUTOCHAINDONE.  Note that I/O's
1106          * can complete while the swap system is still appending new
1107          * BIOs to the chain.
1108          */
1109         nextp = &nbio->bio_caller_info1.cluster_head;
1110         while (*nextp != bufx) {
1111                 KKASSERT(*nextp != NULL);
1112                 nextp = &(*nextp)->b_cluster_next;
1113         }
1114         *nextp = bufx->b_cluster_next;
1115         if (bp->b_flags & B_WANT) {
1116                 bp->b_flags &= ~B_WANT;
1117                 wakeup(bp);
1118         }
1119
1120         /*
1121          * Clean up bufx.  If this was the last buffer in the chain
1122          * and AUTOCHAINDONE was set, finish off the original I/O
1123          * as well.
1124          *
1125          * nbio was just a fake BIO layer to hold the cluster links,
1126          * we can issue the biodone() on the layer above it.
1127          */
1128         if (nbio->bio_caller_info1.cluster_head == NULL &&
1129             nbio->bio_caller_info2.cluster_tail == AUTOCHAINDONE
1130         ) {
1131                 nbio->bio_caller_info2.cluster_tail = NULL;
1132                 if (bp->b_resid != 0 && !(bp->b_flags & B_ERROR)) {
1133                         bp->b_flags |= B_ERROR;
1134                         bp->b_error = EINVAL;
1135                 }
1136                 biodone(nbio->bio_prev);
1137         }
1138         bufx->b_flags &= ~B_ASYNC;
1139         relpbuf(bufx, NULL);
1140 }
1141
1142 /*
1143  * SWAP_PAGER_GETPAGES() - bring pages in from swap
1144  *
1145  *      Attempt to retrieve (m, count) pages from backing store, but make
1146  *      sure we retrieve at least m[reqpage].  We try to load in as large
1147  *      a chunk surrounding m[reqpage] as is contiguous in swap and which
1148  *      belongs to the same object.
1149  *
1150  *      The code is designed for asynchronous operation and 
1151  *      immediate-notification of 'reqpage' but tends not to be
1152  *      used that way.  Please do not optimize-out this algorithmic
1153  *      feature, I intend to improve on it in the future.
1154  *
1155  *      The parent has a single vm_object_pip_add() reference prior to
1156  *      calling us and we should return with the same.
1157  *
1158  *      The parent has BUSY'd the pages.  We should return with 'm'
1159  *      left busy, but the others adjusted.
1160  */
1161
1162 static int
1163 swap_pager_getpages(vm_object_t object, vm_page_t *m, int count, int reqpage)
1164 {
1165         struct buf *bp;
1166         struct bio *bio;
1167         vm_page_t mreq;
1168         int i;
1169         int j;
1170         daddr_t blk;
1171         vm_offset_t kva;
1172         vm_pindex_t lastpindex;
1173
1174         mreq = m[reqpage];
1175
1176         if (mreq->object != object) {
1177                 panic("swap_pager_getpages: object mismatch %p/%p", 
1178                     object, 
1179                     mreq->object
1180                 );
1181         }
1182
1183         /*
1184          * Calculate range to retrieve.  The pages have already been assigned
1185          * their swapblks.  We require a *contiguous* range that falls entirely
1186          * within a single device stripe.   If we do not supply it, bad things
1187          * happen.  Note that blk, iblk & jblk can be SWAPBLK_NONE, but the 
1188          * loops are set up such that the case(s) are handled implicitly.
1189          *
1190          * The swp_*() calls must be made at splvm().  vm_page_free() does
1191          * not need to be, but it will go a little faster if it is.
1192          */
1193         crit_enter();
1194         blk = swp_pager_meta_ctl(mreq->object, mreq->pindex, 0);
1195
1196         for (i = reqpage - 1; i >= 0; --i) {
1197                 daddr_t iblk;
1198
1199                 iblk = swp_pager_meta_ctl(m[i]->object, m[i]->pindex, 0);
1200                 if (blk != iblk + (reqpage - i))
1201                         break;
1202                 if ((blk ^ iblk) & dmmax_mask)
1203                         break;
1204         }
1205         ++i;
1206
1207         for (j = reqpage + 1; j < count; ++j) {
1208                 daddr_t jblk;
1209
1210                 jblk = swp_pager_meta_ctl(m[j]->object, m[j]->pindex, 0);
1211                 if (blk != jblk - (j - reqpage))
1212                         break;
1213                 if ((blk ^ jblk) & dmmax_mask)
1214                         break;
1215         }
1216
1217         /*
1218          * free pages outside our collection range.   Note: we never free
1219          * mreq, it must remain busy throughout.
1220          */
1221
1222         {
1223                 int k;
1224
1225                 for (k = 0; k < i; ++k)
1226                         vm_page_free(m[k]);
1227                 for (k = j; k < count; ++k)
1228                         vm_page_free(m[k]);
1229         }
1230         crit_exit();
1231
1232
1233         /*
1234          * Return VM_PAGER_FAIL if we have nothing to do.  Return mreq 
1235          * still busy, but the others unbusied.
1236          */
1237
1238         if (blk == SWAPBLK_NONE)
1239                 return(VM_PAGER_FAIL);
1240
1241         /*
1242          * Get a swap buffer header to perform the IO
1243          */
1244
1245         bp = getpbuf(&nsw_rcount);
1246         bio = &bp->b_bio1;
1247         kva = (vm_offset_t) bp->b_data;
1248
1249         /*
1250          * map our page(s) into kva for input
1251          */
1252
1253         pmap_qenter(kva, m + i, j - i);
1254
1255         bp->b_data = (caddr_t) kva;
1256         bp->b_bcount = PAGE_SIZE * (j - i);
1257         bio->bio_done = swp_pager_async_iodone;
1258         bio->bio_offset = (off_t)(blk - (reqpage - i)) << PAGE_SHIFT;
1259         bio->bio_driver_info = (void *)(intptr_t)(reqpage - i);
1260
1261         {
1262                 int k;
1263
1264                 for (k = i; k < j; ++k) {
1265                         bp->b_xio.xio_pages[k - i] = m[k];
1266                         vm_page_flag_set(m[k], PG_SWAPINPROG);
1267                 }
1268         }
1269         bp->b_xio.xio_npages = j - i;
1270
1271         mycpu->gd_cnt.v_swapin++;
1272         mycpu->gd_cnt.v_swappgsin += bp->b_xio.xio_npages;
1273
1274         /*
1275          * We still hold the lock on mreq, and our automatic completion routine
1276          * does not remove it.
1277          */
1278
1279         vm_object_pip_add(mreq->object, bp->b_xio.xio_npages);
1280         lastpindex = m[j-1]->pindex;
1281
1282         /*
1283          * perform the I/O.  NOTE!!!  bp cannot be considered valid after
1284          * this point because we automatically release it on completion.
1285          * Instead, we look at the one page we are interested in which we
1286          * still hold a lock on even through the I/O completion.
1287          *
1288          * The other pages in our m[] array are also released on completion,
1289          * so we cannot assume they are valid anymore either.
1290          */
1291
1292         bp->b_cmd = BUF_CMD_READ;
1293         BUF_KERNPROC(bp);
1294         vn_strategy(swapdev_vp, bio);
1295
1296         /*
1297          * wait for the page we want to complete.  PG_SWAPINPROG is always
1298          * cleared on completion.  If an I/O error occurs, SWAPBLK_NONE
1299          * is set in the meta-data.
1300          */
1301
1302         crit_enter();
1303
1304         while ((mreq->flags & PG_SWAPINPROG) != 0) {
1305                 vm_page_flag_set(mreq, PG_WANTED | PG_REFERENCED);
1306                 mycpu->gd_cnt.v_intrans++;
1307                 if (tsleep(mreq, 0, "swread", hz*20)) {
1308                         kprintf(
1309                             "swap_pager: indefinite wait buffer: "
1310                                 " offset: %lld, size: %ld\n",
1311                             (long long)bio->bio_offset,
1312                             (long)bp->b_bcount
1313                         );
1314                 }
1315         }
1316
1317         crit_exit();
1318
1319         /*
1320          * mreq is left bussied after completion, but all the other pages
1321          * are freed.  If we had an unrecoverable read error the page will
1322          * not be valid.
1323          */
1324
1325         if (mreq->valid != VM_PAGE_BITS_ALL) {
1326                 return(VM_PAGER_ERROR);
1327         } else {
1328                 return(VM_PAGER_OK);
1329         }
1330
1331         /*
1332          * A final note: in a low swap situation, we cannot deallocate swap
1333          * and mark a page dirty here because the caller is likely to mark
1334          * the page clean when we return, causing the page to possibly revert 
1335          * to all-zero's later.
1336          */
1337 }
1338
1339 /*
1340  *      swap_pager_putpages: 
1341  *
1342  *      Assign swap (if necessary) and initiate I/O on the specified pages.
1343  *
1344  *      We support both OBJT_DEFAULT and OBJT_SWAP objects.  DEFAULT objects
1345  *      are automatically converted to SWAP objects.
1346  *
1347  *      In a low memory situation we may block in vn_strategy(), but the new 
1348  *      vm_page reservation system coupled with properly written VFS devices 
1349  *      should ensure that no low-memory deadlock occurs.  This is an area
1350  *      which needs work.
1351  *
1352  *      The parent has N vm_object_pip_add() references prior to
1353  *      calling us and will remove references for rtvals[] that are
1354  *      not set to VM_PAGER_PEND.  We need to remove the rest on I/O
1355  *      completion.
1356  *
1357  *      The parent has soft-busy'd the pages it passes us and will unbusy
1358  *      those whos rtvals[] entry is not set to VM_PAGER_PEND on return.
1359  *      We need to unbusy the rest on I/O completion.
1360  */
1361 void
1362 swap_pager_putpages(vm_object_t object, vm_page_t *m, int count,
1363                     boolean_t sync, int *rtvals)
1364 {
1365         int i;
1366         int n = 0;
1367
1368         if (count && m[0]->object != object) {
1369                 panic("swap_pager_getpages: object mismatch %p/%p", 
1370                     object, 
1371                     m[0]->object
1372                 );
1373         }
1374
1375         /*
1376          * Step 1
1377          *
1378          * Turn object into OBJT_SWAP
1379          * check for bogus sysops
1380          * force sync if not pageout process
1381          */
1382
1383         if (object->type != OBJT_SWAP)
1384                 swp_pager_meta_build(object, 0, SWAPBLK_NONE);
1385
1386         if (curthread != pagethread)
1387                 sync = TRUE;
1388
1389         /*
1390          * Step 2
1391          *
1392          * Update nsw parameters from swap_async_max sysctl values.  
1393          * Do not let the sysop crash the machine with bogus numbers.
1394          */
1395
1396         if (swap_async_max != nsw_wcount_async_max) {
1397                 int n;
1398
1399                 /*
1400                  * limit range
1401                  */
1402                 if ((n = swap_async_max) > nswbuf / 2)
1403                         n = nswbuf / 2;
1404                 if (n < 1)
1405                         n = 1;
1406                 swap_async_max = n;
1407
1408                 /*
1409                  * Adjust difference ( if possible ).  If the current async
1410                  * count is too low, we may not be able to make the adjustment
1411                  * at this time.
1412                  */
1413                 crit_enter();
1414                 n -= nsw_wcount_async_max;
1415                 if (nsw_wcount_async + n >= 0) {
1416                         nsw_wcount_async += n;
1417                         nsw_wcount_async_max += n;
1418                         wakeup(&nsw_wcount_async);
1419                 }
1420                 crit_exit();
1421         }
1422
1423         /*
1424          * Step 3
1425          *
1426          * Assign swap blocks and issue I/O.  We reallocate swap on the fly.
1427          * The page is left dirty until the pageout operation completes
1428          * successfully.
1429          */
1430
1431         for (i = 0; i < count; i += n) {
1432                 struct buf *bp;
1433                 struct bio *bio;
1434                 daddr_t blk;
1435                 int j;
1436
1437                 /*
1438                  * Maximum I/O size is limited by a number of factors.
1439                  */
1440
1441                 n = min(BLIST_MAX_ALLOC, count - i);
1442                 n = min(n, nsw_cluster_max);
1443
1444                 crit_enter();
1445
1446                 /*
1447                  * Get biggest block of swap we can.  If we fail, fall
1448                  * back and try to allocate a smaller block.  Don't go
1449                  * overboard trying to allocate space if it would overly
1450                  * fragment swap.
1451                  */
1452                 while (
1453                     (blk = swp_pager_getswapspace(n)) == SWAPBLK_NONE &&
1454                     n > 4
1455                 ) {
1456                         n >>= 1;
1457                 }
1458                 if (blk == SWAPBLK_NONE) {
1459                         for (j = 0; j < n; ++j)
1460                                 rtvals[i+j] = VM_PAGER_FAIL;
1461                         crit_exit();
1462                         continue;
1463                 }
1464
1465                 /*
1466                  * The I/O we are constructing cannot cross a physical
1467                  * disk boundry in the swap stripe.  Note: we are still
1468                  * at splvm().
1469                  */
1470                 if ((blk ^ (blk + n)) & dmmax_mask) {
1471                         j = ((blk + dmmax) & dmmax_mask) - blk;
1472                         swp_pager_freeswapspace(blk + j, n - j);
1473                         n = j;
1474                 }
1475
1476                 /*
1477                  * All I/O parameters have been satisfied, build the I/O
1478                  * request and assign the swap space.
1479                  */
1480
1481                 if (sync == TRUE)
1482                         bp = getpbuf(&nsw_wcount_sync);
1483                 else
1484                         bp = getpbuf(&nsw_wcount_async);
1485                 bio = &bp->b_bio1;
1486
1487                 pmap_qenter((vm_offset_t)bp->b_data, &m[i], n);
1488
1489                 bp->b_bcount = PAGE_SIZE * n;
1490                 bio->bio_offset = (off_t)blk << PAGE_SHIFT;
1491
1492                 for (j = 0; j < n; ++j) {
1493                         vm_page_t mreq = m[i+j];
1494
1495                         swp_pager_meta_build(
1496                             mreq->object, 
1497                             mreq->pindex,
1498                             blk + j
1499                         );
1500                         vm_page_dirty(mreq);
1501                         rtvals[i+j] = VM_PAGER_OK;
1502
1503                         vm_page_flag_set(mreq, PG_SWAPINPROG);
1504                         bp->b_xio.xio_pages[j] = mreq;
1505                 }
1506                 bp->b_xio.xio_npages = n;
1507
1508                 mycpu->gd_cnt.v_swapout++;
1509                 mycpu->gd_cnt.v_swappgsout += bp->b_xio.xio_npages;
1510
1511                 crit_exit();
1512
1513                 bp->b_dirtyoff = 0;             /* req'd for NFS */
1514                 bp->b_dirtyend = bp->b_bcount;  /* req'd for NFS */
1515                 bp->b_cmd = BUF_CMD_WRITE;
1516
1517                 /*
1518                  * asynchronous
1519                  */
1520                 if (sync == FALSE) {
1521                         bp->b_flags |= B_ASYNC;
1522                         bio->bio_done = swp_pager_async_iodone;
1523                         BUF_KERNPROC(bp);
1524                         vn_strategy(swapdev_vp, bio);
1525
1526                         for (j = 0; j < n; ++j)
1527                                 rtvals[i+j] = VM_PAGER_PEND;
1528                         continue;
1529                 }
1530
1531                 /*
1532                  * synchronous
1533                  */
1534
1535                 bio->bio_done = swp_pager_sync_iodone;
1536                 vn_strategy(swapdev_vp, bio);
1537
1538                 /*
1539                  * Wait for the sync I/O to complete, then update rtvals.
1540                  * We just set the rtvals[] to VM_PAGER_PEND so we can call
1541                  * our async completion routine at the end, thus avoiding a
1542                  * double-free.
1543                  */
1544                 crit_enter();
1545
1546                 while (bp->b_cmd != BUF_CMD_DONE)
1547                         tsleep(bp, 0, "swwrt", 0);
1548
1549                 for (j = 0; j < n; ++j)
1550                         rtvals[i+j] = VM_PAGER_PEND;
1551
1552                 /*
1553                  * Now that we are through with the bp, we can call the
1554                  * normal async completion, which frees everything up.
1555                  */
1556
1557                 swp_pager_async_iodone(bio);
1558
1559                 crit_exit();
1560         }
1561 }
1562
1563 void
1564 swap_pager_newswap(void)
1565 {
1566         swp_sizecheck();
1567 }
1568
1569 /*
1570  *      swap_pager_sync_iodone:
1571  *
1572  *      Completion routine for synchronous reads and writes from/to swap.
1573  *      We just mark the bp is complete and wake up anyone waiting on it.
1574  *
1575  *      This routine may not block.  This routine is called at splbio()
1576  *      or better.
1577  */
1578
1579 static void
1580 swp_pager_sync_iodone(struct bio *bio)
1581 {
1582         struct buf *bp = bio->bio_buf;
1583
1584         bp->b_flags &= ~B_ASYNC;
1585         bp->b_cmd = BUF_CMD_DONE;
1586         wakeup(bp);
1587 }
1588
1589 /*
1590  *      swp_pager_async_iodone:
1591  *
1592  *      Completion routine for asynchronous reads and writes from/to swap.
1593  *      Also called manually by synchronous code to finish up a bp.
1594  *
1595  *      For READ operations, the pages are PG_BUSY'd.  For WRITE operations, 
1596  *      the pages are vm_page_t->busy'd.  For READ operations, we PG_BUSY 
1597  *      unbusy all pages except the 'main' request page.  For WRITE 
1598  *      operations, we vm_page_t->busy'd unbusy all pages ( we can do this 
1599  *      because we marked them all VM_PAGER_PEND on return from putpages ).
1600  *
1601  *      This routine may not block.
1602  */
1603
1604 static void
1605 swp_pager_async_iodone(struct bio *bio)
1606 {
1607         struct buf *bp = bio->bio_buf;
1608         vm_object_t object = NULL;
1609         int i;
1610         int *nswptr;
1611
1612         /*
1613          * report error
1614          */
1615         if (bp->b_flags & B_ERROR) {
1616                 kprintf(
1617                     "swap_pager: I/O error - %s failed; offset %lld,"
1618                         "size %ld, error %d\n",
1619                     ((bp->b_cmd == BUF_CMD_READ) ? "pagein" : "pageout"),
1620                     (long long)bio->bio_offset,
1621                     (long)bp->b_bcount,
1622                     bp->b_error
1623                 );
1624         }
1625
1626         /*
1627          * set object, raise to splvm().
1628          */
1629
1630         if (bp->b_xio.xio_npages)
1631                 object = bp->b_xio.xio_pages[0]->object;
1632         crit_enter();
1633
1634         /*
1635          * remove the mapping for kernel virtual
1636          */
1637
1638         pmap_qremove((vm_offset_t)bp->b_data, bp->b_xio.xio_npages);
1639
1640         /*
1641          * cleanup pages.  If an error occurs writing to swap, we are in
1642          * very serious trouble.  If it happens to be a disk error, though,
1643          * we may be able to recover by reassigning the swap later on.  So
1644          * in this case we remove the m->swapblk assignment for the page 
1645          * but do not free it in the rlist.  The errornous block(s) are thus
1646          * never reallocated as swap.  Redirty the page and continue.
1647          */
1648
1649         for (i = 0; i < bp->b_xio.xio_npages; ++i) {
1650                 vm_page_t m = bp->b_xio.xio_pages[i];
1651
1652                 vm_page_flag_clear(m, PG_SWAPINPROG);
1653
1654                 if (bp->b_flags & B_ERROR) {
1655                         /*
1656                          * If an error occurs I'd love to throw the swapblk
1657                          * away without freeing it back to swapspace, so it
1658                          * can never be used again.  But I can't from an 
1659                          * interrupt.
1660                          */
1661
1662                         if (bp->b_cmd == BUF_CMD_READ) {
1663                                 /*
1664                                  * When reading, reqpage needs to stay
1665                                  * locked for the parent, but all other
1666                                  * pages can be freed.  We still want to
1667                                  * wakeup the parent waiting on the page,
1668                                  * though.  ( also: pg_reqpage can be -1 and 
1669                                  * not match anything ).
1670                                  *
1671                                  * We have to wake specifically requested pages
1672                                  * up too because we cleared PG_SWAPINPROG and
1673                                  * someone may be waiting for that.
1674                                  *
1675                                  * NOTE: for reads, m->dirty will probably
1676                                  * be overridden by the original caller of
1677                                  * getpages so don't play cute tricks here.
1678                                  *
1679                                  * NOTE: We can't actually free the page from
1680                                  * here, because this is an interrupt.  It
1681                                  * is not legal to mess with object->memq
1682                                  * from an interrupt.  Deactivate the page
1683                                  * instead.
1684                                  */
1685
1686                                 m->valid = 0;
1687                                 vm_page_flag_clear(m, PG_ZERO);
1688
1689                                 /*
1690                                  * bio_driver_info holds the requested page
1691                                  * index.
1692                                  */
1693                                 if (i != (int)(intptr_t)bio->bio_driver_info) {
1694                                         vm_page_deactivate(m);
1695                                         vm_page_wakeup(m);
1696                                 } else {
1697                                         vm_page_flash(m);
1698                                 }
1699                                 /*
1700                                  * If i == bp->b_pager.pg_reqpage, do not wake 
1701                                  * the page up.  The caller needs to.
1702                                  */
1703                         } else {
1704                                 /*
1705                                  * If a write error occurs, reactivate page
1706                                  * so it doesn't clog the inactive list,
1707                                  * then finish the I/O.
1708                                  */
1709                                 vm_page_dirty(m);
1710                                 kprintf("f");
1711                                 vm_page_activate(m);
1712                                 vm_page_io_finish(m);
1713                         }
1714                 } else if (bp->b_cmd == BUF_CMD_READ) {
1715                         /*
1716                          * NOTE: for reads, m->dirty will probably be 
1717                          * overridden by the original caller of getpages so
1718                          * we cannot set them in order to free the underlying
1719                          * swap in a low-swap situation.  I don't think we'd
1720                          * want to do that anyway, but it was an optimization
1721                          * that existed in the old swapper for a time before
1722                          * it got ripped out due to precisely this problem.
1723                          *
1724                          * clear PG_ZERO in page.
1725                          *
1726                          * If not the requested page then deactivate it.
1727                          *
1728                          * Note that the requested page, reqpage, is left
1729                          * busied, but we still have to wake it up.  The
1730                          * other pages are released (unbusied) by 
1731                          * vm_page_wakeup().  We do not set reqpage's
1732                          * valid bits here, it is up to the caller.
1733                          */
1734
1735                         /* 
1736                          * NOTE: can't call pmap_clear_modify(m) from an
1737                          * interrupt thread, the pmap code may have to map
1738                          * non-kernel pmaps and currently asserts the case.
1739                          */
1740                         /*pmap_clear_modify(m);*/
1741                         m->valid = VM_PAGE_BITS_ALL;
1742                         vm_page_undirty(m);
1743                         vm_page_flag_clear(m, PG_ZERO);
1744
1745                         /*
1746                          * We have to wake specifically requested pages
1747                          * up too because we cleared PG_SWAPINPROG and
1748                          * could be waiting for it in getpages.  However,
1749                          * be sure to not unbusy getpages specifically
1750                          * requested page - getpages expects it to be 
1751                          * left busy.
1752                          *
1753                          * bio_driver_info holds the requested page
1754                          */
1755                         if (i != (int)(intptr_t)bio->bio_driver_info) {
1756                                 vm_page_deactivate(m);
1757                                 vm_page_wakeup(m);
1758                         } else {
1759                                 vm_page_flash(m);
1760                         }
1761                 } else {
1762                         /*
1763                          * Mark the page clean but do not mess with the
1764                          * pmap-layer's modified state.  That state should
1765                          * also be clear since the caller protected the
1766                          * page VM_PROT_READ, but allow the case.
1767                          *
1768                          * We are in an interrupt, avoid pmap operations.
1769                          *
1770                          * If we have a severe page deficit, deactivate the
1771                          * page.  Do not try to cache it (which would also
1772                          * involve a pmap op), because the page might still
1773                          * be read-heavy.
1774                          */
1775                         vm_page_undirty(m);
1776                         vm_page_io_finish(m);
1777                         if (vm_page_count_severe())
1778                                 vm_page_deactivate(m);
1779 #if 0
1780                         if (!vm_page_count_severe() || !vm_page_try_to_cache(m))
1781                                 vm_page_protect(m, VM_PROT_READ);
1782 #endif
1783                 }
1784         }
1785
1786         /*
1787          * adjust pip.  NOTE: the original parent may still have its own
1788          * pip refs on the object.
1789          */
1790
1791         if (object)
1792                 vm_object_pip_wakeupn(object, bp->b_xio.xio_npages);
1793
1794         /*
1795          * release the physical I/O buffer
1796          */
1797         if (bp->b_cmd == BUF_CMD_READ)
1798                 nswptr = &nsw_rcount;
1799         else if (bp->b_flags & B_ASYNC)
1800                 nswptr = &nsw_wcount_async;
1801         else
1802                 nswptr = &nsw_wcount_sync;
1803         bp->b_cmd = BUF_CMD_DONE;
1804         relpbuf(bp, nswptr);
1805         crit_exit();
1806 }
1807
1808 /************************************************************************
1809  *                              SWAP META DATA                          *
1810  ************************************************************************
1811  *
1812  *      These routines manipulate the swap metadata stored in the 
1813  *      OBJT_SWAP object.  All swp_*() routines must be called at
1814  *      splvm() because swap can be freed up by the low level vm_page
1815  *      code which might be called from interrupts beyond what splbio() covers.
1816  *
1817  *      Swap metadata is implemented with a global hash and not directly
1818  *      linked into the object.  Instead the object simply contains
1819  *      appropriate tracking counters.
1820  */
1821
1822 /*
1823  * SWP_PAGER_HASH() -   hash swap meta data
1824  *
1825  *      This is an inline helper function which hashes the swapblk given
1826  *      the object and page index.  It returns a pointer to a pointer
1827  *      to the object, or a pointer to a NULL pointer if it could not
1828  *      find a swapblk.
1829  *
1830  *      This routine must be called at splvm().
1831  */
1832
1833 static __inline struct swblock **
1834 swp_pager_hash(vm_object_t object, vm_pindex_t index)
1835 {
1836         struct swblock **pswap;
1837         struct swblock *swap;
1838
1839         index &= ~SWAP_META_MASK;
1840         pswap = &swhash[(index ^ (int)(intptr_t)object) & swhash_mask];
1841
1842         while ((swap = *pswap) != NULL) {
1843                 if (swap->swb_object == object &&
1844                     swap->swb_index == index
1845                 ) {
1846                         break;
1847                 }
1848                 pswap = &swap->swb_hnext;
1849         }
1850         return(pswap);
1851 }
1852
1853 /*
1854  * SWP_PAGER_META_BUILD() -     add swap block to swap meta data for object
1855  *
1856  *      We first convert the object to a swap object if it is a default
1857  *      object.
1858  *
1859  *      The specified swapblk is added to the object's swap metadata.  If
1860  *      the swapblk is not valid, it is freed instead.  Any previously
1861  *      assigned swapblk is freed.
1862  *
1863  *      This routine must be called at splvm(), except when used to convert
1864  *      an OBJT_DEFAULT object into an OBJT_SWAP object.
1865
1866  */
1867
1868 static void
1869 swp_pager_meta_build(
1870         vm_object_t object, 
1871         vm_pindex_t index,
1872         daddr_t swapblk
1873 ) {
1874         struct swblock *swap;
1875         struct swblock **pswap;
1876
1877         /*
1878          * Convert default object to swap object if necessary
1879          */
1880
1881         if (object->type != OBJT_SWAP) {
1882                 object->type = OBJT_SWAP;
1883                 object->un_pager.swp.swp_bcount = 0;
1884
1885                 if (object->handle != NULL) {
1886                         TAILQ_INSERT_TAIL(
1887                             NOBJLIST(object->handle),
1888                             object, 
1889                             pager_object_list
1890                         );
1891                 } else {
1892                         TAILQ_INSERT_TAIL(
1893                             &swap_pager_un_object_list,
1894                             object, 
1895                             pager_object_list
1896                         );
1897                 }
1898         }
1899         
1900         /*
1901          * Locate hash entry.  If not found create, but if we aren't adding
1902          * anything just return.  If we run out of space in the map we wait
1903          * and, since the hash table may have changed, retry.
1904          */
1905
1906 retry:
1907         pswap = swp_pager_hash(object, index);
1908
1909         if ((swap = *pswap) == NULL) {
1910                 int i;
1911
1912                 if (swapblk == SWAPBLK_NONE)
1913                         return;
1914
1915                 swap = *pswap = zalloc(swap_zone);
1916                 if (swap == NULL) {
1917                         vm_wait(0);
1918                         goto retry;
1919                 }
1920                 swap->swb_hnext = NULL;
1921                 swap->swb_object = object;
1922                 swap->swb_index = index & ~SWAP_META_MASK;
1923                 swap->swb_count = 0;
1924
1925                 ++object->un_pager.swp.swp_bcount;
1926
1927                 for (i = 0; i < SWAP_META_PAGES; ++i)
1928                         swap->swb_pages[i] = SWAPBLK_NONE;
1929         }
1930
1931         /*
1932          * Delete prior contents of metadata
1933          */
1934
1935         index &= SWAP_META_MASK;
1936
1937         if (swap->swb_pages[index] != SWAPBLK_NONE) {
1938                 swp_pager_freeswapspace(swap->swb_pages[index], 1);
1939                 --swap->swb_count;
1940         }
1941
1942         /*
1943          * Enter block into metadata
1944          */
1945
1946         swap->swb_pages[index] = swapblk;
1947         if (swapblk != SWAPBLK_NONE)
1948                 ++swap->swb_count;
1949 }
1950
1951 /*
1952  * SWP_PAGER_META_FREE() - free a range of blocks in the object's swap metadata
1953  *
1954  *      The requested range of blocks is freed, with any associated swap 
1955  *      returned to the swap bitmap.
1956  *
1957  *      This routine will free swap metadata structures as they are cleaned 
1958  *      out.  This routine does *NOT* operate on swap metadata associated
1959  *      with resident pages.
1960  *
1961  *      This routine must be called at splvm()
1962  */
1963
1964 static void
1965 swp_pager_meta_free(vm_object_t object, vm_pindex_t index, daddr_t count)
1966 {
1967         if (object->type != OBJT_SWAP)
1968                 return;
1969
1970         while (count > 0) {
1971                 struct swblock **pswap;
1972                 struct swblock *swap;
1973
1974                 pswap = swp_pager_hash(object, index);
1975
1976                 if ((swap = *pswap) != NULL) {
1977                         daddr_t v = swap->swb_pages[index & SWAP_META_MASK];
1978
1979                         if (v != SWAPBLK_NONE) {
1980                                 swp_pager_freeswapspace(v, 1);
1981                                 swap->swb_pages[index & SWAP_META_MASK] =
1982                                         SWAPBLK_NONE;
1983                                 if (--swap->swb_count == 0) {
1984                                         *pswap = swap->swb_hnext;
1985                                         zfree(swap_zone, swap);
1986                                         --object->un_pager.swp.swp_bcount;
1987                                 }
1988                         }
1989                         --count;
1990                         ++index;
1991                 } else {
1992                         int n = SWAP_META_PAGES - (index & SWAP_META_MASK);
1993                         count -= n;
1994                         index += n;
1995                 }
1996         }
1997 }
1998
1999 /*
2000  * SWP_PAGER_META_FREE_ALL() - destroy all swap metadata associated with object
2001  *
2002  *      This routine locates and destroys all swap metadata associated with
2003  *      an object.
2004  *
2005  *      This routine must be called at splvm()
2006  */
2007
2008 static void
2009 swp_pager_meta_free_all(vm_object_t object)
2010 {
2011         daddr_t index = 0;
2012
2013         if (object->type != OBJT_SWAP)
2014                 return;
2015
2016         while (object->un_pager.swp.swp_bcount) {
2017                 struct swblock **pswap;
2018                 struct swblock *swap;
2019
2020                 pswap = swp_pager_hash(object, index);
2021                 if ((swap = *pswap) != NULL) {
2022                         int i;
2023
2024                         for (i = 0; i < SWAP_META_PAGES; ++i) {
2025                                 daddr_t v = swap->swb_pages[i];
2026                                 if (v != SWAPBLK_NONE) {
2027                                         --swap->swb_count;
2028                                         swp_pager_freeswapspace(v, 1);
2029                                 }
2030                         }
2031                         if (swap->swb_count != 0)
2032                                 panic("swap_pager_meta_free_all: swb_count != 0");
2033                         *pswap = swap->swb_hnext;
2034                         zfree(swap_zone, swap);
2035                         --object->un_pager.swp.swp_bcount;
2036                 }
2037                 index += SWAP_META_PAGES;
2038                 if (index > 0x20000000)
2039                         panic("swp_pager_meta_free_all: failed to locate all swap meta blocks");
2040         }
2041 }
2042
2043 /*
2044  * SWP_PAGER_METACTL() -  misc control of swap and vm_page_t meta data.
2045  *
2046  *      This routine is capable of looking up, popping, or freeing
2047  *      swapblk assignments in the swap meta data or in the vm_page_t.
2048  *      The routine typically returns the swapblk being looked-up, or popped,
2049  *      or SWAPBLK_NONE if the block was freed, or SWAPBLK_NONE if the block
2050  *      was invalid.  This routine will automatically free any invalid 
2051  *      meta-data swapblks.
2052  *
2053  *      It is not possible to store invalid swapblks in the swap meta data
2054  *      (other then a literal 'SWAPBLK_NONE'), so we don't bother checking.
2055  *
2056  *      When acting on a busy resident page and paging is in progress, we 
2057  *      have to wait until paging is complete but otherwise can act on the 
2058  *      busy page.
2059  *
2060  *      This routine must be called at splvm().
2061  *
2062  *      SWM_FREE        remove and free swap block from metadata
2063  *      SWM_POP         remove from meta data but do not free.. pop it out
2064  */
2065
2066 static daddr_t
2067 swp_pager_meta_ctl(
2068         vm_object_t object,
2069         vm_pindex_t index,
2070         int flags
2071 ) {
2072         struct swblock **pswap;
2073         struct swblock *swap;
2074         daddr_t r1;
2075
2076         /*
2077          * The meta data only exists of the object is OBJT_SWAP 
2078          * and even then might not be allocated yet.
2079          */
2080
2081         if (object->type != OBJT_SWAP)
2082                 return(SWAPBLK_NONE);
2083
2084         r1 = SWAPBLK_NONE;
2085         pswap = swp_pager_hash(object, index);
2086
2087         if ((swap = *pswap) != NULL) {
2088                 index &= SWAP_META_MASK;
2089                 r1 = swap->swb_pages[index];
2090
2091                 if (r1 != SWAPBLK_NONE) {
2092                         if (flags & SWM_FREE) {
2093                                 swp_pager_freeswapspace(r1, 1);
2094                                 r1 = SWAPBLK_NONE;
2095                         }
2096                         if (flags & (SWM_FREE|SWM_POP)) {
2097                                 swap->swb_pages[index] = SWAPBLK_NONE;
2098                                 if (--swap->swb_count == 0) {
2099                                         *pswap = swap->swb_hnext;
2100                                         zfree(swap_zone, swap);
2101                                         --object->un_pager.swp.swp_bcount;
2102                                 }
2103                         } 
2104                 }
2105         }
2106         return(r1);
2107 }