061ce6cb72fdeef1472b58447405df61f04660e5
[dragonfly.git] / 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 #include <sys/thread2.h>
66
67 #include <vm/vm.h>
68 #include <vm/vm_object.h>
69 #include <vm/vm_page.h>
70 #include <vm/vm_pager.h>
71 #include <vm/vm_map.h>
72 #include <vm/vnode_pager.h>
73 #include <vm/vm_extern.h>
74
75 static void vnode_pager_dealloc (vm_object_t);
76 static int vnode_pager_getpages (vm_object_t, vm_page_t *, int, int);
77 static void vnode_pager_putpages (vm_object_t, vm_page_t *, int, boolean_t, int *);
78 static boolean_t vnode_pager_haspage (vm_object_t, vm_pindex_t, int *, int *);
79
80 struct pagerops vnodepagerops = {
81         NULL,
82         vnode_pager_alloc,
83         vnode_pager_dealloc,
84         vnode_pager_getpages,
85         vnode_pager_putpages,
86         vnode_pager_haspage,
87         NULL
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                 vp->v_flag |= VOWANT;
126                 tsleep(vp, 0, "vnpobj", 0);
127         }
128         vp->v_flag |= 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, OFF_TO_IDX(round_page(size)));
147                 object->flags = 0;
148                 object->handle = handle;
149                 vp->v_object = object;
150                 vp->v_filesize = size;
151         } else {
152                 object->ref_count++;
153                 if (vp->v_filesize != size)
154                         kprintf("vnode_pager_alloc: Warning, filesize mismatch %lld/%lld\n", vp->v_filesize, size);
155         }
156         vref(vp);
157
158         vp->v_flag &= ~VOLOCK;
159         if (vp->v_flag & VOWANT) {
160                 vp->v_flag &= ~VOWANT;
161                 wakeup(vp);
162         }
163         return (object);
164 }
165
166 static void
167 vnode_pager_dealloc(vm_object_t object)
168 {
169         struct vnode *vp = object->handle;
170
171         if (vp == NULL)
172                 panic("vnode_pager_dealloc: pager already dealloced");
173
174         vm_object_pip_wait(object, "vnpdea");
175
176         object->handle = NULL;
177         object->type = OBJT_DEAD;
178         vp->v_object = NULL;
179         vp->v_filesize = NOOFFSET;
180         vp->v_flag &= ~(VTEXT | VOBJBUF);
181 }
182
183 /*
184  * Return whether the vnode pager has the requested page.  Return the
185  * number of disk-contiguous pages before and after the requested page,
186  * not including the requested page.
187  */
188 static boolean_t
189 vnode_pager_haspage(vm_object_t object, vm_pindex_t pindex, int *before,
190                     int *after)
191 {
192         struct vnode *vp = object->handle;
193         off_t loffset;
194         off_t doffset;
195         int voff;
196         int bsize;
197         int error;
198
199         /*
200          * If no vp or vp is doomed or marked transparent to VM, we do not
201          * have the page.
202          */
203         if ((vp == NULL) || (vp->v_flag & VRECLAIMED))
204                 return FALSE;
205
206         /*
207          * If filesystem no longer mounted or offset beyond end of file we do
208          * not have the page.
209          */
210         loffset = IDX_TO_OFF(pindex);
211
212         if (vp->v_mount == NULL || loffset >= vp->v_filesize)
213                 return FALSE;
214
215         bsize = vp->v_mount->mnt_stat.f_iosize;
216         voff = loffset % bsize;
217
218         /*
219          * BMAP returns byte counts before and after, where after
220          * is inclusive of the base page.  haspage must return page
221          * counts before and after where after does not include the
222          * base page.
223          *
224          * BMAP is allowed to return a *after of 0 for backwards
225          * compatibility.  The base page is still considered valid if
226          * no error is returned.
227          */
228         error = VOP_BMAP(vp, loffset - voff, &doffset, after, before, 0);
229         if (error) {
230                 if (before)
231                         *before = 0;
232                 if (after)
233                         *after = 0;
234                 return TRUE;
235         }
236         if (doffset == NOOFFSET)
237                 return FALSE;
238
239         if (before) {
240                 *before = (*before + voff) >> PAGE_SHIFT;
241         }
242         if (after) {
243                 *after -= voff;
244                 if (loffset + *after > vp->v_filesize)
245                         *after = vp->v_filesize - loffset;
246                 *after >>= PAGE_SHIFT;
247                 if (*after < 0)
248                         *after = 0;
249         }
250         return TRUE;
251 }
252
253 /*
254  * Lets the VM system know about a change in size for a file.
255  * We adjust our own internal size and flush any cached pages in
256  * the associated object that are affected by the size change.
257  *
258  * NOTE: This routine may be invoked as a result of a pager put
259  * operation (possibly at object termination time), so we must be careful.
260  *
261  * NOTE: vp->v_filesize is initialized to NOOFFSET (-1), be sure that
262  * we do not blow up on the case.  nsize will always be >= 0, however.
263  */
264 void
265 vnode_pager_setsize(struct vnode *vp, vm_ooffset_t nsize)
266 {
267         vm_pindex_t nobjsize;
268         vm_pindex_t oobjsize;
269         vm_object_t object = vp->v_object;
270
271         if (object == NULL)
272                 return;
273
274         /*
275          * Hasn't changed size
276          */
277         if (nsize == vp->v_filesize)
278                 return;
279
280         /*
281          * Has changed size.  Adjust the VM object's size and v_filesize
282          * before we start scanning pages to prevent new pages from being
283          * allocated during the scan.
284          */
285         nobjsize = OFF_TO_IDX(nsize + PAGE_MASK);
286         oobjsize = object->size;
287         object->size = nobjsize;
288
289         /*
290          * File has shrunk. Toss any cached pages beyond the new EOF.
291          */
292         if (nsize < vp->v_filesize) {
293                 vp->v_filesize = nsize;
294                 if (nobjsize < oobjsize) {
295                         vm_object_page_remove(object, nobjsize, oobjsize,
296                                               FALSE);
297                 }
298                 /*
299                  * This gets rid of garbage at the end of a page that is now
300                  * only partially backed by the vnode.  Since we are setting
301                  * the entire page valid & clean after we are done we have
302                  * to be sure that the portion of the page within the file
303                  * bounds is already valid.  If it isn't then making it
304                  * valid would create a corrupt block.
305                  */
306                 if (nsize & PAGE_MASK) {
307                         vm_offset_t kva;
308                         vm_page_t m;
309
310                         do {
311                                 m = vm_page_lookup(object, OFF_TO_IDX(nsize));
312                         } while (m && vm_page_sleep_busy(m, TRUE, "vsetsz"));
313
314                         if (m && m->valid) {
315                                 int base = (int)nsize & PAGE_MASK;
316                                 int size = PAGE_SIZE - base;
317                                 struct sf_buf *sf;
318
319                                 /*
320                                  * Clear out partial-page garbage in case
321                                  * the page has been mapped.
322                                  */
323                                 vm_page_busy(m);
324                                 sf = sf_buf_alloc(m, SFB_CPUPRIVATE);
325                                 kva = sf_buf_kva(sf);
326                                 bzero((caddr_t)kva + base, size);
327                                 sf_buf_free(sf);
328
329                                 /*
330                                  * XXX work around SMP data integrity race
331                                  * by unmapping the page from user processes.
332                                  * The garbage we just cleared may be mapped
333                                  * to a user process running on another cpu
334                                  * and this code is not running through normal
335                                  * I/O channels which handle SMP issues for
336                                  * us, so unmap page to synchronize all cpus.
337                                  *
338                                  * XXX should vm_pager_unmap_page() have
339                                  * dealt with this?
340                                  */
341                                 vm_page_protect(m, VM_PROT_NONE);
342
343                                 /*
344                                  * Clear out partial-page dirty bits.  This
345                                  * has the side effect of setting the valid
346                                  * bits, but that is ok.  There are a bunch
347                                  * of places in the VM system where we expected
348                                  * m->dirty == VM_PAGE_BITS_ALL.  The file EOF
349                                  * case is one of them.  If the page is still
350                                  * partially dirty, make it fully dirty.
351                                  *
352                                  * note that we do not clear out the valid
353                                  * bits.  This would prevent bogus_page
354                                  * replacement from working properly.
355                                  */
356                                 vm_page_set_validclean(m, base, size);
357                                 if (m->dirty != 0)
358                                         m->dirty = VM_PAGE_BITS_ALL;
359                                 vm_page_wakeup(m);
360                         }
361                 }
362         } else {
363                 vp->v_filesize = nsize;
364         }
365 }
366
367 /*
368  * Release a page busied for a getpages operation.  The page may have become
369  * wired (typically due to being used by the buffer cache) or otherwise been
370  * soft-busied and cannot be freed in that case.  A held page can still be
371  * freed.
372  */
373 void
374 vnode_pager_freepage(vm_page_t m)
375 {
376         if (m->busy || m->wire_count) {
377                 vm_page_activate(m);
378                 vm_page_wakeup(m);
379         } else {
380                 vm_page_free(m);
381         }
382 }
383
384 /*
385  * EOPNOTSUPP is no longer legal.  For local media VFS's that do not
386  * implement their own VOP_GETPAGES, their VOP_GETPAGES should call to
387  * vnode_pager_generic_getpages() to implement the previous behaviour.
388  *
389  * All other FS's should use the bypass to get to the local media
390  * backing vp's VOP_GETPAGES.
391  */
392 static int
393 vnode_pager_getpages(vm_object_t object, vm_page_t *m, int count, int reqpage)
394 {
395         int rtval;
396         struct vnode *vp;
397         int bytes = count * PAGE_SIZE;
398
399         vp = object->handle;
400         rtval = VOP_GETPAGES(vp, m, bytes, reqpage, 0);
401         if (rtval == EOPNOTSUPP)
402                 panic("vnode_pager: vfs's must implement vop_getpages\n");
403         return rtval;
404 }
405
406 /*
407  * This is now called from local media FS's to operate against their
408  * own vnodes if they fail to implement VOP_GETPAGES.
409  *
410  * With all the caching local media devices do these days there is really
411  * very little point to attempting to restrict the I/O size to contiguous
412  * blocks on-disk, especially if our caller thinks we need all the specified
413  * pages.  Just construct and issue a READ.
414  */
415 int
416 vnode_pager_generic_getpages(struct vnode *vp, vm_page_t *m, int bytecount,
417                              int reqpage)
418 {
419         struct iovec aiov;
420         struct uio auio;
421         off_t foff;
422         int error;
423         int count;
424         int i;
425         int ioflags;
426
427         /*
428          * Do not do anything if the vnode is bad.
429          */
430         if (vp->v_mount == NULL)
431                 return VM_PAGER_BAD;
432
433         /*
434          * Calculate the number of pages.  Since we are paging in whole
435          * pages, adjust bytecount to be an integral multiple of the page
436          * size.  It will be clipped to the file EOF later on.
437          */
438         bytecount = round_page(bytecount);
439         count = bytecount / PAGE_SIZE;
440
441         /*
442          * If we have a completely valid page available to us, we can
443          * clean up and return.  Otherwise we have to re-read the
444          * media.
445          *
446          * Note that this does not work with NFS, so NFS has its own
447          * getpages routine.  The problem is that NFS can have partially
448          * valid pages associated with the buffer cache due to the piecemeal
449          * write support.  If we were to fall through and re-read the media
450          * as we do here, dirty data could be lost.
451          */
452         if (m[reqpage]->valid == VM_PAGE_BITS_ALL) {
453                 for (i = 0; i < count; i++) {
454                         if (i != reqpage)
455                                 vnode_pager_freepage(m[i]);
456                 }
457                 return VM_PAGER_OK;
458         }
459
460         /*
461          * Discard pages past the file EOF.  If the requested page is past
462          * the file EOF we just leave its valid bits set to 0, the caller
463          * expects to maintain ownership of the requested page.  If the
464          * entire range is past file EOF discard everything and generate
465          * a pagein error.
466          */
467         foff = IDX_TO_OFF(m[0]->pindex);
468         if (foff >= vp->v_filesize) {
469                 for (i = 0; i < count; i++) {
470                         if (i != reqpage)
471                                 vnode_pager_freepage(m[i]);
472                 }
473                 return VM_PAGER_ERROR;
474         }
475
476         if (foff + bytecount > vp->v_filesize) {
477                 bytecount = vp->v_filesize - foff;
478                 i = round_page(bytecount) / PAGE_SIZE;
479                 while (count > i) {
480                         --count;
481                         if (count != reqpage)
482                                 vnode_pager_freepage(m[count]);
483                 }
484         }
485
486         /*
487          * The size of the transfer is bytecount.  bytecount will be an
488          * integral multiple of the page size unless it has been clipped
489          * to the file EOF.  The transfer cannot exceed the file EOF.
490          *
491          * When dealing with real devices we must round-up to the device
492          * sector size.
493          */
494         if (vp->v_type == VBLK || vp->v_type == VCHR) {
495                 int secmask = vp->v_rdev->si_bsize_phys - 1;
496                 KASSERT(secmask < PAGE_SIZE, ("vnode_pager_generic_getpages: sector size %d too large\n", secmask + 1));
497                 bytecount = (bytecount + secmask) & ~secmask;
498         }
499
500         /*
501          * Severe hack to avoid deadlocks with the buffer cache
502          */
503         for (i = 0; i < count; ++i) {
504                 vm_page_t mt = m[i];
505
506                 vm_page_io_start(mt);
507                 vm_page_wakeup(mt);
508         }
509
510         /*
511          * Issue the I/O without any read-ahead
512          */
513         ioflags = IO_VMIO;
514         /*ioflags |= IO_SEQMAX << IO_SEQSHIFT;*/
515
516         aiov.iov_base = (caddr_t) 0;
517         aiov.iov_len = bytecount;
518         auio.uio_iov = &aiov;
519         auio.uio_iovcnt = 1;
520         auio.uio_offset = foff;
521         auio.uio_segflg = UIO_NOCOPY;
522         auio.uio_rw = UIO_READ;
523         auio.uio_resid = bytecount;
524         auio.uio_td = NULL;
525         mycpu->gd_cnt.v_vnodein++;
526         mycpu->gd_cnt.v_vnodepgsin += count;
527
528         error = VOP_READ(vp, &auio, ioflags, proc0.p_ucred);
529
530         /*
531          * Severe hack to avoid deadlocks with the buffer cache
532          */
533         for (i = 0; i < count; ++i) {
534                 vm_page_t mt = m[i];
535
536                 while (vm_page_sleep_busy(mt, FALSE, "getpgs"))
537                         ;
538                 vm_page_busy(mt);
539                 vm_page_io_finish(mt);
540         }
541
542         /*
543          * Calculate the actual number of bytes read and clean up the
544          * page list.  
545          */
546         bytecount -= auio.uio_resid;
547
548         for (i = 0; i < count; ++i) {
549                 vm_page_t mt = m[i];
550
551                 if (i != reqpage) {
552                         if (error == 0 && mt->valid) {
553                                 if (mt->flags & PG_WANTED)
554                                         vm_page_activate(mt);
555                                 else
556                                         vm_page_deactivate(mt);
557                                 vm_page_wakeup(mt);
558                         } else {
559                                 vnode_pager_freepage(mt);
560                         }
561                 } else if (mt->valid == 0) {
562                         if (error == 0) {
563                                 kprintf("page failed but no I/O error page %p object %p pindex %d\n", mt, mt->object, (int) mt->pindex);
564                                 /* whoops, something happened */
565                                 error = EINVAL;
566                         }
567                 } else if (mt->valid != VM_PAGE_BITS_ALL) {
568                         /*
569                          * Zero-extend the requested page if necessary (if
570                          * the filesystem is using a small block size).
571                          */
572                         vm_page_zero_invalid(mt, TRUE);
573                 }
574         }
575         if (error) {
576                 kprintf("vnode_pager_getpages: I/O read error\n");
577         }
578         return (error ? VM_PAGER_ERROR : VM_PAGER_OK);
579 }
580
581 /*
582  * EOPNOTSUPP is no longer legal.  For local media VFS's that do not
583  * implement their own VOP_PUTPAGES, their VOP_PUTPAGES should call to
584  * vnode_pager_generic_putpages() to implement the previous behaviour.
585  *
586  * All other FS's should use the bypass to get to the local media
587  * backing vp's VOP_PUTPAGES.
588  */
589 static void
590 vnode_pager_putpages(vm_object_t object, vm_page_t *m, int count,
591     boolean_t sync, int *rtvals)
592 {
593         int rtval;
594         struct vnode *vp;
595         int bytes = count * PAGE_SIZE;
596
597         /*
598          * Force synchronous operation if we are extremely low on memory
599          * to prevent a low-memory deadlock.  VOP operations often need to
600          * allocate more memory to initiate the I/O ( i.e. do a BMAP 
601          * operation ).  The swapper handles the case by limiting the amount
602          * of asynchronous I/O, but that sort of solution doesn't scale well
603          * for the vnode pager without a lot of work.
604          *
605          * Also, the backing vnode's iodone routine may not wake the pageout
606          * daemon up.  This should be probably be addressed XXX.
607          */
608
609         if ((vmstats.v_free_count + vmstats.v_cache_count) < vmstats.v_pageout_free_min)
610                 sync |= OBJPC_SYNC;
611
612         /*
613          * Call device-specific putpages function
614          */
615
616         vp = object->handle;
617         rtval = VOP_PUTPAGES(vp, m, bytes, sync, rtvals, 0);
618         if (rtval == EOPNOTSUPP) {
619             kprintf("vnode_pager: *** WARNING *** stale FS putpages\n");
620             rtval = vnode_pager_generic_putpages( vp, m, bytes, sync, rtvals);
621         }
622 }
623
624
625 /*
626  * This is now called from local media FS's to operate against their
627  * own vnodes if they fail to implement VOP_PUTPAGES.
628  *
629  * This is typically called indirectly via the pageout daemon and
630  * clustering has already typically occured, so in general we ask the
631  * underlying filesystem to write the data out asynchronously rather
632  * then delayed.
633  */
634 int
635 vnode_pager_generic_putpages(struct vnode *vp, vm_page_t *m, int bytecount,
636                              int flags, int *rtvals)
637 {
638         int i;
639         vm_object_t object;
640         int count;
641
642         int maxsize, ncount;
643         vm_ooffset_t poffset;
644         struct uio auio;
645         struct iovec aiov;
646         int error;
647         int ioflags;
648
649         object = vp->v_object;
650         count = bytecount / PAGE_SIZE;
651
652         for (i = 0; i < count; i++)
653                 rtvals[i] = VM_PAGER_AGAIN;
654
655         if ((int) m[0]->pindex < 0) {
656                 kprintf("vnode_pager_putpages: attempt to write meta-data!!! -- 0x%lx(%x)\n",
657                         (long)m[0]->pindex, m[0]->dirty);
658                 rtvals[0] = VM_PAGER_BAD;
659                 return VM_PAGER_BAD;
660         }
661
662         maxsize = count * PAGE_SIZE;
663         ncount = count;
664
665         poffset = IDX_TO_OFF(m[0]->pindex);
666
667         /*
668          * If the page-aligned write is larger then the actual file we
669          * have to invalidate pages occuring beyond the file EOF.  However,
670          * there is an edge case where a file may not be page-aligned where
671          * the last page is partially invalid.  In this case the filesystem
672          * may not properly clear the dirty bits for the entire page (which
673          * could be VM_PAGE_BITS_ALL due to the page having been mmap()d).
674          * With the page locked we are free to fix-up the dirty bits here.
675          *
676          * We do not under any circumstances truncate the valid bits, as
677          * this will screw up bogus page replacement.
678          *
679          * The caller has already read-protected the pages.  The VFS must
680          * use the buffer cache to wrap the pages.  The pages might not
681          * be immediately flushed by the buffer cache but once under its
682          * control the pages themselves can wind up being marked clean
683          * and their covering buffer cache buffer can be marked dirty.
684          */
685         if (maxsize + poffset > vp->v_filesize) {
686                 if (vp->v_filesize > poffset) {
687                         int pgoff;
688
689                         maxsize = vp->v_filesize - poffset;
690                         ncount = btoc(maxsize);
691                         if ((pgoff = (int)maxsize & PAGE_MASK) != 0) {
692                                 vm_page_clear_dirty(m[ncount - 1], pgoff,
693                                         PAGE_SIZE - pgoff);
694                         }
695                 } else {
696                         maxsize = 0;
697                         ncount = 0;
698                 }
699                 if (ncount < count) {
700                         for (i = ncount; i < count; i++) {
701                                 rtvals[i] = VM_PAGER_BAD;
702                         }
703                 }
704         }
705
706         /*
707          * pageouts are already clustered, use IO_ASYNC to force a bawrite()
708          * rather then a bdwrite() to prevent paging I/O from saturating
709          * the buffer cache.  Dummy-up the sequential heuristic to cause
710          * large ranges to cluster.  If neither IO_SYNC or IO_ASYNC is set,
711          * the system decides how to cluster.
712          */
713         ioflags = IO_VMIO;
714         if (flags & (VM_PAGER_PUT_SYNC | VM_PAGER_PUT_INVAL))
715                 ioflags |= IO_SYNC;
716         else if ((flags & VM_PAGER_CLUSTER_OK) == 0)
717                 ioflags |= IO_ASYNC;
718         ioflags |= (flags & VM_PAGER_PUT_INVAL) ? IO_INVAL: 0;
719         ioflags |= IO_SEQMAX << IO_SEQSHIFT;
720
721         aiov.iov_base = (caddr_t) 0;
722         aiov.iov_len = maxsize;
723         auio.uio_iov = &aiov;
724         auio.uio_iovcnt = 1;
725         auio.uio_offset = poffset;
726         auio.uio_segflg = UIO_NOCOPY;
727         auio.uio_rw = UIO_WRITE;
728         auio.uio_resid = maxsize;
729         auio.uio_td = NULL;
730         error = VOP_WRITE(vp, &auio, ioflags, proc0.p_ucred);
731         mycpu->gd_cnt.v_vnodeout++;
732         mycpu->gd_cnt.v_vnodepgsout += ncount;
733
734         if (error) {
735                 krateprintf(&vbadrate,
736                             "vnode_pager_putpages: I/O error %d\n", error);
737         }
738         if (auio.uio_resid) {
739                 krateprintf(&vresrate,
740                             "vnode_pager_putpages: residual I/O %d at %lu\n",
741                             auio.uio_resid, (u_long)m[0]->pindex);
742         }
743         for (i = 0; i < ncount; i++)
744                 rtvals[i] = VM_PAGER_OK;
745         return rtvals[0];
746 }
747
748 struct vnode *
749 vnode_pager_lock(vm_object_t object)
750 {
751         struct thread *td = curthread;  /* XXX */
752         int error;
753
754         for (; object != NULL; object = object->backing_object) {
755                 if (object->type != OBJT_VNODE)
756                         continue;
757                 if (object->flags & OBJ_DEAD)
758                         return NULL;
759
760                 for (;;) {
761                         struct vnode *vp = object->handle;
762                         error = vget(vp, LK_SHARED | LK_RETRY | LK_CANRECURSE);
763                         if (error == 0) {
764                                 if (object->handle != vp) {
765                                         vput(vp);
766                                         continue;
767                                 }
768                                 return (vp);
769                         }
770                         if ((object->flags & OBJ_DEAD) ||
771                             (object->type != OBJT_VNODE)) {
772                                 return NULL;
773                         }
774                         kprintf("vnode_pager_lock: vp %p error %d lockstatus %d, retrying\n", vp, error, lockstatus(&vp->v_lock, td));
775                         tsleep(object->handle, 0, "vnpgrl", hz);
776                 }
777         }
778         return NULL;
779 }