FreeBSD/Linux Kernel Cross Reference
sys/uvm/uvm_fault.c
1 /* $NetBSD: uvm_fault.c,v 1.116 2006/12/01 19:15:22 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 * from: Id: uvm_fault.c,v 1.1.2.23 1998/02/06 05:29:05 chs Exp
35 */
36
37 /*
38 * uvm_fault.c: fault handler
39 */
40
41 #include <sys/cdefs.h>
42 __KERNEL_RCSID(0, "$NetBSD: uvm_fault.c,v 1.116 2006/12/01 19:15:22 yamt Exp $");
43
44 #include "opt_uvmhist.h"
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/kernel.h>
49 #include <sys/proc.h>
50 #include <sys/malloc.h>
51 #include <sys/mman.h>
52 #include <sys/user.h>
53
54 #include <uvm/uvm.h>
55
56 /*
57 *
58 * a word on page faults:
59 *
60 * types of page faults we handle:
61 *
62 * CASE 1: upper layer faults CASE 2: lower layer faults
63 *
64 * CASE 1A CASE 1B CASE 2A CASE 2B
65 * read/write1 write>1 read/write +-cow_write/zero
66 * | | | |
67 * +--|--+ +--|--+ +-----+ + | + | +-----+
68 * amap | V | | ----------->new| | | | ^ |
69 * +-----+ +-----+ +-----+ + | + | +--|--+
70 * | | |
71 * +-----+ +-----+ +--|--+ | +--|--+
72 * uobj | d/c | | d/c | | V | +----| |
73 * +-----+ +-----+ +-----+ +-----+
74 *
75 * d/c = don't care
76 *
77 * case [0]: layerless fault
78 * no amap or uobj is present. this is an error.
79 *
80 * case [1]: upper layer fault [anon active]
81 * 1A: [read] or [write with anon->an_ref == 1]
82 * I/O takes place in top level anon and uobj is not touched.
83 * 1B: [write with anon->an_ref > 1]
84 * new anon is alloc'd and data is copied off ["COW"]
85 *
86 * case [2]: lower layer fault [uobj]
87 * 2A: [read on non-NULL uobj] or [write to non-copy_on_write area]
88 * I/O takes place directly in object.
89 * 2B: [write to copy_on_write] or [read on NULL uobj]
90 * data is "promoted" from uobj to a new anon.
91 * if uobj is null, then we zero fill.
92 *
93 * we follow the standard UVM locking protocol ordering:
94 *
95 * MAPS => AMAP => UOBJ => ANON => PAGE QUEUES (PQ)
96 * we hold a PG_BUSY page if we unlock for I/O
97 *
98 *
99 * the code is structured as follows:
100 *
101 * - init the "IN" params in the ufi structure
102 * ReFault:
103 * - do lookups [locks maps], check protection, handle needs_copy
104 * - check for case 0 fault (error)
105 * - establish "range" of fault
106 * - if we have an amap lock it and extract the anons
107 * - if sequential advice deactivate pages behind us
108 * - at the same time check pmap for unmapped areas and anon for pages
109 * that we could map in (and do map it if found)
110 * - check object for resident pages that we could map in
111 * - if (case 2) goto Case2
112 * - >>> handle case 1
113 * - ensure source anon is resident in RAM
114 * - if case 1B alloc new anon and copy from source
115 * - map the correct page in
116 * Case2:
117 * - >>> handle case 2
118 * - ensure source page is resident (if uobj)
119 * - if case 2B alloc new anon and copy from source (could be zero
120 * fill if uobj == NULL)
121 * - map the correct page in
122 * - done!
123 *
124 * note on paging:
125 * if we have to do I/O we place a PG_BUSY page in the correct object,
126 * unlock everything, and do the I/O. when I/O is done we must reverify
127 * the state of the world before assuming that our data structures are
128 * valid. [because mappings could change while the map is unlocked]
129 *
130 * alternative 1: unbusy the page in question and restart the page fault
131 * from the top (ReFault). this is easy but does not take advantage
132 * of the information that we already have from our previous lookup,
133 * although it is possible that the "hints" in the vm_map will help here.
134 *
135 * alternative 2: the system already keeps track of a "version" number of
136 * a map. [i.e. every time you write-lock a map (e.g. to change a
137 * mapping) you bump the version number up by one...] so, we can save
138 * the version number of the map before we release the lock and start I/O.
139 * then when I/O is done we can relock and check the version numbers
140 * to see if anything changed. this might save us some over 1 because
141 * we don't have to unbusy the page and may be less compares(?).
142 *
143 * alternative 3: put in backpointers or a way to "hold" part of a map
144 * in place while I/O is in progress. this could be complex to
145 * implement (especially with structures like amap that can be referenced
146 * by multiple map entries, and figuring out what should wait could be
147 * complex as well...).
148 *
149 * given that we are not currently multiprocessor or multithreaded we might
150 * as well choose alternative 2 now. maybe alternative 3 would be useful
151 * in the future. XXX keep in mind for future consideration//rechecking.
152 */
153
154 /*
155 * local data structures
156 */
157
158 struct uvm_advice {
159 int advice;
160 int nback;
161 int nforw;
162 };
163
164 /*
165 * page range array:
166 * note: index in array must match "advice" value
167 * XXX: borrowed numbers from freebsd. do they work well for us?
168 */
169
170 static const struct uvm_advice uvmadvice[] = {
171 { MADV_NORMAL, 3, 4 },
172 { MADV_RANDOM, 0, 0 },
173 { MADV_SEQUENTIAL, 8, 7},
174 };
175
176 #define UVM_MAXRANGE 16 /* must be MAX() of nback+nforw+1 */
177
178 /*
179 * private prototypes
180 */
181
182 /*
183 * inline functions
184 */
185
186 /*
187 * uvmfault_anonflush: try and deactivate pages in specified anons
188 *
189 * => does not have to deactivate page if it is busy
190 */
191
192 static inline void
193 uvmfault_anonflush(struct vm_anon **anons, int n)
194 {
195 int lcv;
196 struct vm_page *pg;
197
198 for (lcv = 0 ; lcv < n ; lcv++) {
199 if (anons[lcv] == NULL)
200 continue;
201 simple_lock(&anons[lcv]->an_lock);
202 pg = anons[lcv]->an_page;
203 if (pg && (pg->flags & PG_BUSY) == 0 && pg->loan_count == 0) {
204 uvm_lock_pageq();
205 if (pg->wire_count == 0) {
206 pmap_clear_reference(pg);
207 uvm_pagedeactivate(pg);
208 }
209 uvm_unlock_pageq();
210 }
211 simple_unlock(&anons[lcv]->an_lock);
212 }
213 }
214
215 /*
216 * normal functions
217 */
218
219 /*
220 * uvmfault_amapcopy: clear "needs_copy" in a map.
221 *
222 * => called with VM data structures unlocked (usually, see below)
223 * => we get a write lock on the maps and clear needs_copy for a VA
224 * => if we are out of RAM we sleep (waiting for more)
225 */
226
227 static void
228 uvmfault_amapcopy(struct uvm_faultinfo *ufi)
229 {
230 for (;;) {
231
232 /*
233 * no mapping? give up.
234 */
235
236 if (uvmfault_lookup(ufi, TRUE) == FALSE)
237 return;
238
239 /*
240 * copy if needed.
241 */
242
243 if (UVM_ET_ISNEEDSCOPY(ufi->entry))
244 amap_copy(ufi->map, ufi->entry, AMAP_COPY_NOWAIT,
245 ufi->orig_rvaddr, ufi->orig_rvaddr + 1);
246
247 /*
248 * didn't work? must be out of RAM. unlock and sleep.
249 */
250
251 if (UVM_ET_ISNEEDSCOPY(ufi->entry)) {
252 uvmfault_unlockmaps(ufi, TRUE);
253 uvm_wait("fltamapcopy");
254 continue;
255 }
256
257 /*
258 * got it! unlock and return.
259 */
260
261 uvmfault_unlockmaps(ufi, TRUE);
262 return;
263 }
264 /*NOTREACHED*/
265 }
266
267 /*
268 * uvmfault_anonget: get data in an anon into a non-busy, non-released
269 * page in that anon.
270 *
271 * => maps, amap, and anon locked by caller.
272 * => if we fail (result != 0) we unlock everything.
273 * => if we are successful, we return with everything still locked.
274 * => we don't move the page on the queues [gets moved later]
275 * => if we allocate a new page [we_own], it gets put on the queues.
276 * either way, the result is that the page is on the queues at return time
277 * => for pages which are on loan from a uvm_object (and thus are not
278 * owned by the anon): if successful, we return with the owning object
279 * locked. the caller must unlock this object when it unlocks everything
280 * else.
281 */
282
283 int
284 uvmfault_anonget(struct uvm_faultinfo *ufi, struct vm_amap *amap,
285 struct vm_anon *anon)
286 {
287 boolean_t we_own; /* we own anon's page? */
288 boolean_t locked; /* did we relock? */
289 struct vm_page *pg;
290 int error;
291 UVMHIST_FUNC("uvmfault_anonget"); UVMHIST_CALLED(maphist);
292
293 LOCK_ASSERT(simple_lock_held(&anon->an_lock));
294
295 error = 0;
296 uvmexp.fltanget++;
297 /* bump rusage counters */
298 if (anon->an_page)
299 curproc->p_stats->p_ru.ru_minflt++;
300 else
301 curproc->p_stats->p_ru.ru_majflt++;
302
303 /*
304 * loop until we get it, or fail.
305 */
306
307 for (;;) {
308 we_own = FALSE; /* TRUE if we set PG_BUSY on a page */
309 pg = anon->an_page;
310
311 /*
312 * if there is a resident page and it is loaned, then anon
313 * may not own it. call out to uvm_anon_lockpage() to ensure
314 * the real owner of the page has been identified and locked.
315 */
316
317 if (pg && pg->loan_count)
318 pg = uvm_anon_lockloanpg(anon);
319
320 /*
321 * page there? make sure it is not busy/released.
322 */
323
324 if (pg) {
325
326 /*
327 * at this point, if the page has a uobject [meaning
328 * we have it on loan], then that uobject is locked
329 * by us! if the page is busy, we drop all the
330 * locks (including uobject) and try again.
331 */
332
333 if ((pg->flags & PG_BUSY) == 0) {
334 UVMHIST_LOG(maphist, "<- OK",0,0,0,0);
335 return (0);
336 }
337 pg->flags |= PG_WANTED;
338 uvmexp.fltpgwait++;
339
340 /*
341 * the last unlock must be an atomic unlock+wait on
342 * the owner of page
343 */
344
345 if (pg->uobject) { /* owner is uobject ? */
346 uvmfault_unlockall(ufi, amap, NULL, anon);
347 UVMHIST_LOG(maphist, " unlock+wait on uobj",0,
348 0,0,0);
349 UVM_UNLOCK_AND_WAIT(pg,
350 &pg->uobject->vmobjlock,
351 FALSE, "anonget1",0);
352 } else {
353 /* anon owns page */
354 uvmfault_unlockall(ufi, amap, NULL, NULL);
355 UVMHIST_LOG(maphist, " unlock+wait on anon",0,
356 0,0,0);
357 UVM_UNLOCK_AND_WAIT(pg,&anon->an_lock,0,
358 "anonget2",0);
359 }
360 } else {
361 #if defined(VMSWAP)
362
363 /*
364 * no page, we must try and bring it in.
365 */
366
367 pg = uvm_pagealloc(NULL, 0, anon, 0);
368 if (pg == NULL) { /* out of RAM. */
369 uvmfault_unlockall(ufi, amap, NULL, anon);
370 uvmexp.fltnoram++;
371 UVMHIST_LOG(maphist, " noram -- UVM_WAIT",0,
372 0,0,0);
373 if (!uvm_reclaimable()) {
374 return ENOMEM;
375 }
376 uvm_wait("flt_noram1");
377 } else {
378 /* we set the PG_BUSY bit */
379 we_own = TRUE;
380 uvmfault_unlockall(ufi, amap, NULL, anon);
381
382 /*
383 * we are passing a PG_BUSY+PG_FAKE+PG_CLEAN
384 * page into the uvm_swap_get function with
385 * all data structures unlocked. note that
386 * it is ok to read an_swslot here because
387 * we hold PG_BUSY on the page.
388 */
389 uvmexp.pageins++;
390 error = uvm_swap_get(pg, anon->an_swslot,
391 PGO_SYNCIO);
392
393 /*
394 * we clean up after the i/o below in the
395 * "we_own" case
396 */
397 }
398 #else /* defined(VMSWAP) */
399 panic("%s: no page", __func__);
400 #endif /* defined(VMSWAP) */
401 }
402
403 /*
404 * now relock and try again
405 */
406
407 locked = uvmfault_relock(ufi);
408 if (locked && amap != NULL) {
409 amap_lock(amap);
410 }
411 if (locked || we_own)
412 simple_lock(&anon->an_lock);
413
414 /*
415 * if we own the page (i.e. we set PG_BUSY), then we need
416 * to clean up after the I/O. there are three cases to
417 * consider:
418 * [1] page released during I/O: free anon and ReFault.
419 * [2] I/O not OK. free the page and cause the fault
420 * to fail.
421 * [3] I/O OK! activate the page and sync with the
422 * non-we_own case (i.e. drop anon lock if not locked).
423 */
424
425 if (we_own) {
426 #if defined(VMSWAP)
427 if (pg->flags & PG_WANTED) {
428 wakeup(pg);
429 }
430 if (error) {
431
432 /*
433 * remove the swap slot from the anon
434 * and mark the anon as having no real slot.
435 * don't free the swap slot, thus preventing
436 * it from being used again.
437 */
438
439 if (anon->an_swslot > 0)
440 uvm_swap_markbad(anon->an_swslot, 1);
441 anon->an_swslot = SWSLOT_BAD;
442
443 if ((pg->flags & PG_RELEASED) != 0)
444 goto released;
445
446 /*
447 * note: page was never !PG_BUSY, so it
448 * can't be mapped and thus no need to
449 * pmap_page_protect it...
450 */
451
452 uvm_lock_pageq();
453 uvm_pagefree(pg);
454 uvm_unlock_pageq();
455
456 if (locked)
457 uvmfault_unlockall(ufi, amap, NULL,
458 anon);
459 else
460 simple_unlock(&anon->an_lock);
461 UVMHIST_LOG(maphist, "<- ERROR", 0,0,0,0);
462 return error;
463 }
464
465 if ((pg->flags & PG_RELEASED) != 0) {
466 released:
467 KASSERT(anon->an_ref == 0);
468
469 /*
470 * released while we unlocked amap.
471 */
472
473 if (locked)
474 uvmfault_unlockall(ufi, amap, NULL,
475 NULL);
476
477 uvm_anon_release(anon);
478
479 if (error) {
480 UVMHIST_LOG(maphist,
481 "<- ERROR/RELEASED", 0,0,0,0);
482 return error;
483 }
484
485 UVMHIST_LOG(maphist, "<- RELEASED", 0,0,0,0);
486 return ERESTART;
487 }
488
489 /*
490 * we've successfully read the page, activate it.
491 */
492
493 uvm_lock_pageq();
494 uvm_pageactivate(pg);
495 uvm_unlock_pageq();
496 pg->flags &= ~(PG_WANTED|PG_BUSY|PG_FAKE);
497 UVM_PAGE_OWN(pg, NULL);
498 if (!locked)
499 simple_unlock(&anon->an_lock);
500 #else /* defined(VMSWAP) */
501 panic("%s: we_own", __func__);
502 #endif /* defined(VMSWAP) */
503 }
504
505 /*
506 * we were not able to relock. restart fault.
507 */
508
509 if (!locked) {
510 UVMHIST_LOG(maphist, "<- REFAULT", 0,0,0,0);
511 return (ERESTART);
512 }
513
514 /*
515 * verify no one has touched the amap and moved the anon on us.
516 */
517
518 if (ufi != NULL &&
519 amap_lookup(&ufi->entry->aref,
520 ufi->orig_rvaddr - ufi->entry->start) != anon) {
521
522 uvmfault_unlockall(ufi, amap, NULL, anon);
523 UVMHIST_LOG(maphist, "<- REFAULT", 0,0,0,0);
524 return (ERESTART);
525 }
526
527 /*
528 * try it again!
529 */
530
531 uvmexp.fltanretry++;
532 continue;
533 }
534 /*NOTREACHED*/
535 }
536
537 /*
538 * uvmfault_promote: promote data to a new anon. used for 1B and 2B.
539 *
540 * 1. allocate an anon and a page.
541 * 2. fill its contents.
542 * 3. put it into amap.
543 *
544 * => if we fail (result != 0) we unlock everything.
545 * => on success, return a new locked anon via 'nanon'.
546 * (*nanon)->an_page will be a resident, locked, dirty page.
547 */
548
549 static int
550 uvmfault_promote(struct uvm_faultinfo *ufi,
551 struct vm_anon *oanon,
552 struct vm_page *uobjpage,
553 struct vm_anon **nanon, /* OUT: allocated anon */
554 struct vm_anon **spare)
555 {
556 struct vm_amap *amap = ufi->entry->aref.ar_amap;
557 struct uvm_object *uobj;
558 struct vm_anon *anon;
559 struct vm_page *pg;
560 struct vm_page *opg;
561 int error;
562 UVMHIST_FUNC(__func__); UVMHIST_CALLED(maphist);
563
564 if (oanon) {
565 /* anon COW */
566 opg = oanon->an_page;
567 KASSERT(opg != NULL);
568 KASSERT(opg->uobject == NULL || opg->loan_count > 0);
569 } else if (uobjpage != PGO_DONTCARE) {
570 /* object-backed COW */
571 opg = uobjpage;
572 } else {
573 /* ZFOD */
574 opg = NULL;
575 }
576 if (opg != NULL) {
577 uobj = opg->uobject;
578 } else {
579 uobj = NULL;
580 }
581
582 KASSERT(amap != NULL);
583 KASSERT(uobjpage != NULL);
584 KASSERT(uobjpage == PGO_DONTCARE || (uobjpage->flags & PG_BUSY) != 0);
585 LOCK_ASSERT(simple_lock_held(&amap->am_l));
586 LOCK_ASSERT(oanon == NULL || simple_lock_held(&oanon->an_lock));
587 LOCK_ASSERT(uobj == NULL || simple_lock_held(&uobj->vmobjlock));
588 LOCK_ASSERT(*spare == NULL || !simple_lock_held(&(*spare)->an_lock));
589
590 if (*spare != NULL) {
591 anon = *spare;
592 *spare = NULL;
593 simple_lock(&anon->an_lock);
594 } else if (ufi->map != kernel_map) {
595 anon = uvm_analloc();
596 } else {
597 UVMHIST_LOG(maphist, "kernel_map, unlock and retry", 0,0,0,0);
598
599 /*
600 * we can't allocate anons with kernel_map locked.
601 */
602
603 uvm_page_unbusy(&uobjpage, 1);
604 uvmfault_unlockall(ufi, amap, uobj, oanon);
605
606 *spare = uvm_analloc();
607 if (*spare == NULL) {
608 goto nomem;
609 }
610 simple_unlock(&(*spare)->an_lock);
611 error = ERESTART;
612 goto done;
613 }
614 if (anon) {
615
616 /*
617 * The new anon is locked.
618 *
619 * if opg == NULL, we want a zero'd, dirty page,
620 * so have uvm_pagealloc() do that for us.
621 */
622
623 pg = uvm_pagealloc(NULL, 0, anon,
624 (opg == NULL) ? UVM_PGA_ZERO : 0);
625 } else {
626 pg = NULL;
627 }
628
629 /*
630 * out of memory resources?
631 */
632
633 if (pg == NULL) {
634 /* save anon for the next try. */
635 if (anon != NULL) {
636 simple_unlock(&anon->an_lock);
637 *spare = anon;
638 }
639
640 /* unlock and fail ... */
641 uvm_page_unbusy(&uobjpage, 1);
642 uvmfault_unlockall(ufi, amap, uobj, oanon);
643 nomem:
644 if (!uvm_reclaimable()) {
645 UVMHIST_LOG(maphist, "out of VM", 0,0,0,0);
646 uvmexp.fltnoanon++;
647 error = ENOMEM;
648 goto done;
649 }
650
651 UVMHIST_LOG(maphist, "out of RAM, waiting for more", 0,0,0,0);
652 uvmexp.fltnoram++;
653 uvm_wait("flt_noram5");
654 error = ERESTART;
655 goto done;
656 }
657
658 /* copy page [pg now dirty] */
659 if (opg) {
660 uvm_pagecopy(opg, pg);
661 }
662
663 amap_add(&ufi->entry->aref, ufi->orig_rvaddr - ufi->entry->start, anon,
664 oanon != NULL);
665
666 *nanon = anon;
667 error = 0;
668 done:
669 return error;
670 }
671
672
673 /*
674 * F A U L T - m a i n e n t r y p o i n t
675 */
676
677 /*
678 * uvm_fault: page fault handler
679 *
680 * => called from MD code to resolve a page fault
681 * => VM data structures usually should be unlocked. however, it is
682 * possible to call here with the main map locked if the caller
683 * gets a write lock, sets it recusive, and then calls us (c.f.
684 * uvm_map_pageable). this should be avoided because it keeps
685 * the map locked off during I/O.
686 * => MUST NEVER BE CALLED IN INTERRUPT CONTEXT
687 */
688
689 #define MASK(entry) (UVM_ET_ISCOPYONWRITE(entry) ? \
690 ~VM_PROT_WRITE : VM_PROT_ALL)
691
692 /* fault_flag values passed from uvm_fault_wire to uvm_fault_internal */
693 #define UVM_FAULT_WIRE 1
694 #define UVM_FAULT_WIREMAX 2
695
696 int
697 uvm_fault_internal(struct vm_map *orig_map, vaddr_t vaddr,
698 vm_prot_t access_type, int fault_flag)
699 {
700 struct uvm_faultinfo ufi;
701 vm_prot_t enter_prot, check_prot;
702 boolean_t wired, narrow, promote, locked, shadowed, wire_fault, cow_now;
703 int npages, nback, nforw, centeridx, error, lcv, gotpages;
704 vaddr_t startva, currva;
705 voff_t uoff;
706 struct vm_amap *amap;
707 struct uvm_object *uobj;
708 struct vm_anon *anons_store[UVM_MAXRANGE], **anons, *anon, *oanon;
709 struct vm_anon *anon_spare;
710 struct vm_page *pages[UVM_MAXRANGE], *pg, *uobjpage;
711 UVMHIST_FUNC("uvm_fault"); UVMHIST_CALLED(maphist);
712
713 UVMHIST_LOG(maphist, "(map=0x%x, vaddr=0x%x, at=%d, ff=%d)",
714 orig_map, vaddr, access_type, fault_flag);
715
716 anon = anon_spare = NULL;
717 pg = NULL;
718
719 uvmexp.faults++; /* XXX: locking? */
720
721 /*
722 * init the IN parameters in the ufi
723 */
724
725 ufi.orig_map = orig_map;
726 ufi.orig_rvaddr = trunc_page(vaddr);
727 ufi.orig_size = PAGE_SIZE; /* can't get any smaller than this */
728 wire_fault = (fault_flag > 0);
729 if (wire_fault)
730 narrow = TRUE; /* don't look for neighborhood
731 * pages on wire */
732 else
733 narrow = FALSE; /* normal fault */
734
735 /*
736 * "goto ReFault" means restart the page fault from ground zero.
737 */
738 ReFault:
739
740 /*
741 * lookup and lock the maps
742 */
743
744 if (uvmfault_lookup(&ufi, FALSE) == FALSE) {
745 UVMHIST_LOG(maphist, "<- no mapping @ 0x%x", vaddr, 0,0,0);
746 error = EFAULT;
747 goto done;
748 }
749 /* locked: maps(read) */
750
751 #ifdef DIAGNOSTIC
752 if ((ufi.map->flags & VM_MAP_PAGEABLE) == 0) {
753 printf("Page fault on non-pageable map:\n");
754 printf("ufi.map = %p\n", ufi.map);
755 printf("ufi.orig_map = %p\n", ufi.orig_map);
756 printf("ufi.orig_rvaddr = 0x%lx\n", (u_long) ufi.orig_rvaddr);
757 panic("uvm_fault: (ufi.map->flags & VM_MAP_PAGEABLE) == 0");
758 }
759 #endif
760
761 /*
762 * check protection
763 */
764
765 check_prot = fault_flag == UVM_FAULT_WIREMAX ?
766 ufi.entry->max_protection : ufi.entry->protection;
767 if ((check_prot & access_type) != access_type) {
768 UVMHIST_LOG(maphist,
769 "<- protection failure (prot=0x%x, access=0x%x)",
770 ufi.entry->protection, access_type, 0, 0);
771 uvmfault_unlockmaps(&ufi, FALSE);
772 error = EACCES;
773 goto done;
774 }
775
776 /*
777 * "enter_prot" is the protection we want to enter the page in at.
778 * for certain pages (e.g. copy-on-write pages) this protection can
779 * be more strict than ufi.entry->protection. "wired" means either
780 * the entry is wired or we are fault-wiring the pg.
781 */
782
783 enter_prot = ufi.entry->protection;
784 wired = VM_MAPENT_ISWIRED(ufi.entry) || wire_fault;
785 if (wired) {
786 access_type = enter_prot; /* full access for wired */
787 cow_now = (check_prot & VM_PROT_WRITE) != 0;
788 } else {
789 cow_now = (access_type & VM_PROT_WRITE) != 0;
790 }
791
792 /*
793 * handle "needs_copy" case. if we need to copy the amap we will
794 * have to drop our readlock and relock it with a write lock. (we
795 * need a write lock to change anything in a map entry [e.g.
796 * needs_copy]).
797 */
798
799 if (UVM_ET_ISNEEDSCOPY(ufi.entry)) {
800 if (cow_now || (ufi.entry->object.uvm_obj == NULL)) {
801 KASSERT(fault_flag != UVM_FAULT_WIREMAX);
802 /* need to clear */
803 UVMHIST_LOG(maphist,
804 " need to clear needs_copy and refault",0,0,0,0);
805 uvmfault_unlockmaps(&ufi, FALSE);
806 uvmfault_amapcopy(&ufi);
807 uvmexp.fltamcopy++;
808 goto ReFault;
809
810 } else {
811
812 /*
813 * ensure that we pmap_enter page R/O since
814 * needs_copy is still true
815 */
816
817 enter_prot &= ~VM_PROT_WRITE;
818 }
819 }
820
821 /*
822 * identify the players
823 */
824
825 amap = ufi.entry->aref.ar_amap; /* top layer */
826 uobj = ufi.entry->object.uvm_obj; /* bottom layer */
827
828 /*
829 * check for a case 0 fault. if nothing backing the entry then
830 * error now.
831 */
832
833 if (amap == NULL && uobj == NULL) {
834 uvmfault_unlockmaps(&ufi, FALSE);
835 UVMHIST_LOG(maphist,"<- no backing store, no overlay",0,0,0,0);
836 error = EFAULT;
837 goto done;
838 }
839
840 /*
841 * establish range of interest based on advice from mapper
842 * and then clip to fit map entry. note that we only want
843 * to do this the first time through the fault. if we
844 * ReFault we will disable this by setting "narrow" to true.
845 */
846
847 if (narrow == FALSE) {
848
849 /* wide fault (!narrow) */
850 KASSERT(uvmadvice[ufi.entry->advice].advice ==
851 ufi.entry->advice);
852 nback = MIN(uvmadvice[ufi.entry->advice].nback,
853 (ufi.orig_rvaddr - ufi.entry->start) >> PAGE_SHIFT);
854 startva = ufi.orig_rvaddr - (nback << PAGE_SHIFT);
855 nforw = MIN(uvmadvice[ufi.entry->advice].nforw,
856 ((ufi.entry->end - ufi.orig_rvaddr) >>
857 PAGE_SHIFT) - 1);
858 /*
859 * note: "-1" because we don't want to count the
860 * faulting page as forw
861 */
862 npages = nback + nforw + 1;
863 centeridx = nback;
864
865 narrow = TRUE; /* ensure only once per-fault */
866
867 } else {
868
869 /* narrow fault! */
870 nback = nforw = 0;
871 startva = ufi.orig_rvaddr;
872 npages = 1;
873 centeridx = 0;
874
875 }
876
877 /* locked: maps(read) */
878 UVMHIST_LOG(maphist, " narrow=%d, back=%d, forw=%d, startva=0x%x",
879 narrow, nback, nforw, startva);
880 UVMHIST_LOG(maphist, " entry=0x%x, amap=0x%x, obj=0x%x", ufi.entry,
881 amap, uobj, 0);
882
883 /*
884 * if we've got an amap, lock it and extract current anons.
885 */
886
887 if (amap) {
888 amap_lock(amap);
889 anons = anons_store;
890 amap_lookups(&ufi.entry->aref, startva - ufi.entry->start,
891 anons, npages);
892 } else {
893 anons = NULL; /* to be safe */
894 }
895
896 /* locked: maps(read), amap(if there) */
897 LOCK_ASSERT(amap == NULL || simple_lock_held(&amap->am_l));
898
899 /*
900 * for MADV_SEQUENTIAL mappings we want to deactivate the back pages
901 * now and then forget about them (for the rest of the fault).
902 */
903
904 if (ufi.entry->advice == MADV_SEQUENTIAL && nback != 0) {
905
906 UVMHIST_LOG(maphist, " MADV_SEQUENTIAL: flushing backpages",
907 0,0,0,0);
908 /* flush back-page anons? */
909 if (amap)
910 uvmfault_anonflush(anons, nback);
911
912 /* flush object? */
913 if (uobj) {
914 uoff = (startva - ufi.entry->start) + ufi.entry->offset;
915 simple_lock(&uobj->vmobjlock);
916 (void) (uobj->pgops->pgo_put)(uobj, uoff, uoff +
917 (nback << PAGE_SHIFT), PGO_DEACTIVATE);
918 }
919
920 /* now forget about the backpages */
921 if (amap)
922 anons += nback;
923 startva += (nback << PAGE_SHIFT);
924 npages -= nback;
925 nback = centeridx = 0;
926 }
927
928 /* locked: maps(read), amap(if there) */
929 LOCK_ASSERT(amap == NULL || simple_lock_held(&amap->am_l));
930
931 /*
932 * map in the backpages and frontpages we found in the amap in hopes
933 * of preventing future faults. we also init the pages[] array as
934 * we go.
935 */
936
937 currva = startva;
938 shadowed = FALSE;
939 for (lcv = 0 ; lcv < npages ; lcv++, currva += PAGE_SIZE) {
940
941 /*
942 * dont play with VAs that are already mapped
943 * except for center)
944 */
945 if (lcv != centeridx &&
946 pmap_extract(ufi.orig_map->pmap, currva, NULL)) {
947 pages[lcv] = PGO_DONTCARE;
948 continue;
949 }
950
951 /*
952 * unmapped or center page. check if any anon at this level.
953 */
954 if (amap == NULL || anons[lcv] == NULL) {
955 pages[lcv] = NULL;
956 continue;
957 }
958
959 /*
960 * check for present page and map if possible. re-activate it.
961 */
962
963 pages[lcv] = PGO_DONTCARE;
964 if (lcv == centeridx) { /* save center for later! */
965 shadowed = TRUE;
966 continue;
967 }
968 anon = anons[lcv];
969 simple_lock(&anon->an_lock);
970 /* ignore loaned pages */
971 if (anon->an_page && anon->an_page->loan_count == 0 &&
972 (anon->an_page->flags & PG_BUSY) == 0) {
973 uvm_lock_pageq();
974 uvm_pageenqueue(anon->an_page);
975 uvm_unlock_pageq();
976 UVMHIST_LOG(maphist,
977 " MAPPING: n anon: pm=0x%x, va=0x%x, pg=0x%x",
978 ufi.orig_map->pmap, currva, anon->an_page, 0);
979 uvmexp.fltnamap++;
980
981 /*
982 * Since this isn't the page that's actually faulting,
983 * ignore pmap_enter() failures; it's not critical
984 * that we enter these right now.
985 */
986
987 (void) pmap_enter(ufi.orig_map->pmap, currva,
988 VM_PAGE_TO_PHYS(anon->an_page),
989 (anon->an_ref > 1) ? (enter_prot & ~VM_PROT_WRITE) :
990 enter_prot,
991 PMAP_CANFAIL |
992 (VM_MAPENT_ISWIRED(ufi.entry) ? PMAP_WIRED : 0));
993 }
994 simple_unlock(&anon->an_lock);
995 pmap_update(ufi.orig_map->pmap);
996 }
997
998 /* locked: maps(read), amap(if there) */
999 LOCK_ASSERT(amap == NULL || simple_lock_held(&amap->am_l));
1000 /* (shadowed == TRUE) if there is an anon at the faulting address */
1001 UVMHIST_LOG(maphist, " shadowed=%d, will_get=%d", shadowed,
1002 (uobj && shadowed == FALSE),0,0);
1003
1004 /*
1005 * note that if we are really short of RAM we could sleep in the above
1006 * call to pmap_enter with everything locked. bad?
1007 *
1008 * XXX Actually, that is bad; pmap_enter() should just fail in that
1009 * XXX case. --thorpej
1010 */
1011
1012 /*
1013 * if the desired page is not shadowed by the amap and we have a
1014 * backing object, then we check to see if the backing object would
1015 * prefer to handle the fault itself (rather than letting us do it
1016 * with the usual pgo_get hook). the backing object signals this by
1017 * providing a pgo_fault routine.
1018 */
1019
1020 if (uobj && shadowed == FALSE && uobj->pgops->pgo_fault != NULL) {
1021 simple_lock(&uobj->vmobjlock);
1022
1023 /* locked: maps(read), amap (if there), uobj */
1024 error = uobj->pgops->pgo_fault(&ufi, startva, pages, npages,
1025 centeridx, access_type, PGO_LOCKED|PGO_SYNCIO);
1026
1027 /* locked: nothing, pgo_fault has unlocked everything */
1028
1029 if (error == ERESTART)
1030 goto ReFault; /* try again! */
1031 /*
1032 * object fault routine responsible for pmap_update().
1033 */
1034 goto done;
1035 }
1036
1037 /*
1038 * now, if the desired page is not shadowed by the amap and we have
1039 * a backing object that does not have a special fault routine, then
1040 * we ask (with pgo_get) the object for resident pages that we care
1041 * about and attempt to map them in. we do not let pgo_get block
1042 * (PGO_LOCKED).
1043 */
1044
1045 if (uobj && shadowed == FALSE) {
1046 simple_lock(&uobj->vmobjlock);
1047
1048 /* locked (!shadowed): maps(read), amap (if there), uobj */
1049 /*
1050 * the following call to pgo_get does _not_ change locking state
1051 */
1052
1053 uvmexp.fltlget++;
1054 gotpages = npages;
1055 (void) uobj->pgops->pgo_get(uobj, ufi.entry->offset +
1056 (startva - ufi.entry->start),
1057 pages, &gotpages, centeridx,
1058 access_type & MASK(ufi.entry),
1059 ufi.entry->advice, PGO_LOCKED);
1060
1061 /*
1062 * check for pages to map, if we got any
1063 */
1064
1065 uobjpage = NULL;
1066
1067 if (gotpages) {
1068 currva = startva;
1069 for (lcv = 0; lcv < npages;
1070 lcv++, currva += PAGE_SIZE) {
1071 struct vm_page *curpg;
1072 boolean_t readonly;
1073
1074 curpg = pages[lcv];
1075 if (curpg == NULL || curpg == PGO_DONTCARE) {
1076 continue;
1077 }
1078 KASSERT(curpg->uobject == uobj);
1079
1080 /*
1081 * if center page is resident and not
1082 * PG_BUSY|PG_RELEASED then pgo_get
1083 * made it PG_BUSY for us and gave
1084 * us a handle to it. remember this
1085 * page as "uobjpage." (for later use).
1086 */
1087
1088 if (lcv == centeridx) {
1089 uobjpage = curpg;
1090 UVMHIST_LOG(maphist, " got uobjpage "
1091 "(0x%x) with locked get",
1092 uobjpage, 0,0,0);
1093 continue;
1094 }
1095
1096 /*
1097 * calling pgo_get with PGO_LOCKED returns us
1098 * pages which are neither busy nor released,
1099 * so we don't need to check for this.
1100 * we can just directly enter the pages.
1101 */
1102
1103 uvm_lock_pageq();
1104 uvm_pageenqueue(curpg);
1105 uvm_unlock_pageq();
1106 UVMHIST_LOG(maphist,
1107 " MAPPING: n obj: pm=0x%x, va=0x%x, pg=0x%x",
1108 ufi.orig_map->pmap, currva, curpg, 0);
1109 uvmexp.fltnomap++;
1110
1111 /*
1112 * Since this page isn't the page that's
1113 * actually faulting, ignore pmap_enter()
1114 * failures; it's not critical that we
1115 * enter these right now.
1116 */
1117 KASSERT((curpg->flags & PG_PAGEOUT) == 0);
1118 KASSERT((curpg->flags & PG_RELEASED) == 0);
1119 KASSERT(!UVM_OBJ_IS_CLEAN(curpg->uobject) ||
1120 (curpg->flags & PG_CLEAN) != 0);
1121 readonly = (curpg->flags & PG_RDONLY)
1122 || (curpg->loan_count > 0)
1123 || UVM_OBJ_NEEDS_WRITEFAULT(curpg->uobject);
1124
1125 (void) pmap_enter(ufi.orig_map->pmap, currva,
1126 VM_PAGE_TO_PHYS(curpg),
1127 readonly ?
1128 enter_prot & ~VM_PROT_WRITE :
1129 enter_prot & MASK(ufi.entry),
1130 PMAP_CANFAIL |
1131 (wired ? PMAP_WIRED : 0));
1132
1133 /*
1134 * NOTE: page can't be PG_WANTED or PG_RELEASED
1135 * because we've held the lock the whole time
1136 * we've had the handle.
1137 */
1138 KASSERT((curpg->flags & PG_WANTED) == 0);
1139 KASSERT((curpg->flags & PG_RELEASED) == 0);
1140
1141 curpg->flags &= ~(PG_BUSY);
1142 UVM_PAGE_OWN(curpg, NULL);
1143 }
1144 pmap_update(ufi.orig_map->pmap);
1145 }
1146 } else {
1147 uobjpage = NULL;
1148 }
1149
1150 /* locked (shadowed): maps(read), amap */
1151 /* locked (!shadowed): maps(read), amap(if there),
1152 uobj(if !null), uobjpage(if !null) */
1153 if (shadowed) {
1154 LOCK_ASSERT(simple_lock_held(&amap->am_l));
1155 } else {
1156 LOCK_ASSERT(amap == NULL || simple_lock_held(&amap->am_l));
1157 LOCK_ASSERT(uobj == NULL || simple_lock_held(&uobj->vmobjlock));
1158 KASSERT(uobjpage == NULL || (uobjpage->flags & PG_BUSY) != 0);
1159 }
1160
1161 /*
1162 * note that at this point we are done with any front or back pages.
1163 * we are now going to focus on the center page (i.e. the one we've
1164 * faulted on). if we have faulted on the top (anon) layer
1165 * [i.e. case 1], then the anon we want is anons[centeridx] (we have
1166 * not touched it yet). if we have faulted on the bottom (uobj)
1167 * layer [i.e. case 2] and the page was both present and available,
1168 * then we've got a pointer to it as "uobjpage" and we've already
1169 * made it BUSY.
1170 */
1171
1172 /*
1173 * there are four possible cases we must address: 1A, 1B, 2A, and 2B
1174 */
1175
1176 /*
1177 * redirect case 2: if we are not shadowed, go to case 2.
1178 */
1179
1180 if (shadowed == FALSE)
1181 goto Case2;
1182
1183 /* locked: maps(read), amap */
1184
1185 /*
1186 * handle case 1: fault on an anon in our amap
1187 */
1188
1189 anon = anons[centeridx];
1190 UVMHIST_LOG(maphist, " case 1 fault: anon=0x%x", anon, 0,0,0);
1191 simple_lock(&anon->an_lock);
1192
1193 /* locked: maps(read), amap, anon */
1194 LOCK_ASSERT(simple_lock_held(&amap->am_l));
1195 LOCK_ASSERT(simple_lock_held(&anon->an_lock));
1196
1197 /*
1198 * no matter if we have case 1A or case 1B we are going to need to
1199 * have the anon's memory resident. ensure that now.
1200 */
1201
1202 /*
1203 * let uvmfault_anonget do the dirty work.
1204 * if it fails (!OK) it will unlock everything for us.
1205 * if it succeeds, locks are still valid and locked.
1206 * also, if it is OK, then the anon's page is on the queues.
1207 * if the page is on loan from a uvm_object, then anonget will
1208 * lock that object for us if it does not fail.
1209 */
1210
1211 error = uvmfault_anonget(&ufi, amap, anon);
1212 switch (error) {
1213 case 0:
1214 break;
1215
1216 case ERESTART:
1217 goto ReFault;
1218
1219 case EAGAIN:
1220 tsleep(&lbolt, PVM, "fltagain1", 0);
1221 goto ReFault;
1222
1223 default:
1224 goto done;
1225 }
1226
1227 /*
1228 * uobj is non null if the page is on loan from an object (i.e. uobj)
1229 */
1230
1231 uobj = anon->an_page->uobject; /* locked by anonget if !NULL */
1232
1233 /* locked: maps(read), amap, anon, uobj(if one) */
1234 LOCK_ASSERT(simple_lock_held(&amap->am_l));
1235 LOCK_ASSERT(simple_lock_held(&anon->an_lock));
1236 LOCK_ASSERT(uobj == NULL || simple_lock_held(&uobj->vmobjlock));
1237
1238 /*
1239 * special handling for loaned pages
1240 */
1241
1242 if (anon->an_page->loan_count) {
1243
1244 if (!cow_now) {
1245
1246 /*
1247 * for read faults on loaned pages we just cap the
1248 * protection at read-only.
1249 */
1250
1251 enter_prot = enter_prot & ~VM_PROT_WRITE;
1252
1253 } else {
1254 /*
1255 * note that we can't allow writes into a loaned page!
1256 *
1257 * if we have a write fault on a loaned page in an
1258 * anon then we need to look at the anon's ref count.
1259 * if it is greater than one then we are going to do
1260 * a normal copy-on-write fault into a new anon (this
1261 * is not a problem). however, if the reference count
1262 * is one (a case where we would normally allow a
1263 * write directly to the page) then we need to kill
1264 * the loan before we continue.
1265 */
1266
1267 /* >1 case is already ok */
1268 if (anon->an_ref == 1) {
1269
1270 /* get new un-owned replacement page */
1271 pg = uvm_pagealloc(NULL, 0, NULL, 0);
1272 if (pg == NULL) {
1273 uvmfault_unlockall(&ufi, amap, uobj,
1274 anon);
1275 uvm_wait("flt_noram2");
1276 goto ReFault;
1277 }
1278
1279 /*
1280 * copy data, kill loan, and drop uobj lock
1281 * (if any)
1282 */
1283 /* copy old -> new */
1284 uvm_pagecopy(anon->an_page, pg);
1285
1286 /* force reload */
1287 pmap_page_protect(anon->an_page, VM_PROT_NONE);
1288 uvm_lock_pageq(); /* KILL loan */
1289
1290 anon->an_page->uanon = NULL;
1291 /* in case we owned */
1292 anon->an_page->pqflags &= ~PQ_ANON;
1293
1294 if (uobj) {
1295 /* if we were receiver of loan */
1296 anon->an_page->loan_count--;
1297 } else {
1298 /*
1299 * we were the lender (A->K); need
1300 * to remove the page from pageq's.
1301 */
1302 uvm_pagedequeue(anon->an_page);
1303 }
1304
1305 if (uobj) {
1306 simple_unlock(&uobj->vmobjlock);
1307 uobj = NULL;
1308 }
1309
1310 /* install new page in anon */
1311 anon->an_page = pg;
1312 pg->uanon = anon;
1313 pg->pqflags |= PQ_ANON;
1314
1315 uvm_pageactivate(pg);
1316 uvm_unlock_pageq();
1317
1318 pg->flags &= ~(PG_BUSY|PG_FAKE);
1319 UVM_PAGE_OWN(pg, NULL);
1320
1321 /* done! */
1322 } /* ref == 1 */
1323 } /* write fault */
1324 } /* loan count */
1325
1326 /*
1327 * if we are case 1B then we will need to allocate a new blank
1328 * anon to transfer the data into. note that we have a lock
1329 * on anon, so no one can busy or release the page until we are done.
1330 * also note that the ref count can't drop to zero here because
1331 * it is > 1 and we are only dropping one ref.
1332 *
1333 * in the (hopefully very rare) case that we are out of RAM we
1334 * will unlock, wait for more RAM, and refault.
1335 *
1336 * if we are out of anon VM we kill the process (XXX: could wait?).
1337 */
1338
1339 if (cow_now && anon->an_ref > 1) {
1340
1341 UVMHIST_LOG(maphist, " case 1B: COW fault",0,0,0,0);
1342 uvmexp.flt_acow++;
1343 oanon = anon; /* oanon = old, locked anon */
1344
1345 error = uvmfault_promote(&ufi, oanon, PGO_DONTCARE,
1346 &anon, &anon_spare);
1347 switch (error) {
1348 case 0:
1349 break;
1350 case ERESTART:
1351 goto ReFault;
1352 default:
1353 goto done;
1354 }
1355
1356 pg = anon->an_page;
1357 uvm_lock_pageq();
1358 uvm_pageactivate(pg);
1359 uvm_unlock_pageq();
1360 pg->flags &= ~(PG_BUSY|PG_FAKE);
1361 UVM_PAGE_OWN(pg, NULL);
1362
1363 /* deref: can not drop to zero here by defn! */
1364 oanon->an_ref--;
1365
1366 /*
1367 * note: oanon is still locked, as is the new anon. we
1368 * need to check for this later when we unlock oanon; if
1369 * oanon != anon, we'll have to unlock anon, too.
1370 */
1371
1372 } else {
1373
1374 uvmexp.flt_anon++;
1375 oanon = anon; /* old, locked anon is same as anon */
1376 pg = anon->an_page;
1377 if (anon->an_ref > 1) /* disallow writes to ref > 1 anons */
1378 enter_prot = enter_prot & ~VM_PROT_WRITE;
1379
1380 }
1381
1382 /* locked: maps(read), amap, oanon, anon (if different from oanon) */
1383 LOCK_ASSERT(simple_lock_held(&amap->am_l));
1384 LOCK_ASSERT(simple_lock_held(&anon->an_lock));
1385 LOCK_ASSERT(simple_lock_held(&oanon->an_lock));
1386
1387 /*
1388 * now map the page in.
1389 */
1390
1391 UVMHIST_LOG(maphist, " MAPPING: anon: pm=0x%x, va=0x%x, pg=0x%x",
1392 ufi.orig_map->pmap, ufi.orig_rvaddr, pg, 0);
1393 if (pmap_enter(ufi.orig_map->pmap, ufi.orig_rvaddr, VM_PAGE_TO_PHYS(pg),
1394 enter_prot, access_type | PMAP_CANFAIL | (wired ? PMAP_WIRED : 0))
1395 != 0) {
1396
1397 /*
1398 * No need to undo what we did; we can simply think of
1399 * this as the pmap throwing away the mapping information.
1400 *
1401 * We do, however, have to go through the ReFault path,
1402 * as the map may change while we're asleep.
1403 */
1404
1405 if (anon != oanon)
1406 simple_unlock(&anon->an_lock);
1407 uvmfault_unlockall(&ufi, amap, uobj, oanon);
1408 if (!uvm_reclaimable()) {
1409 UVMHIST_LOG(maphist,
1410 "<- failed. out of VM",0,0,0,0);
1411 /* XXX instrumentation */
1412 error = ENOMEM;
1413 goto done;
1414 }
1415 /* XXX instrumentation */
1416 uvm_wait("flt_pmfail1");
1417 goto ReFault;
1418 }
1419
1420 /*
1421 * ... update the page queues.
1422 */
1423
1424 uvm_lock_pageq();
1425 if (wire_fault) {
1426 uvm_pagewire(pg);
1427
1428 /*
1429 * since the now-wired page cannot be paged out,
1430 * release its swap resources for others to use.
1431 * since an anon with no swap cannot be PG_CLEAN,
1432 * clear its clean flag now.
1433 */
1434
1435 pg->flags &= ~(PG_CLEAN);
1436 uvm_anon_dropswap(anon);
1437 } else {
1438 uvm_pageactivate(pg);
1439 }
1440 uvm_unlock_pageq();
1441
1442 /*
1443 * done case 1! finish up by unlocking everything and returning success
1444 */
1445
1446 if (anon != oanon)
1447 simple_unlock(&anon->an_lock);
1448 uvmfault_unlockall(&ufi, amap, uobj, oanon);
1449 pmap_update(ufi.orig_map->pmap);
1450 error = 0;
1451 goto done;
1452
1453 Case2:
1454 /*
1455 * handle case 2: faulting on backing object or zero fill
1456 */
1457
1458 /*
1459 * locked:
1460 * maps(read), amap(if there), uobj(if !null), uobjpage(if !null)
1461 */
1462 LOCK_ASSERT(amap == NULL || simple_lock_held(&amap->am_l));
1463 LOCK_ASSERT(uobj == NULL || simple_lock_held(&uobj->vmobjlock));
1464 LOCK_ASSERT(uobjpage == NULL || (uobjpage->flags & PG_BUSY) != 0);
1465
1466 /*
1467 * note that uobjpage can not be PGO_DONTCARE at this point. we now
1468 * set uobjpage to PGO_DONTCARE if we are doing a zero fill. if we
1469 * have a backing object, check and see if we are going to promote
1470 * the data up to an anon during the fault.
1471 */
1472
1473 if (uobj == NULL) {
1474 uobjpage = PGO_DONTCARE;
1475 promote = TRUE; /* always need anon here */
1476 } else {
1477 KASSERT(uobjpage != PGO_DONTCARE);
1478 promote = cow_now && UVM_ET_ISCOPYONWRITE(ufi.entry);
1479 }
1480 UVMHIST_LOG(maphist, " case 2 fault: promote=%d, zfill=%d",
1481 promote, (uobj == NULL), 0,0);
1482
1483 /*
1484 * if uobjpage is not null then we do not need to do I/O to get the
1485 * uobjpage.
1486 *
1487 * if uobjpage is null, then we need to unlock and ask the pager to
1488 * get the data for us. once we have the data, we need to reverify
1489 * the state the world. we are currently not holding any resources.
1490 */
1491
1492 if (uobjpage) {
1493 /* update rusage counters */
1494 curproc->p_stats->p_ru.ru_minflt++;
1495 } else {
1496 /* update rusage counters */
1497 curproc->p_stats->p_ru.ru_majflt++;
1498
1499 /* locked: maps(read), amap(if there), uobj */
1500 uvmfault_unlockall(&ufi, amap, NULL, NULL);
1501 /* locked: uobj */
1502
1503 uvmexp.fltget++;
1504 gotpages = 1;
1505 uoff = (ufi.orig_rvaddr - ufi.entry->start) + ufi.entry->offset;
1506 error = uobj->pgops->pgo_get(uobj, uoff, &uobjpage, &gotpages,
1507 0, access_type & MASK(ufi.entry), ufi.entry->advice,
1508 PGO_SYNCIO);
1509 /* locked: uobjpage(if no error) */
1510 LOCK_ASSERT(error != 0 || (uobjpage->flags & PG_BUSY) != 0);
1511
1512 /*
1513 * recover from I/O
1514 */
1515
1516 if (error) {
1517 if (error == EAGAIN) {
1518 UVMHIST_LOG(maphist,
1519 " pgo_get says TRY AGAIN!",0,0,0,0);
1520 tsleep(&lbolt, PVM, "fltagain2", 0);
1521 goto ReFault;
1522 }
1523
1524 UVMHIST_LOG(maphist, "<- pgo_get failed (code %d)",
1525 error, 0,0,0);
1526 goto done;
1527 }
1528
1529 /* locked: uobjpage */
1530
1531 uvm_lock_pageq();
1532 uvm_pageactivate(uobjpage);
1533 uvm_unlock_pageq();
1534
1535 /*
1536 * re-verify the state of the world by first trying to relock
1537 * the maps. always relock the object.
1538 */
1539
1540 locked = uvmfault_relock(&ufi);
1541 if (locked && amap)
1542 amap_lock(amap);
1543 uobj = uobjpage->uobject;
1544 simple_lock(&uobj->vmobjlock);
1545
1546 /* locked(locked): maps(read), amap(if !null), uobj, uobjpage */
1547 /* locked(!locked): uobj, uobjpage */
1548
1549 /*
1550 * verify that the page has not be released and re-verify
1551 * that amap slot is still free. if there is a problem,
1552 * we unlock and clean up.
1553 */
1554
1555 if ((uobjpage->flags & PG_RELEASED) != 0 ||
1556 (locked && amap &&
1557 amap_lookup(&ufi.entry->aref,
1558 ufi.orig_rvaddr - ufi.entry->start))) {
1559 if (locked)
1560 uvmfault_unlockall(&ufi, amap, NULL, NULL);
1561 locked = FALSE;
1562 }
1563
1564 /*
1565 * didn't get the lock? release the page and retry.
1566 */
1567
1568 if (locked == FALSE) {
1569 UVMHIST_LOG(maphist,
1570 " wasn't able to relock after fault: retry",
1571 0,0,0,0);
1572 if (uobjpage->flags & PG_WANTED)
1573 wakeup(uobjpage);
1574 if (uobjpage->flags & PG_RELEASED) {
1575 uvmexp.fltpgrele++;
1576 uvm_pagefree(uobjpage);
1577 goto ReFault;
1578 }
1579 uobjpage->flags &= ~(PG_BUSY|PG_WANTED);
1580 UVM_PAGE_OWN(uobjpage, NULL);
1581 simple_unlock(&uobj->vmobjlock);
1582 goto ReFault;
1583 }
1584
1585 /*
1586 * we have the data in uobjpage which is busy and
1587 * not released. we are holding object lock (so the page
1588 * can't be released on us).
1589 */
1590
1591 /* locked: maps(read), amap(if !null), uobj, uobjpage */
1592 }
1593
1594 /*
1595 * locked:
1596 * maps(read), amap(if !null), uobj(if !null), uobjpage(if uobj)
1597 */
1598 LOCK_ASSERT(amap == NULL || simple_lock_held(&amap->am_l));
1599 LOCK_ASSERT(uobj == NULL || simple_lock_held(&uobj->vmobjlock));
1600 LOCK_ASSERT(uobj == NULL || (uobjpage->flags & PG_BUSY) != 0);
1601
1602 /*
1603 * notes:
1604 * - at this point uobjpage can not be NULL
1605 * - at this point uobjpage can not be PG_RELEASED (since we checked
1606 * for it above)
1607 * - at this point uobjpage could be PG_WANTED (handle later)
1608 */
1609
1610 KASSERT(uobj == NULL || uobj == uobjpage->uobject);
1611 KASSERT(uobj == NULL || !UVM_OBJ_IS_CLEAN(uobjpage->uobject) ||
1612 (uobjpage->flags & PG_CLEAN) != 0);
1613 if (promote == FALSE) {
1614
1615 /*
1616 * we are not promoting. if the mapping is COW ensure that we
1617 * don't give more access than we should (e.g. when doing a read
1618 * fault on a COPYONWRITE mapping we want to map the COW page in
1619 * R/O even though the entry protection could be R/W).
1620 *
1621 * set "pg" to the page we want to map in (uobjpage, usually)
1622 */
1623
1624 /* no anon in this case. */
1625 anon = NULL;
1626
1627 uvmexp.flt_obj++;
1628 if (UVM_ET_ISCOPYONWRITE(ufi.entry) ||
1629 UVM_OBJ_NEEDS_WRITEFAULT(uobjpage->uobject))
1630 enter_prot &= ~VM_PROT_WRITE;
1631 pg = uobjpage; /* map in the actual object */
1632
1633 KASSERT(uobjpage != PGO_DONTCARE);
1634
1635 /*
1636 * we are faulting directly on the page. be careful
1637 * about writing to loaned pages...
1638 */
1639
1640 if (uobjpage->loan_count) {
1641 if (!cow_now) {
1642 /* read fault: cap the protection at readonly */
1643 /* cap! */
1644 enter_prot = enter_prot & ~VM_PROT_WRITE;
1645 } else {
1646 /* write fault: must break the loan here */
1647
1648 pg = uvm_loanbreak(uobjpage);
1649 if (pg == NULL) {
1650
1651 /*
1652 * drop ownership of page, it can't
1653 * be released
1654 */
1655
1656 if (uobjpage->flags & PG_WANTED)
1657 wakeup(uobjpage);
1658 uobjpage->flags &= ~(PG_BUSY|PG_WANTED);
1659 UVM_PAGE_OWN(uobjpage, NULL);
1660
1661 uvmfault_unlockall(&ufi, amap, uobj,
1662 NULL);
1663 UVMHIST_LOG(maphist,
1664 " out of RAM breaking loan, waiting",
1665 0,0,0,0);
1666 uvmexp.fltnoram++;
1667 uvm_wait("flt_noram4");
1668 goto ReFault;
1669 }
1670 uobjpage = pg;
1671 }
1672 }
1673 } else {
1674
1675 /*
1676 * if we are going to promote the data to an anon we
1677 * allocate a blank anon here and plug it into our amap.
1678 */
1679 #if DIAGNOSTIC
1680 if (amap == NULL)
1681 panic("uvm_fault: want to promote data, but no anon");
1682 #endif
1683 error = uvmfault_promote(&ufi, NULL, uobjpage,
1684 &anon, &anon_spare);
1685 switch (error) {
1686 case 0:
1687 break;
1688 case ERESTART:
1689 goto ReFault;
1690 default:
1691 goto done;
1692 }
1693
1694 pg = anon->an_page;
1695
1696 /*
1697 * fill in the data
1698 */
1699
1700 if (uobjpage != PGO_DONTCARE) {
1701 uvmexp.flt_prcopy++;
1702
1703 /*
1704 * promote to shared amap? make sure all sharing
1705 * procs see it
1706 */
1707
1708 if ((amap_flags(amap) & AMAP_SHARED) != 0) {
1709 pmap_page_protect(uobjpage, VM_PROT_NONE);
1710 /*
1711 * XXX: PAGE MIGHT BE WIRED!
1712 */
1713 }
1714
1715 /*
1716 * dispose of uobjpage. it can't be PG_RELEASED
1717 * since we still hold the object lock.
1718 * drop handle to uobj as well.
1719 */
1720
1721 if (uobjpage->flags & PG_WANTED)
1722 /* still have the obj lock */
1723 wakeup(uobjpage);
1724 uobjpage->flags &= ~(PG_BUSY|PG_WANTED);
1725 UVM_PAGE_OWN(uobjpage, NULL);
1726 simple_unlock(&uobj->vmobjlock);
1727 uobj = NULL;
1728
1729 UVMHIST_LOG(maphist,
1730 " promote uobjpage 0x%x to anon/page 0x%x/0x%x",
1731 uobjpage, anon, pg, 0);
1732
1733 } else {
1734 uvmexp.flt_przero++;
1735
1736 /*
1737 * Page is zero'd and marked dirty by
1738 * uvmfault_promote().
1739 */
1740
1741 UVMHIST_LOG(maphist," zero fill anon/page 0x%x/0%x",
1742 anon, pg, 0, 0);
1743 }
1744 }
1745
1746 /*
1747 * locked:
1748 * maps(read), amap(if !null), uobj(if !null), uobjpage(if uobj),
1749 * anon(if !null), pg(if anon)
1750 *
1751 * note: pg is either the uobjpage or the new page in the new anon
1752 */
1753 LOCK_ASSERT(amap == NULL || simple_lock_held(&amap->am_l));
1754 LOCK_ASSERT(uobj == NULL || simple_lock_held(&uobj->vmobjlock));
1755 LOCK_ASSERT(uobj == NULL || (uobjpage->flags & PG_BUSY) != 0);
1756 LOCK_ASSERT(anon == NULL || simple_lock_held(&anon->an_lock));
1757 LOCK_ASSERT((pg->flags & PG_BUSY) != 0);
1758
1759 /*
1760 * all resources are present. we can now map it in and free our
1761 * resources.
1762 */
1763
1764 UVMHIST_LOG(maphist,
1765 " MAPPING: case2: pm=0x%x, va=0x%x, pg=0x%x, promote=%d",
1766 ufi.orig_map->pmap, ufi.orig_rvaddr, pg, promote);
1767 KASSERT((access_type & VM_PROT_WRITE) == 0 ||
1768 (pg->flags & PG_RDONLY) == 0);
1769 if (pmap_enter(ufi.orig_map->pmap, ufi.orig_rvaddr, VM_PAGE_TO_PHYS(pg),
1770 pg->flags & PG_RDONLY ? enter_prot & ~VM_PROT_WRITE : enter_prot,
1771 access_type | PMAP_CANFAIL | (wired ? PMAP_WIRED : 0)) != 0) {
1772
1773 /*
1774 * No need to undo what we did; we can simply think of
1775 * this as the pmap throwing away the mapping information.
1776 *
1777 * We do, however, have to go through the ReFault path,
1778 * as the map may change while we're asleep.
1779 */
1780
1781 if (pg->flags & PG_WANTED)
1782 wakeup(pg);
1783
1784 /*
1785 * note that pg can't be PG_RELEASED since we did not drop
1786 * the object lock since the last time we checked.
1787 */
1788 KASSERT((pg->flags & PG_RELEASED) == 0);
1789
1790 pg->flags &= ~(PG_BUSY|PG_FAKE|PG_WANTED);
1791 UVM_PAGE_OWN(pg, NULL);
1792 uvmfault_unlockall(&ufi, amap, uobj, anon);
1793 if (!uvm_reclaimable()) {
1794 UVMHIST_LOG(maphist,
1795 "<- failed. out of VM",0,0,0,0);
1796 /* XXX instrumentation */
1797 error = ENOMEM;
1798 goto done;
1799 }
1800 /* XXX instrumentation */
1801 uvm_wait("flt_pmfail2");
1802 goto ReFault;
1803 }
1804
1805 uvm_lock_pageq();
1806 if (wire_fault) {
1807 uvm_pagewire(pg);
1808 if (pg->pqflags & PQ_AOBJ) {
1809
1810 /*
1811 * since the now-wired page cannot be paged out,
1812 * release its swap resources for others to use.
1813 * since an aobj page with no swap cannot be PG_CLEAN,
1814 * clear its clean flag now.
1815 */
1816
1817 KASSERT(uobj != NULL);
1818 pg->flags &= ~(PG_CLEAN);
1819 uao_dropswap(uobj, pg->offset >> PAGE_SHIFT);
1820 }
1821 } else {
1822 uvm_pageactivate(pg);
1823 }
1824 uvm_unlock_pageq();
1825 if (pg->flags & PG_WANTED)
1826 wakeup(pg);
1827
1828 /*
1829 * note that pg can't be PG_RELEASED since we did not drop the object
1830 * lock since the last time we checked.
1831 */
1832 KASSERT((pg->flags & PG_RELEASED) == 0);
1833
1834 pg->flags &= ~(PG_BUSY|PG_FAKE|PG_WANTED);
1835 UVM_PAGE_OWN(pg, NULL);
1836 uvmfault_unlockall(&ufi, amap, uobj, anon);
1837 pmap_update(ufi.orig_map->pmap);
1838 UVMHIST_LOG(maphist, "<- done (SUCCESS!)",0,0,0,0);
1839 error = 0;
1840 done:
1841 if (anon_spare != NULL) {
1842 anon_spare->an_ref--;
1843 uvm_anfree(anon_spare);
1844 }
1845 return error;
1846 }
1847
1848
1849 /*
1850 * uvm_fault_wire: wire down a range of virtual addresses in a map.
1851 *
1852 * => map may be read-locked by caller, but MUST NOT be write-locked.
1853 * => if map is read-locked, any operations which may cause map to
1854 * be write-locked in uvm_fault() must be taken care of by
1855 * the caller. See uvm_map_pageable().
1856 */
1857
1858 int
1859 uvm_fault_wire(struct vm_map *map, vaddr_t start, vaddr_t end,
1860 vm_prot_t access_type, int wiremax)
1861 {
1862 vaddr_t va;
1863 int error;
1864
1865 /*
1866 * now fault it in a page at a time. if the fault fails then we have
1867 * to undo what we have done. note that in uvm_fault VM_PROT_NONE
1868 * is replaced with the max protection if fault_type is VM_FAULT_WIRE.
1869 */
1870
1871 /*
1872 * XXX work around overflowing a vaddr_t. this prevents us from
1873 * wiring the last page in the address space, though.
1874 */
1875 if (start > end) {
1876 return EFAULT;
1877 }
1878
1879 for (va = start ; va < end ; va += PAGE_SIZE) {
1880 error = uvm_fault_internal(map, va, access_type,
1881 wiremax ? UVM_FAULT_WIREMAX : UVM_FAULT_WIRE);
1882 if (error) {
1883 if (va != start) {
1884 uvm_fault_unwire(map, start, va);
1885 }
1886 return error;
1887 }
1888 }
1889 return 0;
1890 }
1891
1892 /*
1893 * uvm_fault_unwire(): unwire range of virtual space.
1894 */
1895
1896 void
1897 uvm_fault_unwire(struct vm_map *map, vaddr_t start, vaddr_t end)
1898 {
1899 vm_map_lock_read(map);
1900 uvm_fault_unwire_locked(map, start, end);
1901 vm_map_unlock_read(map);
1902 }
1903
1904 /*
1905 * uvm_fault_unwire_locked(): the guts of uvm_fault_unwire().
1906 *
1907 * => map must be at least read-locked.
1908 */
1909
1910 void
1911 uvm_fault_unwire_locked(struct vm_map *map, vaddr_t start, vaddr_t end)
1912 {
1913 struct vm_map_entry *entry;
1914 pmap_t pmap = vm_map_pmap(map);
1915 vaddr_t va;
1916 paddr_t pa;
1917 struct vm_page *pg;
1918
1919 KASSERT((map->flags & VM_MAP_INTRSAFE) == 0);
1920
1921 /*
1922 * we assume that the area we are unwiring has actually been wired
1923 * in the first place. this means that we should be able to extract
1924 * the PAs from the pmap. we also lock out the page daemon so that
1925 * we can call uvm_pageunwire.
1926 */
1927
1928 uvm_lock_pageq();
1929
1930 /*
1931 * find the beginning map entry for the region.
1932 */
1933
1934 KASSERT(start >= vm_map_min(map) && end <= vm_map_max(map));
1935 if (uvm_map_lookup_entry(map, start, &entry) == FALSE)
1936 panic("uvm_fault_unwire_locked: address not in map");
1937
1938 for (va = start; va < end; va += PAGE_SIZE) {
1939 if (pmap_extract(pmap, va, &pa) == FALSE)
1940 continue;
1941
1942 /*
1943 * find the map entry for the current address.
1944 */
1945
1946 KASSERT(va >= entry->start);
1947 while (va >= entry->end) {
1948 KASSERT(entry->next != &map->header &&
1949 entry->next->start <= entry->end);
1950 entry = entry->next;
1951 }
1952
1953 /*
1954 * if the entry is no longer wired, tell the pmap.
1955 */
1956
1957 if (VM_MAPENT_ISWIRED(entry) == 0)
1958 pmap_unwire(pmap, va);
1959
1960 pg = PHYS_TO_VM_PAGE(pa);
1961 if (pg)
1962 uvm_pageunwire(pg);
1963 }
1964
1965 uvm_unlock_pageq();
1966 }
Cache object: b92a06ec3a4fe451db89dc4e0cb71572
|