uvm_vnode.c revision 1.68 1 1.67 yamt /* $NetBSD: uvm_vnode.c,v 1.68 2005/11/29 22:52:03 yamt 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.67 yamt __KERNEL_RCSID(0, "$NetBSD: uvm_vnode.c,v 1.68 2005/11/29 22:52:03 yamt Exp $");
54 1.55 lukem
55 1.6 thorpej #include "fs_nfs.h"
56 1.4 mrg #include "opt_uvmhist.h"
57 1.67 yamt #include "opt_readahead.h"
58 1.37 chs #include "opt_ddb.h"
59 1.1 mrg
60 1.1 mrg #include <sys/param.h>
61 1.1 mrg #include <sys/systm.h>
62 1.37 chs #include <sys/kernel.h>
63 1.1 mrg #include <sys/proc.h>
64 1.1 mrg #include <sys/malloc.h>
65 1.1 mrg #include <sys/vnode.h>
66 1.13 thorpej #include <sys/disklabel.h>
67 1.13 thorpej #include <sys/ioctl.h>
68 1.13 thorpej #include <sys/fcntl.h>
69 1.13 thorpej #include <sys/conf.h>
70 1.37 chs #include <sys/pool.h>
71 1.37 chs #include <sys/mount.h>
72 1.13 thorpej
73 1.13 thorpej #include <miscfs/specfs/specdev.h>
74 1.1 mrg
75 1.1 mrg #include <uvm/uvm.h>
76 1.68 yamt #include <uvm/uvm_readahead.h>
77 1.1 mrg
78 1.1 mrg /*
79 1.1 mrg * functions
80 1.1 mrg */
81 1.1 mrg
82 1.66 thorpej static void uvn_detach(struct uvm_object *);
83 1.66 thorpej static int uvn_get(struct uvm_object *, voff_t, struct vm_page **, int *,
84 1.66 thorpej int, vm_prot_t, int, int);
85 1.66 thorpej static int uvn_put(struct uvm_object *, voff_t, voff_t, int);
86 1.66 thorpej static void uvn_reference(struct uvm_object *);
87 1.52 chs
88 1.66 thorpej static int uvn_findpage(struct uvm_object *, voff_t, struct vm_page **,
89 1.66 thorpej int);
90 1.1 mrg
91 1.1 mrg /*
92 1.1 mrg * master pager structure
93 1.1 mrg */
94 1.1 mrg
95 1.1 mrg struct uvm_pagerops uvm_vnodeops = {
96 1.37 chs NULL,
97 1.8 mrg uvn_reference,
98 1.8 mrg uvn_detach,
99 1.37 chs NULL,
100 1.8 mrg uvn_get,
101 1.8 mrg uvn_put,
102 1.1 mrg };
103 1.1 mrg
104 1.1 mrg /*
105 1.1 mrg * the ops!
106 1.1 mrg */
107 1.1 mrg
108 1.1 mrg /*
109 1.1 mrg * uvn_attach
110 1.1 mrg *
111 1.1 mrg * attach a vnode structure to a VM object. if the vnode is already
112 1.1 mrg * attached, then just bump the reference count by one and return the
113 1.1 mrg * VM object. if not already attached, attach and return the new VM obj.
114 1.1 mrg * the "accessprot" tells the max access the attaching thread wants to
115 1.1 mrg * our pages.
116 1.1 mrg *
117 1.1 mrg * => caller must _not_ already be holding the lock on the uvm_object.
118 1.1 mrg * => in fact, nothing should be locked so that we can sleep here.
119 1.1 mrg * => note that uvm_object is first thing in vnode structure, so their
120 1.1 mrg * pointers are equiv.
121 1.1 mrg */
122 1.1 mrg
123 1.8 mrg struct uvm_object *
124 1.65 thorpej uvn_attach(void *arg, vm_prot_t accessprot)
125 1.8 mrg {
126 1.8 mrg struct vnode *vp = arg;
127 1.52 chs struct uvm_object *uobj = &vp->v_uobj;
128 1.8 mrg struct vattr vattr;
129 1.59 gehenna const struct bdevsw *bdev;
130 1.37 chs int result;
131 1.13 thorpej struct partinfo pi;
132 1.37 chs voff_t used_vnode_size;
133 1.8 mrg UVMHIST_FUNC("uvn_attach"); UVMHIST_CALLED(maphist);
134 1.8 mrg
135 1.8 mrg UVMHIST_LOG(maphist, "(vn=0x%x)", arg,0,0,0);
136 1.37 chs used_vnode_size = (voff_t)0;
137 1.13 thorpej
138 1.8 mrg /*
139 1.52 chs * first get a lock on the uobj.
140 1.8 mrg */
141 1.52 chs
142 1.52 chs simple_lock(&uobj->vmobjlock);
143 1.52 chs while (vp->v_flag & VXLOCK) {
144 1.52 chs vp->v_flag |= VXWANT;
145 1.8 mrg UVMHIST_LOG(maphist, " SLEEPING on blocked vn",0,0,0,0);
146 1.52 chs UVM_UNLOCK_AND_WAIT(uobj, &uobj->vmobjlock, FALSE,
147 1.8 mrg "uvn_attach", 0);
148 1.52 chs simple_lock(&uobj->vmobjlock);
149 1.8 mrg UVMHIST_LOG(maphist," WOKE UP",0,0,0,0);
150 1.8 mrg }
151 1.1 mrg
152 1.8 mrg /*
153 1.18 bouyer * if we're mapping a BLK device, make sure it is a disk.
154 1.13 thorpej */
155 1.59 gehenna if (vp->v_type == VBLK) {
156 1.59 gehenna bdev = bdevsw_lookup(vp->v_rdev);
157 1.59 gehenna if (bdev == NULL || bdev->d_type != D_DISK) {
158 1.59 gehenna simple_unlock(&uobj->vmobjlock);
159 1.59 gehenna UVMHIST_LOG(maphist,"<- done (VBLK not D_DISK!)",
160 1.59 gehenna 0,0,0,0);
161 1.59 gehenna return(NULL);
162 1.59 gehenna }
163 1.13 thorpej }
164 1.51 chs KASSERT(vp->v_type == VREG || vp->v_type == VBLK);
165 1.37 chs
166 1.13 thorpej /*
167 1.37 chs * set up our idea of the size
168 1.37 chs * if this hasn't been done already.
169 1.8 mrg */
170 1.52 chs if (vp->v_size == VSIZENOTSET) {
171 1.8 mrg
172 1.52 chs
173 1.52 chs vp->v_flag |= VXLOCK;
174 1.52 chs simple_unlock(&uobj->vmobjlock); /* drop lock in case we sleep */
175 1.8 mrg /* XXX: curproc? */
176 1.13 thorpej if (vp->v_type == VBLK) {
177 1.13 thorpej /*
178 1.13 thorpej * We could implement this as a specfs getattr call, but:
179 1.13 thorpej *
180 1.13 thorpej * (1) VOP_GETATTR() would get the file system
181 1.13 thorpej * vnode operation, not the specfs operation.
182 1.13 thorpej *
183 1.13 thorpej * (2) All we want is the size, anyhow.
184 1.13 thorpej */
185 1.59 gehenna bdev = bdevsw_lookup(vp->v_rdev);
186 1.59 gehenna if (bdev != NULL) {
187 1.59 gehenna result = (*bdev->d_ioctl)(vp->v_rdev, DIOCGPART,
188 1.62 fvdl (caddr_t)&pi, FREAD, curproc);
189 1.59 gehenna } else {
190 1.59 gehenna result = ENXIO;
191 1.59 gehenna }
192 1.13 thorpej if (result == 0) {
193 1.13 thorpej /* XXX should remember blocksize */
194 1.37 chs used_vnode_size = (voff_t)pi.disklab->d_secsize *
195 1.37 chs (voff_t)pi.part->p_size;
196 1.13 thorpej }
197 1.13 thorpej } else {
198 1.62 fvdl result = VOP_GETATTR(vp, &vattr, curproc->p_ucred, curproc);
199 1.13 thorpej if (result == 0)
200 1.13 thorpej used_vnode_size = vattr.va_size;
201 1.8 mrg }
202 1.1 mrg
203 1.8 mrg /* relock object */
204 1.52 chs simple_lock(&uobj->vmobjlock);
205 1.37 chs
206 1.52 chs if (vp->v_flag & VXWANT) {
207 1.52 chs wakeup(vp);
208 1.52 chs }
209 1.52 chs vp->v_flag &= ~(VXLOCK|VXWANT);
210 1.1 mrg
211 1.8 mrg if (result != 0) {
212 1.52 chs simple_unlock(&uobj->vmobjlock);
213 1.8 mrg UVMHIST_LOG(maphist,"<- done (VOP_GETATTR FAILED!)", 0,0,0,0);
214 1.8 mrg return(NULL);
215 1.8 mrg }
216 1.52 chs vp->v_size = used_vnode_size;
217 1.8 mrg
218 1.8 mrg }
219 1.8 mrg
220 1.52 chs simple_unlock(&uobj->vmobjlock);
221 1.52 chs UVMHIST_LOG(maphist,"<- done, refcnt=%d", vp->v_usecount,
222 1.37 chs 0, 0, 0);
223 1.52 chs return uobj;
224 1.1 mrg }
225 1.1 mrg
226 1.1 mrg
227 1.1 mrg /*
228 1.1 mrg * uvn_reference
229 1.1 mrg *
230 1.1 mrg * duplicate a reference to a VM object. Note that the reference
231 1.49 chs * count must already be at least one (the passed in reference) so
232 1.1 mrg * there is no chance of the uvn being killed or locked out here.
233 1.1 mrg *
234 1.49 chs * => caller must call with object unlocked.
235 1.1 mrg * => caller must be using the same accessprot as was used at attach time
236 1.1 mrg */
237 1.1 mrg
238 1.66 thorpej static void
239 1.65 thorpej uvn_reference(struct uvm_object *uobj)
240 1.1 mrg {
241 1.37 chs VREF((struct vnode *)uobj);
242 1.1 mrg }
243 1.1 mrg
244 1.52 chs
245 1.1 mrg /*
246 1.1 mrg * uvn_detach
247 1.1 mrg *
248 1.1 mrg * remove a reference to a VM object.
249 1.1 mrg *
250 1.1 mrg * => caller must call with object unlocked and map locked.
251 1.1 mrg */
252 1.52 chs
253 1.66 thorpej static void
254 1.65 thorpej uvn_detach(struct uvm_object *uobj)
255 1.8 mrg {
256 1.37 chs vrele((struct vnode *)uobj);
257 1.1 mrg }
258 1.1 mrg
259 1.1 mrg /*
260 1.1 mrg * uvn_put: flush page data to backing store.
261 1.1 mrg *
262 1.53 sommerfe * => object must be locked on entry! VOP_PUTPAGES must unlock it.
263 1.1 mrg * => flags: PGO_SYNCIO -- use sync. I/O
264 1.1 mrg * => note: caller must set PG_CLEAN and pmap_clear_modify (if needed)
265 1.1 mrg */
266 1.1 mrg
267 1.66 thorpej static int
268 1.65 thorpej uvn_put(struct uvm_object *uobj, voff_t offlo, voff_t offhi, int flags)
269 1.1 mrg {
270 1.37 chs struct vnode *vp = (struct vnode *)uobj;
271 1.37 chs int error;
272 1.1 mrg
273 1.53 sommerfe LOCK_ASSERT(simple_lock_held(&vp->v_interlock));
274 1.54 chs error = VOP_PUTPAGES(vp, offlo, offhi, flags);
275 1.53 sommerfe LOCK_ASSERT(!simple_lock_held(&vp->v_interlock));
276 1.48 chs return error;
277 1.1 mrg }
278 1.1 mrg
279 1.1 mrg
280 1.1 mrg /*
281 1.1 mrg * uvn_get: get pages (synchronously) from backing store
282 1.1 mrg *
283 1.1 mrg * => prefer map unlocked (not required)
284 1.1 mrg * => object must be locked! we will _unlock_ it before starting any I/O.
285 1.1 mrg * => flags: PGO_ALLPAGES: get all of the pages
286 1.1 mrg * PGO_LOCKED: fault data structures are locked
287 1.1 mrg * => NOTE: offset is the offset of pps[0], _NOT_ pps[centeridx]
288 1.1 mrg * => NOTE: caller must check for released pages!!
289 1.1 mrg */
290 1.49 chs
291 1.66 thorpej static int
292 1.65 thorpej uvn_get(struct uvm_object *uobj, voff_t offset,
293 1.65 thorpej struct vm_page **pps /* IN/OUT */,
294 1.65 thorpej int *npagesp /* IN (OUT if PGO_LOCKED)*/,
295 1.65 thorpej int centeridx, vm_prot_t access_type, int advice, int flags)
296 1.8 mrg {
297 1.37 chs struct vnode *vp = (struct vnode *)uobj;
298 1.37 chs int error;
299 1.67 yamt #if defined(READAHEAD_STATS)
300 1.67 yamt int orignpages = *npagesp;
301 1.67 yamt #endif /* defined(READAHEAD_STATS) */
302 1.67 yamt
303 1.37 chs UVMHIST_FUNC("uvn_get"); UVMHIST_CALLED(ubchist);
304 1.37 chs
305 1.37 chs UVMHIST_LOG(ubchist, "vp %p off 0x%x", vp, (int)offset, 0,0);
306 1.68 yamt
307 1.68 yamt if ((access_type & VM_PROT_WRITE) == 0 && (flags & PGO_LOCKED) == 0) {
308 1.68 yamt simple_unlock(&vp->v_interlock);
309 1.68 yamt vn_ra_allocctx(vp);
310 1.68 yamt uvm_ra_request(vp->v_ractx, advice, uobj, offset,
311 1.68 yamt *npagesp << PAGE_SHIFT);
312 1.68 yamt simple_lock(&vp->v_interlock);
313 1.68 yamt }
314 1.68 yamt
315 1.37 chs error = VOP_GETPAGES(vp, offset, pps, npagesp, centeridx,
316 1.37 chs access_type, advice, flags);
317 1.67 yamt
318 1.67 yamt #if defined(READAHEAD_STATS)
319 1.67 yamt if (((flags & PGO_LOCKED) != 0 && *npagesp > 0) ||
320 1.67 yamt ((flags & (PGO_LOCKED|PGO_SYNCIO)) == PGO_SYNCIO && error == 0)) {
321 1.67 yamt int i;
322 1.67 yamt
323 1.67 yamt if ((flags & PGO_LOCKED) == 0) {
324 1.67 yamt simple_lock(&uobj->vmobjlock);
325 1.67 yamt }
326 1.67 yamt for (i = 0; i < orignpages; i++) {
327 1.67 yamt struct vm_page *pg = pps[i];
328 1.67 yamt
329 1.67 yamt if (pg == NULL || pg == PGO_DONTCARE) {
330 1.67 yamt continue;
331 1.67 yamt }
332 1.67 yamt if ((pg->flags & PG_SPECULATIVE) != 0) {
333 1.67 yamt pg->flags &= ~PG_SPECULATIVE;
334 1.67 yamt uvm_ra_hit.ev_count++;
335 1.67 yamt }
336 1.67 yamt }
337 1.67 yamt if ((flags & PGO_LOCKED) == 0) {
338 1.67 yamt simple_unlock(&uobj->vmobjlock);
339 1.67 yamt }
340 1.67 yamt }
341 1.67 yamt #endif /* defined(READAHEAD_STATS) */
342 1.67 yamt
343 1.48 chs return error;
344 1.37 chs }
345 1.8 mrg
346 1.8 mrg
347 1.37 chs /*
348 1.37 chs * uvn_findpages:
349 1.37 chs * return the page for the uobj and offset requested, allocating if needed.
350 1.37 chs * => uobj must be locked.
351 1.52 chs * => returned pages will be BUSY.
352 1.37 chs */
353 1.1 mrg
354 1.58 enami int
355 1.65 thorpej uvn_findpages(struct uvm_object *uobj, voff_t offset, int *npagesp,
356 1.65 thorpej struct vm_page **pgs, int flags)
357 1.37 chs {
358 1.58 enami int i, count, found, npages, rv;
359 1.8 mrg
360 1.58 enami count = found = 0;
361 1.37 chs npages = *npagesp;
362 1.52 chs if (flags & UFP_BACKWARD) {
363 1.52 chs for (i = npages - 1; i >= 0; i--, offset -= PAGE_SIZE) {
364 1.52 chs rv = uvn_findpage(uobj, offset, &pgs[i], flags);
365 1.58 enami if (rv == 0) {
366 1.58 enami if (flags & UFP_DIRTYONLY)
367 1.58 enami break;
368 1.58 enami } else
369 1.58 enami found++;
370 1.52 chs count++;
371 1.52 chs }
372 1.52 chs } else {
373 1.52 chs for (i = 0; i < npages; i++, offset += PAGE_SIZE) {
374 1.52 chs rv = uvn_findpage(uobj, offset, &pgs[i], flags);
375 1.58 enami if (rv == 0) {
376 1.58 enami if (flags & UFP_DIRTYONLY)
377 1.58 enami break;
378 1.58 enami } else
379 1.58 enami found++;
380 1.52 chs count++;
381 1.52 chs }
382 1.37 chs }
383 1.52 chs *npagesp = count;
384 1.58 enami return (found);
385 1.37 chs }
386 1.8 mrg
387 1.66 thorpej static int
388 1.65 thorpej uvn_findpage(struct uvm_object *uobj, voff_t offset, struct vm_page **pgp,
389 1.65 thorpej int flags)
390 1.37 chs {
391 1.37 chs struct vm_page *pg;
392 1.52 chs boolean_t dirty;
393 1.37 chs UVMHIST_FUNC("uvn_findpage"); UVMHIST_CALLED(ubchist);
394 1.37 chs UVMHIST_LOG(ubchist, "vp %p off 0x%lx", uobj, offset,0,0);
395 1.8 mrg
396 1.37 chs if (*pgp != NULL) {
397 1.37 chs UVMHIST_LOG(ubchist, "dontcare", 0,0,0,0);
398 1.37 chs return 0;
399 1.37 chs }
400 1.37 chs for (;;) {
401 1.37 chs /* look for an existing page */
402 1.37 chs pg = uvm_pagelookup(uobj, offset);
403 1.37 chs
404 1.52 chs /* nope? allocate one now */
405 1.37 chs if (pg == NULL) {
406 1.37 chs if (flags & UFP_NOALLOC) {
407 1.37 chs UVMHIST_LOG(ubchist, "noalloc", 0,0,0,0);
408 1.37 chs return 0;
409 1.37 chs }
410 1.47 chs pg = uvm_pagealloc(uobj, offset, NULL, 0);
411 1.37 chs if (pg == NULL) {
412 1.37 chs if (flags & UFP_NOWAIT) {
413 1.37 chs UVMHIST_LOG(ubchist, "nowait",0,0,0,0);
414 1.37 chs return 0;
415 1.8 mrg }
416 1.37 chs simple_unlock(&uobj->vmobjlock);
417 1.37 chs uvm_wait("uvn_fp1");
418 1.8 mrg simple_lock(&uobj->vmobjlock);
419 1.37 chs continue;
420 1.47 chs }
421 1.52 chs UVMHIST_LOG(ubchist, "alloced %p", pg,0,0,0);
422 1.37 chs break;
423 1.37 chs } else if (flags & UFP_NOCACHE) {
424 1.37 chs UVMHIST_LOG(ubchist, "nocache",0,0,0,0);
425 1.37 chs return 0;
426 1.8 mrg }
427 1.8 mrg
428 1.37 chs /* page is there, see if we need to wait on it */
429 1.52 chs if ((pg->flags & PG_BUSY) != 0) {
430 1.37 chs if (flags & UFP_NOWAIT) {
431 1.37 chs UVMHIST_LOG(ubchist, "nowait",0,0,0,0);
432 1.37 chs return 0;
433 1.37 chs }
434 1.37 chs pg->flags |= PG_WANTED;
435 1.58 enami UVMHIST_LOG(ubchist, "wait %p", pg,0,0,0);
436 1.37 chs UVM_UNLOCK_AND_WAIT(pg, &uobj->vmobjlock, 0,
437 1.37 chs "uvn_fp2", 0);
438 1.37 chs simple_lock(&uobj->vmobjlock);
439 1.37 chs continue;
440 1.8 mrg }
441 1.49 chs
442 1.37 chs /* skip PG_RDONLY pages if requested */
443 1.37 chs if ((flags & UFP_NORDONLY) && (pg->flags & PG_RDONLY)) {
444 1.37 chs UVMHIST_LOG(ubchist, "nordonly",0,0,0,0);
445 1.37 chs return 0;
446 1.8 mrg }
447 1.8 mrg
448 1.52 chs /* stop on clean pages if requested */
449 1.52 chs if (flags & UFP_DIRTYONLY) {
450 1.52 chs dirty = pmap_clear_modify(pg) ||
451 1.52 chs (pg->flags & PG_CLEAN) == 0;
452 1.52 chs pg->flags |= PG_CLEAN;
453 1.52 chs if (!dirty) {
454 1.58 enami UVMHIST_LOG(ubchist, "dirtonly", 0,0,0,0);
455 1.52 chs return 0;
456 1.52 chs }
457 1.52 chs }
458 1.52 chs
459 1.37 chs /* mark the page BUSY and we're done. */
460 1.37 chs pg->flags |= PG_BUSY;
461 1.37 chs UVM_PAGE_OWN(pg, "uvn_findpage");
462 1.52 chs UVMHIST_LOG(ubchist, "found %p", pg,0,0,0);
463 1.37 chs break;
464 1.8 mrg }
465 1.37 chs *pgp = pg;
466 1.37 chs return 1;
467 1.1 mrg }
468 1.1 mrg
469 1.1 mrg /*
470 1.52 chs * uvm_vnp_setsize: grow or shrink a vnode uobj
471 1.1 mrg *
472 1.1 mrg * grow => just update size value
473 1.1 mrg * shrink => toss un-needed pages
474 1.1 mrg *
475 1.49 chs * => we assume that the caller has a reference of some sort to the
476 1.1 mrg * vnode in question so that it will not be yanked out from under
477 1.1 mrg * us.
478 1.1 mrg */
479 1.1 mrg
480 1.8 mrg void
481 1.65 thorpej uvm_vnp_setsize(struct vnode *vp, voff_t newsize)
482 1.8 mrg {
483 1.52 chs struct uvm_object *uobj = &vp->v_uobj;
484 1.46 enami voff_t pgend = round_page(newsize);
485 1.37 chs UVMHIST_FUNC("uvm_vnp_setsize"); UVMHIST_CALLED(ubchist);
486 1.37 chs
487 1.52 chs simple_lock(&uobj->vmobjlock);
488 1.52 chs UVMHIST_LOG(ubchist, "vp %p old 0x%x new 0x%x",
489 1.52 chs vp, vp->v_size, newsize, 0);
490 1.1 mrg
491 1.8 mrg /*
492 1.37 chs * now check if the size has changed: if we shrink we had better
493 1.37 chs * toss some pages...
494 1.8 mrg */
495 1.1 mrg
496 1.52 chs if (vp->v_size > pgend && vp->v_size != VSIZENOTSET) {
497 1.57 chs (void) uvn_put(uobj, pgend, 0, PGO_FREE | PGO_SYNCIO);
498 1.52 chs } else {
499 1.52 chs simple_unlock(&uobj->vmobjlock);
500 1.8 mrg }
501 1.52 chs vp->v_size = newsize;
502 1.1 mrg }
503 1.1 mrg
504 1.1 mrg /*
505 1.37 chs * uvm_vnp_zerorange: set a range of bytes in a file to zero.
506 1.1 mrg */
507 1.1 mrg
508 1.8 mrg void
509 1.65 thorpej uvm_vnp_zerorange(struct vnode *vp, off_t off, size_t len)
510 1.8 mrg {
511 1.64 chs void *win;
512 1.64 chs int flags;
513 1.64 chs
514 1.64 chs /*
515 1.64 chs * XXXUBC invent kzero() and use it
516 1.64 chs */
517 1.8 mrg
518 1.64 chs while (len) {
519 1.64 chs vsize_t bytelen = len;
520 1.64 chs
521 1.68 yamt win = ubc_alloc(&vp->v_uobj, off, &bytelen, UVM_ADV_NORMAL,
522 1.68 yamt UBC_WRITE);
523 1.64 chs memset(win, 0, bytelen);
524 1.64 chs flags = UBC_WANT_UNMAP(vp) ? UBC_UNMAP : 0;
525 1.64 chs ubc_release(win, flags);
526 1.64 chs
527 1.64 chs off += bytelen;
528 1.64 chs len -= bytelen;
529 1.64 chs }
530 1.1 mrg }
531