sys/vm/vnode_pager.c

   1 /*
   2  * Copyright (c) 1990 University of Utah.
   3  * Copyright (c) 1991 The Regents of the University of California.
   4  * All rights reserved.
   5  * Copyright (c) 1993, 1994 John S. Dyson
   6  * Copyright (c) 1995, David Greenman
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * the Systems Programming Group of the University of Utah Computer
  10  * Science Department.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *      This product includes software developed by the University of
  23  *      California, Berkeley and its contributors.
  24  * 4. Neither the name of the University nor the names of its contributors
  25  *    may be used to endorse or promote products derived from this software
  26  *    without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  38  * SUCH DAMAGE.
  39  *
  40  *      from: @(#)vnode_pager.c 7.5 (Berkeley) 4/20/91
  41  * $FreeBSD: src/sys/vm/vnode_pager.c,v 1.116.2.7 2002/12/31 09:34:51 dillon Exp $
  42  * $DragonFly: src/sys/vm/vnode_pager.c,v 1.43 2008/06/19 23:27:39 dillon Exp $
  43  */
  44
  45 /*
  46  * Page to/from files (vnodes).
  47  */
  48
  49 /*
  50  * TODO:
  51  *      Implement VOP_GETPAGES/PUTPAGES interface for filesystems. Will
  52  *      greatly re-simplify the vnode_pager.
  53  */
  54
  55 #include <sys/param.h>
  56 #include <sys/systm.h>
  57 #include <sys/kernel.h>
  58 #include <sys/proc.h>
  59 #include <sys/vnode.h>
  60 #include <sys/mount.h>
  61 #include <sys/buf.h>
  62 #include <sys/vmmeter.h>
  63 #include <sys/conf.h>
  64 #include <sys/sfbuf.h>
  65
  66 #include <vm/vm.h>
  67 #include <vm/vm_object.h>
  68 #include <vm/vm_page.h>
  69 #include <vm/vm_pager.h>
  70 #include <vm/vm_map.h>
  71 #include <vm/vnode_pager.h>
  72 #include <vm/swap_pager.h>
  73 #include <vm/vm_extern.h>
  74
  75 #include <sys/thread2.h>
  76 #include <vm/vm_page2.h>
  77
  78 static void vnode_pager_dealloc (vm_object_t);
  79 static int vnode_pager_getpage (vm_object_t, vm_page_t *, int);
  80 static void vnode_pager_putpages (vm_object_t, vm_page_t *, int, boolean_t, int *);
  81 static boolean_t vnode_pager_haspage (vm_object_t, vm_pindex_t);
  82
  83 struct pagerops vnodepagerops = {
  84         vnode_pager_dealloc,
  85         vnode_pager_getpage,
  86         vnode_pager_putpages,
  87         vnode_pager_haspage
  88 };
  89
  90 static struct krate vbadrate = { 1 };
  91 static struct krate vresrate = { 1 };
  92
  93 int vnode_pbuf_freecnt = -1;    /* start out unlimited */
  94
  95 /*
  96  * Allocate (or lookup) pager for a vnode.
  97  * Handle is a vnode pointer.
  98  */
  99 vm_object_t
 100 vnode_pager_alloc(void *handle, off_t size, vm_prot_t prot, off_t offset)
 101 {
 102         vm_object_t object;
 103         struct vnode *vp;
 104
 105         /*
 106          * Pageout to vnode, no can do yet.
 107          */
 108         if (handle == NULL)
 109                 return (NULL);
 110
 111         /*
 112          * XXX hack - This initialization should be put somewhere else.
 113          */
 114         if (vnode_pbuf_freecnt < 0) {
 115             vnode_pbuf_freecnt = nswbuf / 2 + 1;
 116         }
 117
 118         vp = (struct vnode *) handle;
 119
 120         /*
 121          * Prevent race condition when allocating the object. This
 122          * can happen with NFS vnodes since the nfsnode isn't locked.
 123          */
 124         while (vp->v_flag & VOLOCK) {
 125                 vsetflags(vp, VOWANT);
 126                 tsleep(vp, 0, "vnpobj", 0);
 127         }
 128         vsetflags(vp, VOLOCK);
 129
 130         /*
 131          * If the object is being terminated, wait for it to
 132          * go away.
 133          */
 134         while (((object = vp->v_object) != NULL) &&
 135                 (object->flags & OBJ_DEAD)) {
 136                 vm_object_dead_sleep(object, "vadead");
 137         }
 138
 139         if (vp->v_sysref.refcnt <= 0)
 140                 panic("vnode_pager_alloc: no vnode reference");
 141
 142         if (object == NULL) {
 143                 /*
 144                  * And an object of the appropriate size
 145                  */
 146                 object = vm_object_allocate(OBJT_VNODE,
 147                                             OFF_TO_IDX(round_page64(size)));
 148                 object->flags = 0;
 149                 object->handle = handle;
 150                 vp->v_object = object;
 151                 vp->v_filesize = size;
 152         } else {
 153                 object->ref_count++;
 154                 if (vp->v_filesize != size) {
 155                         kprintf("vnode_pager_alloc: Warning, filesize "
 156                                 "mismatch %lld/%lld\n",
 157                                 (long long)vp->v_filesize,
 158                                 (long long)size);
 159                 }
 160         }
 161         vref(vp);
 162
 163         vclrflags(vp, VOLOCK);
 164         if (vp->v_flag & VOWANT) {
 165                 vclrflags(vp, VOWANT);
 166                 wakeup(vp);
 167         }
 168         return (object);
 169 }
 170
 171 /*
 172  * Add a ref to a vnode's existing VM object, return the object or
 173  * NULL if the vnode did not have one.  This does not create the
 174  * object (we can't since we don't know what the proper blocksize/boff
 175  * is to match the VFS's use of the buffer cache).
 176  */
 177 vm_object_t
 178 vnode_pager_reference(struct vnode *vp)
 179 {
 180         vm_object_t object;
 181
 182         /*
 183          * Prevent race condition when allocating the object. This
 184          * can happen with NFS vnodes since the nfsnode isn't locked.
 185          */
 186         while (vp->v_flag & VOLOCK) {
 187                 vsetflags(vp, VOWANT);
 188                 tsleep(vp, 0, "vnpobj", 0);
 189         }
 190         vsetflags(vp, VOLOCK);
 191
 192         /*
 193          * Prevent race conditions against deallocation of the VM
 194          * object.
 195          */
 196         while (((object = vp->v_object) != NULL) &&
 197                 (object->flags & OBJ_DEAD)) {
 198                 vm_object_dead_sleep(object, "vadead");
 199         }
 200
 201         /*
 202          * The object is expected to exist, the caller will handle
 203          * NULL returns if it does not.
 204          */
 205         if (object) {
 206                 object->ref_count++;
 207                 vref(vp);
 208         }
 209
 210         vclrflags(vp, VOLOCK);
 211         if (vp->v_flag & VOWANT) {
 212                 vclrflags(vp, VOWANT);
 213                 wakeup(vp);
 214         }
 215         return (object);
 216 }
 217
 218 static void
 219 vnode_pager_dealloc(vm_object_t object)
 220 {
 221         struct vnode *vp = object->handle;
 222
 223         if (vp == NULL)
 224                 panic("vnode_pager_dealloc: pager already dealloced");
 225
 226         vm_object_pip_wait(object, "vnpdea");
 227
 228         object->handle = NULL;
 229         object->type = OBJT_DEAD;
 230         vp->v_object = NULL;
 231         vp->v_filesize = NOOFFSET;
 232         vclrflags(vp, VTEXT | VOBJBUF);
 233         swap_pager_freespace_all(object);
 234 }
 235
 236 /*
 237  * Return whether the vnode pager has the requested page.  Return the
 238  * number of disk-contiguous pages before and after the requested page,
 239  * not including the requested page.
 240  */
 241 static boolean_t
 242 vnode_pager_haspage(vm_object_t object, vm_pindex_t pindex)
 243 {
 244         struct vnode *vp = object->handle;
 245         off_t loffset;
 246         off_t doffset;
 247         int voff;
 248         int bsize;
 249         int error;
 250
 251         /*
 252          * If no vp or vp is doomed or marked transparent to VM, we do not
 253          * have the page.
 254          */
 255         if ((vp == NULL) || (vp->v_flag & VRECLAIMED))
 256                 return FALSE;
 257
 258         /*
 259          * If filesystem no longer mounted or offset beyond end of file we do
 260          * not have the page.
 261          */
 262         loffset = IDX_TO_OFF(pindex);
 263
 264         if (vp->v_mount == NULL || loffset >= vp->v_filesize)
 265                 return FALSE;
 266
 267         bsize = vp->v_mount->mnt_stat.f_iosize;
 268         voff = loffset % bsize;
 269
 270         /*
 271          * XXX
 272          *
 273          * BMAP returns byte counts before and after, where after
 274          * is inclusive of the base page.  haspage must return page
 275          * counts before and after where after does not include the
 276          * base page.
 277          *
 278          * BMAP is allowed to return a *after of 0 for backwards
 279          * compatibility.  The base page is still considered valid if
 280          * no error is returned.
 281          */
 282         error = VOP_BMAP(vp, loffset - voff, &doffset, NULL, NULL, 0);
 283         if (error)
 284                 return TRUE;
 285         if (doffset == NOOFFSET)
 286                 return FALSE;
 287         return TRUE;
 288 }
 289
 290 /*
 291  * Lets the VM system know about a change in size for a file.
 292  * We adjust our own internal size and flush any cached pages in
 293  * the associated object that are affected by the size change.
 294  *
 295  * NOTE: This routine may be invoked as a result of a pager put
 296  * operation (possibly at object termination time), so we must be careful.
 297  *
 298  * NOTE: vp->v_filesize is initialized to NOOFFSET (-1), be sure that
 299  * we do not blow up on the case.  nsize will always be >= 0, however.
 300  */
 301 void
 302 vnode_pager_setsize(struct vnode *vp, vm_ooffset_t nsize)
 303 {
 304         vm_pindex_t nobjsize;
 305         vm_pindex_t oobjsize;
 306         vm_object_t object = vp->v_object;
 307
 308         if (object == NULL)
 309                 return;
 310
 311         /*
 312          * Hasn't changed size
 313          */
 314         if (nsize == vp->v_filesize)
 315                 return;
 316
 317         /*
 318          * Has changed size.  Adjust the VM object's size and v_filesize
 319          * before we start scanning pages to prevent new pages from being
 320          * allocated during the scan.
 321          */
 322         nobjsize = OFF_TO_IDX(nsize + PAGE_MASK);
 323         oobjsize = object->size;
 324         object->size = nobjsize;
 325
 326         /*
 327          * File has shrunk. Toss any cached pages beyond the new EOF.
 328          */
 329         if (nsize < vp->v_filesize) {
 330                 vp->v_filesize = nsize;
 331                 if (nobjsize < oobjsize) {
 332                         vm_object_page_remove(object, nobjsize, oobjsize,
 333                                               FALSE);
 334                 }
 335                 /*
 336                  * This gets rid of garbage at the end of a page that is now
 337                  * only partially backed by the vnode.  Since we are setting
 338                  * the entire page valid & clean after we are done we have
 339                  * to be sure that the portion of the page within the file
 340                  * bounds is already valid.  If it isn't then making it
 341                  * valid would create a corrupt block.
 342                  */
 343                 if (nsize & PAGE_MASK) {
 344                         vm_offset_t kva;
 345                         vm_page_t m;
 346
 347                         do {
 348                                 m = vm_page_lookup(object, OFF_TO_IDX(nsize));
 349                         } while (m && vm_page_sleep_busy(m, TRUE, "vsetsz"));
 350
 351                         if (m && m->valid) {
 352                                 int base = (int)nsize & PAGE_MASK;
 353                                 int size = PAGE_SIZE - base;
 354                                 struct sf_buf *sf;
 355
 356                                 /*
 357                                  * Clear out partial-page garbage in case
 358                                  * the page has been mapped.
 359                                  *
 360                                  * This is byte aligned.
 361                                  */
 362                                 vm_page_busy(m);
 363                                 sf = sf_buf_alloc(m, SFB_CPUPRIVATE);
 364                                 kva = sf_buf_kva(sf);
 365                                 bzero((caddr_t)kva + base, size);
 366                                 sf_buf_free(sf);
 367
 368                                 /*
 369                                  * XXX work around SMP data integrity race
 370                                  * by unmapping the page from user processes.
 371                                  * The garbage we just cleared may be mapped
 372                                  * to a user process running on another cpu
 373                                  * and this code is not running through normal
 374                                  * I/O channels which handle SMP issues for
 375                                  * us, so unmap page to synchronize all cpus.
 376                                  *
 377                                  * XXX should vm_pager_unmap_page() have
 378                                  * dealt with this?
 379                                  */
 380                                 vm_page_protect(m, VM_PROT_NONE);
 381
 382                                 /*
 383                                  * Clear out partial-page dirty bits.  This
 384                                  * has the side effect of setting the valid
 385                                  * bits, but that is ok.  There are a bunch
 386                                  * of places in the VM system where we expected
 387                                  * m->dirty == VM_PAGE_BITS_ALL.  The file EOF
 388                                  * case is one of them.  If the page is still
 389                                  * partially dirty, make it fully dirty.
 390                                  *
 391                                  * NOTE: We do not clear out the valid
 392                                  * bits.  This would prevent bogus_page
 393                                  * replacement from working properly.
 394                                  *
 395                                  * NOTE: We do not want to clear the dirty
 396                                  * bit for a partial DEV_BSIZE'd truncation!
 397                                  * This is DEV_BSIZE aligned!
 398                                  */
 399                                 vm_page_clear_dirty_beg_nonincl(m, base, size);
 400                                 if (m->dirty != 0)
 401                                         m->dirty = VM_PAGE_BITS_ALL;
 402                                 vm_page_wakeup(m);
 403                         }
 404                 }
 405         } else {
 406                 vp->v_filesize = nsize;
 407         }
 408 }
 409
 410 /*
 411  * Release a page busied for a getpages operation.  The page may have become
 412  * wired (typically due to being used by the buffer cache) or otherwise been
 413  * soft-busied and cannot be freed in that case.  A held page can still be
 414  * freed.
 415  */
 416 void
 417 vnode_pager_freepage(vm_page_t m)
 418 {
 419         if (m->busy || m->wire_count) {
 420                 vm_page_activate(m);
 421                 vm_page_wakeup(m);
 422         } else {
 423                 vm_page_free(m);
 424         }
 425 }
 426
 427 /*
 428  * EOPNOTSUPP is no longer legal.  For local media VFS's that do not
 429  * implement their own VOP_GETPAGES, their VOP_GETPAGES should call to
 430  * vnode_pager_generic_getpages() to implement the previous behaviour.
 431  *
 432  * All other FS's should use the bypass to get to the local media
 433  * backing vp's VOP_GETPAGES.
 434  */
 435 static int
 436 vnode_pager_getpage(vm_object_t object, vm_page_t *mpp, int seqaccess)
 437 {
 438         int rtval;
 439         struct vnode *vp;
 440
 441         vp = object->handle;
 442         rtval = VOP_GETPAGES(vp, mpp, PAGE_SIZE, 0, 0, seqaccess);
 443         if (rtval == EOPNOTSUPP)
 444                 panic("vnode_pager: vfs's must implement vop_getpages\n");
 445         return rtval;
 446 }
 447
 448 /*
 449  * This is now called from local media FS's to operate against their
 450  * own vnodes if they fail to implement VOP_GETPAGES.
 451  *
 452  * With all the caching local media devices do these days there is really
 453  * very little point to attempting to restrict the I/O size to contiguous
 454  * blocks on-disk, especially if our caller thinks we need all the specified
 455  * pages.  Just construct and issue a READ.
 456  */
 457 int
 458 vnode_pager_generic_getpages(struct vnode *vp, vm_page_t *mpp, int bytecount,
 459                              int reqpage, int seqaccess)
 460 {
 461         struct iovec aiov;
 462         struct uio auio;
 463         off_t foff;
 464         int error;
 465         int count;
 466         int i;
 467         int ioflags;
 468
 469         /*
 470          * Do not do anything if the vnode is bad.
 471          */
 472         if (vp->v_mount == NULL)
 473                 return VM_PAGER_BAD;
 474
 475         /*
 476          * Calculate the number of pages.  Since we are paging in whole
 477          * pages, adjust bytecount to be an integral multiple of the page
 478          * size.  It will be clipped to the file EOF later on.
 479          */
 480         bytecount = round_page(bytecount);
 481         count = bytecount / PAGE_SIZE;
 482
 483         /*
 484          * We could check m[reqpage]->valid here and shortcut the operation,
 485          * but doing so breaks read-ahead.  Instead assume that the VM
 486          * system has already done at least the check, don't worry about
 487          * any races, and issue the VOP_READ to allow read-ahead to function.
 488          *
 489          * This keeps the pipeline full for I/O bound sequentially scanned
 490          * mmap()'s
 491          */
 492         /* don't shortcut */
 493
 494         /*
 495          * Discard pages past the file EOF.  If the requested page is past
 496          * the file EOF we just leave its valid bits set to 0, the caller
 497          * expects to maintain ownership of the requested page.  If the
 498          * entire range is past file EOF discard everything and generate
 499          * a pagein error.
 500          */
 501         foff = IDX_TO_OFF(mpp[0]->pindex);
 502         if (foff >= vp->v_filesize) {
 503                 for (i = 0; i < count; i++) {
 504                         if (i != reqpage)
 505                                 vnode_pager_freepage(mpp[i]);
 506                 }
 507                 return VM_PAGER_ERROR;
 508         }
 509
 510         if (foff + bytecount > vp->v_filesize) {
 511                 bytecount = vp->v_filesize - foff;
 512                 i = round_page(bytecount) / PAGE_SIZE;
 513                 while (count > i) {
 514                         --count;
 515                         if (count != reqpage)
 516                                 vnode_pager_freepage(mpp[count]);
 517                 }
 518         }
 519
 520         /*
 521          * The size of the transfer is bytecount.  bytecount will be an
 522          * integral multiple of the page size unless it has been clipped
 523          * to the file EOF.  The transfer cannot exceed the file EOF.
 524          *
 525          * When dealing with real devices we must round-up to the device
 526          * sector size.
 527          */
 528         if (vp->v_type == VBLK || vp->v_type == VCHR) {
 529                 int secmask = vp->v_rdev->si_bsize_phys - 1;
 530                 KASSERT(secmask < PAGE_SIZE, ("vnode_pager_generic_getpages: sector size %d too large\n", secmask + 1));
 531                 bytecount = (bytecount + secmask) & ~secmask;
 532         }
 533
 534         /*
 535          * Severe hack to avoid deadlocks with the buffer cache
 536          */
 537         for (i = 0; i < count; ++i) {
 538                 vm_page_t mt = mpp[i];
 539
 540                 vm_page_io_start(mt);
 541                 vm_page_wakeup(mt);
 542         }
 543
 544         /*
 545          * Issue the I/O with some read-ahead if bytecount > PAGE_SIZE
 546          */
 547         ioflags = IO_VMIO;
 548         if (seqaccess)
 549                 ioflags |= IO_SEQMAX << IO_SEQSHIFT;
 550
 551         aiov.iov_base = NULL;
 552         aiov.iov_len = bytecount;
 553         auio.uio_iov = &aiov;
 554         auio.uio_iovcnt = 1;
 555         auio.uio_offset = foff;
 556         auio.uio_segflg = UIO_NOCOPY;
 557         auio.uio_rw = UIO_READ;
 558         auio.uio_resid = bytecount;
 559         auio.uio_td = NULL;
 560         mycpu->gd_cnt.v_vnodein++;
 561         mycpu->gd_cnt.v_vnodepgsin += count;
 562
 563         error = VOP_READ(vp, &auio, ioflags, proc0.p_ucred);
 564
 565         /*
 566          * Severe hack to avoid deadlocks with the buffer cache
 567          */
 568         for (i = 0; i < count; ++i) {
 569                 vm_page_t mt = mpp[i];
 570
 571                 while (vm_page_sleep_busy(mt, FALSE, "getpgs"))
 572                         ;
 573                 vm_page_busy(mt);
 574                 vm_page_io_finish(mt);
 575         }
 576
 577         /*
 578          * Calculate the actual number of bytes read and clean up the
 579          * page list.
 580          */
 581         bytecount -= auio.uio_resid;
 582
 583         for (i = 0; i < count; ++i) {
 584                 vm_page_t mt = mpp[i];
 585
 586                 if (i != reqpage) {
 587                         if (error == 0 && mt->valid) {
 588                                 if (mt->flags & PG_WANTED)
 589                                         vm_page_activate(mt);
 590                                 else
 591                                         vm_page_deactivate(mt);
 592                                 vm_page_wakeup(mt);
 593                         } else {
 594                                 vnode_pager_freepage(mt);
 595                         }
 596                 } else if (mt->valid == 0) {
 597                         if (error == 0) {
 598                                 kprintf("page failed but no I/O error page %p object %p pindex %d\n", mt, mt->object, (int) mt->pindex);
 599                                 /* whoops, something happened */
 600                                 error = EINVAL;
 601                         }
 602                 } else if (mt->valid != VM_PAGE_BITS_ALL) {
 603                         /*
 604                          * Zero-extend the requested page if necessary (if
 605                          * the filesystem is using a small block size).
 606                          */
 607                         vm_page_zero_invalid(mt, TRUE);
 608                 }
 609         }
 610         if (error) {
 611                 kprintf("vnode_pager_getpage: I/O read error\n");
 612         }
 613         return (error ? VM_PAGER_ERROR : VM_PAGER_OK);
 614 }
 615
 616 /*
 617  * EOPNOTSUPP is no longer legal.  For local media VFS's that do not
 618  * implement their own VOP_PUTPAGES, their VOP_PUTPAGES should call to
 619  * vnode_pager_generic_putpages() to implement the previous behaviour.
 620  *
 621  * Caller has already cleared the pmap modified bits, if any.
 622  *
 623  * All other FS's should use the bypass to get to the local media
 624  * backing vp's VOP_PUTPAGES.
 625  */
 626 static void
 627 vnode_pager_putpages(vm_object_t object, vm_page_t *m, int count,
 628                      boolean_t sync, int *rtvals)
 629 {
 630         int rtval;
 631         struct vnode *vp;
 632         int bytes = count * PAGE_SIZE;
 633
 634         /*
 635          * Force synchronous operation if we are extremely low on memory
 636          * to prevent a low-memory deadlock.  VOP operations often need to
 637          * allocate more memory to initiate the I/O ( i.e. do a BMAP
 638          * operation ).  The swapper handles the case by limiting the amount
 639          * of asynchronous I/O, but that sort of solution doesn't scale well
 640          * for the vnode pager without a lot of work.
 641          *
 642          * Also, the backing vnode's iodone routine may not wake the pageout
 643          * daemon up.  This should be probably be addressed XXX.
 644          */
 645
 646         if ((vmstats.v_free_count + vmstats.v_cache_count) < vmstats.v_pageout_free_min)
 647                 sync |= OBJPC_SYNC;
 648
 649         /*
 650          * Call device-specific putpages function
 651          */
 652         vp = object->handle;
 653         rtval = VOP_PUTPAGES(vp, m, bytes, sync, rtvals, 0);
 654         if (rtval == EOPNOTSUPP) {
 655             kprintf("vnode_pager: *** WARNING *** stale FS putpages\n");
 656             rtval = vnode_pager_generic_putpages( vp, m, bytes, sync, rtvals);
 657         }
 658 }
 659
 660
 661 /*
 662  * This is now called from local media FS's to operate against their
 663  * own vnodes if they fail to implement VOP_PUTPAGES.
 664  *
 665  * This is typically called indirectly via the pageout daemon and
 666  * clustering has already typically occured, so in general we ask the
 667  * underlying filesystem to write the data out asynchronously rather
 668  * then delayed.
 669  */
 670 int
 671 vnode_pager_generic_putpages(struct vnode *vp, vm_page_t *m, int bytecount,
 672                              int flags, int *rtvals)
 673 {
 674         int i;
 675         vm_object_t object;
 676         int maxsize, ncount, count;
 677         vm_ooffset_t poffset;
 678         struct uio auio;
 679         struct iovec aiov;
 680         int error;
 681         int ioflags;
 682
 683         object = vp->v_object;
 684         count = bytecount / PAGE_SIZE;
 685
 686         for (i = 0; i < count; i++)
 687                 rtvals[i] = VM_PAGER_AGAIN;
 688
 689         if ((int) m[0]->pindex < 0) {
 690                 kprintf("vnode_pager_putpages: attempt to write meta-data!!! -- 0x%lx(%x)\n",
 691                         (long)m[0]->pindex, m[0]->dirty);
 692                 rtvals[0] = VM_PAGER_BAD;
 693                 return VM_PAGER_BAD;
 694         }
 695
 696         maxsize = count * PAGE_SIZE;
 697         ncount = count;
 698
 699         poffset = IDX_TO_OFF(m[0]->pindex);
 700
 701         /*
 702          * If the page-aligned write is larger then the actual file we
 703          * have to invalidate pages occuring beyond the file EOF.
 704          *
 705          * If the file EOF resides in the middle of a page we still clear
 706          * all of that page's dirty bits later on.  If we didn't it would
 707          * endlessly re-write.
 708          *
 709          * We do not under any circumstances truncate the valid bits, as
 710          * this will screw up bogus page replacement.
 711          *
 712          * The caller has already read-protected the pages.  The VFS must
 713          * use the buffer cache to wrap the pages.  The pages might not
 714          * be immediately flushed by the buffer cache but once under its
 715          * control the pages themselves can wind up being marked clean
 716          * and their covering buffer cache buffer can be marked dirty.
 717          */
 718         if (poffset + maxsize > vp->v_filesize) {
 719                 if (poffset < vp->v_filesize) {
 720                         maxsize = vp->v_filesize - poffset;
 721                         ncount = btoc(maxsize);
 722                 } else {
 723                         maxsize = 0;
 724                         ncount = 0;
 725                 }
 726                 if (ncount < count) {
 727                         for (i = ncount; i < count; i++) {
 728                                 rtvals[i] = VM_PAGER_BAD;
 729                         }
 730                 }
 731         }
 732
 733         /*
 734          * pageouts are already clustered, use IO_ASYNC to force a bawrite()
 735          * rather then a bdwrite() to prevent paging I/O from saturating
 736          * the buffer cache.  Dummy-up the sequential heuristic to cause
 737          * large ranges to cluster.  If neither IO_SYNC or IO_ASYNC is set,
 738          * the system decides how to cluster.
 739          */
 740         ioflags = IO_VMIO;
 741         if (flags & (VM_PAGER_PUT_SYNC | VM_PAGER_PUT_INVAL))
 742                 ioflags |= IO_SYNC;
 743         else if ((flags & VM_PAGER_CLUSTER_OK) == 0)
 744                 ioflags |= IO_ASYNC;
 745         ioflags |= (flags & VM_PAGER_PUT_INVAL) ? IO_INVAL: 0;
 746         ioflags |= IO_SEQMAX << IO_SEQSHIFT;
 747
 748         aiov.iov_base = (caddr_t) 0;
 749         aiov.iov_len = maxsize;
 750         auio.uio_iov = &aiov;
 751         auio.uio_iovcnt = 1;
 752         auio.uio_offset = poffset;
 753         auio.uio_segflg = UIO_NOCOPY;
 754         auio.uio_rw = UIO_WRITE;
 755         auio.uio_resid = maxsize;
 756         auio.uio_td = NULL;
 757         error = VOP_WRITE(vp, &auio, ioflags, proc0.p_ucred);
 758         mycpu->gd_cnt.v_vnodeout++;
 759         mycpu->gd_cnt.v_vnodepgsout += ncount;
 760
 761         if (error) {
 762                 krateprintf(&vbadrate,
 763                             "vnode_pager_putpages: I/O error %d\n", error);
 764         }
 765         if (auio.uio_resid) {
 766                 krateprintf(&vresrate,
 767                             "vnode_pager_putpages: residual I/O %zd at %lu\n",
 768                             auio.uio_resid, (u_long)m[0]->pindex);
 769         }
 770         if (error == 0) {
 771                 for (i = 0; i < ncount; i++) {
 772                         rtvals[i] = VM_PAGER_OK;
 773                         vm_page_undirty(m[i]);
 774                 }
 775         }
 776         return rtvals[0];
 777 }
 778
 779 struct vnode *
 780 vnode_pager_lock(vm_object_t object)
 781 {
 782         struct thread *td = curthread;  /* XXX */
 783         int error;
 784
 785         for (; object != NULL; object = object->backing_object) {
 786                 if (object->type != OBJT_VNODE)
 787                         continue;
 788                 if (object->flags & OBJ_DEAD)
 789                         return NULL;
 790
 791                 for (;;) {
 792                         struct vnode *vp = object->handle;
 793                         error = vget(vp, LK_SHARED | LK_RETRY | LK_CANRECURSE);
 794                         if (error == 0) {
 795                                 if (object->handle != vp) {
 796                                         vput(vp);
 797                                         continue;
 798                                 }
 799                                 return (vp);
 800                         }
 801                         if ((object->flags & OBJ_DEAD) ||
 802                             (object->type != OBJT_VNODE)) {
 803                                 return NULL;
 804                         }
 805                         kprintf("vnode_pager_lock: vp %p error %d lockstatus %d, retrying\n", vp, error, lockstatus(&vp->v_lock, td));
 806                         tsleep(object->handle, 0, "vnpgrl", hz);
 807                 }
 808         }
 809         return NULL;
 810 }