xref: /freebsd/sys/vm/vnode_pager.c (revision 561cc9fcb5e4ed191cbcec9d0de4e7ff33ebbbd7)
160727d8bSWarner Losh /*-
2df8bae1dSRodney W. Grimes  * Copyright (c) 1990 University of Utah.
326f9a767SRodney W. Grimes  * Copyright (c) 1991 The Regents of the University of California.
426f9a767SRodney W. Grimes  * All rights reserved.
526f9a767SRodney W. Grimes  * Copyright (c) 1993, 1994 John S. Dyson
624a1cce3SDavid Greenman  * Copyright (c) 1995, David Greenman
7df8bae1dSRodney W. Grimes  *
8df8bae1dSRodney W. Grimes  * This code is derived from software contributed to Berkeley by
9df8bae1dSRodney W. Grimes  * the Systems Programming Group of the University of Utah Computer
10df8bae1dSRodney W. Grimes  * Science Department.
11df8bae1dSRodney W. Grimes  *
12df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
13df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
14df8bae1dSRodney W. Grimes  * are met:
15df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
16df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
17df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
18df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
19df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
20df8bae1dSRodney W. Grimes  * 3. All advertising materials mentioning features or use of this software
215929bcfaSPhilippe Charnier  *    must display the following acknowledgement:
22df8bae1dSRodney W. Grimes  *	This product includes software developed by the University of
23df8bae1dSRodney W. Grimes  *	California, Berkeley and its contributors.
24df8bae1dSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
25df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
26df8bae1dSRodney W. Grimes  *    without specific prior written permission.
27df8bae1dSRodney W. Grimes  *
28df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
39df8bae1dSRodney W. Grimes  *
4026f9a767SRodney W. Grimes  *	from: @(#)vnode_pager.c	7.5 (Berkeley) 4/20/91
41df8bae1dSRodney W. Grimes  */
42df8bae1dSRodney W. Grimes 
43df8bae1dSRodney W. Grimes /*
44df8bae1dSRodney W. Grimes  * Page to/from files (vnodes).
45df8bae1dSRodney W. Grimes  */
46df8bae1dSRodney W. Grimes 
4726f9a767SRodney W. Grimes /*
4826f9a767SRodney W. Grimes  * TODO:
4924a1cce3SDavid Greenman  *	Implement VOP_GETPAGES/PUTPAGES interface for filesystems. Will
50f6b04d2bSDavid Greenman  *	greatly re-simplify the vnode_pager.
5126f9a767SRodney W. Grimes  */
5226f9a767SRodney W. Grimes 
53874651b1SDavid E. O'Brien #include <sys/cdefs.h>
54874651b1SDavid E. O'Brien __FBSDID("$FreeBSD$");
55874651b1SDavid E. O'Brien 
56df8bae1dSRodney W. Grimes #include <sys/param.h>
57df8bae1dSRodney W. Grimes #include <sys/systm.h>
58df8bae1dSRodney W. Grimes #include <sys/proc.h>
59df8bae1dSRodney W. Grimes #include <sys/vnode.h>
60df8bae1dSRodney W. Grimes #include <sys/mount.h>
619626b608SPoul-Henning Kamp #include <sys/bio.h>
6224a1cce3SDavid Greenman #include <sys/buf.h>
63efeaf95aSDavid Greenman #include <sys/vmmeter.h>
64d07a6d3fSPoul-Henning Kamp #include <sys/limits.h>
6524579ca1SMatthew Dillon #include <sys/conf.h>
669e0ddbd0SAlan Cox #include <sys/sf_buf.h>
67df8bae1dSRodney W. Grimes 
684f12e0acSSuleiman Souhlal #include <machine/atomic.h>
694f12e0acSSuleiman Souhlal 
70df8bae1dSRodney W. Grimes #include <vm/vm.h>
71efeaf95aSDavid Greenman #include <vm/vm_object.h>
72df8bae1dSRodney W. Grimes #include <vm/vm_page.h>
7324a1cce3SDavid Greenman #include <vm/vm_pager.h>
741efb74fbSJohn Dyson #include <vm/vm_map.h>
75df8bae1dSRodney W. Grimes #include <vm/vnode_pager.h>
76efeaf95aSDavid Greenman #include <vm/vm_extern.h>
77df8bae1dSRodney W. Grimes 
78bff76343SAlan Cox static int vnode_pager_addr(struct vnode *vp, vm_ooffset_t address,
79bff76343SAlan Cox     daddr_t *rtaddress, int *run);
8011caded3SAlfred Perlstein static int vnode_pager_input_smlfs(vm_object_t object, vm_page_t m);
8111caded3SAlfred Perlstein static int vnode_pager_input_old(vm_object_t object, vm_page_t m);
8211caded3SAlfred Perlstein static void vnode_pager_dealloc(vm_object_t);
8311caded3SAlfred Perlstein static int vnode_pager_getpages(vm_object_t, vm_page_t *, int, int);
8411caded3SAlfred Perlstein static void vnode_pager_putpages(vm_object_t, vm_page_t *, int, boolean_t, int *);
8511caded3SAlfred Perlstein static boolean_t vnode_pager_haspage(vm_object_t, vm_pindex_t, int *, int *);
863364c323SKonstantin Belousov static vm_object_t vnode_pager_alloc(void *, vm_ooffset_t, vm_prot_t,
873364c323SKonstantin Belousov     vm_ooffset_t, struct ucred *cred);
880b8253a7SBruce Evans 
89df8bae1dSRodney W. Grimes struct pagerops vnodepagerops = {
904e658600SPoul-Henning Kamp 	.pgo_alloc =	vnode_pager_alloc,
914e658600SPoul-Henning Kamp 	.pgo_dealloc =	vnode_pager_dealloc,
924e658600SPoul-Henning Kamp 	.pgo_getpages =	vnode_pager_getpages,
934e658600SPoul-Henning Kamp 	.pgo_putpages =	vnode_pager_putpages,
944e658600SPoul-Henning Kamp 	.pgo_haspage =	vnode_pager_haspage,
95df8bae1dSRodney W. Grimes };
96df8bae1dSRodney W. Grimes 
97b62b9b64SJohn Baldwin int vnode_pbuf_freecnt;
981c7c3c6aSMatthew Dillon 
99d07a6d3fSPoul-Henning Kamp /* Create the VM system backing object for this vnode */
100d07a6d3fSPoul-Henning Kamp int
101731959b1SYaroslav Tykhiy vnode_create_vobject(struct vnode *vp, off_t isize, struct thread *td)
102d07a6d3fSPoul-Henning Kamp {
103d07a6d3fSPoul-Henning Kamp 	vm_object_t object;
104d07a6d3fSPoul-Henning Kamp 	vm_ooffset_t size = isize;
105d07a6d3fSPoul-Henning Kamp 	struct vattr va;
106d07a6d3fSPoul-Henning Kamp 
107d07a6d3fSPoul-Henning Kamp 	if (!vn_isdisk(vp, NULL) && vn_canvmio(vp) == FALSE)
108d07a6d3fSPoul-Henning Kamp 		return (0);
109d07a6d3fSPoul-Henning Kamp 
110d07a6d3fSPoul-Henning Kamp 	while ((object = vp->v_object) != NULL) {
111d07a6d3fSPoul-Henning Kamp 		VM_OBJECT_LOCK(object);
112d07a6d3fSPoul-Henning Kamp 		if (!(object->flags & OBJ_DEAD)) {
113d07a6d3fSPoul-Henning Kamp 			VM_OBJECT_UNLOCK(object);
114d07a6d3fSPoul-Henning Kamp 			return (0);
115d07a6d3fSPoul-Henning Kamp 		}
11622db15c0SAttilio Rao 		VOP_UNLOCK(vp, 0);
117d07a6d3fSPoul-Henning Kamp 		vm_object_set_flag(object, OBJ_DISCONNECTWNT);
118d07a6d3fSPoul-Henning Kamp 		msleep(object, VM_OBJECT_MTX(object), PDROP | PVM, "vodead", 0);
119cb05b60aSAttilio Rao 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
120d07a6d3fSPoul-Henning Kamp 	}
121d07a6d3fSPoul-Henning Kamp 
122d07a6d3fSPoul-Henning Kamp 	if (size == 0) {
123d07a6d3fSPoul-Henning Kamp 		if (vn_isdisk(vp, NULL)) {
124d07a6d3fSPoul-Henning Kamp 			size = IDX_TO_OFF(INT_MAX);
125d07a6d3fSPoul-Henning Kamp 		} else {
1260359a12eSAttilio Rao 			if (VOP_GETATTR(vp, &va, td->td_ucred))
127d07a6d3fSPoul-Henning Kamp 				return (0);
128d07a6d3fSPoul-Henning Kamp 			size = va.va_size;
129d07a6d3fSPoul-Henning Kamp 		}
130d07a6d3fSPoul-Henning Kamp 	}
131d07a6d3fSPoul-Henning Kamp 
1323364c323SKonstantin Belousov 	object = vnode_pager_alloc(vp, size, 0, 0, td->td_ucred);
133d07a6d3fSPoul-Henning Kamp 	/*
134d07a6d3fSPoul-Henning Kamp 	 * Dereference the reference we just created.  This assumes
135d07a6d3fSPoul-Henning Kamp 	 * that the object is associated with the vp.
136d07a6d3fSPoul-Henning Kamp 	 */
137d07a6d3fSPoul-Henning Kamp 	VM_OBJECT_LOCK(object);
138d07a6d3fSPoul-Henning Kamp 	object->ref_count--;
139d07a6d3fSPoul-Henning Kamp 	VM_OBJECT_UNLOCK(object);
140d07a6d3fSPoul-Henning Kamp 	vrele(vp);
141d07a6d3fSPoul-Henning Kamp 
142d07a6d3fSPoul-Henning Kamp 	KASSERT(vp->v_object != NULL, ("vnode_create_vobject: NULL object"));
143d07a6d3fSPoul-Henning Kamp 
144d07a6d3fSPoul-Henning Kamp 	return (0);
145d07a6d3fSPoul-Henning Kamp }
146d07a6d3fSPoul-Henning Kamp 
1477146d6cbSPoul-Henning Kamp void
1487146d6cbSPoul-Henning Kamp vnode_destroy_vobject(struct vnode *vp)
1497146d6cbSPoul-Henning Kamp {
1507146d6cbSPoul-Henning Kamp 	struct vm_object *obj;
1517146d6cbSPoul-Henning Kamp 
1527146d6cbSPoul-Henning Kamp 	obj = vp->v_object;
1537146d6cbSPoul-Henning Kamp 	if (obj == NULL)
1547146d6cbSPoul-Henning Kamp 		return;
15557fd3d55SPawel Jakub Dawidek 	ASSERT_VOP_ELOCKED(vp, "vnode_destroy_vobject");
1567146d6cbSPoul-Henning Kamp 	VM_OBJECT_LOCK(obj);
1577146d6cbSPoul-Henning Kamp 	if (obj->ref_count == 0) {
1587146d6cbSPoul-Henning Kamp 		/*
1597146d6cbSPoul-Henning Kamp 		 * vclean() may be called twice. The first time
1607146d6cbSPoul-Henning Kamp 		 * removes the primary reference to the object,
1617146d6cbSPoul-Henning Kamp 		 * the second time goes one further and is a
1627146d6cbSPoul-Henning Kamp 		 * special-case to terminate the object.
1637146d6cbSPoul-Henning Kamp 		 *
1647146d6cbSPoul-Henning Kamp 		 * don't double-terminate the object
1657146d6cbSPoul-Henning Kamp 		 */
1667146d6cbSPoul-Henning Kamp 		if ((obj->flags & OBJ_DEAD) == 0)
1677146d6cbSPoul-Henning Kamp 			vm_object_terminate(obj);
1687146d6cbSPoul-Henning Kamp 		else
1697146d6cbSPoul-Henning Kamp 			VM_OBJECT_UNLOCK(obj);
1707146d6cbSPoul-Henning Kamp 	} else {
1717146d6cbSPoul-Henning Kamp 		/*
1727146d6cbSPoul-Henning Kamp 		 * Woe to the process that tries to page now :-).
1737146d6cbSPoul-Henning Kamp 		 */
1747146d6cbSPoul-Henning Kamp 		vm_pager_deallocate(obj);
1757146d6cbSPoul-Henning Kamp 		VM_OBJECT_UNLOCK(obj);
1767146d6cbSPoul-Henning Kamp 	}
1776e4b2820SJeff Roberson 	vp->v_object = NULL;
1787146d6cbSPoul-Henning Kamp }
1797146d6cbSPoul-Henning Kamp 
1807146d6cbSPoul-Henning Kamp 
181df8bae1dSRodney W. Grimes /*
182df8bae1dSRodney W. Grimes  * Allocate (or lookup) pager for a vnode.
183df8bae1dSRodney W. Grimes  * Handle is a vnode pointer.
184990ab7adSAlan Cox  *
185990ab7adSAlan Cox  * MPSAFE
186df8bae1dSRodney W. Grimes  */
18724a1cce3SDavid Greenman vm_object_t
1886cde7a16SDavid Greenman vnode_pager_alloc(void *handle, vm_ooffset_t size, vm_prot_t prot,
1893364c323SKonstantin Belousov     vm_ooffset_t offset, struct ucred *cred)
190df8bae1dSRodney W. Grimes {
19106cb7259SDavid Greenman 	vm_object_t object;
192df8bae1dSRodney W. Grimes 	struct vnode *vp;
193df8bae1dSRodney W. Grimes 
194df8bae1dSRodney W. Grimes 	/*
195df8bae1dSRodney W. Grimes 	 * Pageout to vnode, no can do yet.
196df8bae1dSRodney W. Grimes 	 */
197df8bae1dSRodney W. Grimes 	if (handle == NULL)
198df8bae1dSRodney W. Grimes 		return (NULL);
199df8bae1dSRodney W. Grimes 
200df8bae1dSRodney W. Grimes 	vp = (struct vnode *) handle;
20139d38f93SDavid Greenman 
20239d38f93SDavid Greenman 	/*
20339d38f93SDavid Greenman 	 * If the object is being terminated, wait for it to
20439d38f93SDavid Greenman 	 * go away.
20539d38f93SDavid Greenman 	 */
2062ac78f0eSStephan Uphoff retry:
2071ca58953SAlan Cox 	while ((object = vp->v_object) != NULL) {
2081ca58953SAlan Cox 		VM_OBJECT_LOCK(object);
2091ca58953SAlan Cox 		if ((object->flags & OBJ_DEAD) == 0)
2101ca58953SAlan Cox 			break;
21119187819SAlan Cox 		vm_object_set_flag(object, OBJ_DISCONNECTWNT);
2121ca58953SAlan Cox 		msleep(object, VM_OBJECT_MTX(object), PDROP | PVM, "vadead", 0);
21324a1cce3SDavid Greenman 	}
2140d94caffSDavid Greenman 
2152be70f79SJohn Dyson 	if (vp->v_usecount == 0)
2162be70f79SJohn Dyson 		panic("vnode_pager_alloc: no vnode reference");
2172be70f79SJohn Dyson 
21824a1cce3SDavid Greenman 	if (object == NULL) {
219df8bae1dSRodney W. Grimes 		/*
2202ac78f0eSStephan Uphoff 		 * Add an object of the appropriate size
221df8bae1dSRodney W. Grimes 		 */
2226cde7a16SDavid Greenman 		object = vm_object_allocate(OBJT_VNODE, OFF_TO_IDX(round_page(size)));
223bbc0ec52SDavid Greenman 
2246cde7a16SDavid Greenman 		object->un_pager.vnp.vnp_size = size;
22526f9a767SRodney W. Grimes 
22624a1cce3SDavid Greenman 		object->handle = handle;
22711be8415SStephan Uphoff 		VI_LOCK(vp);
2282ac78f0eSStephan Uphoff 		if (vp->v_object != NULL) {
2292ac78f0eSStephan Uphoff 			/*
2302ac78f0eSStephan Uphoff 			 * Object has been created while we were sleeping
2312ac78f0eSStephan Uphoff 			 */
23211be8415SStephan Uphoff 			VI_UNLOCK(vp);
2332ac78f0eSStephan Uphoff 			vm_object_destroy(object);
2342ac78f0eSStephan Uphoff 			goto retry;
235df8bae1dSRodney W. Grimes 		}
2362ac78f0eSStephan Uphoff 		vp->v_object = object;
23711be8415SStephan Uphoff 		VI_UNLOCK(vp);
23811be8415SStephan Uphoff 	} else {
2392ac78f0eSStephan Uphoff 		object->ref_count++;
2402ac78f0eSStephan Uphoff 		VM_OBJECT_UNLOCK(object);
24111be8415SStephan Uphoff 	}
2427747c038SJeff Roberson 	vref(vp);
24324a1cce3SDavid Greenman 	return (object);
244df8bae1dSRodney W. Grimes }
245df8bae1dSRodney W. Grimes 
246658ad5ffSAlan Cox /*
247658ad5ffSAlan Cox  *	The object must be locked.
248658ad5ffSAlan Cox  */
249f708ef1bSPoul-Henning Kamp static void
25024a1cce3SDavid Greenman vnode_pager_dealloc(object)
2510d94caffSDavid Greenman 	vm_object_t object;
25224a1cce3SDavid Greenman {
253b9f180d1SKonstantin Belousov 	struct vnode *vp;
254b9f180d1SKonstantin Belousov 	int refs;
255df8bae1dSRodney W. Grimes 
256b9f180d1SKonstantin Belousov 	vp = object->handle;
25724a1cce3SDavid Greenman 	if (vp == NULL)
25824a1cce3SDavid Greenman 		panic("vnode_pager_dealloc: pager already dealloced");
25924a1cce3SDavid Greenman 
260658ad5ffSAlan Cox 	VM_OBJECT_LOCK_ASSERT(object, MA_OWNED);
26166095752SJohn Dyson 	vm_object_pip_wait(object, "vnpdea");
262b9f180d1SKonstantin Belousov 	refs = object->ref_count;
26324a1cce3SDavid Greenman 
26424a1cce3SDavid Greenman 	object->handle = NULL;
26595461b45SJohn Dyson 	object->type = OBJT_DEAD;
26619187819SAlan Cox 	if (object->flags & OBJ_DISCONNECTWNT) {
26719187819SAlan Cox 		vm_object_clear_flag(object, OBJ_DISCONNECTWNT);
26819187819SAlan Cox 		wakeup(object);
26919187819SAlan Cox 	}
27057fd3d55SPawel Jakub Dawidek 	ASSERT_VOP_ELOCKED(vp, "vnode_pager_dealloc");
271aa2cabb9SDavid Greenman 	vp->v_object = NULL;
27235764be3SPoul-Henning Kamp 	vp->v_vflag &= ~VV_TEXT;
273b9f180d1SKonstantin Belousov 	while (refs-- > 0)
274b9f180d1SKonstantin Belousov 		vunref(vp);
275df8bae1dSRodney W. Grimes }
27626f9a767SRodney W. Grimes 
277f708ef1bSPoul-Henning Kamp static boolean_t
278a316d390SJohn Dyson vnode_pager_haspage(object, pindex, before, after)
27924a1cce3SDavid Greenman 	vm_object_t object;
280a316d390SJohn Dyson 	vm_pindex_t pindex;
28124a1cce3SDavid Greenman 	int *before;
28224a1cce3SDavid Greenman 	int *after;
283df8bae1dSRodney W. Grimes {
28424a1cce3SDavid Greenman 	struct vnode *vp = object->handle;
28598b0c789SPoul-Henning Kamp 	daddr_t bn;
2863af76890SPoul-Henning Kamp 	int err;
287170db9c6SJohn Dyson 	daddr_t reqblock;
2882c4488fcSJohn Dyson 	int poff;
2892c4488fcSJohn Dyson 	int bsize;
290d63596ceSJohn Dyson 	int pagesperblock, blocksperpage;
291ae51ff11SJeff Roberson 	int vfslocked;
292df8bae1dSRodney W. Grimes 
293f29ba63eSAlan Cox 	VM_OBJECT_LOCK_ASSERT(object, MA_OWNED);
29424579ca1SMatthew Dillon 	/*
29524579ca1SMatthew Dillon 	 * If no vp or vp is doomed or marked transparent to VM, we do not
29624579ca1SMatthew Dillon 	 * have the page.
29724579ca1SMatthew Dillon 	 */
298b73f64c4SJeff Roberson 	if (vp == NULL || vp->v_iflag & VI_DOOMED)
29947221757SJohn Dyson 		return FALSE;
300df8bae1dSRodney W. Grimes 	/*
301b73f64c4SJeff Roberson 	 * If the offset is beyond end of file we do
3020d94caffSDavid Greenman 	 * not have the page.
303df8bae1dSRodney W. Grimes 	 */
304b73f64c4SJeff Roberson 	if (IDX_TO_OFF(pindex) >= object->un_pager.vnp.vnp_size)
3054abc71c0SDavid Greenman 		return FALSE;
306df8bae1dSRodney W. Grimes 
307eed2d59bSDavid Greenman 	bsize = vp->v_mount->mnt_stat.f_iosize;
308170db9c6SJohn Dyson 	pagesperblock = bsize / PAGE_SIZE;
309d63596ceSJohn Dyson 	blocksperpage = 0;
310d63596ceSJohn Dyson 	if (pagesperblock > 0) {
311a316d390SJohn Dyson 		reqblock = pindex / pagesperblock;
312d63596ceSJohn Dyson 	} else {
313d63596ceSJohn Dyson 		blocksperpage = (PAGE_SIZE / bsize);
314d63596ceSJohn Dyson 		reqblock = pindex * blocksperpage;
315d63596ceSJohn Dyson 	}
316f29ba63eSAlan Cox 	VM_OBJECT_UNLOCK(object);
317ae51ff11SJeff Roberson 	vfslocked = VFS_LOCK_GIANT(vp->v_mount);
318ec794849SPoul-Henning Kamp 	err = VOP_BMAP(vp, reqblock, NULL, &bn, after, before);
319ae51ff11SJeff Roberson 	VFS_UNLOCK_GIANT(vfslocked);
320f29ba63eSAlan Cox 	VM_OBJECT_LOCK(object);
3210d94caffSDavid Greenman 	if (err)
32224a1cce3SDavid Greenman 		return TRUE;
3236eab77f2SJohn Dyson 	if (bn == -1)
324ced399eeSJohn Dyson 		return FALSE;
325d63596ceSJohn Dyson 	if (pagesperblock > 0) {
326a316d390SJohn Dyson 		poff = pindex - (reqblock * pagesperblock);
327170db9c6SJohn Dyson 		if (before) {
328170db9c6SJohn Dyson 			*before *= pagesperblock;
329170db9c6SJohn Dyson 			*before += poff;
330170db9c6SJohn Dyson 		}
331170db9c6SJohn Dyson 		if (after) {
332b1fc01b7SJohn Dyson 			int numafter;
333170db9c6SJohn Dyson 			*after *= pagesperblock;
334b1fc01b7SJohn Dyson 			numafter = pagesperblock - (poff + 1);
33547e151ddSRobert Drehmel 			if (IDX_TO_OFF(pindex + numafter) >
33647e151ddSRobert Drehmel 			    object->un_pager.vnp.vnp_size) {
33747e151ddSRobert Drehmel 				numafter =
33847e151ddSRobert Drehmel 		    		    OFF_TO_IDX(object->un_pager.vnp.vnp_size) -
33947e151ddSRobert Drehmel 				    pindex;
340b1fc01b7SJohn Dyson 			}
341b1fc01b7SJohn Dyson 			*after += numafter;
342170db9c6SJohn Dyson 		}
343d63596ceSJohn Dyson 	} else {
344d63596ceSJohn Dyson 		if (before) {
345d63596ceSJohn Dyson 			*before /= blocksperpage;
346d63596ceSJohn Dyson 		}
347d63596ceSJohn Dyson 
348d63596ceSJohn Dyson 		if (after) {
349d63596ceSJohn Dyson 			*after /= blocksperpage;
350d63596ceSJohn Dyson 		}
351d63596ceSJohn Dyson 	}
352ced399eeSJohn Dyson 	return TRUE;
353df8bae1dSRodney W. Grimes }
354df8bae1dSRodney W. Grimes 
355df8bae1dSRodney W. Grimes /*
356df8bae1dSRodney W. Grimes  * Lets the VM system know about a change in size for a file.
35724a1cce3SDavid Greenman  * We adjust our own internal size and flush any cached pages in
358df8bae1dSRodney W. Grimes  * the associated object that are affected by the size change.
359df8bae1dSRodney W. Grimes  *
360df8bae1dSRodney W. Grimes  * Note: this routine may be invoked as a result of a pager put
361df8bae1dSRodney W. Grimes  * operation (possibly at object termination time), so we must be careful.
362df8bae1dSRodney W. Grimes  */
363df8bae1dSRodney W. Grimes void
364df8bae1dSRodney W. Grimes vnode_pager_setsize(vp, nsize)
365df8bae1dSRodney W. Grimes 	struct vnode *vp;
366a316d390SJohn Dyson 	vm_ooffset_t nsize;
367df8bae1dSRodney W. Grimes {
3682a8f9ab5SAlan Cox 	vm_object_t object;
3692a8f9ab5SAlan Cox 	vm_page_t m;
370c576d121SLuoqi Chen 	vm_pindex_t nobjsize;
371df8bae1dSRodney W. Grimes 
3722a8f9ab5SAlan Cox 	if ((object = vp->v_object) == NULL)
373df8bae1dSRodney W. Grimes 		return;
374cb61d698SKonstantin Belousov /* 	ASSERT_VOP_ELOCKED(vp, "vnode_pager_setsize and not locked vnode"); */
3752a8f9ab5SAlan Cox 	VM_OBJECT_LOCK(object);
3762a8f9ab5SAlan Cox 	if (nsize == object->un_pager.vnp.vnp_size) {
377df8bae1dSRodney W. Grimes 		/*
378df8bae1dSRodney W. Grimes 		 * Hasn't changed size
379df8bae1dSRodney W. Grimes 		 */
3802a8f9ab5SAlan Cox 		VM_OBJECT_UNLOCK(object);
381df8bae1dSRodney W. Grimes 		return;
3822a8f9ab5SAlan Cox 	}
383c576d121SLuoqi Chen 	nobjsize = OFF_TO_IDX(nsize + PAGE_MASK);
3842a8f9ab5SAlan Cox 	if (nsize < object->un_pager.vnp.vnp_size) {
385df8bae1dSRodney W. Grimes 		/*
386bbc0ec52SDavid Greenman 		 * File has shrunk. Toss any cached pages beyond the new EOF.
387df8bae1dSRodney W. Grimes 		 */
3882a8f9ab5SAlan Cox 		if (nobjsize < object->size)
389c576d121SLuoqi Chen 			vm_object_page_remove(object, nobjsize, object->size,
3906bbee8e2SAlan Cox 			    0);
391bbc0ec52SDavid Greenman 		/*
392bbc0ec52SDavid Greenman 		 * this gets rid of garbage at the end of a page that is now
3933ebeaf59SMatthew Dillon 		 * only partially backed by the vnode.
3943ebeaf59SMatthew Dillon 		 *
3953ebeaf59SMatthew Dillon 		 * XXX for some reason (I don't know yet), if we take a
3963ebeaf59SMatthew Dillon 		 * completely invalid page and mark it partially valid
3973ebeaf59SMatthew Dillon 		 * it can screw up NFS reads, so we don't allow the case.
398bbc0ec52SDavid Greenman 		 */
3992a8f9ab5SAlan Cox 		if ((nsize & PAGE_MASK) &&
4001b26eb10SAlan Cox 		    (m = vm_page_lookup(object, OFF_TO_IDX(nsize))) != NULL &&
4011b26eb10SAlan Cox 		    m->valid != 0) {
4022b6b0df7SMatthew Dillon 			int base = (int)nsize & PAGE_MASK;
4032b6b0df7SMatthew Dillon 			int size = PAGE_SIZE - base;
4042b6b0df7SMatthew Dillon 
4052b6b0df7SMatthew Dillon 			/*
4062b6b0df7SMatthew Dillon 			 * Clear out partial-page garbage in case
4072b6b0df7SMatthew Dillon 			 * the page has been mapped.
4082b6b0df7SMatthew Dillon 			 */
409fff6062aSAlan Cox 			pmap_zero_page_area(m, base, size);
4102b6b0df7SMatthew Dillon 
4112b6b0df7SMatthew Dillon 			/*
4123c33df62SAlan Cox 			 * Update the valid bits to reflect the blocks that
4133c33df62SAlan Cox 			 * have been zeroed.  Some of these valid bits may
4143c33df62SAlan Cox 			 * have already been set.
4153c33df62SAlan Cox 			 */
4163c33df62SAlan Cox 			vm_page_set_valid(m, base, size);
4173c33df62SAlan Cox 
4183c33df62SAlan Cox 			/*
4193c33df62SAlan Cox 			 * Round "base" to the next block boundary so that the
4203c33df62SAlan Cox 			 * dirty bit for a partially zeroed block is not
4213c33df62SAlan Cox 			 * cleared.
4223c33df62SAlan Cox 			 */
4233c33df62SAlan Cox 			base = roundup2(base, DEV_BSIZE);
4243c33df62SAlan Cox 
4253c33df62SAlan Cox 			/*
4263c33df62SAlan Cox 			 * Clear out partial-page dirty bits.
4273ebeaf59SMatthew Dillon 			 *
4283ebeaf59SMatthew Dillon 			 * note that we do not clear out the valid
4293ebeaf59SMatthew Dillon 			 * bits.  This would prevent bogus_page
4303ebeaf59SMatthew Dillon 			 * replacement from working properly.
4312b6b0df7SMatthew Dillon 			 */
4323c33df62SAlan Cox 			vm_page_clear_dirty(m, base, PAGE_SIZE - base);
4330ab3c7a5SAlan Cox 		} else if ((nsize & PAGE_MASK) &&
4340ab3c7a5SAlan Cox 		    __predict_false(object->cache != NULL)) {
4350ab3c7a5SAlan Cox 			vm_page_cache_free(object, OFF_TO_IDX(nsize),
4360ab3c7a5SAlan Cox 			    nobjsize);
437bbc0ec52SDavid Greenman 		}
438bbc0ec52SDavid Greenman 	}
439a316d390SJohn Dyson 	object->un_pager.vnp.vnp_size = nsize;
440c576d121SLuoqi Chen 	object->size = nobjsize;
4412a8f9ab5SAlan Cox 	VM_OBJECT_UNLOCK(object);
442df8bae1dSRodney W. Grimes }
443df8bae1dSRodney W. Grimes 
44426f9a767SRodney W. Grimes /*
44526f9a767SRodney W. Grimes  * calculate the linear (byte) disk address of specified virtual
44626f9a767SRodney W. Grimes  * file address
44726f9a767SRodney W. Grimes  */
448bff76343SAlan Cox static int
449bff76343SAlan Cox vnode_pager_addr(struct vnode *vp, vm_ooffset_t address, daddr_t *rtaddress,
450bff76343SAlan Cox     int *run)
45126f9a767SRodney W. Grimes {
45226f9a767SRodney W. Grimes 	int bsize;
45326f9a767SRodney W. Grimes 	int err;
454a316d390SJohn Dyson 	daddr_t vblock;
455f3aad9a6SBjoern A. Zeeb 	daddr_t voffset;
45626f9a767SRodney W. Grimes 
4572ad036b6SAlan Cox 	if (address < 0)
4580d94caffSDavid Greenman 		return -1;
4590d94caffSDavid Greenman 
460b73f64c4SJeff Roberson 	if (vp->v_iflag & VI_DOOMED)
4612c4488fcSJohn Dyson 		return -1;
4622c4488fcSJohn Dyson 
46326f9a767SRodney W. Grimes 	bsize = vp->v_mount->mnt_stat.f_iosize;
46426f9a767SRodney W. Grimes 	vblock = address / bsize;
46526f9a767SRodney W. Grimes 	voffset = address % bsize;
46626f9a767SRodney W. Grimes 
467bff76343SAlan Cox 	err = VOP_BMAP(vp, vblock, NULL, rtaddress, run, NULL);
468bff76343SAlan Cox 	if (err == 0) {
469bff76343SAlan Cox 		if (*rtaddress != -1)
470bff76343SAlan Cox 			*rtaddress += voffset / DEV_BSIZE;
471efc68ce1SDavid Greenman 		if (run) {
472efc68ce1SDavid Greenman 			*run += 1;
473efc68ce1SDavid Greenman 			*run *= bsize/PAGE_SIZE;
474efc68ce1SDavid Greenman 			*run -= voffset/PAGE_SIZE;
475efc68ce1SDavid Greenman 		}
476efc68ce1SDavid Greenman 	}
47726f9a767SRodney W. Grimes 
478bff76343SAlan Cox 	return (err);
47926f9a767SRodney W. Grimes }
48026f9a767SRodney W. Grimes 
48126f9a767SRodney W. Grimes /*
48226f9a767SRodney W. Grimes  * small block filesystem vnode pager input
48326f9a767SRodney W. Grimes  */
484f708ef1bSPoul-Henning Kamp static int
48524a1cce3SDavid Greenman vnode_pager_input_smlfs(object, m)
48624a1cce3SDavid Greenman 	vm_object_t object;
48726f9a767SRodney W. Grimes 	vm_page_t m;
48826f9a767SRodney W. Grimes {
4899c83534dSPoul-Henning Kamp 	struct vnode *vp;
4909c83534dSPoul-Henning Kamp 	struct bufobj *bo;
49126f9a767SRodney W. Grimes 	struct buf *bp;
4929e0ddbd0SAlan Cox 	struct sf_buf *sf;
493f3aad9a6SBjoern A. Zeeb 	daddr_t fileaddr;
49426f9a767SRodney W. Grimes 	vm_offset_t bsize;
495*561cc9fcSKonstantin Belousov 	vm_page_bits_t bits;
496*561cc9fcSKonstantin Belousov 	int error, i;
49726f9a767SRodney W. Grimes 
498*561cc9fcSKonstantin Belousov 	error = 0;
49924a1cce3SDavid Greenman 	vp = object->handle;
500b73f64c4SJeff Roberson 	if (vp->v_iflag & VI_DOOMED)
5012c4488fcSJohn Dyson 		return VM_PAGER_BAD;
5022c4488fcSJohn Dyson 
50326f9a767SRodney W. Grimes 	bsize = vp->v_mount->mnt_stat.f_iosize;
5040bdb7528SDavid Greenman 
5059c83534dSPoul-Henning Kamp 	VOP_BMAP(vp, 0, &bo, 0, NULL, NULL);
50626f9a767SRodney W. Grimes 
5079e0ddbd0SAlan Cox 	sf = sf_buf_alloc(m, 0);
50826f9a767SRodney W. Grimes 
50926f9a767SRodney W. Grimes 	for (i = 0; i < PAGE_SIZE / bsize; i++) {
51033c67741SMatthew Dillon 		vm_ooffset_t address;
511bbc0ec52SDavid Greenman 
5120d53a17bSAlan Cox 		bits = vm_page_bits(i * bsize, bsize);
5130d53a17bSAlan Cox 		if (m->valid & bits)
51426f9a767SRodney W. Grimes 			continue;
51526f9a767SRodney W. Grimes 
51633c67741SMatthew Dillon 		address = IDX_TO_OFF(m->pindex) + i * bsize;
51733c67741SMatthew Dillon 		if (address >= object->un_pager.vnp.vnp_size) {
51833c67741SMatthew Dillon 			fileaddr = -1;
51933c67741SMatthew Dillon 		} else {
520bff76343SAlan Cox 			error = vnode_pager_addr(vp, address, &fileaddr, NULL);
521bff76343SAlan Cox 			if (error)
522bff76343SAlan Cox 				break;
52333c67741SMatthew Dillon 		}
52426f9a767SRodney W. Grimes 		if (fileaddr != -1) {
5251c7c3c6aSMatthew Dillon 			bp = getpbuf(&vnode_pbuf_freecnt);
52626f9a767SRodney W. Grimes 
52726f9a767SRodney W. Grimes 			/* build a minimal buffer header */
52821144e3bSPoul-Henning Kamp 			bp->b_iocmd = BIO_READ;
5296a4b5823SPoul-Henning Kamp 			bp->b_iodone = bdone;
530bd78ceceSJohn Baldwin 			KASSERT(bp->b_rcred == NOCRED, ("leaking read ucred"));
531bd78ceceSJohn Baldwin 			KASSERT(bp->b_wcred == NOCRED, ("leaking write ucred"));
532a854ed98SJohn Baldwin 			bp->b_rcred = crhold(curthread->td_ucred);
533a854ed98SJohn Baldwin 			bp->b_wcred = crhold(curthread->td_ucred);
5349e0ddbd0SAlan Cox 			bp->b_data = (caddr_t)sf_buf_kva(sf) + i * bsize;
535187f0071SDavid Greenman 			bp->b_blkno = fileaddr;
5369c83534dSPoul-Henning Kamp 			pbgetbo(bo, bp);
53726f9a767SRodney W. Grimes 			bp->b_bcount = bsize;
53826f9a767SRodney W. Grimes 			bp->b_bufsize = bsize;
5392b6b0df7SMatthew Dillon 			bp->b_runningbufspace = bp->b_bufsize;
5405bd65606SJohn Baldwin 			atomic_add_long(&runningbufspace, bp->b_runningbufspace);
54126f9a767SRodney W. Grimes 
54226f9a767SRodney W. Grimes 			/* do the input */
5432c18019fSPoul-Henning Kamp 			bp->b_iooffset = dbtob(bp->b_blkno);
544b792bebeSPoul-Henning Kamp 			bstrategy(bp);
54526f9a767SRodney W. Grimes 
5466a4b5823SPoul-Henning Kamp 			bwait(bp, PVM, "vnsrd");
5476a4b5823SPoul-Henning Kamp 
548c244d2deSPoul-Henning Kamp 			if ((bp->b_ioflags & BIO_ERROR) != 0)
54926f9a767SRodney W. Grimes 				error = EIO;
55026f9a767SRodney W. Grimes 
55126f9a767SRodney W. Grimes 			/*
55226f9a767SRodney W. Grimes 			 * free the buffer header back to the swap buffer pool
55326f9a767SRodney W. Grimes 			 */
5549c83534dSPoul-Henning Kamp 			pbrelbo(bp);
5551c7c3c6aSMatthew Dillon 			relpbuf(bp, &vnode_pbuf_freecnt);
55626f9a767SRodney W. Grimes 			if (error)
55726f9a767SRodney W. Grimes 				break;
5580d53a17bSAlan Cox 		} else
5599e0ddbd0SAlan Cox 			bzero((caddr_t)sf_buf_kva(sf) + i * bsize, bsize);
5600d53a17bSAlan Cox 		KASSERT((m->dirty & bits) == 0,
5610d53a17bSAlan Cox 		    ("vnode_pager_input_smlfs: page %p is dirty", m));
5620d53a17bSAlan Cox 		VM_OBJECT_LOCK(object);
5630d53a17bSAlan Cox 		m->valid |= bits;
5640d53a17bSAlan Cox 		VM_OBJECT_UNLOCK(object);
56526f9a767SRodney W. Grimes 	}
5669e0ddbd0SAlan Cox 	sf_buf_free(sf);
56726f9a767SRodney W. Grimes 	if (error) {
568a83c285cSDavid Greenman 		return VM_PAGER_ERROR;
56926f9a767SRodney W. Grimes 	}
57026f9a767SRodney W. Grimes 	return VM_PAGER_OK;
57126f9a767SRodney W. Grimes }
57226f9a767SRodney W. Grimes 
57326f9a767SRodney W. Grimes /*
574475e8cc3SPoul-Henning Kamp  * old style vnode pager input routine
57526f9a767SRodney W. Grimes  */
576f708ef1bSPoul-Henning Kamp static int
57724a1cce3SDavid Greenman vnode_pager_input_old(object, m)
57824a1cce3SDavid Greenman 	vm_object_t object;
57926f9a767SRodney W. Grimes 	vm_page_t m;
58026f9a767SRodney W. Grimes {
581df8bae1dSRodney W. Grimes 	struct uio auio;
582df8bae1dSRodney W. Grimes 	struct iovec aiov;
58326f9a767SRodney W. Grimes 	int error;
58426f9a767SRodney W. Grimes 	int size;
5859e0ddbd0SAlan Cox 	struct sf_buf *sf;
586342a1480SJohn Baldwin 	struct vnode *vp;
587df8bae1dSRodney W. Grimes 
58852051abcSAlan Cox 	VM_OBJECT_LOCK_ASSERT(object, MA_OWNED);
58926f9a767SRodney W. Grimes 	error = 0;
590bbc0ec52SDavid Greenman 
591df8bae1dSRodney W. Grimes 	/*
59226f9a767SRodney W. Grimes 	 * Return failure if beyond current EOF
59326f9a767SRodney W. Grimes 	 */
594a316d390SJohn Dyson 	if (IDX_TO_OFF(m->pindex) >= object->un_pager.vnp.vnp_size) {
59526f9a767SRodney W. Grimes 		return VM_PAGER_BAD;
59626f9a767SRodney W. Grimes 	} else {
59726f9a767SRodney W. Grimes 		size = PAGE_SIZE;
598a316d390SJohn Dyson 		if (IDX_TO_OFF(m->pindex) + size > object->un_pager.vnp.vnp_size)
599a316d390SJohn Dyson 			size = object->un_pager.vnp.vnp_size - IDX_TO_OFF(m->pindex);
60052051abcSAlan Cox 		vp = object->handle;
60152051abcSAlan Cox 		VM_OBJECT_UNLOCK(object);
6020bdb7528SDavid Greenman 
60326f9a767SRodney W. Grimes 		/*
604df8bae1dSRodney W. Grimes 		 * Allocate a kernel virtual address and initialize so that
605df8bae1dSRodney W. Grimes 		 * we can use VOP_READ/WRITE routines.
606df8bae1dSRodney W. Grimes 		 */
6079e0ddbd0SAlan Cox 		sf = sf_buf_alloc(m, 0);
6080bdb7528SDavid Greenman 
6099e0ddbd0SAlan Cox 		aiov.iov_base = (caddr_t)sf_buf_kva(sf);
610df8bae1dSRodney W. Grimes 		aiov.iov_len = size;
611df8bae1dSRodney W. Grimes 		auio.uio_iov = &aiov;
612df8bae1dSRodney W. Grimes 		auio.uio_iovcnt = 1;
613a316d390SJohn Dyson 		auio.uio_offset = IDX_TO_OFF(m->pindex);
614df8bae1dSRodney W. Grimes 		auio.uio_segflg = UIO_SYSSPACE;
61526f9a767SRodney W. Grimes 		auio.uio_rw = UIO_READ;
616df8bae1dSRodney W. Grimes 		auio.uio_resid = size;
617b40ce416SJulian Elischer 		auio.uio_td = curthread;
61826f9a767SRodney W. Grimes 
619a854ed98SJohn Baldwin 		error = VOP_READ(vp, &auio, 0, curthread->td_ucred);
620df8bae1dSRodney W. Grimes 		if (!error) {
62154d92145SMatthew Dillon 			int count = size - auio.uio_resid;
622df8bae1dSRodney W. Grimes 
623df8bae1dSRodney W. Grimes 			if (count == 0)
624df8bae1dSRodney W. Grimes 				error = EINVAL;
62526f9a767SRodney W. Grimes 			else if (count != PAGE_SIZE)
6269e0ddbd0SAlan Cox 				bzero((caddr_t)sf_buf_kva(sf) + count,
6279e0ddbd0SAlan Cox 				    PAGE_SIZE - count);
628df8bae1dSRodney W. Grimes 		}
6299e0ddbd0SAlan Cox 		sf_buf_free(sf);
6301b26eb10SAlan Cox 
6311b26eb10SAlan Cox 		VM_OBJECT_LOCK(object);
632df8bae1dSRodney W. Grimes 	}
6330d53a17bSAlan Cox 	KASSERT(m->dirty == 0, ("vnode_pager_input_old: page %p is dirty", m));
6346e3a3f38SRobert V. Baron 	if (!error)
6356e3a3f38SRobert V. Baron 		m->valid = VM_PAGE_BITS_ALL;
636a83c285cSDavid Greenman 	return error ? VM_PAGER_ERROR : VM_PAGER_OK;
63726f9a767SRodney W. Grimes }
63826f9a767SRodney W. Grimes 
63926f9a767SRodney W. Grimes /*
64026f9a767SRodney W. Grimes  * generic vnode pager input routine
64126f9a767SRodney W. Grimes  */
642170db9c6SJohn Dyson 
643ce75f2c3SMike Smith /*
64423955314SAlfred Perlstein  * Local media VFS's that do not implement their own VOP_GETPAGES
64547e151ddSRobert Drehmel  * should have their VOP_GETPAGES call to vnode_pager_generic_getpages()
64647e151ddSRobert Drehmel  * to implement the previous behaviour.
647ce75f2c3SMike Smith  *
648ce75f2c3SMike Smith  * All other FS's should use the bypass to get to the local media
649ce75f2c3SMike Smith  * backing vp's VOP_GETPAGES.
650ce75f2c3SMike Smith  */
651f708ef1bSPoul-Henning Kamp static int
65224a1cce3SDavid Greenman vnode_pager_getpages(object, m, count, reqpage)
65326f9a767SRodney W. Grimes 	vm_object_t object;
65424a1cce3SDavid Greenman 	vm_page_t *m;
65524a1cce3SDavid Greenman 	int count;
65624a1cce3SDavid Greenman 	int reqpage;
65724a1cce3SDavid Greenman {
658170db9c6SJohn Dyson 	int rtval;
659170db9c6SJohn Dyson 	struct vnode *vp;
66086ffbd76SMike Smith 	int bytes = count * PAGE_SIZE;
661ae51ff11SJeff Roberson 	int vfslocked;
66295e5e988SJohn Dyson 
663170db9c6SJohn Dyson 	vp = object->handle;
6648630c117SAlan Cox 	VM_OBJECT_UNLOCK(object);
665ae51ff11SJeff Roberson 	vfslocked = VFS_LOCK_GIANT(vp->v_mount);
66686ffbd76SMike Smith 	rtval = VOP_GETPAGES(vp, m, bytes, reqpage, 0);
66723955314SAlfred Perlstein 	KASSERT(rtval != EOPNOTSUPP,
66823955314SAlfred Perlstein 	    ("vnode_pager: FS getpages not implemented\n"));
669ae51ff11SJeff Roberson 	VFS_UNLOCK_GIANT(vfslocked);
6708630c117SAlan Cox 	VM_OBJECT_LOCK(object);
671170db9c6SJohn Dyson 	return rtval;
672170db9c6SJohn Dyson }
673170db9c6SJohn Dyson 
674ce75f2c3SMike Smith /*
675ce75f2c3SMike Smith  * This is now called from local media FS's to operate against their
676ce75f2c3SMike Smith  * own vnodes if they fail to implement VOP_GETPAGES.
677ce75f2c3SMike Smith  */
678ce75f2c3SMike Smith int
679ce75f2c3SMike Smith vnode_pager_generic_getpages(vp, m, bytecount, reqpage)
680ce75f2c3SMike Smith 	struct vnode *vp;
681170db9c6SJohn Dyson 	vm_page_t *m;
682ce75f2c3SMike Smith 	int bytecount;
683170db9c6SJohn Dyson 	int reqpage;
684170db9c6SJohn Dyson {
685ce75f2c3SMike Smith 	vm_object_t object;
686a316d390SJohn Dyson 	vm_offset_t kva;
6878f9110f6SJohn Dyson 	off_t foff, tfoff, nextoff;
688f3aad9a6SBjoern A. Zeeb 	int i, j, size, bsize, first;
689f4f83da0SAlan Cox 	daddr_t firstaddr, reqblock;
6909c83534dSPoul-Henning Kamp 	struct bufobj *bo;
691efc68ce1SDavid Greenman 	int runpg;
692efc68ce1SDavid Greenman 	int runend;
6930bdb7528SDavid Greenman 	struct buf *bp;
694ce75f2c3SMike Smith 	int count;
6951de11f1aSAlan Cox 	int error;
69626f9a767SRodney W. Grimes 
697ce75f2c3SMike Smith 	object = vp->v_object;
698ce75f2c3SMike Smith 	count = bytecount / PAGE_SIZE;
699ce75f2c3SMike Smith 
7009c83534dSPoul-Henning Kamp 	KASSERT(vp->v_type != VCHR && vp->v_type != VBLK,
7019c83534dSPoul-Henning Kamp 	    ("vnode_pager_generic_getpages does not support devices"));
702b73f64c4SJeff Roberson 	if (vp->v_iflag & VI_DOOMED)
7032c4488fcSJohn Dyson 		return VM_PAGER_BAD;
7042c4488fcSJohn Dyson 
70526f9a767SRodney W. Grimes 	bsize = vp->v_mount->mnt_stat.f_iosize;
70626f9a767SRodney W. Grimes 
70726f9a767SRodney W. Grimes 	/* get the UNDERLYING device for the file with VOP_BMAP() */
708bbc0ec52SDavid Greenman 
70926f9a767SRodney W. Grimes 	/*
710bbc0ec52SDavid Greenman 	 * originally, we did not check for an error return value -- assuming
711bbc0ec52SDavid Greenman 	 * an fs always has a bmap entry point -- that assumption is wrong!!!
71226f9a767SRodney W. Grimes 	 */
713a316d390SJohn Dyson 	foff = IDX_TO_OFF(m[reqpage]->pindex);
714bbc0ec52SDavid Greenman 
71526f9a767SRodney W. Grimes 	/*
71616f62314SDavid Greenman 	 * if we can't bmap, use old VOP code
71726f9a767SRodney W. Grimes 	 */
7181de11f1aSAlan Cox 	error = VOP_BMAP(vp, foff / bsize, &bo, &reqblock, NULL, NULL);
7191de11f1aSAlan Cox 	if (error == EOPNOTSUPP) {
72031953be9SAlan Cox 		VM_OBJECT_LOCK(object);
7212965a453SKip Macy 
722e43c2eabSAlan Cox 		for (i = 0; i < count; i++)
7232965a453SKip Macy 			if (i != reqpage) {
7242965a453SKip Macy 				vm_page_lock(m[i]);
725d8d5fa88SAlfred Perlstein 				vm_page_free(m[i]);
7262965a453SKip Macy 				vm_page_unlock(m[i]);
7272965a453SKip Macy 			}
728b4b70819SAttilio Rao 		PCPU_INC(cnt.v_vnodein);
729b4b70819SAttilio Rao 		PCPU_INC(cnt.v_vnodepgsin);
73052051abcSAlan Cox 		error = vnode_pager_input_old(object, m[reqpage]);
73152051abcSAlan Cox 		VM_OBJECT_UNLOCK(object);
73252051abcSAlan Cox 		return (error);
7331de11f1aSAlan Cox 	} else if (error != 0) {
7341de11f1aSAlan Cox 		VM_OBJECT_LOCK(object);
7351de11f1aSAlan Cox 		for (i = 0; i < count; i++)
7362965a453SKip Macy 			if (i != reqpage) {
7372965a453SKip Macy 				vm_page_lock(m[i]);
7381de11f1aSAlan Cox 				vm_page_free(m[i]);
7392965a453SKip Macy 				vm_page_unlock(m[i]);
7402965a453SKip Macy 			}
7411de11f1aSAlan Cox 		VM_OBJECT_UNLOCK(object);
7421de11f1aSAlan Cox 		return (VM_PAGER_ERROR);
743bbc0ec52SDavid Greenman 
74426f9a767SRodney W. Grimes 		/*
74526f9a767SRodney W. Grimes 		 * if the blocksize is smaller than a page size, then use
74626f9a767SRodney W. Grimes 		 * special small filesystem code.  NFS sometimes has a small
74726f9a767SRodney W. Grimes 		 * blocksize, but it can handle large reads itself.
74826f9a767SRodney W. Grimes 		 */
74926f9a767SRodney W. Grimes 	} else if ((PAGE_SIZE / bsize) > 1 &&
750500b04a2SBruce Evans 	    (vp->v_mount->mnt_stat.f_type != nfs_mount_type)) {
75131953be9SAlan Cox 		VM_OBJECT_LOCK(object);
752e43c2eabSAlan Cox 		for (i = 0; i < count; i++)
7532965a453SKip Macy 			if (i != reqpage) {
7542965a453SKip Macy 				vm_page_lock(m[i]);
755d8d5fa88SAlfred Perlstein 				vm_page_free(m[i]);
7562965a453SKip Macy 				vm_page_unlock(m[i]);
7572965a453SKip Macy 			}
75831953be9SAlan Cox 		VM_OBJECT_UNLOCK(object);
759b4b70819SAttilio Rao 		PCPU_INC(cnt.v_vnodein);
760b4b70819SAttilio Rao 		PCPU_INC(cnt.v_vnodepgsin);
76124a1cce3SDavid Greenman 		return vnode_pager_input_smlfs(object, m[reqpage]);
76226f9a767SRodney W. Grimes 	}
7638d17e694SJulian Elischer 
76426f9a767SRodney W. Grimes 	/*
7658d17e694SJulian Elischer 	 * If we have a completely valid page available to us, we can
7668d17e694SJulian Elischer 	 * clean up and return.  Otherwise we have to re-read the
7678d17e694SJulian Elischer 	 * media.
7680d94caffSDavid Greenman 	 */
76931953be9SAlan Cox 	VM_OBJECT_LOCK(object);
7708b575f6cSAlan Cox 	if (m[reqpage]->valid == VM_PAGE_BITS_ALL) {
771e43c2eabSAlan Cox 		for (i = 0; i < count; i++)
7722965a453SKip Macy 			if (i != reqpage) {
7732965a453SKip Macy 				vm_page_lock(m[i]);
774d8d5fa88SAlfred Perlstein 				vm_page_free(m[i]);
7752965a453SKip Macy 				vm_page_unlock(m[i]);
7762965a453SKip Macy 			}
77731953be9SAlan Cox 		VM_OBJECT_UNLOCK(object);
7780d94caffSDavid Greenman 		return VM_PAGER_OK;
779f4f83da0SAlan Cox 	} else if (reqblock == -1) {
780f4f83da0SAlan Cox 		pmap_zero_page(m[reqpage]);
78112aa4fdcSAlan Cox 		KASSERT(m[reqpage]->dirty == 0,
78212aa4fdcSAlan Cox 		    ("vnode_pager_generic_getpages: page %p is dirty", m));
783f4f83da0SAlan Cox 		m[reqpage]->valid = VM_PAGE_BITS_ALL;
784f4f83da0SAlan Cox 		for (i = 0; i < count; i++)
7852965a453SKip Macy 			if (i != reqpage) {
7862965a453SKip Macy 				vm_page_lock(m[i]);
787f4f83da0SAlan Cox 				vm_page_free(m[i]);
7882965a453SKip Macy 				vm_page_unlock(m[i]);
7892965a453SKip Macy 			}
790f4f83da0SAlan Cox 		VM_OBJECT_UNLOCK(object);
791f4f83da0SAlan Cox 		return (VM_PAGER_OK);
7920d94caffSDavid Greenman 	}
7938d17e694SJulian Elischer 	m[reqpage]->valid = 0;
7948b575f6cSAlan Cox 	VM_OBJECT_UNLOCK(object);
7950bdb7528SDavid Greenman 
7960d94caffSDavid Greenman 	/*
79726f9a767SRodney W. Grimes 	 * here on direct device I/O
79826f9a767SRodney W. Grimes 	 */
799efc68ce1SDavid Greenman 	firstaddr = -1;
800a1287949SEivind Eklund 
80126f9a767SRodney W. Grimes 	/*
802efc68ce1SDavid Greenman 	 * calculate the run that includes the required page
80326f9a767SRodney W. Grimes 	 */
804efc68ce1SDavid Greenman 	for (first = 0, i = 0; i < count; i = runend) {
805bff76343SAlan Cox 		if (vnode_pager_addr(vp, IDX_TO_OFF(m[i]->pindex), &firstaddr,
806bff76343SAlan Cox 		    &runpg) != 0) {
807bff76343SAlan Cox 			VM_OBJECT_LOCK(object);
808bff76343SAlan Cox 			for (; i < count; i++)
8092965a453SKip Macy 				if (i != reqpage) {
8102965a453SKip Macy 					vm_page_lock(m[i]);
811bff76343SAlan Cox 					vm_page_free(m[i]);
8122965a453SKip Macy 					vm_page_unlock(m[i]);
8132965a453SKip Macy 				}
814bff76343SAlan Cox 			VM_OBJECT_UNLOCK(object);
815bff76343SAlan Cox 			return (VM_PAGER_ERROR);
816bff76343SAlan Cox 		}
817efc68ce1SDavid Greenman 		if (firstaddr == -1) {
81831953be9SAlan Cox 			VM_OBJECT_LOCK(object);
81924a1cce3SDavid Greenman 			if (i == reqpage && foff < object->un_pager.vnp.vnp_size) {
820f3aad9a6SBjoern A. Zeeb 				panic("vnode_pager_getpages: unexpected missing page: firstaddr: %jd, foff: 0x%jx%08jx, vnp_size: 0x%jx%08jx",
821f3aad9a6SBjoern A. Zeeb 				    (intmax_t)firstaddr, (uintmax_t)(foff >> 32),
822bf1001faSMaxime Henrion 				    (uintmax_t)foff,
823bf1001faSMaxime Henrion 				    (uintmax_t)
824fc62ef1fSBruce Evans 				    (object->un_pager.vnp.vnp_size >> 32),
825bf1001faSMaxime Henrion 				    (uintmax_t)object->un_pager.vnp.vnp_size);
826efc68ce1SDavid Greenman 			}
8272965a453SKip Macy 			vm_page_lock(m[i]);
828d8d5fa88SAlfred Perlstein 			vm_page_free(m[i]);
8292965a453SKip Macy 			vm_page_unlock(m[i]);
83031953be9SAlan Cox 			VM_OBJECT_UNLOCK(object);
831efc68ce1SDavid Greenman 			runend = i + 1;
832efc68ce1SDavid Greenman 			first = runend;
833efc68ce1SDavid Greenman 			continue;
834efc68ce1SDavid Greenman 		}
835efc68ce1SDavid Greenman 		runend = i + runpg;
836efc68ce1SDavid Greenman 		if (runend <= reqpage) {
83731953be9SAlan Cox 			VM_OBJECT_LOCK(object);
8382965a453SKip Macy 			for (j = i; j < runend; j++) {
8392965a453SKip Macy 				vm_page_lock(m[j]);
840d8d5fa88SAlfred Perlstein 				vm_page_free(m[j]);
8412965a453SKip Macy 				vm_page_unlock(m[j]);
8422965a453SKip Macy 			}
84331953be9SAlan Cox 			VM_OBJECT_UNLOCK(object);
84426f9a767SRodney W. Grimes 		} else {
845efc68ce1SDavid Greenman 			if (runpg < (count - first)) {
84631953be9SAlan Cox 				VM_OBJECT_LOCK(object);
8472965a453SKip Macy 				for (i = first + runpg; i < count; i++) {
8482965a453SKip Macy 					vm_page_lock(m[i]);
849d8d5fa88SAlfred Perlstein 					vm_page_free(m[i]);
8502965a453SKip Macy 					vm_page_unlock(m[i]);
8512965a453SKip Macy 				}
85231953be9SAlan Cox 				VM_OBJECT_UNLOCK(object);
853efc68ce1SDavid Greenman 				count = first + runpg;
85426f9a767SRodney W. Grimes 			}
855efc68ce1SDavid Greenman 			break;
85626f9a767SRodney W. Grimes 		}
857efc68ce1SDavid Greenman 		first = runend;
858efc68ce1SDavid Greenman 	}
85926f9a767SRodney W. Grimes 
86026f9a767SRodney W. Grimes 	/*
861bbc0ec52SDavid Greenman 	 * the first and last page have been calculated now, move input pages
862bbc0ec52SDavid Greenman 	 * to be zero based...
86326f9a767SRodney W. Grimes 	 */
86426f9a767SRodney W. Grimes 	if (first != 0) {
8657e2393ffSAlan Cox 		m += first;
86626f9a767SRodney W. Grimes 		count -= first;
86726f9a767SRodney W. Grimes 		reqpage -= first;
86826f9a767SRodney W. Grimes 	}
869efc68ce1SDavid Greenman 
87026f9a767SRodney W. Grimes 	/*
87126f9a767SRodney W. Grimes 	 * calculate the file virtual address for the transfer
87226f9a767SRodney W. Grimes 	 */
873a316d390SJohn Dyson 	foff = IDX_TO_OFF(m[0]->pindex);
87426f9a767SRodney W. Grimes 
87526f9a767SRodney W. Grimes 	/*
87626f9a767SRodney W. Grimes 	 * calculate the size of the transfer
87726f9a767SRodney W. Grimes 	 */
87826f9a767SRodney W. Grimes 	size = count * PAGE_SIZE;
8791a31a6c3SPoul-Henning Kamp 	KASSERT(count > 0, ("zero count"));
88024a1cce3SDavid Greenman 	if ((foff + size) > object->un_pager.vnp.vnp_size)
88124a1cce3SDavid Greenman 		size = object->un_pager.vnp.vnp_size - foff;
8821a31a6c3SPoul-Henning Kamp 	KASSERT(size > 0, ("zero size"));
88326f9a767SRodney W. Grimes 
88426f9a767SRodney W. Grimes 	/*
88524579ca1SMatthew Dillon 	 * round up physical size for real devices.
88626f9a767SRodney W. Grimes 	 */
8879c83534dSPoul-Henning Kamp 	if (1) {
8889c83534dSPoul-Henning Kamp 		int secmask = bo->bo_bsize - 1;
8896229cc50SPoul-Henning Kamp 		KASSERT(secmask < PAGE_SIZE && secmask > 0,
8906229cc50SPoul-Henning Kamp 		    ("vnode_pager_generic_getpages: sector size %d too large",
8916229cc50SPoul-Henning Kamp 		    secmask + 1));
89224579ca1SMatthew Dillon 		size = (size + secmask) & ~secmask;
89324579ca1SMatthew Dillon 	}
89426f9a767SRodney W. Grimes 
8951c7c3c6aSMatthew Dillon 	bp = getpbuf(&vnode_pbuf_freecnt);
89616f62314SDavid Greenman 	kva = (vm_offset_t) bp->b_data;
89716f62314SDavid Greenman 
89826f9a767SRodney W. Grimes 	/*
89926f9a767SRodney W. Grimes 	 * and map the pages to be read into the kva
90026f9a767SRodney W. Grimes 	 */
90116f62314SDavid Greenman 	pmap_qenter(kva, m, count);
90226f9a767SRodney W. Grimes 
90326f9a767SRodney W. Grimes 	/* build a minimal buffer header */
90421144e3bSPoul-Henning Kamp 	bp->b_iocmd = BIO_READ;
9056a4b5823SPoul-Henning Kamp 	bp->b_iodone = bdone;
906bd78ceceSJohn Baldwin 	KASSERT(bp->b_rcred == NOCRED, ("leaking read ucred"));
907bd78ceceSJohn Baldwin 	KASSERT(bp->b_wcred == NOCRED, ("leaking write ucred"));
908a854ed98SJohn Baldwin 	bp->b_rcred = crhold(curthread->td_ucred);
909a854ed98SJohn Baldwin 	bp->b_wcred = crhold(curthread->td_ucred);
910187f0071SDavid Greenman 	bp->b_blkno = firstaddr;
9119c83534dSPoul-Henning Kamp 	pbgetbo(bo, bp);
91226f9a767SRodney W. Grimes 	bp->b_bcount = size;
91326f9a767SRodney W. Grimes 	bp->b_bufsize = size;
9142b6b0df7SMatthew Dillon 	bp->b_runningbufspace = bp->b_bufsize;
9155bd65606SJohn Baldwin 	atomic_add_long(&runningbufspace, bp->b_runningbufspace);
91626f9a767SRodney W. Grimes 
917b4b70819SAttilio Rao 	PCPU_INC(cnt.v_vnodein);
918b4b70819SAttilio Rao 	PCPU_ADD(cnt.v_vnodepgsin, count);
919976e77fcSDavid Greenman 
92026f9a767SRodney W. Grimes 	/* do the input */
9212c18019fSPoul-Henning Kamp 	bp->b_iooffset = dbtob(bp->b_blkno);
922b792bebeSPoul-Henning Kamp 	bstrategy(bp);
923976e77fcSDavid Greenman 
9246a4b5823SPoul-Henning Kamp 	bwait(bp, PVM, "vnread");
92526f9a767SRodney W. Grimes 
926c244d2deSPoul-Henning Kamp 	if ((bp->b_ioflags & BIO_ERROR) != 0)
92726f9a767SRodney W. Grimes 		error = EIO;
92826f9a767SRodney W. Grimes 
92926f9a767SRodney W. Grimes 	if (!error) {
93026f9a767SRodney W. Grimes 		if (size != count * PAGE_SIZE)
93126f9a767SRodney W. Grimes 			bzero((caddr_t) kva + size, PAGE_SIZE * count - size);
93226f9a767SRodney W. Grimes 	}
93316f62314SDavid Greenman 	pmap_qremove(kva, count);
93426f9a767SRodney W. Grimes 
93526f9a767SRodney W. Grimes 	/*
93626f9a767SRodney W. Grimes 	 * free the buffer header back to the swap buffer pool
93726f9a767SRodney W. Grimes 	 */
9389c83534dSPoul-Henning Kamp 	pbrelbo(bp);
9391c7c3c6aSMatthew Dillon 	relpbuf(bp, &vnode_pbuf_freecnt);
94026f9a767SRodney W. Grimes 
94131953be9SAlan Cox 	VM_OBJECT_LOCK(object);
9428f9110f6SJohn Dyson 	for (i = 0, tfoff = foff; i < count; i++, tfoff = nextoff) {
9438f9110f6SJohn Dyson 		vm_page_t mt;
9448f9110f6SJohn Dyson 
9458f9110f6SJohn Dyson 		nextoff = tfoff + PAGE_SIZE;
9468f9110f6SJohn Dyson 		mt = m[i];
9478f9110f6SJohn Dyson 
94854746b67SDmitrij Tejblum 		if (nextoff <= object->un_pager.vnp.vnp_size) {
9498d17e694SJulian Elischer 			/*
9508d17e694SJulian Elischer 			 * Read filled up entire page.
9518d17e694SJulian Elischer 			 */
9528f9110f6SJohn Dyson 			mt->valid = VM_PAGE_BITS_ALL;
953016a3c93SAlan Cox 			KASSERT(mt->dirty == 0,
954016a3c93SAlan Cox 			    ("vnode_pager_generic_getpages: page %p is dirty",
955016a3c93SAlan Cox 			    mt));
956016a3c93SAlan Cox 			KASSERT(!pmap_page_is_mapped(mt),
957016a3c93SAlan Cox 			    ("vnode_pager_generic_getpages: page %p is mapped",
958016a3c93SAlan Cox 			    mt));
9598f9110f6SJohn Dyson 		} else {
9608d17e694SJulian Elischer 			/*
96142eb4108SAlan Cox 			 * Read did not fill up entire page.
9628d17e694SJulian Elischer 			 *
9638d17e694SJulian Elischer 			 * Currently we do not set the entire page valid,
9648d17e694SJulian Elischer 			 * we just try to clear the piece that we couldn't
9658d17e694SJulian Elischer 			 * read.
9668d17e694SJulian Elischer 			 */
96742eb4108SAlan Cox 			vm_page_set_valid(mt, 0,
96854746b67SDmitrij Tejblum 			    object->un_pager.vnp.vnp_size - tfoff);
96942eb4108SAlan Cox 			KASSERT((mt->dirty & vm_page_bits(0,
97042eb4108SAlan Cox 			    object->un_pager.vnp.vnp_size - tfoff)) == 0,
97142eb4108SAlan Cox 			    ("vnode_pager_generic_getpages: page %p is dirty",
97242eb4108SAlan Cox 			    mt));
9738f9110f6SJohn Dyson 		}
9748f9110f6SJohn Dyson 
97526f9a767SRodney W. Grimes 		if (i != reqpage) {
976bbc0ec52SDavid Greenman 
97726f9a767SRodney W. Grimes 			/*
978bbc0ec52SDavid Greenman 			 * whether or not to leave the page activated is up in
979bbc0ec52SDavid Greenman 			 * the air, but we should put the page on a page queue
980bbc0ec52SDavid Greenman 			 * somewhere. (it already is in the object). Result:
981956f3135SPhilippe Charnier 			 * It appears that empirical results show that
982bbc0ec52SDavid Greenman 			 * deactivating pages is best.
98326f9a767SRodney W. Grimes 			 */
984bbc0ec52SDavid Greenman 
98526f9a767SRodney W. Grimes 			/*
986bbc0ec52SDavid Greenman 			 * just in case someone was asking for this page we
987bbc0ec52SDavid Greenman 			 * now tell them that it is ok to use
98826f9a767SRodney W. Grimes 			 */
98926f9a767SRodney W. Grimes 			if (!error) {
99003679e23SAlan Cox 				if (mt->oflags & VPO_WANTED) {
99103679e23SAlan Cox 					vm_page_lock(mt);
9928f9110f6SJohn Dyson 					vm_page_activate(mt);
99303679e23SAlan Cox 					vm_page_unlock(mt);
99403679e23SAlan Cox 				} else {
99503679e23SAlan Cox 					vm_page_lock(mt);
9968f9110f6SJohn Dyson 					vm_page_deactivate(mt);
99703679e23SAlan Cox 					vm_page_unlock(mt);
99803679e23SAlan Cox 				}
999e69763a3SDoug Rabson 				vm_page_wakeup(mt);
100026f9a767SRodney W. Grimes 			} else {
100103679e23SAlan Cox 				vm_page_lock(mt);
1002d8d5fa88SAlfred Perlstein 				vm_page_free(mt);
10032965a453SKip Macy 				vm_page_unlock(mt);
10042965a453SKip Macy 			}
100503679e23SAlan Cox 		}
100603679e23SAlan Cox 	}
100731953be9SAlan Cox 	VM_OBJECT_UNLOCK(object);
100826f9a767SRodney W. Grimes 	if (error) {
100924a1cce3SDavid Greenman 		printf("vnode_pager_getpages: I/O read error\n");
101026f9a767SRodney W. Grimes 	}
1011a83c285cSDavid Greenman 	return (error ? VM_PAGER_ERROR : VM_PAGER_OK);
101226f9a767SRodney W. Grimes }
101326f9a767SRodney W. Grimes 
1014ce75f2c3SMike Smith /*
1015ce75f2c3SMike Smith  * EOPNOTSUPP is no longer legal.  For local media VFS's that do not
1016ce75f2c3SMike Smith  * implement their own VOP_PUTPAGES, their VOP_PUTPAGES should call to
1017ce75f2c3SMike Smith  * vnode_pager_generic_putpages() to implement the previous behaviour.
1018ce75f2c3SMike Smith  *
1019ce75f2c3SMike Smith  * All other FS's should use the bypass to get to the local media
1020ce75f2c3SMike Smith  * backing vp's VOP_PUTPAGES.
1021ce75f2c3SMike Smith  */
1022e4542174SMatthew Dillon static void
1023170db9c6SJohn Dyson vnode_pager_putpages(object, m, count, sync, rtvals)
1024170db9c6SJohn Dyson 	vm_object_t object;
1025170db9c6SJohn Dyson 	vm_page_t *m;
1026170db9c6SJohn Dyson 	int count;
1027170db9c6SJohn Dyson 	boolean_t sync;
1028170db9c6SJohn Dyson 	int *rtvals;
1029170db9c6SJohn Dyson {
1030170db9c6SJohn Dyson 	int rtval;
1031170db9c6SJohn Dyson 	struct vnode *vp;
103286ffbd76SMike Smith 	int bytes = count * PAGE_SIZE;
1033ad980522SJohn Dyson 
10340e3cdf2cSAlan Cox 	/*
10350e3cdf2cSAlan Cox 	 * Force synchronous operation if we are extremely low on memory
10360e3cdf2cSAlan Cox 	 * to prevent a low-memory deadlock.  VOP operations often need to
10370e3cdf2cSAlan Cox 	 * allocate more memory to initiate the I/O ( i.e. do a BMAP
10380e3cdf2cSAlan Cox 	 * operation ).  The swapper handles the case by limiting the amount
10390e3cdf2cSAlan Cox 	 * of asynchronous I/O, but that sort of solution doesn't scale well
10400e3cdf2cSAlan Cox 	 * for the vnode pager without a lot of work.
10410e3cdf2cSAlan Cox 	 *
10420e3cdf2cSAlan Cox 	 * Also, the backing vnode's iodone routine may not wake the pageout
10430e3cdf2cSAlan Cox 	 * daemon up.  This should be probably be addressed XXX.
10440e3cdf2cSAlan Cox 	 */
10450e3cdf2cSAlan Cox 
10462feb50bfSAttilio Rao 	if ((cnt.v_free_count + cnt.v_cache_count) < cnt.v_pageout_free_min)
10470e3cdf2cSAlan Cox 		sync |= OBJPC_SYNC;
10480e3cdf2cSAlan Cox 
10490e3cdf2cSAlan Cox 	/*
10500e3cdf2cSAlan Cox 	 * Call device-specific putpages function
10510e3cdf2cSAlan Cox 	 */
1052170db9c6SJohn Dyson 	vp = object->handle;
10532e3b314dSAlan Cox 	VM_OBJECT_UNLOCK(object);
105486ffbd76SMike Smith 	rtval = VOP_PUTPAGES(vp, m, bytes, sync, rtvals, 0);
105523955314SAlfred Perlstein 	KASSERT(rtval != EOPNOTSUPP,
105623955314SAlfred Perlstein 	    ("vnode_pager: stale FS putpages\n"));
10572e3b314dSAlan Cox 	VM_OBJECT_LOCK(object);
1058170db9c6SJohn Dyson }
1059170db9c6SJohn Dyson 
1060ce75f2c3SMike Smith 
106126f9a767SRodney W. Grimes /*
1062ce75f2c3SMike Smith  * This is now called from local media FS's to operate against their
10634491ea91SEivind Eklund  * own vnodes if they fail to implement VOP_PUTPAGES.
10642b6b0df7SMatthew Dillon  *
10652b6b0df7SMatthew Dillon  * This is typically called indirectly via the pageout daemon and
10662b6b0df7SMatthew Dillon  * clustering has already typically occured, so in general we ask the
10672b6b0df7SMatthew Dillon  * underlying filesystem to write the data out asynchronously rather
10682b6b0df7SMatthew Dillon  * then delayed.
106926f9a767SRodney W. Grimes  */
1070ce75f2c3SMike Smith int
1071c46b90e9SAlan Cox vnode_pager_generic_putpages(struct vnode *vp, vm_page_t *ma, int bytecount,
1072c46b90e9SAlan Cox     int flags, int *rtvals)
107326f9a767SRodney W. Grimes {
1074f6b04d2bSDavid Greenman 	int i;
1075ce75f2c3SMike Smith 	vm_object_t object;
1076c46b90e9SAlan Cox 	vm_page_t m;
1077ce75f2c3SMike Smith 	int count;
107826f9a767SRodney W. Grimes 
1079f6b04d2bSDavid Greenman 	int maxsize, ncount;
1080a316d390SJohn Dyson 	vm_ooffset_t poffset;
1081f6b04d2bSDavid Greenman 	struct uio auio;
1082f6b04d2bSDavid Greenman 	struct iovec aiov;
1083f6b04d2bSDavid Greenman 	int error;
10848f9110f6SJohn Dyson 	int ioflags;
1085dd498befSPaul Saab 	int ppscheck = 0;
1086dd498befSPaul Saab 	static struct timeval lastfail;
1087dd498befSPaul Saab 	static int curfail;
108826f9a767SRodney W. Grimes 
1089ce75f2c3SMike Smith 	object = vp->v_object;
1090ce75f2c3SMike Smith 	count = bytecount / PAGE_SIZE;
1091ce75f2c3SMike Smith 
109226f9a767SRodney W. Grimes 	for (i = 0; i < count; i++)
1093031ec8c1SKonstantin Belousov 		rtvals[i] = VM_PAGER_ERROR;
109426f9a767SRodney W. Grimes 
1095c46b90e9SAlan Cox 	if ((int64_t)ma[0]->pindex < 0) {
109623562e4bSMarcel Moolenaar 		printf("vnode_pager_putpages: attempt to write meta-data!!! -- 0x%lx(%lx)\n",
1097c46b90e9SAlan Cox 		    (long)ma[0]->pindex, (u_long)ma[0]->dirty);
1098f6b04d2bSDavid Greenman 		rtvals[0] = VM_PAGER_BAD;
1099f6b04d2bSDavid Greenman 		return VM_PAGER_BAD;
11000d94caffSDavid Greenman 	}
11010bdb7528SDavid Greenman 
1102f6b04d2bSDavid Greenman 	maxsize = count * PAGE_SIZE;
1103f6b04d2bSDavid Greenman 	ncount = count;
110426f9a767SRodney W. Grimes 
1105c46b90e9SAlan Cox 	poffset = IDX_TO_OFF(ma[0]->pindex);
110600a6f47fSMatthew Dillon 
110700a6f47fSMatthew Dillon 	/*
110800a6f47fSMatthew Dillon 	 * If the page-aligned write is larger then the actual file we
110900a6f47fSMatthew Dillon 	 * have to invalidate pages occuring beyond the file EOF.  However,
111000a6f47fSMatthew Dillon 	 * there is an edge case where a file may not be page-aligned where
111100a6f47fSMatthew Dillon 	 * the last page is partially invalid.  In this case the filesystem
111200a6f47fSMatthew Dillon 	 * may not properly clear the dirty bits for the entire page (which
111300a6f47fSMatthew Dillon 	 * could be VM_PAGE_BITS_ALL due to the page having been mmap()d).
111400a6f47fSMatthew Dillon 	 * With the page locked we are free to fix-up the dirty bits here.
11153ebeaf59SMatthew Dillon 	 *
11163ebeaf59SMatthew Dillon 	 * We do not under any circumstances truncate the valid bits, as
11173ebeaf59SMatthew Dillon 	 * this will screw up bogus page replacement.
111800a6f47fSMatthew Dillon 	 */
1119c46b90e9SAlan Cox 	VM_OBJECT_LOCK(object);
1120a316d390SJohn Dyson 	if (maxsize + poffset > object->un_pager.vnp.vnp_size) {
112100a6f47fSMatthew Dillon 		if (object->un_pager.vnp.vnp_size > poffset) {
112200a6f47fSMatthew Dillon 			int pgoff;
112300a6f47fSMatthew Dillon 
1124a316d390SJohn Dyson 			maxsize = object->un_pager.vnp.vnp_size - poffset;
1125aa8de40aSPoul-Henning Kamp 			ncount = btoc(maxsize);
112600a6f47fSMatthew Dillon 			if ((pgoff = (int)maxsize & PAGE_MASK) != 0) {
1127c46b90e9SAlan Cox 				/*
1128c46b90e9SAlan Cox 				 * If the object is locked and the following
1129c46b90e9SAlan Cox 				 * conditions hold, then the page's dirty
1130c46b90e9SAlan Cox 				 * field cannot be concurrently changed by a
1131c46b90e9SAlan Cox 				 * pmap operation.
1132c46b90e9SAlan Cox 				 */
1133c46b90e9SAlan Cox 				m = ma[ncount - 1];
1134c46b90e9SAlan Cox 				KASSERT(m->busy > 0,
1135c46b90e9SAlan Cox 		("vnode_pager_generic_putpages: page %p is not busy", m));
11363407fefeSKonstantin Belousov 				KASSERT((m->aflags & PGA_WRITEABLE) == 0,
1137c46b90e9SAlan Cox 		("vnode_pager_generic_putpages: page %p is not read-only", m));
1138c46b90e9SAlan Cox 				vm_page_clear_dirty(m, pgoff, PAGE_SIZE -
1139c46b90e9SAlan Cox 				    pgoff);
114000a6f47fSMatthew Dillon 			}
114100a6f47fSMatthew Dillon 		} else {
114200a6f47fSMatthew Dillon 			maxsize = 0;
114300a6f47fSMatthew Dillon 			ncount = 0;
114400a6f47fSMatthew Dillon 		}
1145f6b04d2bSDavid Greenman 		if (ncount < count) {
1146f6b04d2bSDavid Greenman 			for (i = ncount; i < count; i++) {
1147f6b04d2bSDavid Greenman 				rtvals[i] = VM_PAGER_BAD;
1148f6b04d2bSDavid Greenman 			}
1149f6b04d2bSDavid Greenman 		}
1150f6b04d2bSDavid Greenman 	}
1151c46b90e9SAlan Cox 	VM_OBJECT_UNLOCK(object);
115226f9a767SRodney W. Grimes 
11532b6b0df7SMatthew Dillon 	/*
11542b6b0df7SMatthew Dillon 	 * pageouts are already clustered, use IO_ASYNC to force a bawrite()
11552b6b0df7SMatthew Dillon 	 * rather then a bdwrite() to prevent paging I/O from saturating
115643b7990eSMatthew Dillon 	 * the buffer cache.  Dummy-up the sequential heuristic to cause
115743b7990eSMatthew Dillon 	 * large ranges to cluster.  If neither IO_SYNC or IO_ASYNC is set,
115843b7990eSMatthew Dillon 	 * the system decides how to cluster.
11592b6b0df7SMatthew Dillon 	 */
11608f9110f6SJohn Dyson 	ioflags = IO_VMIO;
116143b7990eSMatthew Dillon 	if (flags & (VM_PAGER_PUT_SYNC | VM_PAGER_PUT_INVAL))
116243b7990eSMatthew Dillon 		ioflags |= IO_SYNC;
116343b7990eSMatthew Dillon 	else if ((flags & VM_PAGER_CLUSTER_OK) == 0)
116443b7990eSMatthew Dillon 		ioflags |= IO_ASYNC;
11658f9110f6SJohn Dyson 	ioflags |= (flags & VM_PAGER_PUT_INVAL) ? IO_INVAL: 0;
116643b7990eSMatthew Dillon 	ioflags |= IO_SEQMAX << IO_SEQSHIFT;
1167f6b04d2bSDavid Greenman 
1168f6b04d2bSDavid Greenman 	aiov.iov_base = (caddr_t) 0;
1169f6b04d2bSDavid Greenman 	aiov.iov_len = maxsize;
1170f6b04d2bSDavid Greenman 	auio.uio_iov = &aiov;
1171f6b04d2bSDavid Greenman 	auio.uio_iovcnt = 1;
1172a316d390SJohn Dyson 	auio.uio_offset = poffset;
1173f6b04d2bSDavid Greenman 	auio.uio_segflg = UIO_NOCOPY;
1174f6b04d2bSDavid Greenman 	auio.uio_rw = UIO_WRITE;
1175f6b04d2bSDavid Greenman 	auio.uio_resid = maxsize;
1176b40ce416SJulian Elischer 	auio.uio_td = (struct thread *) 0;
1177a854ed98SJohn Baldwin 	error = VOP_WRITE(vp, &auio, ioflags, curthread->td_ucred);
1178b4b70819SAttilio Rao 	PCPU_INC(cnt.v_vnodeout);
1179b4b70819SAttilio Rao 	PCPU_ADD(cnt.v_vnodepgsout, ncount);
1180f6b04d2bSDavid Greenman 
1181f6b04d2bSDavid Greenman 	if (error) {
1182dd498befSPaul Saab 		if ((ppscheck = ppsratecheck(&lastfail, &curfail, 1)))
118324a1cce3SDavid Greenman 			printf("vnode_pager_putpages: I/O error %d\n", error);
1184f6b04d2bSDavid Greenman 	}
1185f6b04d2bSDavid Greenman 	if (auio.uio_resid) {
1186dd498befSPaul Saab 		if (ppscheck || ppsratecheck(&lastfail, &curfail, 1))
11879f80ce04SKonstantin Belousov 			printf("vnode_pager_putpages: residual I/O %zd at %lu\n",
1188c46b90e9SAlan Cox 			    auio.uio_resid, (u_long)ma[0]->pindex);
118926f9a767SRodney W. Grimes 	}
1190ffc82b0aSJohn Dyson 	for (i = 0; i < ncount; i++) {
119126f9a767SRodney W. Grimes 		rtvals[i] = VM_PAGER_OK;
119226f9a767SRodney W. Grimes 	}
1193f6b04d2bSDavid Greenman 	return rtvals[0];
119426f9a767SRodney W. Grimes }
1195031ec8c1SKonstantin Belousov 
1196031ec8c1SKonstantin Belousov void
1197031ec8c1SKonstantin Belousov vnode_pager_undirty_pages(vm_page_t *ma, int *rtvals, int written)
1198031ec8c1SKonstantin Belousov {
11999d17da3bSKonstantin Belousov 	vm_object_t obj;
1200031ec8c1SKonstantin Belousov 	int i, pos;
1201031ec8c1SKonstantin Belousov 
12029d17da3bSKonstantin Belousov 	if (written == 0)
12039d17da3bSKonstantin Belousov 		return;
12049d17da3bSKonstantin Belousov 	obj = ma[0]->object;
12059d17da3bSKonstantin Belousov 	VM_OBJECT_LOCK(obj);
1206031ec8c1SKonstantin Belousov 	for (i = 0, pos = 0; pos < written; i++, pos += PAGE_SIZE) {
1207031ec8c1SKonstantin Belousov 		if (pos < trunc_page(written)) {
1208031ec8c1SKonstantin Belousov 			rtvals[i] = VM_PAGER_OK;
1209031ec8c1SKonstantin Belousov 			vm_page_undirty(ma[i]);
1210031ec8c1SKonstantin Belousov 		} else {
1211031ec8c1SKonstantin Belousov 			/* Partially written page. */
1212031ec8c1SKonstantin Belousov 			rtvals[i] = VM_PAGER_AGAIN;
1213031ec8c1SKonstantin Belousov 			vm_page_clear_dirty(ma[i], 0, written & PAGE_MASK);
1214031ec8c1SKonstantin Belousov 		}
1215031ec8c1SKonstantin Belousov 	}
12169d17da3bSKonstantin Belousov 	VM_OBJECT_UNLOCK(obj);
1217031ec8c1SKonstantin Belousov }
1218