Annotation of sys/uvm/uvm_vnode.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: uvm_vnode.c,v 1.49 2007/06/05 00:38:24 deraadt Exp $ */
2: /* $NetBSD: uvm_vnode.c,v 1.36 2000/11/24 20:34:01 chs Exp $ */
3:
4: /*
5: * Copyright (c) 1997 Charles D. Cranor and Washington University.
6: * Copyright (c) 1991, 1993
7: * The Regents of the University of California.
8: * Copyright (c) 1990 University of Utah.
9: *
10: * All rights reserved.
11: *
12: * This code is derived from software contributed to Berkeley by
13: * the Systems Programming Group of the University of Utah Computer
14: * Science Department.
15: *
16: * Redistribution and use in source and binary forms, with or without
17: * modification, are permitted provided that the following conditions
18: * are met:
19: * 1. Redistributions of source code must retain the above copyright
20: * notice, this list of conditions and the following disclaimer.
21: * 2. Redistributions in binary form must reproduce the above copyright
22: * notice, this list of conditions and the following disclaimer in the
23: * documentation and/or other materials provided with the distribution.
24: * 3. All advertising materials mentioning features or use of this software
25: * must display the following acknowledgement:
26: * This product includes software developed by Charles D. Cranor,
27: * Washington University, the University of California, Berkeley and
28: * its contributors.
29: * 4. Neither the name of the University nor the names of its contributors
30: * may be used to endorse or promote products derived from this software
31: * without specific prior written permission.
32: *
33: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
34: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
35: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
37: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
39: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
41: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
42: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43: * SUCH DAMAGE.
44: *
45: * @(#)vnode_pager.c 8.8 (Berkeley) 2/13/94
46: * from: Id: uvm_vnode.c,v 1.1.2.26 1998/02/02 20:38:07 chuck Exp
47: */
48:
49: /*
50: * uvm_vnode.c: the vnode pager.
51: */
52:
53: #include <sys/param.h>
54: #include <sys/systm.h>
55: #include <sys/proc.h>
56: #include <sys/malloc.h>
57: #include <sys/vnode.h>
58: #include <sys/disklabel.h>
59: #include <sys/ioctl.h>
60: #include <sys/fcntl.h>
61: #include <sys/conf.h>
62: #include <sys/rwlock.h>
63:
64: #include <miscfs/specfs/specdev.h>
65:
66: #include <uvm/uvm.h>
67: #include <uvm/uvm_vnode.h>
68:
69: /*
70: * private global data structure
71: *
72: * we keep a list of writeable active vnode-backed VM objects for sync op.
73: * we keep a simpleq of vnodes that are currently being sync'd.
74: */
75:
76: LIST_HEAD(uvn_list_struct, uvm_vnode);
77: struct uvn_list_struct uvn_wlist; /* writeable uvns */
78:
79: SIMPLEQ_HEAD(uvn_sq_struct, uvm_vnode);
80: struct uvn_sq_struct uvn_sync_q; /* sync'ing uvns */
81: struct rwlock uvn_sync_lock; /* locks sync operation */
82:
83: /*
84: * functions
85: */
86:
87: void uvn_cluster(struct uvm_object *, voff_t,
88: voff_t *, voff_t *);
89: void uvn_detach(struct uvm_object *);
90: boolean_t uvn_flush(struct uvm_object *, voff_t,
91: voff_t, int);
92: int uvn_get(struct uvm_object *, voff_t,
93: vm_page_t *, int *, int,
94: vm_prot_t, int, int);
95: void uvn_init(void);
96: int uvn_io(struct uvm_vnode *, vm_page_t *,
97: int, int, int);
98: int uvn_put(struct uvm_object *, vm_page_t *,
99: int, boolean_t);
100: void uvn_reference(struct uvm_object *);
101: boolean_t uvn_releasepg(struct vm_page *,
102: struct vm_page **);
103:
104: /*
105: * master pager structure
106: */
107:
108: struct uvm_pagerops uvm_vnodeops = {
109: uvn_init,
110: uvn_reference,
111: uvn_detach,
112: NULL, /* no specialized fault routine required */
113: uvn_flush,
114: uvn_get,
115: uvn_put,
116: uvn_cluster,
117: uvm_mk_pcluster, /* use generic version of this: see uvm_pager.c */
118: uvn_releasepg,
119: };
120:
121: /*
122: * the ops!
123: */
124:
125: /*
126: * uvn_init
127: *
128: * init pager private data structures.
129: */
130:
131: void
132: uvn_init(void)
133: {
134:
135: LIST_INIT(&uvn_wlist);
136: /* note: uvn_sync_q init'd in uvm_vnp_sync() */
137: rw_init(&uvn_sync_lock, "uvnsync");
138: }
139:
140: /*
141: * uvn_attach
142: *
143: * attach a vnode structure to a VM object. if the vnode is already
144: * attached, then just bump the reference count by one and return the
145: * VM object. if not already attached, attach and return the new VM obj.
146: * the "accessprot" tells the max access the attaching thread wants to
147: * our pages.
148: *
149: * => caller must _not_ already be holding the lock on the uvm_object.
150: * => in fact, nothing should be locked so that we can sleep here.
151: * => note that uvm_object is first thing in vnode structure, so their
152: * pointers are equiv.
153: */
154:
155: struct uvm_object *
156: uvn_attach(arg, accessprot)
157: void *arg;
158: vm_prot_t accessprot;
159: {
160: struct vnode *vp = arg;
161: struct uvm_vnode *uvn = &vp->v_uvm;
162: struct vattr vattr;
163: int oldflags, result;
164: struct partinfo pi;
165: u_quad_t used_vnode_size;
166: UVMHIST_FUNC("uvn_attach"); UVMHIST_CALLED(maphist);
167:
168: UVMHIST_LOG(maphist, "(vn=%p)", arg,0,0,0);
169:
170: used_vnode_size = (u_quad_t)0; /* XXX gcc -Wuninitialized */
171:
172: /*
173: * first get a lock on the uvn.
174: */
175: simple_lock(&uvn->u_obj.vmobjlock);
176: while (uvn->u_flags & UVM_VNODE_BLOCKED) {
177: printf("uvn_attach: blocked at %p flags 0x%x\n",
178: uvn, uvn->u_flags);
179: uvn->u_flags |= UVM_VNODE_WANTED;
180: UVMHIST_LOG(maphist, " SLEEPING on blocked vn",0,0,0,0);
181: UVM_UNLOCK_AND_WAIT(uvn, &uvn->u_obj.vmobjlock, FALSE,
182: "uvn_attach", 0);
183: simple_lock(&uvn->u_obj.vmobjlock);
184: UVMHIST_LOG(maphist," WOKE UP",0,0,0,0);
185: }
186:
187: /*
188: * if we're mapping a BLK device, make sure it is a disk.
189: */
190: if (vp->v_type == VBLK && bdevsw[major(vp->v_rdev)].d_type != D_DISK) {
191: simple_unlock(&uvn->u_obj.vmobjlock); /* drop lock */
192: UVMHIST_LOG(maphist,"<- done (VBLK not D_DISK!)", 0,0,0,0);
193: return(NULL);
194: }
195:
196: /*
197: * now we have lock and uvn must not be in a blocked state.
198: * first check to see if it is already active, in which case
199: * we can bump the reference count, check to see if we need to
200: * add it to the writeable list, and then return.
201: */
202: if (uvn->u_flags & UVM_VNODE_VALID) { /* already active? */
203:
204: /* regain VREF if we were persisting */
205: if (uvn->u_obj.uo_refs == 0) {
206: VREF(vp);
207: UVMHIST_LOG(maphist," VREF (reclaim persisting vnode)",
208: 0,0,0,0);
209: }
210: uvn->u_obj.uo_refs++; /* bump uvn ref! */
211:
212: /* check for new writeable uvn */
213: if ((accessprot & VM_PROT_WRITE) != 0 &&
214: (uvn->u_flags & UVM_VNODE_WRITEABLE) == 0) {
215: LIST_INSERT_HEAD(&uvn_wlist, uvn, u_wlist);
216: /* we are now on wlist! */
217: uvn->u_flags |= UVM_VNODE_WRITEABLE;
218: }
219:
220: /* unlock and return */
221: simple_unlock(&uvn->u_obj.vmobjlock);
222: UVMHIST_LOG(maphist,"<- done, refcnt=%ld", uvn->u_obj.uo_refs,
223: 0, 0, 0);
224: return (&uvn->u_obj);
225: }
226:
227: /*
228: * need to call VOP_GETATTR() to get the attributes, but that could
229: * block (due to I/O), so we want to unlock the object before calling.
230: * however, we want to keep anyone else from playing with the object
231: * while it is unlocked. to do this we set UVM_VNODE_ALOCK which
232: * prevents anyone from attaching to the vnode until we are done with
233: * it.
234: */
235: uvn->u_flags = UVM_VNODE_ALOCK;
236: simple_unlock(&uvn->u_obj.vmobjlock); /* drop lock in case we sleep */
237: /* XXX: curproc? */
238:
239: if (vp->v_type == VBLK) {
240: /*
241: * We could implement this as a specfs getattr call, but:
242: *
243: * (1) VOP_GETATTR() would get the file system
244: * vnode operation, not the specfs operation.
245: *
246: * (2) All we want is the size, anyhow.
247: */
248: result = (*bdevsw[major(vp->v_rdev)].d_ioctl)(vp->v_rdev,
249: DIOCGPART, (caddr_t)&pi, FREAD, curproc);
250: if (result == 0) {
251: /* XXX should remember blocksize */
252: used_vnode_size = (u_quad_t)pi.disklab->d_secsize *
253: (u_quad_t)DL_GETPSIZE(pi.part);
254: }
255: } else {
256: result = VOP_GETATTR(vp, &vattr, curproc->p_ucred, curproc);
257: if (result == 0)
258: used_vnode_size = vattr.va_size;
259: }
260:
261: /* relock object */
262: simple_lock(&uvn->u_obj.vmobjlock);
263:
264: if (result != 0) {
265: if (uvn->u_flags & UVM_VNODE_WANTED)
266: wakeup(uvn);
267: uvn->u_flags = 0;
268: simple_unlock(&uvn->u_obj.vmobjlock); /* drop lock */
269: UVMHIST_LOG(maphist,"<- done (VOP_GETATTR FAILED!)", 0,0,0,0);
270: return(NULL);
271: }
272:
273: /*
274: * make sure that the newsize fits within a vaddr_t
275: * XXX: need to revise addressing data types
276: */
277: #ifdef DEBUG
278: if (vp->v_type == VBLK)
279: printf("used_vnode_size = %llu\n", (long long)used_vnode_size);
280: #endif
281:
282: /*
283: * now set up the uvn.
284: */
285: uvn->u_obj.pgops = &uvm_vnodeops;
286: TAILQ_INIT(&uvn->u_obj.memq);
287: uvn->u_obj.uo_npages = 0;
288: uvn->u_obj.uo_refs = 1; /* just us... */
289: oldflags = uvn->u_flags;
290: uvn->u_flags = UVM_VNODE_VALID|UVM_VNODE_CANPERSIST;
291: uvn->u_nio = 0;
292: uvn->u_size = used_vnode_size;
293:
294: /* if write access, we need to add it to the wlist */
295: if (accessprot & VM_PROT_WRITE) {
296: LIST_INSERT_HEAD(&uvn_wlist, uvn, u_wlist);
297: uvn->u_flags |= UVM_VNODE_WRITEABLE; /* we are on wlist! */
298: }
299:
300: /*
301: * add a reference to the vnode. this reference will stay as long
302: * as there is a valid mapping of the vnode. dropped when the
303: * reference count goes to zero [and we either free or persist].
304: */
305: VREF(vp);
306: simple_unlock(&uvn->u_obj.vmobjlock);
307: if (oldflags & UVM_VNODE_WANTED)
308: wakeup(uvn);
309:
310: UVMHIST_LOG(maphist,"<- done/VREF, ret %p", &uvn->u_obj,0,0,0);
311: return(&uvn->u_obj);
312: }
313:
314:
315: /*
316: * uvn_reference
317: *
318: * duplicate a reference to a VM object. Note that the reference
319: * count must already be at least one (the passed in reference) so
320: * there is no chance of the uvn being killed or locked out here.
321: *
322: * => caller must call with object unlocked.
323: * => caller must be using the same accessprot as was used at attach time
324: */
325:
326:
327: void
328: uvn_reference(uobj)
329: struct uvm_object *uobj;
330: {
331: #ifdef DEBUG
332: struct uvm_vnode *uvn = (struct uvm_vnode *) uobj;
333: #endif
334: UVMHIST_FUNC("uvn_reference"); UVMHIST_CALLED(maphist);
335:
336: simple_lock(&uobj->vmobjlock);
337: #ifdef DEBUG
338: if ((uvn->u_flags & UVM_VNODE_VALID) == 0) {
339: printf("uvn_reference: ref=%d, flags=0x%x\n", uvn->u_flags,
340: uobj->uo_refs);
341: panic("uvn_reference: invalid state");
342: }
343: #endif
344: uobj->uo_refs++;
345: UVMHIST_LOG(maphist, "<- done (uobj=%p, ref = %ld)",
346: uobj, uobj->uo_refs,0,0);
347: simple_unlock(&uobj->vmobjlock);
348: }
349:
350: /*
351: * uvn_detach
352: *
353: * remove a reference to a VM object.
354: *
355: * => caller must call with object unlocked and map locked.
356: * => this starts the detach process, but doesn't have to finish it
357: * (async i/o could still be pending).
358: */
359: void
360: uvn_detach(uobj)
361: struct uvm_object *uobj;
362: {
363: struct uvm_vnode *uvn;
364: struct vnode *vp;
365: int oldflags;
366: UVMHIST_FUNC("uvn_detach"); UVMHIST_CALLED(maphist);
367:
368: simple_lock(&uobj->vmobjlock);
369:
370: UVMHIST_LOG(maphist," (uobj=%p) ref=%ld", uobj,uobj->uo_refs,0,0);
371: uobj->uo_refs--; /* drop ref! */
372: if (uobj->uo_refs) { /* still more refs */
373: simple_unlock(&uobj->vmobjlock);
374: UVMHIST_LOG(maphist, "<- done (rc>0)", 0,0,0,0);
375: return;
376: }
377:
378: /*
379: * get other pointers ...
380: */
381:
382: uvn = (struct uvm_vnode *) uobj;
383: vp = (struct vnode *) uobj;
384:
385: /*
386: * clear VTEXT flag now that there are no mappings left (VTEXT is used
387: * to keep an active text file from being overwritten).
388: */
389: vp->v_flag &= ~VTEXT;
390:
391: /*
392: * we just dropped the last reference to the uvn. see if we can
393: * let it "stick around".
394: */
395:
396: if (uvn->u_flags & UVM_VNODE_CANPERSIST) {
397: /* won't block */
398: uvn_flush(uobj, 0, 0, PGO_DEACTIVATE|PGO_ALLPAGES);
399: simple_unlock(&uobj->vmobjlock);
400: vrele(vp); /* drop vnode reference */
401: UVMHIST_LOG(maphist,"<- done/vrele! (persist)", 0,0,0,0);
402: return;
403: }
404:
405: /*
406: * its a goner!
407: */
408:
409: UVMHIST_LOG(maphist," its a goner (flushing)!", 0,0,0,0);
410:
411: uvn->u_flags |= UVM_VNODE_DYING;
412:
413: /*
414: * even though we may unlock in flush, no one can gain a reference
415: * to us until we clear the "dying" flag [because it blocks
416: * attaches]. we will not do that until after we've disposed of all
417: * the pages with uvn_flush(). note that before the flush the only
418: * pages that could be marked PG_BUSY are ones that are in async
419: * pageout by the daemon. (there can't be any pending "get"'s
420: * because there are no references to the object).
421: */
422:
423: (void) uvn_flush(uobj, 0, 0, PGO_CLEANIT|PGO_FREE|PGO_ALLPAGES);
424:
425: UVMHIST_LOG(maphist," its a goner (done flush)!", 0,0,0,0);
426:
427: /*
428: * given the structure of this pager, the above flush request will
429: * create the following state: all the pages that were in the object
430: * have either been free'd or they are marked PG_BUSY|PG_RELEASED.
431: * the PG_BUSY bit was set either by us or the daemon for async I/O.
432: * in either case, if we have pages left we can't kill the object
433: * yet because i/o is pending. in this case we set the "relkill"
434: * flag which will cause pgo_releasepg to kill the object once all
435: * the I/O's are done [pgo_releasepg will be called from the aiodone
436: * routine or from the page daemon].
437: */
438:
439: if (uobj->uo_npages) { /* I/O pending. iodone will free */
440: #ifdef DEBUG
441: /*
442: * XXXCDC: very unlikely to happen until we have async i/o
443: * so print a little info message in case it does.
444: */
445: printf("uvn_detach: vn %p has pages left after flush - "
446: "relkill mode\n", uobj);
447: #endif
448: uvn->u_flags |= UVM_VNODE_RELKILL;
449: simple_unlock(&uobj->vmobjlock);
450: UVMHIST_LOG(maphist,"<- done! (releasepg will kill obj)", 0, 0,
451: 0, 0);
452: return;
453: }
454:
455: /*
456: * kill object now. note that we can't be on the sync q because
457: * all references are gone.
458: */
459: if (uvn->u_flags & UVM_VNODE_WRITEABLE) {
460: LIST_REMOVE(uvn, u_wlist);
461: }
462: #ifdef DIAGNOSTIC
463: if (!TAILQ_EMPTY(&uobj->memq))
464: panic("uvn_deref: vnode VM object still has pages afer "
465: "syncio/free flush");
466: #endif
467: oldflags = uvn->u_flags;
468: uvn->u_flags = 0;
469: simple_unlock(&uobj->vmobjlock);
470:
471: /* wake up any sleepers */
472: if (oldflags & UVM_VNODE_WANTED)
473: wakeup(uvn);
474:
475: /*
476: * drop our reference to the vnode.
477: */
478: vrele(vp);
479: UVMHIST_LOG(maphist,"<- done (vrele) final", 0,0,0,0);
480:
481: return;
482: }
483:
484: /*
485: * uvm_vnp_terminate: external hook to clear out a vnode's VM
486: *
487: * called in two cases:
488: * [1] when a persisting vnode vm object (i.e. one with a zero reference
489: * count) needs to be freed so that a vnode can be reused. this
490: * happens under "getnewvnode" in vfs_subr.c. if the vnode from
491: * the free list is still attached (i.e. not VBAD) then vgone is
492: * called. as part of the vgone trace this should get called to
493: * free the vm object. this is the common case.
494: * [2] when a filesystem is being unmounted by force (MNT_FORCE,
495: * "umount -f") the vgone() function is called on active vnodes
496: * on the mounted file systems to kill their data (the vnodes become
497: * "dead" ones [see src/sys/miscfs/deadfs/...]). that results in a
498: * call here (even if the uvn is still in use -- i.e. has a non-zero
499: * reference count). this case happens at "umount -f" and during a
500: * "reboot/halt" operation.
501: *
502: * => the caller must XLOCK and VOP_LOCK the vnode before calling us
503: * [protects us from getting a vnode that is already in the DYING
504: * state...]
505: * => unlike uvn_detach, this function must not return until all the
506: * uvn's pages are disposed of.
507: * => in case [2] the uvn is still alive after this call, but all I/O
508: * ops will fail (due to the backing vnode now being "dead"). this
509: * will prob. kill any process using the uvn due to pgo_get failing.
510: */
511:
512: void
513: uvm_vnp_terminate(vp)
514: struct vnode *vp;
515: {
516: struct uvm_vnode *uvn = &vp->v_uvm;
517: int oldflags;
518: UVMHIST_FUNC("uvm_vnp_terminate"); UVMHIST_CALLED(maphist);
519:
520: /*
521: * lock object and check if it is valid
522: */
523: simple_lock(&uvn->u_obj.vmobjlock);
524: UVMHIST_LOG(maphist, " vp=%p, ref=%ld, flag=0x%lx", vp,
525: uvn->u_obj.uo_refs, uvn->u_flags, 0);
526: if ((uvn->u_flags & UVM_VNODE_VALID) == 0) {
527: simple_unlock(&uvn->u_obj.vmobjlock);
528: UVMHIST_LOG(maphist, "<- done (not active)", 0, 0, 0, 0);
529: return;
530: }
531:
532: /*
533: * must be a valid uvn that is not already dying (because XLOCK
534: * protects us from that). the uvn can't in the ALOCK state
535: * because it is valid, and uvn's that are in the ALOCK state haven't
536: * been marked valid yet.
537: */
538:
539: #ifdef DEBUG
540: /*
541: * debug check: are we yanking the vnode out from under our uvn?
542: */
543: if (uvn->u_obj.uo_refs) {
544: printf("uvm_vnp_terminate(%p): terminating active vnode "
545: "(refs=%d)\n", uvn, uvn->u_obj.uo_refs);
546: }
547: #endif
548:
549: /*
550: * it is possible that the uvn was detached and is in the relkill
551: * state [i.e. waiting for async i/o to finish so that releasepg can
552: * kill object]. we take over the vnode now and cancel the relkill.
553: * we want to know when the i/o is done so we can recycle right
554: * away. note that a uvn can only be in the RELKILL state if it
555: * has a zero reference count.
556: */
557:
558: if (uvn->u_flags & UVM_VNODE_RELKILL)
559: uvn->u_flags &= ~UVM_VNODE_RELKILL; /* cancel RELKILL */
560:
561: /*
562: * block the uvn by setting the dying flag, and then flush the
563: * pages. (note that flush may unlock object while doing I/O, but
564: * it will re-lock it before it returns control here).
565: *
566: * also, note that we tell I/O that we are already VOP_LOCK'd so
567: * that uvn_io doesn't attempt to VOP_LOCK again.
568: *
569: * XXXCDC: setting VNISLOCKED on an active uvn which is being terminated
570: * due to a forceful unmount might not be a good idea. maybe we
571: * need a way to pass in this info to uvn_flush through a
572: * pager-defined PGO_ constant [currently there are none].
573: */
574: uvn->u_flags |= UVM_VNODE_DYING|UVM_VNODE_VNISLOCKED;
575:
576: (void) uvn_flush(&uvn->u_obj, 0, 0, PGO_CLEANIT|PGO_FREE|PGO_ALLPAGES);
577:
578: /*
579: * as we just did a flush we expect all the pages to be gone or in
580: * the process of going. sleep to wait for the rest to go [via iosync].
581: */
582:
583: while (uvn->u_obj.uo_npages) {
584: #ifdef DEBUG
585: struct vm_page *pp;
586: TAILQ_FOREACH(pp, &uvn->u_obj.memq, listq) {
587: if ((pp->pg_flags & PG_BUSY) == 0)
588: panic("uvm_vnp_terminate: detected unbusy pg");
589: }
590: if (uvn->u_nio == 0)
591: panic("uvm_vnp_terminate: no I/O to wait for?");
592: printf("uvm_vnp_terminate: waiting for I/O to fin.\n");
593: /*
594: * XXXCDC: this is unlikely to happen without async i/o so we
595: * put a printf in just to keep an eye on it.
596: */
597: #endif
598: uvn->u_flags |= UVM_VNODE_IOSYNC;
599: UVM_UNLOCK_AND_WAIT(&uvn->u_nio, &uvn->u_obj.vmobjlock, FALSE,
600: "uvn_term",0);
601: simple_lock(&uvn->u_obj.vmobjlock);
602: }
603:
604: /*
605: * done. now we free the uvn if its reference count is zero
606: * (true if we are zapping a persisting uvn). however, if we are
607: * terminating a uvn with active mappings we let it live ... future
608: * calls down to the vnode layer will fail.
609: */
610:
611: oldflags = uvn->u_flags;
612: if (uvn->u_obj.uo_refs) {
613:
614: /*
615: * uvn must live on it is dead-vnode state until all references
616: * are gone. restore flags. clear CANPERSIST state.
617: */
618:
619: uvn->u_flags &= ~(UVM_VNODE_DYING|UVM_VNODE_VNISLOCKED|
620: UVM_VNODE_WANTED|UVM_VNODE_CANPERSIST);
621:
622: } else {
623:
624: /*
625: * free the uvn now. note that the VREF reference is already
626: * gone [it is dropped when we enter the persist state].
627: */
628: if (uvn->u_flags & UVM_VNODE_IOSYNCWANTED)
629: panic("uvm_vnp_terminate: io sync wanted bit set");
630:
631: if (uvn->u_flags & UVM_VNODE_WRITEABLE) {
632: LIST_REMOVE(uvn, u_wlist);
633: }
634: uvn->u_flags = 0; /* uvn is history, clear all bits */
635: }
636:
637: if (oldflags & UVM_VNODE_WANTED)
638: wakeup(uvn); /* object lock still held */
639:
640: simple_unlock(&uvn->u_obj.vmobjlock);
641: UVMHIST_LOG(maphist, "<- done", 0, 0, 0, 0);
642:
643: }
644:
645: /*
646: * uvn_releasepg: handled a released page in a uvn
647: *
648: * => "pg" is a PG_BUSY [caller owns it], PG_RELEASED page that we need
649: * to dispose of.
650: * => caller must handled PG_WANTED case
651: * => called with page's object locked, pageq's unlocked
652: * => returns TRUE if page's object is still alive, FALSE if we
653: * killed the page's object. if we return TRUE, then we
654: * return with the object locked.
655: * => if (nextpgp != NULL) => we return pageq.tqe_next here, and return
656: * with the page queues locked [for pagedaemon]
657: * => if (nextpgp == NULL) => we return with page queues unlocked [normal case]
658: * => we kill the uvn if it is not referenced and we are suppose to
659: * kill it ("relkill").
660: */
661:
662: boolean_t
663: uvn_releasepg(pg, nextpgp)
664: struct vm_page *pg;
665: struct vm_page **nextpgp; /* OUT */
666: {
667: struct uvm_vnode *uvn = (struct uvm_vnode *) pg->uobject;
668: #ifdef DIAGNOSTIC
669: if ((pg->pg_flags & PG_RELEASED) == 0)
670: panic("uvn_releasepg: page not released!");
671: #endif
672:
673: /*
674: * dispose of the page [caller handles PG_WANTED]
675: */
676: pmap_page_protect(pg, VM_PROT_NONE);
677: uvm_lock_pageq();
678: if (nextpgp)
679: *nextpgp = TAILQ_NEXT(pg, pageq); /* next page for daemon */
680: uvm_pagefree(pg);
681: if (!nextpgp)
682: uvm_unlock_pageq();
683:
684: /*
685: * now see if we need to kill the object
686: */
687: if (uvn->u_flags & UVM_VNODE_RELKILL) {
688: if (uvn->u_obj.uo_refs)
689: panic("uvn_releasepg: kill flag set on referenced "
690: "object!");
691: if (uvn->u_obj.uo_npages == 0) {
692: if (uvn->u_flags & UVM_VNODE_WRITEABLE) {
693: LIST_REMOVE(uvn, u_wlist);
694: }
695: #ifdef DIAGNOSTIC
696: if (!TAILQ_EMPTY(&uvn->u_obj.memq))
697: panic("uvn_releasepg: pages in object with npages == 0");
698: #endif
699: if (uvn->u_flags & UVM_VNODE_WANTED)
700: /* still holding object lock */
701: wakeup(uvn);
702:
703: uvn->u_flags = 0; /* DEAD! */
704: simple_unlock(&uvn->u_obj.vmobjlock);
705: return (FALSE);
706: }
707: }
708: return (TRUE);
709: }
710:
711: /*
712: * NOTE: currently we have to use VOP_READ/VOP_WRITE because they go
713: * through the buffer cache and allow I/O in any size. These VOPs use
714: * synchronous i/o. [vs. VOP_STRATEGY which can be async, but doesn't
715: * go through the buffer cache or allow I/O sizes larger than a
716: * block]. we will eventually want to change this.
717: *
718: * issues to consider:
719: * uvm provides the uvm_aiodesc structure for async i/o management.
720: * there are two tailq's in the uvm. structure... one for pending async
721: * i/o and one for "done" async i/o. to do an async i/o one puts
722: * an aiodesc on the "pending" list (protected by splbio()), starts the
723: * i/o and returns VM_PAGER_PEND. when the i/o is done, we expect
724: * some sort of "i/o done" function to be called (at splbio(), interrupt
725: * time). this function should remove the aiodesc from the pending list
726: * and place it on the "done" list and wakeup the daemon. the daemon
727: * will run at normal spl() and will remove all items from the "done"
728: * list and call the "aiodone" hook for each done request (see uvm_pager.c).
729: * [in the old vm code, this was done by calling the "put" routine with
730: * null arguments which made the code harder to read and understand because
731: * you had one function ("put") doing two things.]
732: *
733: * so the current pager needs:
734: * int uvn_aiodone(struct uvm_aiodesc *)
735: *
736: * => return 0 (aio finished, free it). otherwise requeue for later collection.
737: * => called with pageq's locked by the daemon.
738: *
739: * general outline:
740: * - "try" to lock object. if fail, just return (will try again later)
741: * - drop "u_nio" (this req is done!)
742: * - if (object->iosync && u_naio == 0) { wakeup &uvn->u_naio }
743: * - get "page" structures (atop?).
744: * - handle "wanted" pages
745: * - handle "released" pages [using pgo_releasepg]
746: * >>> pgo_releasepg may kill the object
747: * dont forget to look at "object" wanted flag in all cases.
748: */
749:
750:
751: /*
752: * uvn_flush: flush pages out of a uvm object.
753: *
754: * => object should be locked by caller. we may _unlock_ the object
755: * if (and only if) we need to clean a page (PGO_CLEANIT).
756: * we return with the object locked.
757: * => if PGO_CLEANIT is set, we may block (due to I/O). thus, a caller
758: * might want to unlock higher level resources (e.g. vm_map)
759: * before calling flush.
760: * => if PGO_CLEANIT is not set, then we will neither unlock the object
761: * or block.
762: * => if PGO_ALLPAGE is set, then all pages in the object are valid targets
763: * for flushing.
764: * => NOTE: we rely on the fact that the object's memq is a TAILQ and
765: * that new pages are inserted on the tail end of the list. thus,
766: * we can make a complete pass through the object in one go by starting
767: * at the head and working towards the tail (new pages are put in
768: * front of us).
769: * => NOTE: we are allowed to lock the page queues, so the caller
770: * must not be holding the lock on them [e.g. pagedaemon had
771: * better not call us with the queues locked]
772: * => we return TRUE unless we encountered some sort of I/O error
773: *
774: * comment on "cleaning" object and PG_BUSY pages:
775: * this routine is holding the lock on the object. the only time
776: * that it can run into a PG_BUSY page that it does not own is if
777: * some other process has started I/O on the page (e.g. either
778: * a pagein, or a pageout). if the PG_BUSY page is being paged
779: * in, then it can not be dirty (!PG_CLEAN) because no one has
780: * had a chance to modify it yet. if the PG_BUSY page is being
781: * paged out then it means that someone else has already started
782: * cleaning the page for us (how nice!). in this case, if we
783: * have syncio specified, then after we make our pass through the
784: * object we need to wait for the other PG_BUSY pages to clear
785: * off (i.e. we need to do an iosync). also note that once a
786: * page is PG_BUSY it must stay in its object until it is un-busyed.
787: *
788: * note on page traversal:
789: * we can traverse the pages in an object either by going down the
790: * linked list in "uobj->memq", or we can go over the address range
791: * by page doing hash table lookups for each address. depending
792: * on how many pages are in the object it may be cheaper to do one
793: * or the other. we set "by_list" to true if we are using memq.
794: * if the cost of a hash lookup was equal to the cost of the list
795: * traversal we could compare the number of pages in the start->stop
796: * range to the total number of pages in the object. however, it
797: * seems that a hash table lookup is more expensive than the linked
798: * list traversal, so we multiply the number of pages in the
799: * start->stop range by a penalty which we define below.
800: */
801:
802: #define UVN_HASH_PENALTY 4 /* XXX: a guess */
803:
804: boolean_t
805: uvn_flush(uobj, start, stop, flags)
806: struct uvm_object *uobj;
807: voff_t start, stop;
808: int flags;
809: {
810: struct uvm_vnode *uvn = (struct uvm_vnode *) uobj;
811: struct vm_page *pp, *ppnext, *ptmp;
812: struct vm_page *pps[MAXBSIZE >> PAGE_SHIFT], **ppsp;
813: int npages, result, lcv;
814: boolean_t retval, need_iosync, by_list, needs_clean, all;
815: voff_t curoff;
816: u_short pp_version;
817: UVMHIST_FUNC("uvn_flush"); UVMHIST_CALLED(maphist);
818:
819: curoff = 0; /* XXX: shut up gcc */
820: /*
821: * get init vals and determine how we are going to traverse object
822: */
823:
824: need_iosync = FALSE;
825: retval = TRUE; /* return value */
826: if (flags & PGO_ALLPAGES) {
827: all = TRUE;
828: by_list = TRUE; /* always go by the list */
829: } else {
830: start = trunc_page(start);
831: stop = round_page(stop);
832: #ifdef DEBUG
833: if (stop > round_page(uvn->u_size))
834: printf("uvn_flush: strange, got an out of range "
835: "flush (fixed)\n");
836: #endif
837: all = FALSE;
838: by_list = (uobj->uo_npages <=
839: ((stop - start) >> PAGE_SHIFT) * UVN_HASH_PENALTY);
840: }
841:
842: UVMHIST_LOG(maphist,
843: " flush start=0x%lx, stop=0x%lx, by_list=%ld, flags=0x%lx",
844: (u_long)start, (u_long)stop, by_list, flags);
845:
846: /*
847: * PG_CLEANCHK: this bit is used by the pgo_mk_pcluster function as
848: * a _hint_ as to how up to date the PG_CLEAN bit is. if the hint
849: * is wrong it will only prevent us from clustering... it won't break
850: * anything. we clear all PG_CLEANCHK bits here, and pgo_mk_pcluster
851: * will set them as it syncs PG_CLEAN. This is only an issue if we
852: * are looking at non-inactive pages (because inactive page's PG_CLEAN
853: * bit is always up to date since there are no mappings).
854: * [borrowed PG_CLEANCHK idea from FreeBSD VM]
855: */
856:
857: if ((flags & PGO_CLEANIT) != 0 &&
858: uobj->pgops->pgo_mk_pcluster != NULL) {
859: if (by_list) {
860: TAILQ_FOREACH(pp, &uobj->memq, listq) {
861: if (!all &&
862: (pp->offset < start || pp->offset >= stop))
863: continue;
864: atomic_clearbits_int(&pp->pg_flags,
865: PG_CLEANCHK);
866: }
867:
868: } else { /* by hash */
869: for (curoff = start ; curoff < stop;
870: curoff += PAGE_SIZE) {
871: pp = uvm_pagelookup(uobj, curoff);
872: if (pp)
873: atomic_clearbits_int(&pp->pg_flags,
874: PG_CLEANCHK);
875: }
876: }
877: }
878:
879: /*
880: * now do it. note: we must update ppnext in body of loop or we
881: * will get stuck. we need to use ppnext because we may free "pp"
882: * before doing the next loop.
883: */
884:
885: if (by_list) {
886: pp = TAILQ_FIRST(&uobj->memq);
887: } else {
888: curoff = start;
889: pp = uvm_pagelookup(uobj, curoff);
890: }
891:
892: ppnext = NULL; /* XXX: shut up gcc */
893: ppsp = NULL; /* XXX: shut up gcc */
894: uvm_lock_pageq(); /* page queues locked */
895:
896: /* locked: both page queues and uobj */
897: for ( ; (by_list && pp != NULL) ||
898: (!by_list && curoff < stop) ; pp = ppnext) {
899:
900: if (by_list) {
901:
902: /*
903: * range check
904: */
905:
906: if (!all &&
907: (pp->offset < start || pp->offset >= stop)) {
908: ppnext = TAILQ_NEXT(pp, listq);
909: continue;
910: }
911:
912: } else {
913:
914: /*
915: * null check
916: */
917:
918: curoff += PAGE_SIZE;
919: if (pp == NULL) {
920: if (curoff < stop)
921: ppnext = uvm_pagelookup(uobj, curoff);
922: continue;
923: }
924:
925: }
926:
927: /*
928: * handle case where we do not need to clean page (either
929: * because we are not clean or because page is not dirty or
930: * is busy):
931: *
932: * NOTE: we are allowed to deactivate a non-wired active
933: * PG_BUSY page, but once a PG_BUSY page is on the inactive
934: * queue it must stay put until it is !PG_BUSY (so as not to
935: * confuse pagedaemon).
936: */
937:
938: if ((flags & PGO_CLEANIT) == 0 || (pp->pg_flags & PG_BUSY) != 0) {
939: needs_clean = FALSE;
940: if ((pp->pg_flags & PG_BUSY) != 0 &&
941: (flags & (PGO_CLEANIT|PGO_SYNCIO)) ==
942: (PGO_CLEANIT|PGO_SYNCIO))
943: need_iosync = TRUE;
944: } else {
945: /*
946: * freeing: nuke all mappings so we can sync
947: * PG_CLEAN bit with no race
948: */
949: if ((pp->pg_flags & PG_CLEAN) != 0 &&
950: (flags & PGO_FREE) != 0 &&
951: (pp->pg_flags & PQ_ACTIVE) != 0)
952: pmap_page_protect(pp, VM_PROT_NONE);
953: if ((pp->pg_flags & PG_CLEAN) != 0 &&
954: pmap_is_modified(pp))
955: atomic_clearbits_int(&pp->pg_flags, PG_CLEAN);
956: atomic_setbits_int(&pp->pg_flags, PG_CLEANCHK);
957:
958: needs_clean = ((pp->pg_flags & PG_CLEAN) == 0);
959: }
960:
961: /*
962: * if we don't need a clean... load ppnext and dispose of pp
963: */
964: if (!needs_clean) {
965: /* load ppnext */
966: if (by_list)
967: ppnext = TAILQ_NEXT(pp, listq);
968: else {
969: if (curoff < stop)
970: ppnext = uvm_pagelookup(uobj, curoff);
971: }
972:
973: /* now dispose of pp */
974: if (flags & PGO_DEACTIVATE) {
975: if ((pp->pg_flags & PQ_INACTIVE) == 0 &&
976: pp->wire_count == 0) {
977: pmap_page_protect(pp, VM_PROT_NONE);
978: uvm_pagedeactivate(pp);
979: }
980:
981: } else if (flags & PGO_FREE) {
982: if (pp->pg_flags & PG_BUSY) {
983: /* release busy pages */
984: atomic_setbits_int(&pp->pg_flags,
985: PG_RELEASED);
986: } else {
987: pmap_page_protect(pp, VM_PROT_NONE);
988: /* removed page from object */
989: uvm_pagefree(pp);
990: }
991: }
992: /* ppnext is valid so we can continue... */
993: continue;
994: }
995:
996: /*
997: * pp points to a page in the locked object that we are
998: * working on. if it is !PG_CLEAN,!PG_BUSY and we asked
999: * for cleaning (PGO_CLEANIT). we clean it now.
1000: *
1001: * let uvm_pager_put attempted a clustered page out.
1002: * note: locked: uobj and page queues.
1003: */
1004:
1005: atomic_setbits_int(&pp->pg_flags, PG_BUSY);
1006: UVM_PAGE_OWN(pp, "uvn_flush");
1007: pmap_page_protect(pp, VM_PROT_READ);
1008: pp_version = pp->pg_version;
1009: ReTry:
1010: ppsp = pps;
1011: npages = sizeof(pps) / sizeof(struct vm_page *);
1012:
1013: /* locked: page queues, uobj */
1014: result = uvm_pager_put(uobj, pp, &ppsp, &npages,
1015: flags | PGO_DOACTCLUST, start, stop);
1016: /* unlocked: page queues, uobj */
1017:
1018: /*
1019: * at this point nothing is locked. if we did an async I/O
1020: * it is remotely possible for the async i/o to complete and
1021: * the page "pp" be freed or what not before we get a chance
1022: * to relock the object. in order to detect this, we have
1023: * saved the version number of the page in "pp_version".
1024: */
1025:
1026: /* relock! */
1027: simple_lock(&uobj->vmobjlock);
1028: uvm_lock_pageq();
1029:
1030: /*
1031: * VM_PAGER_AGAIN: given the structure of this pager, this
1032: * can only happen when we are doing async I/O and can't
1033: * map the pages into kernel memory (pager_map) due to lack
1034: * of vm space. if this happens we drop back to sync I/O.
1035: */
1036:
1037: if (result == VM_PAGER_AGAIN) {
1038: /*
1039: * it is unlikely, but page could have been released
1040: * while we had the object lock dropped. we ignore
1041: * this now and retry the I/O. we will detect and
1042: * handle the released page after the syncio I/O
1043: * completes.
1044: */
1045: #ifdef DIAGNOSTIC
1046: if (flags & PGO_SYNCIO)
1047: panic("uvn_flush: PGO_SYNCIO return 'try again' error (impossible)");
1048: #endif
1049: flags |= PGO_SYNCIO;
1050: goto ReTry;
1051: }
1052:
1053: /*
1054: * the cleaning operation is now done. finish up. note that
1055: * on error (!OK, !PEND) uvm_pager_put drops the cluster for us.
1056: * if success (OK, PEND) then uvm_pager_put returns the cluster
1057: * to us in ppsp/npages.
1058: */
1059:
1060: /*
1061: * for pending async i/o if we are not deactivating/freeing
1062: * we can move on to the next page.
1063: */
1064:
1065: if (result == VM_PAGER_PEND) {
1066:
1067: if ((flags & (PGO_DEACTIVATE|PGO_FREE)) == 0) {
1068: /*
1069: * no per-page ops: refresh ppnext and continue
1070: */
1071: if (by_list) {
1072: if (pp->pg_version == pp_version)
1073: ppnext = TAILQ_NEXT(pp, listq);
1074: else
1075: /* reset */
1076: ppnext = TAILQ_FIRST(&uobj->memq);
1077: } else {
1078: if (curoff < stop)
1079: ppnext = uvm_pagelookup(uobj,
1080: curoff);
1081: }
1082: continue;
1083: }
1084:
1085: /* need to do anything here? */
1086: }
1087:
1088: /*
1089: * need to look at each page of the I/O operation. we defer
1090: * processing "pp" until the last trip through this "for" loop
1091: * so that we can load "ppnext" for the main loop after we
1092: * play with the cluster pages [thus the "npages + 1" in the
1093: * loop below].
1094: */
1095:
1096: for (lcv = 0 ; lcv < npages + 1 ; lcv++) {
1097:
1098: /*
1099: * handle ppnext for outside loop, and saving pp
1100: * until the end.
1101: */
1102: if (lcv < npages) {
1103: if (ppsp[lcv] == pp)
1104: continue; /* skip pp until the end */
1105: ptmp = ppsp[lcv];
1106: } else {
1107: ptmp = pp;
1108:
1109: /* set up next page for outer loop */
1110: if (by_list) {
1111: if (pp->pg_version == pp_version)
1112: ppnext = TAILQ_NEXT(pp, listq);
1113: else
1114: /* reset */
1115: ppnext = TAILQ_FIRST(&uobj->memq);
1116: } else {
1117: if (curoff < stop)
1118: ppnext = uvm_pagelookup(uobj, curoff);
1119: }
1120: }
1121:
1122: /*
1123: * verify the page didn't get moved while obj was
1124: * unlocked
1125: */
1126: if (result == VM_PAGER_PEND && ptmp->uobject != uobj)
1127: continue;
1128:
1129: /*
1130: * unbusy the page if I/O is done. note that for
1131: * pending I/O it is possible that the I/O op
1132: * finished before we relocked the object (in
1133: * which case the page is no longer busy).
1134: */
1135:
1136: if (result != VM_PAGER_PEND) {
1137: if (ptmp->pg_flags & PG_WANTED)
1138: /* still holding object lock */
1139: wakeup(ptmp);
1140:
1141: atomic_clearbits_int(&ptmp->pg_flags,
1142: PG_WANTED|PG_BUSY);
1143: UVM_PAGE_OWN(ptmp, NULL);
1144: if (ptmp->pg_flags & PG_RELEASED) {
1145:
1146: /* pgo_releasepg wants this */
1147: uvm_unlock_pageq();
1148: if (!uvn_releasepg(ptmp, NULL))
1149: return (TRUE);
1150:
1151: uvm_lock_pageq(); /* relock */
1152: continue; /* next page */
1153:
1154: } else {
1155: atomic_setbits_int(&ptmp->pg_flags,
1156: PG_CLEAN|PG_CLEANCHK);
1157: if ((flags & PGO_FREE) == 0)
1158: pmap_clear_modify(ptmp);
1159: }
1160: }
1161:
1162: /*
1163: * dispose of page
1164: */
1165:
1166: if (flags & PGO_DEACTIVATE) {
1167: if ((pp->pg_flags & PQ_INACTIVE) == 0 &&
1168: pp->wire_count == 0) {
1169: pmap_page_protect(ptmp, VM_PROT_NONE);
1170: uvm_pagedeactivate(ptmp);
1171: }
1172:
1173: } else if (flags & PGO_FREE) {
1174: if (result == VM_PAGER_PEND) {
1175: if ((ptmp->pg_flags & PG_BUSY) != 0)
1176: /* signal for i/o done */
1177: atomic_setbits_int(
1178: &ptmp->pg_flags,
1179: PG_RELEASED);
1180: } else {
1181: if (result != VM_PAGER_OK) {
1182: printf("uvn_flush: obj=%p, "
1183: "offset=0x%llx. error "
1184: "during pageout.\n",
1185: pp->uobject,
1186: (long long)pp->offset);
1187: printf("uvn_flush: WARNING: "
1188: "changes to page may be "
1189: "lost!\n");
1190: retval = FALSE;
1191: }
1192: pmap_page_protect(ptmp, VM_PROT_NONE);
1193: uvm_pagefree(ptmp);
1194: }
1195: }
1196:
1197: } /* end of "lcv" for loop */
1198:
1199: } /* end of "pp" for loop */
1200:
1201: /*
1202: * done with pagequeues: unlock
1203: */
1204: uvm_unlock_pageq();
1205:
1206: /*
1207: * now wait for all I/O if required.
1208: */
1209: if (need_iosync) {
1210:
1211: UVMHIST_LOG(maphist," <<DOING IOSYNC>>",0,0,0,0);
1212: while (uvn->u_nio != 0) {
1213: uvn->u_flags |= UVM_VNODE_IOSYNC;
1214: UVM_UNLOCK_AND_WAIT(&uvn->u_nio, &uvn->u_obj.vmobjlock,
1215: FALSE, "uvn_flush",0);
1216: simple_lock(&uvn->u_obj.vmobjlock);
1217: }
1218: if (uvn->u_flags & UVM_VNODE_IOSYNCWANTED)
1219: wakeup(&uvn->u_flags);
1220: uvn->u_flags &= ~(UVM_VNODE_IOSYNC|UVM_VNODE_IOSYNCWANTED);
1221: }
1222:
1223: /* return, with object locked! */
1224: UVMHIST_LOG(maphist,"<- done (retval=0x%lx)",retval,0,0,0);
1225: return(retval);
1226: }
1227:
1228: /*
1229: * uvn_cluster
1230: *
1231: * we are about to do I/O in an object at offset. this function is called
1232: * to establish a range of offsets around "offset" in which we can cluster
1233: * I/O.
1234: *
1235: * - currently doesn't matter if obj locked or not.
1236: */
1237:
1238: void
1239: uvn_cluster(uobj, offset, loffset, hoffset)
1240: struct uvm_object *uobj;
1241: voff_t offset;
1242: voff_t *loffset, *hoffset; /* OUT */
1243: {
1244: struct uvm_vnode *uvn = (struct uvm_vnode *) uobj;
1245: *loffset = offset;
1246:
1247: if (*loffset >= uvn->u_size)
1248: panic("uvn_cluster: offset out of range");
1249:
1250: /*
1251: * XXX: old pager claims we could use VOP_BMAP to get maxcontig value.
1252: */
1253: *hoffset = *loffset + MAXBSIZE;
1254: if (*hoffset > round_page(uvn->u_size)) /* past end? */
1255: *hoffset = round_page(uvn->u_size);
1256:
1257: return;
1258: }
1259:
1260: /*
1261: * uvn_put: flush page data to backing store.
1262: *
1263: * => prefer map unlocked (not required)
1264: * => object must be locked! we will _unlock_ it before starting I/O.
1265: * => flags: PGO_SYNCIO -- use sync. I/O
1266: * => note: caller must set PG_CLEAN and pmap_clear_modify (if needed)
1267: * => XXX: currently we use VOP_READ/VOP_WRITE which are only sync.
1268: * [thus we never do async i/o! see iodone comment]
1269: */
1270:
1271: int
1272: uvn_put(uobj, pps, npages, flags)
1273: struct uvm_object *uobj;
1274: struct vm_page **pps;
1275: int npages, flags;
1276: {
1277: int retval;
1278:
1279: /* note: object locked */
1280: retval = uvn_io((struct uvm_vnode*)uobj, pps, npages, flags, UIO_WRITE);
1281: /* note: object unlocked */
1282:
1283: return(retval);
1284: }
1285:
1286:
1287: /*
1288: * uvn_get: get pages (synchronously) from backing store
1289: *
1290: * => prefer map unlocked (not required)
1291: * => object must be locked! we will _unlock_ it before starting any I/O.
1292: * => flags: PGO_ALLPAGES: get all of the pages
1293: * PGO_LOCKED: fault data structures are locked
1294: * => NOTE: offset is the offset of pps[0], _NOT_ pps[centeridx]
1295: * => NOTE: caller must check for released pages!!
1296: */
1297:
1298: int
1299: uvn_get(uobj, offset, pps, npagesp, centeridx, access_type, advice, flags)
1300: struct uvm_object *uobj;
1301: voff_t offset;
1302: struct vm_page **pps; /* IN/OUT */
1303: int *npagesp; /* IN (OUT if PGO_LOCKED) */
1304: int centeridx, advice, flags;
1305: vm_prot_t access_type;
1306: {
1307: voff_t current_offset;
1308: struct vm_page *ptmp;
1309: int lcv, result, gotpages;
1310: boolean_t done;
1311: UVMHIST_FUNC("uvn_get"); UVMHIST_CALLED(maphist);
1312: UVMHIST_LOG(maphist, "flags=%ld", flags,0,0,0);
1313:
1314: /*
1315: * step 1: handled the case where fault data structures are locked.
1316: */
1317:
1318: if (flags & PGO_LOCKED) {
1319:
1320: /*
1321: * gotpages is the current number of pages we've gotten (which
1322: * we pass back up to caller via *npagesp.
1323: */
1324:
1325: gotpages = 0;
1326:
1327: /*
1328: * step 1a: get pages that are already resident. only do this
1329: * if the data structures are locked (i.e. the first time
1330: * through).
1331: */
1332:
1333: done = TRUE; /* be optimistic */
1334:
1335: for (lcv = 0, current_offset = offset ; lcv < *npagesp ;
1336: lcv++, current_offset += PAGE_SIZE) {
1337:
1338: /* do we care about this page? if not, skip it */
1339: if (pps[lcv] == PGO_DONTCARE)
1340: continue;
1341:
1342: /* lookup page */
1343: ptmp = uvm_pagelookup(uobj, current_offset);
1344:
1345: /* to be useful must get a non-busy, non-released pg */
1346: if (ptmp == NULL ||
1347: (ptmp->pg_flags & (PG_BUSY|PG_RELEASED)) != 0) {
1348: if (lcv == centeridx || (flags & PGO_ALLPAGES)
1349: != 0)
1350: done = FALSE; /* need to do a wait or I/O! */
1351: continue;
1352: }
1353:
1354: /*
1355: * useful page: busy/lock it and plug it in our
1356: * result array
1357: */
1358: atomic_setbits_int(&ptmp->pg_flags, PG_BUSY);
1359: UVM_PAGE_OWN(ptmp, "uvn_get1");
1360: pps[lcv] = ptmp;
1361: gotpages++;
1362:
1363: } /* "for" lcv loop */
1364:
1365: /*
1366: * XXX: given the "advice", should we consider async read-ahead?
1367: * XXX: fault current does deactive of pages behind us. is
1368: * this good (other callers might now).
1369: */
1370: /*
1371: * XXX: read-ahead currently handled by buffer cache (bread)
1372: * level.
1373: * XXX: no async i/o available.
1374: * XXX: so we don't do anything now.
1375: */
1376:
1377: /*
1378: * step 1c: now we've either done everything needed or we to
1379: * unlock and do some waiting or I/O.
1380: */
1381:
1382: *npagesp = gotpages; /* let caller know */
1383: if (done)
1384: return(VM_PAGER_OK); /* bingo! */
1385: else
1386: /* EEK! Need to unlock and I/O */
1387: return(VM_PAGER_UNLOCK);
1388: }
1389:
1390: /*
1391: * step 2: get non-resident or busy pages.
1392: * object is locked. data structures are unlocked.
1393: *
1394: * XXX: because we can't do async I/O at this level we get things
1395: * page at a time (otherwise we'd chunk). the VOP_READ() will do
1396: * async-read-ahead for us at a lower level.
1397: */
1398:
1399: for (lcv = 0, current_offset = offset;
1400: lcv < *npagesp ; lcv++, current_offset += PAGE_SIZE) {
1401:
1402: /* skip over pages we've already gotten or don't want */
1403: /* skip over pages we don't _have_ to get */
1404: if (pps[lcv] != NULL || (lcv != centeridx &&
1405: (flags & PGO_ALLPAGES) == 0))
1406: continue;
1407:
1408: /*
1409: * we have yet to locate the current page (pps[lcv]). we first
1410: * look for a page that is already at the current offset. if
1411: * we fine a page, we check to see if it is busy or released.
1412: * if that is the case, then we sleep on the page until it is
1413: * no longer busy or released and repeat the lookup. if the
1414: * page we found is neither busy nor released, then we busy it
1415: * (so we own it) and plug it into pps[lcv]. this breaks the
1416: * following while loop and indicates we are ready to move on
1417: * to the next page in the "lcv" loop above.
1418: *
1419: * if we exit the while loop with pps[lcv] still set to NULL,
1420: * then it means that we allocated a new busy/fake/clean page
1421: * ptmp in the object and we need to do I/O to fill in the data.
1422: */
1423:
1424: while (pps[lcv] == NULL) { /* top of "pps" while loop */
1425:
1426: /* look for a current page */
1427: ptmp = uvm_pagelookup(uobj, current_offset);
1428:
1429: /* nope? allocate one now (if we can) */
1430: if (ptmp == NULL) {
1431:
1432: ptmp = uvm_pagealloc(uobj, current_offset,
1433: NULL, 0);
1434:
1435: /* out of RAM? */
1436: if (ptmp == NULL) {
1437: simple_unlock(&uobj->vmobjlock);
1438: uvm_wait("uvn_getpage");
1439: simple_lock(&uobj->vmobjlock);
1440:
1441: /* goto top of pps while loop */
1442: continue;
1443: }
1444:
1445: /*
1446: * got new page ready for I/O. break pps
1447: * while loop. pps[lcv] is still NULL.
1448: */
1449: break;
1450: }
1451:
1452: /* page is there, see if we need to wait on it */
1453: if ((ptmp->pg_flags & (PG_BUSY|PG_RELEASED)) != 0) {
1454: atomic_setbits_int(&ptmp->pg_flags, PG_WANTED);
1455: UVM_UNLOCK_AND_WAIT(ptmp,
1456: &uobj->vmobjlock, FALSE, "uvn_get",0);
1457: simple_lock(&uobj->vmobjlock);
1458: continue; /* goto top of pps while loop */
1459: }
1460:
1461: /*
1462: * if we get here then the page has become resident
1463: * and unbusy between steps 1 and 2. we busy it
1464: * now (so we own it) and set pps[lcv] (so that we
1465: * exit the while loop).
1466: */
1467: atomic_setbits_int(&ptmp->pg_flags, PG_BUSY);
1468: UVM_PAGE_OWN(ptmp, "uvn_get2");
1469: pps[lcv] = ptmp;
1470: }
1471:
1472: /*
1473: * if we own the a valid page at the correct offset, pps[lcv]
1474: * will point to it. nothing more to do except go to the
1475: * next page.
1476: */
1477:
1478: if (pps[lcv])
1479: continue; /* next lcv */
1480:
1481: /*
1482: * we have a "fake/busy/clean" page that we just allocated. do
1483: * I/O to fill it with valid data. note that object must be
1484: * locked going into uvn_io, but will be unlocked afterwards.
1485: */
1486:
1487: result = uvn_io((struct uvm_vnode *) uobj, &ptmp, 1,
1488: PGO_SYNCIO, UIO_READ);
1489:
1490: /*
1491: * I/O done. object is unlocked (by uvn_io). because we used
1492: * syncio the result can not be PEND or AGAIN. we must relock
1493: * and check for errors.
1494: */
1495:
1496: /* lock object. check for errors. */
1497: simple_lock(&uobj->vmobjlock);
1498: if (result != VM_PAGER_OK) {
1499: if (ptmp->pg_flags & PG_WANTED)
1500: /* object lock still held */
1501: wakeup(ptmp);
1502:
1503: atomic_clearbits_int(&ptmp->pg_flags,
1504: PG_WANTED|PG_BUSY);
1505: UVM_PAGE_OWN(ptmp, NULL);
1506: uvm_lock_pageq();
1507: uvm_pagefree(ptmp);
1508: uvm_unlock_pageq();
1509: simple_unlock(&uobj->vmobjlock);
1510: return(result);
1511: }
1512:
1513: /*
1514: * we got the page! clear the fake flag (indicates valid
1515: * data now in page) and plug into our result array. note
1516: * that page is still busy.
1517: *
1518: * it is the callers job to:
1519: * => check if the page is released
1520: * => unbusy the page
1521: * => activate the page
1522: */
1523:
1524: /* data is valid ... */
1525: atomic_clearbits_int(&ptmp->pg_flags, PG_FAKE);
1526: pmap_clear_modify(ptmp); /* ... and clean */
1527: pps[lcv] = ptmp;
1528:
1529: } /* lcv loop */
1530:
1531: /*
1532: * finally, unlock object and return.
1533: */
1534:
1535: simple_unlock(&uobj->vmobjlock);
1536: return (VM_PAGER_OK);
1537: }
1538:
1539: /*
1540: * uvn_io: do I/O to a vnode
1541: *
1542: * => prefer map unlocked (not required)
1543: * => object must be locked! we will _unlock_ it before starting I/O.
1544: * => flags: PGO_SYNCIO -- use sync. I/O
1545: * => XXX: currently we use VOP_READ/VOP_WRITE which are only sync.
1546: * [thus we never do async i/o! see iodone comment]
1547: */
1548:
1549: int
1550: uvn_io(uvn, pps, npages, flags, rw)
1551: struct uvm_vnode *uvn;
1552: vm_page_t *pps;
1553: int npages, flags, rw;
1554: {
1555: struct vnode *vn;
1556: struct uio uio;
1557: struct iovec iov;
1558: vaddr_t kva;
1559: off_t file_offset;
1560: int waitf, result, mapinflags;
1561: size_t got, wanted;
1562: UVMHIST_FUNC("uvn_io"); UVMHIST_CALLED(maphist);
1563:
1564: UVMHIST_LOG(maphist, "rw=%ld", rw,0,0,0);
1565:
1566: /*
1567: * init values
1568: */
1569:
1570: waitf = (flags & PGO_SYNCIO) ? M_WAITOK : M_NOWAIT;
1571: vn = (struct vnode *) uvn;
1572: file_offset = pps[0]->offset;
1573:
1574: /*
1575: * check for sync'ing I/O.
1576: */
1577:
1578: while (uvn->u_flags & UVM_VNODE_IOSYNC) {
1579: if (waitf == M_NOWAIT) {
1580: simple_unlock(&uvn->u_obj.vmobjlock);
1581: UVMHIST_LOG(maphist,"<- try again (iosync)",0,0,0,0);
1582: return(VM_PAGER_AGAIN);
1583: }
1584: uvn->u_flags |= UVM_VNODE_IOSYNCWANTED;
1585: UVM_UNLOCK_AND_WAIT(&uvn->u_flags, &uvn->u_obj.vmobjlock,
1586: FALSE, "uvn_iosync",0);
1587: simple_lock(&uvn->u_obj.vmobjlock);
1588: }
1589:
1590: /*
1591: * check size
1592: */
1593:
1594: if (file_offset >= uvn->u_size) {
1595: simple_unlock(&uvn->u_obj.vmobjlock);
1596: UVMHIST_LOG(maphist,"<- BAD (size check)",0,0,0,0);
1597: return(VM_PAGER_BAD);
1598: }
1599:
1600: /*
1601: * first try and map the pages in (without waiting)
1602: */
1603:
1604: mapinflags = (rw == UIO_READ) ?
1605: UVMPAGER_MAPIN_READ : UVMPAGER_MAPIN_WRITE;
1606:
1607: kva = uvm_pagermapin(pps, npages, mapinflags);
1608: if (kva == 0 && waitf == M_NOWAIT) {
1609: simple_unlock(&uvn->u_obj.vmobjlock);
1610: UVMHIST_LOG(maphist,"<- mapin failed (try again)",0,0,0,0);
1611: return(VM_PAGER_AGAIN);
1612: }
1613:
1614: /*
1615: * ok, now bump u_nio up. at this point we are done with uvn
1616: * and can unlock it. if we still don't have a kva, try again
1617: * (this time with sleep ok).
1618: */
1619:
1620: uvn->u_nio++; /* we have an I/O in progress! */
1621: simple_unlock(&uvn->u_obj.vmobjlock);
1622: /* NOTE: object now unlocked */
1623: if (kva == 0)
1624: kva = uvm_pagermapin(pps, npages,
1625: mapinflags | UVMPAGER_MAPIN_WAITOK);
1626:
1627: /*
1628: * ok, mapped in. our pages are PG_BUSY so they are not going to
1629: * get touched (so we can look at "offset" without having to lock
1630: * the object). set up for I/O.
1631: */
1632:
1633: /*
1634: * fill out uio/iov
1635: */
1636:
1637: iov.iov_base = (caddr_t) kva;
1638: wanted = npages << PAGE_SHIFT;
1639: if (file_offset + wanted > uvn->u_size)
1640: wanted = uvn->u_size - file_offset; /* XXX: needed? */
1641: iov.iov_len = wanted;
1642: uio.uio_iov = &iov;
1643: uio.uio_iovcnt = 1;
1644: uio.uio_offset = file_offset;
1645: uio.uio_segflg = UIO_SYSSPACE;
1646: uio.uio_rw = rw;
1647: uio.uio_resid = wanted;
1648: uio.uio_procp = curproc;
1649:
1650: /*
1651: * do the I/O! (XXX: curproc?)
1652: */
1653:
1654: UVMHIST_LOG(maphist, "calling VOP",0,0,0,0);
1655:
1656: /*
1657: * This process may already have this vnode locked, if we faulted in
1658: * copyin() or copyout() on a region backed by this vnode
1659: * while doing I/O to the vnode. If this is the case, don't
1660: * panic.. instead, return the error to the user.
1661: *
1662: * XXX this is a stopgap to prevent a panic.
1663: * Ideally, this kind of operation *should* work.
1664: */
1665: result = 0;
1666: if ((uvn->u_flags & UVM_VNODE_VNISLOCKED) == 0)
1667: result = vn_lock(vn, LK_EXCLUSIVE | LK_RECURSEFAIL, curproc);
1668:
1669: if (result == 0) {
1670: /* NOTE: vnode now locked! */
1671:
1672: if (rw == UIO_READ)
1673: result = VOP_READ(vn, &uio, 0, curproc->p_ucred);
1674: else
1675: result = VOP_WRITE(vn, &uio, 0, curproc->p_ucred);
1676:
1677: if ((uvn->u_flags & UVM_VNODE_VNISLOCKED) == 0)
1678: VOP_UNLOCK(vn, 0, curproc);
1679: }
1680:
1681: /* NOTE: vnode now unlocked (unless vnislocked) */
1682:
1683: UVMHIST_LOG(maphist, "done calling VOP",0,0,0,0);
1684:
1685: /*
1686: * result == unix style errno (0 == OK!)
1687: *
1688: * zero out rest of buffer (if needed)
1689: */
1690:
1691: if (result == 0) {
1692: got = wanted - uio.uio_resid;
1693:
1694: if (wanted && got == 0) {
1695: result = EIO; /* XXX: error? */
1696: } else if (got < PAGE_SIZE * npages && rw == UIO_READ) {
1697: memset((void *) (kva + got), 0,
1698: (npages << PAGE_SHIFT) - got);
1699: }
1700: }
1701:
1702: /*
1703: * now remove pager mapping
1704: */
1705: uvm_pagermapout(kva, npages);
1706:
1707: /*
1708: * now clean up the object (i.e. drop I/O count)
1709: */
1710:
1711: simple_lock(&uvn->u_obj.vmobjlock);
1712: /* NOTE: object now locked! */
1713:
1714: uvn->u_nio--; /* I/O DONE! */
1715: if ((uvn->u_flags & UVM_VNODE_IOSYNC) != 0 && uvn->u_nio == 0) {
1716: wakeup(&uvn->u_nio);
1717: }
1718: simple_unlock(&uvn->u_obj.vmobjlock);
1719: /* NOTE: object now unlocked! */
1720:
1721: /*
1722: * done!
1723: */
1724:
1725: UVMHIST_LOG(maphist, "<- done (result %ld)", result,0,0,0);
1726: if (result == 0)
1727: return(VM_PAGER_OK);
1728: else
1729: return(VM_PAGER_ERROR);
1730: }
1731:
1732: /*
1733: * uvm_vnp_uncache: disable "persisting" in a vnode... when last reference
1734: * is gone we will kill the object (flushing dirty pages back to the vnode
1735: * if needed).
1736: *
1737: * => returns TRUE if there was no uvm_object attached or if there was
1738: * one and we killed it [i.e. if there is no active uvn]
1739: * => called with the vnode VOP_LOCK'd [we will unlock it for I/O, if
1740: * needed]
1741: *
1742: * => XXX: given that we now kill uvn's when a vnode is recycled (without
1743: * having to hold a reference on the vnode) and given a working
1744: * uvm_vnp_sync(), how does that effect the need for this function?
1745: * [XXXCDC: seems like it can die?]
1746: *
1747: * => XXX: this function should DIE once we merge the VM and buffer
1748: * cache.
1749: *
1750: * research shows that this is called in the following places:
1751: * ext2fs_truncate, ffs_truncate, detrunc[msdosfs]: called when vnode
1752: * changes sizes
1753: * ext2fs_write, WRITE [ufs_readwrite], msdosfs_write: called when we
1754: * are written to
1755: * ex2fs_chmod, ufs_chmod: called if VTEXT vnode and the sticky bit
1756: * is off
1757: * ffs_realloccg: when we can't extend the current block and have
1758: * to allocate a new one we call this [XXX: why?]
1759: * nfsrv_rename, rename_files: called when the target filename is there
1760: * and we want to remove it
1761: * nfsrv_remove, sys_unlink: called on file we are removing
1762: * nfsrv_access: if VTEXT and we want WRITE access and we don't uncache
1763: * then return "text busy"
1764: * nfs_open: seems to uncache any file opened with nfs
1765: * vn_writechk: if VTEXT vnode and can't uncache return "text busy"
1766: */
1767:
1768: boolean_t
1769: uvm_vnp_uncache(vp)
1770: struct vnode *vp;
1771: {
1772: struct uvm_vnode *uvn = &vp->v_uvm;
1773:
1774: /*
1775: * lock uvn part of the vnode and check to see if we need to do anything
1776: */
1777:
1778: simple_lock(&uvn->u_obj.vmobjlock);
1779: if ((uvn->u_flags & UVM_VNODE_VALID) == 0 ||
1780: (uvn->u_flags & UVM_VNODE_BLOCKED) != 0) {
1781: simple_unlock(&uvn->u_obj.vmobjlock);
1782: return(TRUE);
1783: }
1784:
1785: /*
1786: * we have a valid, non-blocked uvn. clear persist flag.
1787: * if uvn is currently active we can return now.
1788: */
1789:
1790: uvn->u_flags &= ~UVM_VNODE_CANPERSIST;
1791: if (uvn->u_obj.uo_refs) {
1792: simple_unlock(&uvn->u_obj.vmobjlock);
1793: return(FALSE);
1794: }
1795:
1796: /*
1797: * uvn is currently persisting! we have to gain a reference to
1798: * it so that we can call uvn_detach to kill the uvn.
1799: */
1800:
1801: VREF(vp); /* seems ok, even with VOP_LOCK */
1802: uvn->u_obj.uo_refs++; /* value is now 1 */
1803: simple_unlock(&uvn->u_obj.vmobjlock);
1804:
1805:
1806: #ifdef DEBUG
1807: /*
1808: * carry over sanity check from old vnode pager: the vnode should
1809: * be VOP_LOCK'd, and we confirm it here.
1810: */
1811: if (!VOP_ISLOCKED(vp)) {
1812: boolean_t is_ok_anyway = FALSE;
1813: #if defined(NFSCLIENT)
1814: extern int (**nfsv2_vnodeop_p)(void *);
1815: extern int (**spec_nfsv2nodeop_p)(void *);
1816: #if defined(FIFO)
1817: extern int (**fifo_nfsv2nodeop_p)(void *);
1818: #endif /* defined(FIFO) */
1819:
1820: /* vnode is NOT VOP_LOCKed: some vnode types _never_ lock */
1821: if (vp->v_op == nfsv2_vnodeop_p ||
1822: vp->v_op == spec_nfsv2nodeop_p) {
1823: is_ok_anyway = TRUE;
1824: }
1825: #if defined(FIFO)
1826: if (vp->v_op == fifo_nfsv2nodeop_p) {
1827: is_ok_anyway = TRUE;
1828: }
1829: #endif /* defined(FIFO) */
1830: #endif /* defined(NFSSERVER) || defined(NFSCLIENT) */
1831: if (!is_ok_anyway)
1832: panic("uvm_vnp_uncache: vnode not locked!");
1833: }
1834: #endif /* DEBUG */
1835:
1836: /*
1837: * now drop our reference to the vnode. if we have the sole
1838: * reference to the vnode then this will cause it to die [as we
1839: * just cleared the persist flag]. we have to unlock the vnode
1840: * while we are doing this as it may trigger I/O.
1841: *
1842: * XXX: it might be possible for uvn to get reclaimed while we are
1843: * unlocked causing us to return TRUE when we should not. we ignore
1844: * this as a false-positive return value doesn't hurt us.
1845: */
1846: VOP_UNLOCK(vp, 0, curproc);
1847: uvn_detach(&uvn->u_obj);
1848: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curproc);
1849:
1850: /*
1851: * and return...
1852: */
1853:
1854: return(TRUE);
1855: }
1856:
1857: /*
1858: * uvm_vnp_setsize: grow or shrink a vnode uvn
1859: *
1860: * grow => just update size value
1861: * shrink => toss un-needed pages
1862: *
1863: * => we assume that the caller has a reference of some sort to the
1864: * vnode in question so that it will not be yanked out from under
1865: * us.
1866: *
1867: * called from:
1868: * => truncate fns (ext2fs_truncate, ffs_truncate, detrunc[msdos])
1869: * => "write" fns (ext2fs_write, WRITE [ufs/ufs], msdosfs_write, nfs_write)
1870: * => ffs_balloc [XXX: why? doesn't WRITE handle?]
1871: * => NFS: nfs_loadattrcache, nfs_getattrcache, nfs_setattr
1872: * => union fs: union_newsize
1873: */
1874:
1875: void
1876: uvm_vnp_setsize(vp, newsize)
1877: struct vnode *vp;
1878: voff_t newsize;
1879: {
1880: struct uvm_vnode *uvn = &vp->v_uvm;
1881:
1882: /*
1883: * lock uvn and check for valid object, and if valid: do it!
1884: */
1885: simple_lock(&uvn->u_obj.vmobjlock);
1886: if (uvn->u_flags & UVM_VNODE_VALID) {
1887:
1888: /*
1889: * now check if the size has changed: if we shrink we had better
1890: * toss some pages...
1891: */
1892:
1893: if (uvn->u_size > newsize) {
1894: (void)uvn_flush(&uvn->u_obj, newsize,
1895: uvn->u_size, PGO_FREE);
1896: }
1897: uvn->u_size = newsize;
1898: }
1899: simple_unlock(&uvn->u_obj.vmobjlock);
1900:
1901: /*
1902: * done
1903: */
1904: return;
1905: }
1906:
1907: /*
1908: * uvm_vnp_sync: flush all dirty VM pages back to their backing vnodes.
1909: *
1910: * => called from sys_sync with no VM structures locked
1911: * => only one process can do a sync at a time (because the uvn
1912: * structure only has one queue for sync'ing). we ensure this
1913: * by holding the uvn_sync_lock while the sync is in progress.
1914: * other processes attempting a sync will sleep on this lock
1915: * until we are done.
1916: */
1917:
1918: void
1919: uvm_vnp_sync(mp)
1920: struct mount *mp;
1921: {
1922: struct uvm_vnode *uvn;
1923: struct vnode *vp;
1924: boolean_t got_lock;
1925:
1926: /*
1927: * step 1: ensure we are only ones using the uvn_sync_q by locking
1928: * our lock...
1929: */
1930: rw_enter_write(&uvn_sync_lock);
1931:
1932: /*
1933: * step 2: build up a simpleq of uvns of interest based on the
1934: * write list. we gain a reference to uvns of interest.
1935: */
1936: SIMPLEQ_INIT(&uvn_sync_q);
1937: LIST_FOREACH(uvn, &uvn_wlist, u_wlist) {
1938:
1939: vp = (struct vnode *) uvn;
1940: if (mp && vp->v_mount != mp)
1941: continue;
1942:
1943: /* attempt to gain reference */
1944: while ((got_lock = simple_lock_try(&uvn->u_obj.vmobjlock)) ==
1945: FALSE &&
1946: (uvn->u_flags & UVM_VNODE_BLOCKED) == 0)
1947: /* spin */;
1948:
1949: /*
1950: * we will exit the loop if either if the following are true:
1951: * - we got the lock [always true if NCPU == 1]
1952: * - we failed to get the lock but noticed the vnode was
1953: * "blocked" -- in this case the vnode must be a dying
1954: * vnode, and since dying vnodes are in the process of
1955: * being flushed out, we can safely skip this one
1956: *
1957: * we want to skip over the vnode if we did not get the lock,
1958: * or if the vnode is already dying (due to the above logic).
1959: *
1960: * note that uvn must already be valid because we found it on
1961: * the wlist (this also means it can't be ALOCK'd).
1962: */
1963: if (!got_lock || (uvn->u_flags & UVM_VNODE_BLOCKED) != 0) {
1964: if (got_lock)
1965: simple_unlock(&uvn->u_obj.vmobjlock);
1966: continue; /* skip it */
1967: }
1968:
1969: /*
1970: * gain reference. watch out for persisting uvns (need to
1971: * regain vnode REF).
1972: */
1973: if (uvn->u_obj.uo_refs == 0)
1974: VREF(vp);
1975: uvn->u_obj.uo_refs++;
1976: simple_unlock(&uvn->u_obj.vmobjlock);
1977:
1978: /*
1979: * got it!
1980: */
1981: SIMPLEQ_INSERT_HEAD(&uvn_sync_q, uvn, u_syncq);
1982: }
1983:
1984: /*
1985: * step 3: we now have a list of uvn's that may need cleaning.
1986: * we are holding the uvn_sync_lock.
1987: */
1988:
1989: SIMPLEQ_FOREACH(uvn, &uvn_sync_q, u_syncq) {
1990: simple_lock(&uvn->u_obj.vmobjlock);
1991: #ifdef DEBUG
1992: if (uvn->u_flags & UVM_VNODE_DYING) {
1993: printf("uvm_vnp_sync: dying vnode on sync list\n");
1994: }
1995: #endif
1996: uvn_flush(&uvn->u_obj, 0, 0,
1997: PGO_CLEANIT|PGO_ALLPAGES|PGO_DOACTCLUST);
1998:
1999: /*
2000: * if we have the only reference and we just cleaned the uvn,
2001: * then we can pull it out of the UVM_VNODE_WRITEABLE state
2002: * thus allowing us to avoid thinking about flushing it again
2003: * on later sync ops.
2004: */
2005: if (uvn->u_obj.uo_refs == 1 &&
2006: (uvn->u_flags & UVM_VNODE_WRITEABLE)) {
2007: LIST_REMOVE(uvn, u_wlist);
2008: uvn->u_flags &= ~UVM_VNODE_WRITEABLE;
2009: }
2010:
2011: simple_unlock(&uvn->u_obj.vmobjlock);
2012:
2013: /* now drop our reference to the uvn */
2014: uvn_detach(&uvn->u_obj);
2015: }
2016:
2017: /*
2018: * done! release sync lock
2019: */
2020: rw_exit_write(&uvn_sync_lock);
2021: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to uvm_vnode.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / uvm