Home | History | Annotate | Line # | Download | only in uvm
uvm_vnode.c revision 1.79
      1  1.79   thorpej /*	$NetBSD: uvm_vnode.c,v 1.79 2007/02/21 23:00:15 thorpej Exp $	*/
      2   1.1       mrg 
      3   1.1       mrg /*
      4   1.1       mrg  * Copyright (c) 1997 Charles D. Cranor and Washington University.
      5   1.1       mrg  * Copyright (c) 1991, 1993
      6  1.49       chs  *      The Regents of the University of California.
      7   1.1       mrg  * Copyright (c) 1990 University of Utah.
      8   1.1       mrg  *
      9   1.1       mrg  * All rights reserved.
     10   1.1       mrg  *
     11   1.1       mrg  * This code is derived from software contributed to Berkeley by
     12   1.1       mrg  * the Systems Programming Group of the University of Utah Computer
     13   1.1       mrg  * Science Department.
     14   1.1       mrg  *
     15   1.1       mrg  * Redistribution and use in source and binary forms, with or without
     16   1.1       mrg  * modification, are permitted provided that the following conditions
     17   1.1       mrg  * are met:
     18   1.1       mrg  * 1. Redistributions of source code must retain the above copyright
     19   1.1       mrg  *    notice, this list of conditions and the following disclaimer.
     20   1.1       mrg  * 2. Redistributions in binary form must reproduce the above copyright
     21   1.1       mrg  *    notice, this list of conditions and the following disclaimer in the
     22   1.1       mrg  *    documentation and/or other materials provided with the distribution.
     23   1.1       mrg  * 3. All advertising materials mentioning features or use of this software
     24   1.1       mrg  *    must display the following acknowledgement:
     25   1.1       mrg  *      This product includes software developed by Charles D. Cranor,
     26  1.49       chs  *	Washington University, the University of California, Berkeley and
     27   1.1       mrg  *	its contributors.
     28   1.1       mrg  * 4. Neither the name of the University nor the names of its contributors
     29   1.1       mrg  *    may be used to endorse or promote products derived from this software
     30   1.1       mrg  *    without specific prior written permission.
     31   1.1       mrg  *
     32   1.1       mrg  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     33   1.1       mrg  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     34   1.1       mrg  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     35   1.1       mrg  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     36   1.1       mrg  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     37   1.1       mrg  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     38   1.1       mrg  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     39   1.1       mrg  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     40   1.1       mrg  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     41   1.1       mrg  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     42   1.1       mrg  * SUCH DAMAGE.
     43   1.1       mrg  *
     44   1.1       mrg  *      @(#)vnode_pager.c       8.8 (Berkeley) 2/13/94
     45   1.3       mrg  * from: Id: uvm_vnode.c,v 1.1.2.26 1998/02/02 20:38:07 chuck Exp
     46   1.1       mrg  */
     47   1.1       mrg 
     48  1.55     lukem /*
     49  1.55     lukem  * uvm_vnode.c: the vnode pager.
     50  1.55     lukem  */
     51  1.55     lukem 
     52  1.55     lukem #include <sys/cdefs.h>
     53  1.79   thorpej __KERNEL_RCSID(0, "$NetBSD: uvm_vnode.c,v 1.79 2007/02/21 23:00:15 thorpej Exp $");
     54  1.55     lukem 
     55   1.6   thorpej #include "fs_nfs.h"
     56   1.4       mrg #include "opt_uvmhist.h"
     57  1.37       chs #include "opt_ddb.h"
     58   1.1       mrg 
     59   1.1       mrg #include <sys/param.h>
     60   1.1       mrg #include <sys/systm.h>
     61  1.37       chs #include <sys/kernel.h>
     62   1.1       mrg #include <sys/proc.h>
     63   1.1       mrg #include <sys/malloc.h>
     64   1.1       mrg #include <sys/vnode.h>
     65  1.13   thorpej #include <sys/disklabel.h>
     66  1.13   thorpej #include <sys/ioctl.h>
     67  1.13   thorpej #include <sys/fcntl.h>
     68  1.13   thorpej #include <sys/conf.h>
     69  1.37       chs #include <sys/pool.h>
     70  1.37       chs #include <sys/mount.h>
     71  1.13   thorpej 
     72  1.13   thorpej #include <miscfs/specfs/specdev.h>
     73   1.1       mrg 
     74   1.1       mrg #include <uvm/uvm.h>
     75  1.68      yamt #include <uvm/uvm_readahead.h>
     76   1.1       mrg 
     77   1.1       mrg /*
     78   1.1       mrg  * functions
     79   1.1       mrg  */
     80   1.1       mrg 
     81  1.66   thorpej static void	uvn_detach(struct uvm_object *);
     82  1.66   thorpej static int	uvn_get(struct uvm_object *, voff_t, struct vm_page **, int *,
     83  1.66   thorpej 			int, vm_prot_t, int, int);
     84  1.66   thorpej static int	uvn_put(struct uvm_object *, voff_t, voff_t, int);
     85  1.66   thorpej static void	uvn_reference(struct uvm_object *);
     86  1.52       chs 
     87  1.66   thorpej static int	uvn_findpage(struct uvm_object *, voff_t, struct vm_page **,
     88  1.66   thorpej 			     int);
     89   1.1       mrg 
     90   1.1       mrg /*
     91   1.1       mrg  * master pager structure
     92   1.1       mrg  */
     93   1.1       mrg 
     94   1.1       mrg struct uvm_pagerops uvm_vnodeops = {
     95  1.37       chs 	NULL,
     96   1.8       mrg 	uvn_reference,
     97   1.8       mrg 	uvn_detach,
     98  1.37       chs 	NULL,
     99   1.8       mrg 	uvn_get,
    100   1.8       mrg 	uvn_put,
    101   1.1       mrg };
    102   1.1       mrg 
    103   1.1       mrg /*
    104   1.1       mrg  * the ops!
    105   1.1       mrg  */
    106   1.1       mrg 
    107   1.1       mrg /*
    108   1.1       mrg  * uvn_attach
    109   1.1       mrg  *
    110   1.1       mrg  * attach a vnode structure to a VM object.  if the vnode is already
    111   1.1       mrg  * attached, then just bump the reference count by one and return the
    112   1.1       mrg  * VM object.   if not already attached, attach and return the new VM obj.
    113   1.1       mrg  * the "accessprot" tells the max access the attaching thread wants to
    114   1.1       mrg  * our pages.
    115   1.1       mrg  *
    116   1.1       mrg  * => caller must _not_ already be holding the lock on the uvm_object.
    117   1.1       mrg  * => in fact, nothing should be locked so that we can sleep here.
    118   1.1       mrg  * => note that uvm_object is first thing in vnode structure, so their
    119   1.1       mrg  *    pointers are equiv.
    120   1.1       mrg  */
    121   1.1       mrg 
    122   1.8       mrg struct uvm_object *
    123  1.77      yamt uvn_attach(void *arg, vm_prot_t accessprot)
    124   1.8       mrg {
    125   1.8       mrg 	struct vnode *vp = arg;
    126  1.52       chs 	struct uvm_object *uobj = &vp->v_uobj;
    127   1.8       mrg 	struct vattr vattr;
    128  1.59   gehenna 	const struct bdevsw *bdev;
    129  1.37       chs 	int result;
    130  1.13   thorpej 	struct partinfo pi;
    131  1.37       chs 	voff_t used_vnode_size;
    132   1.8       mrg 	UVMHIST_FUNC("uvn_attach"); UVMHIST_CALLED(maphist);
    133   1.8       mrg 
    134   1.8       mrg 	UVMHIST_LOG(maphist, "(vn=0x%x)", arg,0,0,0);
    135  1.37       chs 	used_vnode_size = (voff_t)0;
    136  1.13   thorpej 
    137   1.8       mrg 	/*
    138  1.52       chs 	 * first get a lock on the uobj.
    139   1.8       mrg 	 */
    140  1.52       chs 
    141  1.52       chs 	simple_lock(&uobj->vmobjlock);
    142  1.52       chs 	while (vp->v_flag & VXLOCK) {
    143  1.52       chs 		vp->v_flag |= VXWANT;
    144   1.8       mrg 		UVMHIST_LOG(maphist, "  SLEEPING on blocked vn",0,0,0,0);
    145  1.52       chs 		UVM_UNLOCK_AND_WAIT(uobj, &uobj->vmobjlock, FALSE,
    146   1.8       mrg 		    "uvn_attach", 0);
    147  1.52       chs 		simple_lock(&uobj->vmobjlock);
    148   1.8       mrg 		UVMHIST_LOG(maphist,"  WOKE UP",0,0,0,0);
    149   1.8       mrg 	}
    150   1.1       mrg 
    151   1.8       mrg 	/*
    152  1.18    bouyer 	 * if we're mapping a BLK device, make sure it is a disk.
    153  1.13   thorpej 	 */
    154  1.59   gehenna 	if (vp->v_type == VBLK) {
    155  1.59   gehenna 		bdev = bdevsw_lookup(vp->v_rdev);
    156  1.59   gehenna 		if (bdev == NULL || bdev->d_type != D_DISK) {
    157  1.59   gehenna 			simple_unlock(&uobj->vmobjlock);
    158  1.59   gehenna 			UVMHIST_LOG(maphist,"<- done (VBLK not D_DISK!)",
    159  1.59   gehenna 				    0,0,0,0);
    160  1.59   gehenna 			return(NULL);
    161  1.59   gehenna 		}
    162  1.13   thorpej 	}
    163  1.51       chs 	KASSERT(vp->v_type == VREG || vp->v_type == VBLK);
    164  1.37       chs 
    165  1.13   thorpej 	/*
    166  1.37       chs 	 * set up our idea of the size
    167  1.37       chs 	 * if this hasn't been done already.
    168   1.8       mrg 	 */
    169  1.52       chs 	if (vp->v_size == VSIZENOTSET) {
    170   1.8       mrg 
    171  1.52       chs 
    172  1.52       chs 	vp->v_flag |= VXLOCK;
    173  1.52       chs 	simple_unlock(&uobj->vmobjlock); /* drop lock in case we sleep */
    174   1.8       mrg 		/* XXX: curproc? */
    175  1.13   thorpej 	if (vp->v_type == VBLK) {
    176  1.13   thorpej 		/*
    177  1.13   thorpej 		 * We could implement this as a specfs getattr call, but:
    178  1.13   thorpej 		 *
    179  1.13   thorpej 		 *	(1) VOP_GETATTR() would get the file system
    180  1.13   thorpej 		 *	    vnode operation, not the specfs operation.
    181  1.13   thorpej 		 *
    182  1.13   thorpej 		 *	(2) All we want is the size, anyhow.
    183  1.13   thorpej 		 */
    184  1.59   gehenna 		bdev = bdevsw_lookup(vp->v_rdev);
    185  1.59   gehenna 		if (bdev != NULL) {
    186  1.59   gehenna 			result = (*bdev->d_ioctl)(vp->v_rdev, DIOCGPART,
    187  1.69  christos 						  (caddr_t)&pi, FREAD, curlwp);
    188  1.59   gehenna 		} else {
    189  1.59   gehenna 			result = ENXIO;
    190  1.59   gehenna 		}
    191  1.13   thorpej 		if (result == 0) {
    192  1.13   thorpej 			/* XXX should remember blocksize */
    193  1.37       chs 			used_vnode_size = (voff_t)pi.disklab->d_secsize *
    194  1.37       chs 			    (voff_t)pi.part->p_size;
    195  1.13   thorpej 		}
    196  1.13   thorpej 	} else {
    197  1.71        ad 		result = VOP_GETATTR(vp, &vattr, curlwp->l_cred, curlwp);
    198  1.13   thorpej 		if (result == 0)
    199  1.13   thorpej 			used_vnode_size = vattr.va_size;
    200   1.8       mrg 	}
    201   1.1       mrg 
    202   1.8       mrg 	/* relock object */
    203  1.52       chs 	simple_lock(&uobj->vmobjlock);
    204  1.37       chs 
    205  1.52       chs 	if (vp->v_flag & VXWANT) {
    206  1.52       chs 		wakeup(vp);
    207  1.52       chs 	}
    208  1.52       chs 	vp->v_flag &= ~(VXLOCK|VXWANT);
    209   1.1       mrg 
    210   1.8       mrg 	if (result != 0) {
    211  1.52       chs 		simple_unlock(&uobj->vmobjlock);
    212   1.8       mrg 		UVMHIST_LOG(maphist,"<- done (VOP_GETATTR FAILED!)", 0,0,0,0);
    213   1.8       mrg 		return(NULL);
    214   1.8       mrg 	}
    215  1.52       chs 	vp->v_size = used_vnode_size;
    216   1.8       mrg 
    217   1.8       mrg 	}
    218   1.8       mrg 
    219  1.52       chs 	simple_unlock(&uobj->vmobjlock);
    220  1.52       chs 	UVMHIST_LOG(maphist,"<- done, refcnt=%d", vp->v_usecount,
    221  1.37       chs 	    0, 0, 0);
    222  1.52       chs 	return uobj;
    223   1.1       mrg }
    224   1.1       mrg 
    225   1.1       mrg 
    226   1.1       mrg /*
    227   1.1       mrg  * uvn_reference
    228   1.1       mrg  *
    229   1.1       mrg  * duplicate a reference to a VM object.  Note that the reference
    230  1.49       chs  * count must already be at least one (the passed in reference) so
    231   1.1       mrg  * there is no chance of the uvn being killed or locked out here.
    232   1.1       mrg  *
    233  1.49       chs  * => caller must call with object unlocked.
    234   1.1       mrg  * => caller must be using the same accessprot as was used at attach time
    235   1.1       mrg  */
    236   1.1       mrg 
    237  1.66   thorpej static void
    238  1.65   thorpej uvn_reference(struct uvm_object *uobj)
    239   1.1       mrg {
    240  1.37       chs 	VREF((struct vnode *)uobj);
    241   1.1       mrg }
    242   1.1       mrg 
    243  1.52       chs 
    244   1.1       mrg /*
    245   1.1       mrg  * uvn_detach
    246   1.1       mrg  *
    247   1.1       mrg  * remove a reference to a VM object.
    248   1.1       mrg  *
    249   1.1       mrg  * => caller must call with object unlocked and map locked.
    250   1.1       mrg  */
    251  1.52       chs 
    252  1.66   thorpej static void
    253  1.65   thorpej uvn_detach(struct uvm_object *uobj)
    254   1.8       mrg {
    255  1.37       chs 	vrele((struct vnode *)uobj);
    256   1.1       mrg }
    257   1.1       mrg 
    258   1.1       mrg /*
    259   1.1       mrg  * uvn_put: flush page data to backing store.
    260   1.1       mrg  *
    261  1.53  sommerfe  * => object must be locked on entry!   VOP_PUTPAGES must unlock it.
    262   1.1       mrg  * => flags: PGO_SYNCIO -- use sync. I/O
    263   1.1       mrg  * => note: caller must set PG_CLEAN and pmap_clear_modify (if needed)
    264   1.1       mrg  */
    265   1.1       mrg 
    266  1.66   thorpej static int
    267  1.65   thorpej uvn_put(struct uvm_object *uobj, voff_t offlo, voff_t offhi, int flags)
    268   1.1       mrg {
    269  1.37       chs 	struct vnode *vp = (struct vnode *)uobj;
    270  1.37       chs 	int error;
    271   1.1       mrg 
    272  1.53  sommerfe 	LOCK_ASSERT(simple_lock_held(&vp->v_interlock));
    273  1.54       chs 	error = VOP_PUTPAGES(vp, offlo, offhi, flags);
    274  1.53  sommerfe 	LOCK_ASSERT(!simple_lock_held(&vp->v_interlock));
    275  1.48       chs 	return error;
    276   1.1       mrg }
    277   1.1       mrg 
    278   1.1       mrg 
    279   1.1       mrg /*
    280   1.1       mrg  * uvn_get: get pages (synchronously) from backing store
    281   1.1       mrg  *
    282   1.1       mrg  * => prefer map unlocked (not required)
    283   1.1       mrg  * => object must be locked!  we will _unlock_ it before starting any I/O.
    284   1.1       mrg  * => flags: PGO_ALLPAGES: get all of the pages
    285   1.1       mrg  *           PGO_LOCKED: fault data structures are locked
    286   1.1       mrg  * => NOTE: offset is the offset of pps[0], _NOT_ pps[centeridx]
    287   1.1       mrg  * => NOTE: caller must check for released pages!!
    288   1.1       mrg  */
    289  1.49       chs 
    290  1.66   thorpej static int
    291  1.65   thorpej uvn_get(struct uvm_object *uobj, voff_t offset,
    292  1.65   thorpej     struct vm_page **pps /* IN/OUT */,
    293  1.65   thorpej     int *npagesp /* IN (OUT if PGO_LOCKED)*/,
    294  1.65   thorpej     int centeridx, vm_prot_t access_type, int advice, int flags)
    295   1.8       mrg {
    296  1.37       chs 	struct vnode *vp = (struct vnode *)uobj;
    297  1.37       chs 	int error;
    298  1.67      yamt 
    299  1.37       chs 	UVMHIST_FUNC("uvn_get"); UVMHIST_CALLED(ubchist);
    300  1.37       chs 
    301  1.37       chs 	UVMHIST_LOG(ubchist, "vp %p off 0x%x", vp, (int)offset, 0,0);
    302  1.68      yamt 
    303  1.68      yamt 	if ((access_type & VM_PROT_WRITE) == 0 && (flags & PGO_LOCKED) == 0) {
    304  1.68      yamt 		simple_unlock(&vp->v_interlock);
    305  1.68      yamt 		vn_ra_allocctx(vp);
    306  1.68      yamt 		uvm_ra_request(vp->v_ractx, advice, uobj, offset,
    307  1.68      yamt 		    *npagesp << PAGE_SHIFT);
    308  1.68      yamt 		simple_lock(&vp->v_interlock);
    309  1.68      yamt 	}
    310  1.68      yamt 
    311  1.37       chs 	error = VOP_GETPAGES(vp, offset, pps, npagesp, centeridx,
    312  1.37       chs 			     access_type, advice, flags);
    313  1.67      yamt 
    314  1.78       chs 	LOCK_ASSERT(((flags & PGO_LOCKED) != 0 &&
    315  1.78       chs 		     simple_lock_held(&vp->v_interlock)) ||
    316  1.78       chs 		    ((flags & PGO_LOCKED) == 0 &&
    317  1.78       chs 		     !simple_lock_held(&vp->v_interlock)));
    318  1.48       chs 	return error;
    319  1.37       chs }
    320   1.8       mrg 
    321   1.8       mrg 
    322  1.37       chs /*
    323  1.37       chs  * uvn_findpages:
    324  1.37       chs  * return the page for the uobj and offset requested, allocating if needed.
    325  1.37       chs  * => uobj must be locked.
    326  1.52       chs  * => returned pages will be BUSY.
    327  1.37       chs  */
    328   1.1       mrg 
    329  1.58     enami int
    330  1.65   thorpej uvn_findpages(struct uvm_object *uobj, voff_t offset, int *npagesp,
    331  1.65   thorpej     struct vm_page **pgs, int flags)
    332  1.37       chs {
    333  1.58     enami 	int i, count, found, npages, rv;
    334   1.8       mrg 
    335  1.58     enami 	count = found = 0;
    336  1.37       chs 	npages = *npagesp;
    337  1.52       chs 	if (flags & UFP_BACKWARD) {
    338  1.52       chs 		for (i = npages - 1; i >= 0; i--, offset -= PAGE_SIZE) {
    339  1.52       chs 			rv = uvn_findpage(uobj, offset, &pgs[i], flags);
    340  1.58     enami 			if (rv == 0) {
    341  1.58     enami 				if (flags & UFP_DIRTYONLY)
    342  1.58     enami 					break;
    343  1.58     enami 			} else
    344  1.58     enami 				found++;
    345  1.52       chs 			count++;
    346  1.52       chs 		}
    347  1.52       chs 	} else {
    348  1.52       chs 		for (i = 0; i < npages; i++, offset += PAGE_SIZE) {
    349  1.52       chs 			rv = uvn_findpage(uobj, offset, &pgs[i], flags);
    350  1.58     enami 			if (rv == 0) {
    351  1.58     enami 				if (flags & UFP_DIRTYONLY)
    352  1.58     enami 					break;
    353  1.58     enami 			} else
    354  1.58     enami 				found++;
    355  1.52       chs 			count++;
    356  1.52       chs 		}
    357  1.37       chs 	}
    358  1.52       chs 	*npagesp = count;
    359  1.58     enami 	return (found);
    360  1.37       chs }
    361   1.8       mrg 
    362  1.66   thorpej static int
    363  1.65   thorpej uvn_findpage(struct uvm_object *uobj, voff_t offset, struct vm_page **pgp,
    364  1.65   thorpej     int flags)
    365  1.37       chs {
    366  1.37       chs 	struct vm_page *pg;
    367  1.79   thorpej 	bool dirty;
    368  1.37       chs 	UVMHIST_FUNC("uvn_findpage"); UVMHIST_CALLED(ubchist);
    369  1.37       chs 	UVMHIST_LOG(ubchist, "vp %p off 0x%lx", uobj, offset,0,0);
    370   1.8       mrg 
    371  1.37       chs 	if (*pgp != NULL) {
    372  1.37       chs 		UVMHIST_LOG(ubchist, "dontcare", 0,0,0,0);
    373  1.37       chs 		return 0;
    374  1.37       chs 	}
    375  1.37       chs 	for (;;) {
    376  1.37       chs 		/* look for an existing page */
    377  1.37       chs 		pg = uvm_pagelookup(uobj, offset);
    378  1.37       chs 
    379  1.52       chs 		/* nope?  allocate one now */
    380  1.37       chs 		if (pg == NULL) {
    381  1.37       chs 			if (flags & UFP_NOALLOC) {
    382  1.37       chs 				UVMHIST_LOG(ubchist, "noalloc", 0,0,0,0);
    383  1.37       chs 				return 0;
    384  1.37       chs 			}
    385  1.47       chs 			pg = uvm_pagealloc(uobj, offset, NULL, 0);
    386  1.37       chs 			if (pg == NULL) {
    387  1.37       chs 				if (flags & UFP_NOWAIT) {
    388  1.37       chs 					UVMHIST_LOG(ubchist, "nowait",0,0,0,0);
    389  1.37       chs 					return 0;
    390   1.8       mrg 				}
    391  1.37       chs 				simple_unlock(&uobj->vmobjlock);
    392  1.37       chs 				uvm_wait("uvn_fp1");
    393   1.8       mrg 				simple_lock(&uobj->vmobjlock);
    394  1.37       chs 				continue;
    395  1.47       chs 			}
    396  1.52       chs 			UVMHIST_LOG(ubchist, "alloced %p", pg,0,0,0);
    397  1.37       chs 			break;
    398  1.37       chs 		} else if (flags & UFP_NOCACHE) {
    399  1.37       chs 			UVMHIST_LOG(ubchist, "nocache",0,0,0,0);
    400  1.37       chs 			return 0;
    401   1.8       mrg 		}
    402   1.8       mrg 
    403  1.37       chs 		/* page is there, see if we need to wait on it */
    404  1.52       chs 		if ((pg->flags & PG_BUSY) != 0) {
    405  1.37       chs 			if (flags & UFP_NOWAIT) {
    406  1.37       chs 				UVMHIST_LOG(ubchist, "nowait",0,0,0,0);
    407  1.37       chs 				return 0;
    408  1.37       chs 			}
    409  1.37       chs 			pg->flags |= PG_WANTED;
    410  1.58     enami 			UVMHIST_LOG(ubchist, "wait %p", pg,0,0,0);
    411  1.37       chs 			UVM_UNLOCK_AND_WAIT(pg, &uobj->vmobjlock, 0,
    412  1.37       chs 					    "uvn_fp2", 0);
    413  1.37       chs 			simple_lock(&uobj->vmobjlock);
    414  1.37       chs 			continue;
    415   1.8       mrg 		}
    416  1.49       chs 
    417  1.37       chs 		/* skip PG_RDONLY pages if requested */
    418  1.37       chs 		if ((flags & UFP_NORDONLY) && (pg->flags & PG_RDONLY)) {
    419  1.37       chs 			UVMHIST_LOG(ubchist, "nordonly",0,0,0,0);
    420  1.37       chs 			return 0;
    421   1.8       mrg 		}
    422   1.8       mrg 
    423  1.52       chs 		/* stop on clean pages if requested */
    424  1.52       chs 		if (flags & UFP_DIRTYONLY) {
    425  1.52       chs 			dirty = pmap_clear_modify(pg) ||
    426  1.52       chs 				(pg->flags & PG_CLEAN) == 0;
    427  1.52       chs 			pg->flags |= PG_CLEAN;
    428  1.52       chs 			if (!dirty) {
    429  1.58     enami 				UVMHIST_LOG(ubchist, "dirtonly", 0,0,0,0);
    430  1.52       chs 				return 0;
    431  1.52       chs 			}
    432  1.52       chs 		}
    433  1.52       chs 
    434  1.37       chs 		/* mark the page BUSY and we're done. */
    435  1.37       chs 		pg->flags |= PG_BUSY;
    436  1.37       chs 		UVM_PAGE_OWN(pg, "uvn_findpage");
    437  1.52       chs 		UVMHIST_LOG(ubchist, "found %p", pg,0,0,0);
    438  1.37       chs 		break;
    439   1.8       mrg 	}
    440  1.37       chs 	*pgp = pg;
    441  1.37       chs 	return 1;
    442   1.1       mrg }
    443   1.1       mrg 
    444   1.1       mrg /*
    445  1.52       chs  * uvm_vnp_setsize: grow or shrink a vnode uobj
    446   1.1       mrg  *
    447   1.1       mrg  * grow   => just update size value
    448   1.1       mrg  * shrink => toss un-needed pages
    449   1.1       mrg  *
    450  1.49       chs  * => we assume that the caller has a reference of some sort to the
    451   1.1       mrg  *	vnode in question so that it will not be yanked out from under
    452   1.1       mrg  *	us.
    453   1.1       mrg  */
    454   1.1       mrg 
    455   1.8       mrg void
    456  1.65   thorpej uvm_vnp_setsize(struct vnode *vp, voff_t newsize)
    457   1.8       mrg {
    458  1.52       chs 	struct uvm_object *uobj = &vp->v_uobj;
    459  1.46     enami 	voff_t pgend = round_page(newsize);
    460  1.72      yamt 	voff_t oldsize;
    461  1.37       chs 	UVMHIST_FUNC("uvm_vnp_setsize"); UVMHIST_CALLED(ubchist);
    462  1.37       chs 
    463  1.52       chs 	simple_lock(&uobj->vmobjlock);
    464  1.52       chs 	UVMHIST_LOG(ubchist, "vp %p old 0x%x new 0x%x",
    465  1.52       chs 	    vp, vp->v_size, newsize, 0);
    466   1.1       mrg 
    467   1.8       mrg 	/*
    468  1.37       chs 	 * now check if the size has changed: if we shrink we had better
    469  1.37       chs 	 * toss some pages...
    470   1.8       mrg 	 */
    471   1.1       mrg 
    472  1.72      yamt 	oldsize = vp->v_size;
    473  1.72      yamt 	if (oldsize > pgend && oldsize != VSIZENOTSET) {
    474  1.57       chs 		(void) uvn_put(uobj, pgend, 0, PGO_FREE | PGO_SYNCIO);
    475  1.76      yamt 		simple_lock(&uobj->vmobjlock);
    476   1.8       mrg 	}
    477  1.76      yamt 	vp->v_size = newsize;
    478  1.76      yamt 	simple_unlock(&uobj->vmobjlock);
    479   1.1       mrg }
    480   1.1       mrg 
    481   1.1       mrg /*
    482  1.37       chs  * uvm_vnp_zerorange:  set a range of bytes in a file to zero.
    483   1.1       mrg  */
    484   1.1       mrg 
    485   1.8       mrg void
    486  1.65   thorpej uvm_vnp_zerorange(struct vnode *vp, off_t off, size_t len)
    487   1.8       mrg {
    488  1.64       chs 	void *win;
    489  1.64       chs 	int flags;
    490  1.64       chs 
    491  1.64       chs 	/*
    492  1.64       chs 	 * XXXUBC invent kzero() and use it
    493  1.64       chs 	 */
    494   1.8       mrg 
    495  1.64       chs 	while (len) {
    496  1.64       chs 		vsize_t bytelen = len;
    497  1.64       chs 
    498  1.68      yamt 		win = ubc_alloc(&vp->v_uobj, off, &bytelen, UVM_ADV_NORMAL,
    499  1.68      yamt 		    UBC_WRITE);
    500  1.64       chs 		memset(win, 0, bytelen);
    501  1.64       chs 		flags = UBC_WANT_UNMAP(vp) ? UBC_UNMAP : 0;
    502  1.64       chs 		ubc_release(win, flags);
    503  1.64       chs 
    504  1.64       chs 		off += bytelen;
    505  1.64       chs 		len -= bytelen;
    506  1.64       chs 	}
    507   1.1       mrg }
    508  1.75      yamt 
    509  1.79   thorpej bool
    510  1.75      yamt uvn_text_p(struct uvm_object *uobj)
    511  1.75      yamt {
    512  1.75      yamt 	struct vnode *vp = (struct vnode *)uobj;
    513  1.75      yamt 
    514  1.75      yamt 	return (vp->v_flag & VEXECMAP) != 0;
    515  1.75      yamt }
    516  1.75      yamt 
    517  1.79   thorpej bool
    518  1.75      yamt uvn_clean_p(struct uvm_object *uobj)
    519  1.75      yamt {
    520  1.75      yamt 	struct vnode *vp = (struct vnode *)uobj;
    521  1.75      yamt 
    522  1.75      yamt 	return (vp->v_flag & VONWORKLST) == 0;
    523  1.75      yamt }
    524  1.75      yamt 
    525  1.79   thorpej bool
    526  1.75      yamt uvn_needs_writefault_p(struct uvm_object *uobj)
    527  1.75      yamt {
    528  1.75      yamt 	struct vnode *vp = (struct vnode *)uobj;
    529  1.75      yamt 
    530  1.75      yamt 	return uvn_clean_p(uobj) ||
    531  1.75      yamt 	    (vp->v_flag & (VWRITEMAP|VWRITEMAPDIRTY)) == VWRITEMAP;
    532  1.75      yamt }
    533