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