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