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