![[BACK]](/icons/back.gif){kind=icon}
Return to uvm_anon.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / uvm|
Return to uvm_anon.c CVS log | Up to [local] / sys / uvm |
1.1 nbrk 1: /* $OpenBSD: uvm_anon.c,v 1.28 2007/06/18 21:51:15 pedro Exp $ */
2: /* $NetBSD: uvm_anon.c,v 1.10 2000/11/25 06:27:59 chs Exp $ */
3:
4: /*
5: *
6: * Copyright (c) 1997 Charles D. Cranor and Washington University.
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Charles D. Cranor and
20: * Washington University.
21: * 4. The name of the author may not be used to endorse or promote products
22: * derived from this software without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
25: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: /*
37: * uvm_anon.c: uvm anon ops
38: */
39:
40: #include <sys/param.h>
41: #include <sys/systm.h>
42: #include <sys/proc.h>
43: #include <sys/malloc.h>
44: #include <sys/pool.h>
45: #include <sys/kernel.h>
46:
47: #include <uvm/uvm.h>
48: #include <uvm/uvm_swap.h>
49:
50: struct pool uvm_anon_pool;
51:
52: /*
53: * allocate anons
54: */
55: void
56: uvm_anon_init()
57: {
58: pool_init(&uvm_anon_pool, sizeof(struct vm_anon), 0, 0, 0, "anonpl",
59: &pool_allocator_nointr);
60: pool_sethiwat(&uvm_anon_pool, uvmexp.free / 16);
61: }
62:
63: /*
64: * allocate an anon
65: */
66: struct vm_anon *
67: uvm_analloc()
68: {
69: struct vm_anon *anon;
70:
71: anon = pool_get(&uvm_anon_pool, PR_NOWAIT);
72: if (anon) {
73: simple_lock_init(&anon->an_lock);
74: anon->an_ref = 1;
75: anon->an_page = NULL;
76: anon->an_swslot = 0;
77: simple_lock(&anon->an_lock);
78: }
79: return(anon);
80: }
81:
82: /*
83: * uvm_anfree: free a single anon structure
84: *
85: * => caller must remove anon from its amap before calling (if it was in
86: * an amap).
87: * => anon must be unlocked and have a zero reference count.
88: * => we may lock the pageq's.
89: */
90: void
91: uvm_anfree(anon)
92: struct vm_anon *anon;
93: {
94: struct vm_page *pg;
95: UVMHIST_FUNC("uvm_anfree"); UVMHIST_CALLED(maphist);
96: UVMHIST_LOG(maphist,"(anon=%p)", anon, 0,0,0);
97:
98: /*
99: * get page
100: */
101:
102: pg = anon->an_page;
103:
104: /*
105: * if there is a resident page and it is loaned, then anon may not
106: * own it. call out to uvm_anon_lockpage() to ensure the real owner
107: * of the page has been identified and locked.
108: */
109:
110: if (pg && pg->loan_count)
111: pg = uvm_anon_lockloanpg(anon);
112:
113: /*
114: * if we have a resident page, we must dispose of it before freeing
115: * the anon.
116: */
117:
118: if (pg) {
119:
120: /*
121: * if the page is owned by a uobject (now locked), then we must
122: * kill the loan on the page rather than free it.
123: */
124:
125: if (pg->uobject) {
126: uvm_lock_pageq();
127: KASSERT(pg->loan_count > 0);
128: pg->loan_count--;
129: pg->uanon = NULL;
130: uvm_unlock_pageq();
131: simple_unlock(&pg->uobject->vmobjlock);
132: } else {
133:
134: /*
135: * page has no uobject, so we must be the owner of it.
136: *
137: * if page is busy then we just mark it as released
138: * (who ever has it busy must check for this when they
139: * wake up). if the page is not busy then we can
140: * free it now.
141: */
142:
143: if ((pg->pg_flags & PG_BUSY) != 0) {
144: /* tell them to dump it when done */
145: atomic_setbits_int(&pg->pg_flags, PG_RELEASED);
146: UVMHIST_LOG(maphist,
147: " anon %p, page %p: BUSY (released!)",
148: anon, pg, 0, 0);
149: return;
150: }
151: pmap_page_protect(pg, VM_PROT_NONE);
152: uvm_lock_pageq(); /* lock out pagedaemon */
153: uvm_pagefree(pg); /* bye bye */
154: uvm_unlock_pageq(); /* free the daemon */
155: UVMHIST_LOG(maphist,"anon %p, page %p: freed now!",
156: anon, pg, 0, 0);
157: }
158: }
159:
160: /*
161: * free any swap resources.
162: */
163: uvm_anon_dropswap(anon);
164:
165: /*
166: * now that we've stripped the data areas from the anon, free the anon
167: * itself!
168: */
169: KASSERT(anon->an_page == NULL);
170: KASSERT(anon->an_swslot == 0);
171:
172: pool_put(&uvm_anon_pool, anon);
173: UVMHIST_LOG(maphist,"<- done!",0,0,0,0);
174: }
175:
176: /*
177: * uvm_anon_dropswap: release any swap resources from this anon.
178: *
179: * => anon must be locked or have a reference count of 0.
180: */
181: void
182: uvm_anon_dropswap(anon)
183: struct vm_anon *anon;
184: {
185: UVMHIST_FUNC("uvm_anon_dropswap"); UVMHIST_CALLED(maphist);
186:
187: if (anon->an_swslot == 0)
188: return;
189:
190: UVMHIST_LOG(maphist,"freeing swap for anon %p, paged to swslot 0x%lx",
191: anon, anon->an_swslot, 0, 0);
192: uvm_swap_free(anon->an_swslot, 1);
193: anon->an_swslot = 0;
194:
195: if (anon->an_page == NULL) {
196: /* this page is no longer only in swap. */
197: simple_lock(&uvm.swap_data_lock);
198: uvmexp.swpgonly--;
199: simple_unlock(&uvm.swap_data_lock);
200: }
201: }
202:
203: /*
204: * uvm_anon_lockloanpg: given a locked anon, lock its resident page
205: *
206: * => anon is locked by caller
207: * => on return: anon is locked
208: * if there is a resident page:
209: * if it has a uobject, it is locked by us
210: * if it is ownerless, we take over as owner
211: * we return the resident page (it can change during
212: * this function)
213: * => note that the only time an anon has an ownerless resident page
214: * is if the page was loaned from a uvm_object and the uvm_object
215: * disowned it
216: * => this only needs to be called when you want to do an operation
217: * on an anon's resident page and that page has a non-zero loan
218: * count.
219: */
220: struct vm_page *
221: uvm_anon_lockloanpg(anon)
222: struct vm_anon *anon;
223: {
224: struct vm_page *pg;
225: boolean_t locked = FALSE;
226:
227: /*
228: * loop while we have a resident page that has a non-zero loan count.
229: * if we successfully get our lock, we will "break" the loop.
230: * note that the test for pg->loan_count is not protected -- this
231: * may produce false positive results. note that a false positive
232: * result may cause us to do more work than we need to, but it will
233: * not produce an incorrect result.
234: */
235:
236: while (((pg = anon->an_page) != NULL) && pg->loan_count != 0) {
237:
238: /*
239: * quickly check to see if the page has an object before
240: * bothering to lock the page queues. this may also produce
241: * a false positive result, but that's ok because we do a real
242: * check after that.
243: *
244: * XXX: quick check -- worth it? need volatile?
245: */
246:
247: if (pg->uobject) {
248:
249: uvm_lock_pageq();
250: if (pg->uobject) { /* the "real" check */
251: locked =
252: simple_lock_try(&pg->uobject->vmobjlock);
253: } else {
254: /* object disowned before we got PQ lock */
255: locked = TRUE;
256: }
257: uvm_unlock_pageq();
258:
259: /*
260: * if we didn't get a lock (try lock failed), then we
261: * toggle our anon lock and try again
262: */
263:
264: if (!locked) {
265: simple_unlock(&anon->an_lock);
266:
267: /*
268: * someone locking the object has a chance to
269: * lock us right now
270: */
271:
272: simple_lock(&anon->an_lock);
273: continue;
274: }
275: }
276:
277: /*
278: * if page is un-owned [i.e. the object dropped its ownership],
279: * then we can take over as owner!
280: */
281:
282: if (pg->uobject == NULL && (pg->pg_flags & PQ_ANON) == 0) {
283: uvm_lock_pageq();
284: atomic_setbits_int(&pg->pg_flags, PQ_ANON);
285: pg->loan_count--; /* ... and drop our loan */
286: uvm_unlock_pageq();
287: }
288:
289: /*
290: * we did it! break the loop
291: */
292:
293: break;
294: }
295: return(pg);
296: }
297:
298: /*
299: * fetch an anon's page.
300: *
301: * => anon must be locked, and is unlocked upon return.
302: * => returns TRUE if pagein was aborted due to lack of memory.
303: */
304:
305: boolean_t
306: uvm_anon_pagein(anon)
307: struct vm_anon *anon;
308: {
309: struct vm_page *pg;
310: struct uvm_object *uobj;
311: int rv;
312:
313: /* locked: anon */
314: rv = uvmfault_anonget(NULL, NULL, anon);
315: /*
316: * if rv == VM_PAGER_OK, anon is still locked, else anon
317: * is unlocked
318: */
319:
320: switch (rv) {
321: case VM_PAGER_OK:
322: break;
323:
324: case VM_PAGER_ERROR:
325: case VM_PAGER_REFAULT:
326:
327: /*
328: * nothing more to do on errors.
329: * VM_PAGER_REFAULT can only mean that the anon was freed,
330: * so again there's nothing to do.
331: */
332:
333: return FALSE;
334:
335: default:
336: #ifdef DIAGNOSTIC
337: panic("anon_pagein: uvmfault_anonget -> %d", rv);
338: #else
339: return FALSE;
340: #endif
341: }
342:
343: /*
344: * ok, we've got the page now.
345: * mark it as dirty, clear its swslot and un-busy it.
346: */
347:
348: pg = anon->an_page;
349: uobj = pg->uobject;
350: uvm_swap_free(anon->an_swslot, 1);
351: anon->an_swslot = 0;
352: atomic_clearbits_int(&pg->pg_flags, PG_CLEAN);
353:
354: /*
355: * deactivate the page (to put it on a page queue)
356: */
357:
358: pmap_clear_reference(pg);
359: pmap_page_protect(pg, VM_PROT_NONE);
360: uvm_lock_pageq();
361: uvm_pagedeactivate(pg);
362: uvm_unlock_pageq();
363:
364: /*
365: * unlock the anon and we're done.
366: */
367:
368: simple_unlock(&anon->an_lock);
369: if (uobj) {
370: simple_unlock(&uobj->vmobjlock);
371: }
372: return FALSE;
373: }