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