1 /* $NetBSD: uvm_fault.c,v 1.204 2018/05/08 19:33:57 christos Exp $ */ 2 3 /* 4 * Copyright (c) 1997 Charles D. Cranor and Washington University. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * from: Id: uvm_fault.c,v 1.1.2.23 1998/02/06 05:29:05 chs Exp 28 */ 29 30 /* 31 * uvm_fault.c: fault handler 32 */ 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: uvm_fault.c,v 1.204 2018/05/08 19:33:57 christos Exp $"); 36 37 #include "opt_uvmhist.h" 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/kernel.h> 42 #include <sys/mman.h> 43 44 #include <uvm/uvm.h> 45 46 /* 47 * 48 * a word on page faults: 49 * 50 * types of page faults we handle: 51 * 52 * CASE 1: upper layer faults CASE 2: lower layer faults 53 * 54 * CASE 1A CASE 1B CASE 2A CASE 2B 55 * read/write1 write>1 read/write +-cow_write/zero 56 * | | | | 57 * +--|--+ +--|--+ +-----+ + | + | +-----+ 58 * amap | V | | ---------> new | | | | ^ | 59 * +-----+ +-----+ +-----+ + | + | +--|--+ 60 * | | | 61 * +-----+ +-----+ +--|--+ | +--|--+ 62 * uobj | d/c | | d/c | | V | +----+ | 63 * +-----+ +-----+ +-----+ +-----+ 64 * 65 * d/c = don't care 66 * 67 * case [0]: layerless fault 68 * no amap or uobj is present. this is an error. 69 * 70 * case [1]: upper layer fault [anon active] 71 * 1A: [read] or [write with anon->an_ref == 1] 72 * I/O takes place in upper level anon and uobj is not touched. 73 * 1B: [write with anon->an_ref > 1] 74 * new anon is alloc'd and data is copied off ["COW"] 75 * 76 * case [2]: lower layer fault [uobj] 77 * 2A: [read on non-NULL uobj] or [write to non-copy_on_write area] 78 * I/O takes place directly in object. 79 * 2B: [write to copy_on_write] or [read on NULL uobj] 80 * data is "promoted" from uobj to a new anon. 81 * if uobj is null, then we zero fill. 82 * 83 * we follow the standard UVM locking protocol ordering: 84 * 85 * MAPS => AMAP => UOBJ => ANON => PAGE QUEUES (PQ) 86 * we hold a PG_BUSY page if we unlock for I/O 87 * 88 * 89 * the code is structured as follows: 90 * 91 * - init the "IN" params in the ufi structure 92 * ReFault: (ERESTART returned to the loop in uvm_fault_internal) 93 * - do lookups [locks maps], check protection, handle needs_copy 94 * - check for case 0 fault (error) 95 * - establish "range" of fault 96 * - if we have an amap lock it and extract the anons 97 * - if sequential advice deactivate pages behind us 98 * - at the same time check pmap for unmapped areas and anon for pages 99 * that we could map in (and do map it if found) 100 * - check object for resident pages that we could map in 101 * - if (case 2) goto Case2 102 * - >>> handle case 1 103 * - ensure source anon is resident in RAM 104 * - if case 1B alloc new anon and copy from source 105 * - map the correct page in 106 * Case2: 107 * - >>> handle case 2 108 * - ensure source page is resident (if uobj) 109 * - if case 2B alloc new anon and copy from source (could be zero 110 * fill if uobj == NULL) 111 * - map the correct page in 112 * - done! 113 * 114 * note on paging: 115 * if we have to do I/O we place a PG_BUSY page in the correct object, 116 * unlock everything, and do the I/O. when I/O is done we must reverify 117 * the state of the world before assuming that our data structures are 118 * valid. [because mappings could change while the map is unlocked] 119 * 120 * alternative 1: unbusy the page in question and restart the page fault 121 * from the top (ReFault). this is easy but does not take advantage 122 * of the information that we already have from our previous lookup, 123 * although it is possible that the "hints" in the vm_map will help here. 124 * 125 * alternative 2: the system already keeps track of a "version" number of 126 * a map. [i.e. every time you write-lock a map (e.g. to change a 127 * mapping) you bump the version number up by one...] so, we can save 128 * the version number of the map before we release the lock and start I/O. 129 * then when I/O is done we can relock and check the version numbers 130 * to see if anything changed. this might save us some over 1 because 131 * we don't have to unbusy the page and may be less compares(?). 132 * 133 * alternative 3: put in backpointers or a way to "hold" part of a map 134 * in place while I/O is in progress. this could be complex to 135 * implement (especially with structures like amap that can be referenced 136 * by multiple map entries, and figuring out what should wait could be 137 * complex as well...). 138 * 139 * we use alternative 2. given that we are multi-threaded now we may want 140 * to reconsider the choice. 141 */ 142 143 /* 144 * local data structures 145 */ 146 147 struct uvm_advice { 148 int advice; 149 int nback; 150 int nforw; 151 }; 152 153 /* 154 * page range array: 155 * note: index in array must match "advice" value 156 * XXX: borrowed numbers from freebsd. do they work well for us? 157 */ 158 159 static const struct uvm_advice uvmadvice[] = { 160 { UVM_ADV_NORMAL, 3, 4 }, 161 { UVM_ADV_RANDOM, 0, 0 }, 162 { UVM_ADV_SEQUENTIAL, 8, 7}, 163 }; 164 165 #define UVM_MAXRANGE 16 /* must be MAX() of nback+nforw+1 */ 166 167 /* 168 * private prototypes 169 */ 170 171 /* 172 * externs from other modules 173 */ 174 175 extern int start_init_exec; /* Is init_main() done / init running? */ 176 177 /* 178 * inline functions 179 */ 180 181 /* 182 * uvmfault_anonflush: try and deactivate pages in specified anons 183 * 184 * => does not have to deactivate page if it is busy 185 */ 186 187 static inline void 188 uvmfault_anonflush(struct vm_anon **anons, int n) 189 { 190 int lcv; 191 struct vm_page *pg; 192 193 for (lcv = 0; lcv < n; lcv++) { 194 if (anons[lcv] == NULL) 195 continue; 196 KASSERT(mutex_owned(anons[lcv]->an_lock)); 197 pg = anons[lcv]->an_page; 198 if (pg && (pg->flags & PG_BUSY) == 0) { 199 mutex_enter(&uvm_pageqlock); 200 if (pg->wire_count == 0) { 201 uvm_pagedeactivate(pg); 202 } 203 mutex_exit(&uvm_pageqlock); 204 } 205 } 206 } 207 208 /* 209 * normal functions 210 */ 211 212 /* 213 * uvmfault_amapcopy: clear "needs_copy" in a map. 214 * 215 * => called with VM data structures unlocked (usually, see below) 216 * => we get a write lock on the maps and clear needs_copy for a VA 217 * => if we are out of RAM we sleep (waiting for more) 218 */ 219 220 static void 221 uvmfault_amapcopy(struct uvm_faultinfo *ufi) 222 { 223 for (;;) { 224 225 /* 226 * no mapping? give up. 227 */ 228 229 if (uvmfault_lookup(ufi, true) == false) 230 return; 231 232 /* 233 * copy if needed. 234 */ 235 236 if (UVM_ET_ISNEEDSCOPY(ufi->entry)) 237 amap_copy(ufi->map, ufi->entry, AMAP_COPY_NOWAIT, 238 ufi->orig_rvaddr, ufi->orig_rvaddr + 1); 239 240 /* 241 * didn't work? must be out of RAM. unlock and sleep. 242 */ 243 244 if (UVM_ET_ISNEEDSCOPY(ufi->entry)) { 245 uvmfault_unlockmaps(ufi, true); 246 uvm_wait("fltamapcopy"); 247 continue; 248 } 249 250 /* 251 * got it! unlock and return. 252 */ 253 254 uvmfault_unlockmaps(ufi, true); 255 return; 256 } 257 /*NOTREACHED*/ 258 } 259 260 /* 261 * uvmfault_anonget: get data in an anon into a non-busy, non-released 262 * page in that anon. 263 * 264 * => Map, amap and thus anon should be locked by caller. 265 * => If we fail, we unlock everything and error is returned. 266 * => If we are successful, return with everything still locked. 267 * => We do not move the page on the queues [gets moved later]. If we 268 * allocate a new page [we_own], it gets put on the queues. Either way, 269 * the result is that the page is on the queues at return time 270 * => For pages which are on loan from a uvm_object (and thus are not owned 271 * by the anon): if successful, return with the owning object locked. 272 * The caller must unlock this object when it unlocks everything else. 273 */ 274 275 int 276 uvmfault_anonget(struct uvm_faultinfo *ufi, struct vm_amap *amap, 277 struct vm_anon *anon) 278 { 279 struct vm_page *pg; 280 int error; 281 282 UVMHIST_FUNC("uvmfault_anonget"); UVMHIST_CALLED(maphist); 283 KASSERT(mutex_owned(anon->an_lock)); 284 KASSERT(anon->an_lock == amap->am_lock); 285 286 /* Increment the counters.*/ 287 uvmexp.fltanget++; 288 if (anon->an_page) { 289 curlwp->l_ru.ru_minflt++; 290 } else { 291 curlwp->l_ru.ru_majflt++; 292 } 293 error = 0; 294 295 /* 296 * Loop until we get the anon data, or fail. 297 */ 298 299 for (;;) { 300 bool we_own, locked; 301 /* 302 * Note: 'we_own' will become true if we set PG_BUSY on a page. 303 */ 304 we_own = false; 305 pg = anon->an_page; 306 307 /* 308 * If there is a resident page and it is loaned, then anon 309 * may not own it. Call out to uvm_anon_lockloanpg() to 310 * identify and lock the real owner of the page. 311 */ 312 313 if (pg && pg->loan_count) 314 pg = uvm_anon_lockloanpg(anon); 315 316 /* 317 * Is page resident? Make sure it is not busy/released. 318 */ 319 320 if (pg) { 321 322 /* 323 * at this point, if the page has a uobject [meaning 324 * we have it on loan], then that uobject is locked 325 * by us! if the page is busy, we drop all the 326 * locks (including uobject) and try again. 327 */ 328 329 if ((pg->flags & PG_BUSY) == 0) { 330 UVMHIST_LOG(maphist, "<- OK",0,0,0,0); 331 return 0; 332 } 333 pg->flags |= PG_WANTED; 334 uvmexp.fltpgwait++; 335 336 /* 337 * The last unlock must be an atomic unlock and wait 338 * on the owner of page. 339 */ 340 341 if (pg->uobject) { 342 /* Owner of page is UVM object. */ 343 uvmfault_unlockall(ufi, amap, NULL); 344 UVMHIST_LOG(maphist, " unlock+wait on uobj",0, 345 0,0,0); 346 UVM_UNLOCK_AND_WAIT(pg, 347 pg->uobject->vmobjlock, 348 false, "anonget1", 0); 349 } else { 350 /* Owner of page is anon. */ 351 uvmfault_unlockall(ufi, NULL, NULL); 352 UVMHIST_LOG(maphist, " unlock+wait on anon",0, 353 0,0,0); 354 UVM_UNLOCK_AND_WAIT(pg, anon->an_lock, 355 false, "anonget2", 0); 356 } 357 } else { 358 #if defined(VMSWAP) 359 /* 360 * No page, therefore allocate one. 361 */ 362 363 pg = uvm_pagealloc(NULL, 364 ufi != NULL ? ufi->orig_rvaddr : 0, 365 anon, ufi != NULL ? UVM_FLAG_COLORMATCH : 0); 366 if (pg == NULL) { 367 /* Out of memory. Wait a little. */ 368 uvmfault_unlockall(ufi, amap, NULL); 369 uvmexp.fltnoram++; 370 UVMHIST_LOG(maphist, " noram -- UVM_WAIT",0, 371 0,0,0); 372 if (!uvm_reclaimable()) { 373 return ENOMEM; 374 } 375 uvm_wait("flt_noram1"); 376 } else { 377 /* PG_BUSY bit is set. */ 378 we_own = true; 379 uvmfault_unlockall(ufi, amap, NULL); 380 381 /* 382 * Pass a PG_BUSY+PG_FAKE+PG_CLEAN page into 383 * the uvm_swap_get() function with all data 384 * structures unlocked. Note that it is OK 385 * to read an_swslot here, because we hold 386 * PG_BUSY on the page. 387 */ 388 uvmexp.pageins++; 389 error = uvm_swap_get(pg, anon->an_swslot, 390 PGO_SYNCIO); 391 392 /* 393 * We clean up after the I/O below in the 394 * 'we_own' case. 395 */ 396 } 397 #else 398 panic("%s: no page", __func__); 399 #endif /* defined(VMSWAP) */ 400 } 401 402 /* 403 * Re-lock the map and anon. 404 */ 405 406 locked = uvmfault_relock(ufi); 407 if (locked || we_own) { 408 mutex_enter(anon->an_lock); 409 } 410 411 /* 412 * If we own the page (i.e. we set PG_BUSY), then we need 413 * to clean up after the I/O. There are three cases to 414 * consider: 415 * 416 * 1) Page was released during I/O: free anon and ReFault. 417 * 2) I/O not OK. Free the page and cause the fault to fail. 418 * 3) I/O OK! Activate the page and sync with the non-we_own 419 * case (i.e. drop anon lock if not locked). 420 */ 421 422 if (we_own) { 423 #if defined(VMSWAP) 424 if (pg->flags & PG_WANTED) { 425 wakeup(pg); 426 } 427 if (error) { 428 429 /* 430 * Remove the swap slot from the anon and 431 * mark the anon as having no real slot. 432 * Do not free the swap slot, thus preventing 433 * it from being used again. 434 */ 435 436 if (anon->an_swslot > 0) { 437 uvm_swap_markbad(anon->an_swslot, 1); 438 } 439 anon->an_swslot = SWSLOT_BAD; 440 441 if ((pg->flags & PG_RELEASED) != 0) { 442 goto released; 443 } 444 445 /* 446 * Note: page was never !PG_BUSY, so it 447 * cannot be mapped and thus no need to 448 * pmap_page_protect() it. 449 */ 450 451 mutex_enter(&uvm_pageqlock); 452 uvm_pagefree(pg); 453 mutex_exit(&uvm_pageqlock); 454 455 if (locked) { 456 uvmfault_unlockall(ufi, NULL, NULL); 457 } 458 mutex_exit(anon->an_lock); 459 UVMHIST_LOG(maphist, "<- ERROR", 0,0,0,0); 460 return error; 461 } 462 463 if ((pg->flags & PG_RELEASED) != 0) { 464 released: 465 KASSERT(anon->an_ref == 0); 466 467 /* 468 * Released while we had unlocked amap. 469 */ 470 471 if (locked) { 472 uvmfault_unlockall(ufi, NULL, NULL); 473 } 474 uvm_anon_release(anon); 475 476 if (error) { 477 UVMHIST_LOG(maphist, 478 "<- ERROR/RELEASED", 0,0,0,0); 479 return error; 480 } 481 482 UVMHIST_LOG(maphist, "<- RELEASED", 0,0,0,0); 483 return ERESTART; 484 } 485 486 /* 487 * We have successfully read the page, activate it. 488 */ 489 490 mutex_enter(&uvm_pageqlock); 491 uvm_pageactivate(pg); 492 mutex_exit(&uvm_pageqlock); 493 pg->flags &= ~(PG_WANTED|PG_BUSY|PG_FAKE); 494 UVM_PAGE_OWN(pg, NULL); 495 #else 496 panic("%s: we_own", __func__); 497 #endif /* defined(VMSWAP) */ 498 } 499 500 /* 501 * We were not able to re-lock the map - restart the fault. 502 */ 503 504 if (!locked) { 505 if (we_own) { 506 mutex_exit(anon->an_lock); 507 } 508 UVMHIST_LOG(maphist, "<- REFAULT", 0,0,0,0); 509 return ERESTART; 510 } 511 512 /* 513 * Verify that no one has touched the amap and moved 514 * the anon on us. 515 */ 516 517 if (ufi != NULL && amap_lookup(&ufi->entry->aref, 518 ufi->orig_rvaddr - ufi->entry->start) != anon) { 519 520 uvmfault_unlockall(ufi, amap, NULL); 521 UVMHIST_LOG(maphist, "<- REFAULT", 0,0,0,0); 522 return ERESTART; 523 } 524 525 /* 526 * Retry.. 527 */ 528 529 uvmexp.fltanretry++; 530 continue; 531 } 532 /*NOTREACHED*/ 533 } 534 535 /* 536 * uvmfault_promote: promote data to a new anon. used for 1B and 2B. 537 * 538 * 1. allocate an anon and a page. 539 * 2. fill its contents. 540 * 3. put it into amap. 541 * 542 * => if we fail (result != 0) we unlock everything. 543 * => on success, return a new locked anon via 'nanon'. 544 * (*nanon)->an_page will be a resident, locked, dirty page. 545 * => it's caller's responsibility to put the promoted nanon->an_page to the 546 * page queue. 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 KASSERT(mutex_owned(amap->am_lock)); 586 KASSERT(oanon == NULL || amap->am_lock == oanon->an_lock); 587 KASSERT(uobj == NULL || mutex_owned(uobj->vmobjlock)); 588 589 if (*spare != NULL) { 590 anon = *spare; 591 *spare = NULL; 592 } else { 593 anon = uvm_analloc(); 594 } 595 if (anon) { 596 597 /* 598 * The new anon is locked. 599 * 600 * if opg == NULL, we want a zero'd, dirty page, 601 * so have uvm_pagealloc() do that for us. 602 */ 603 604 KASSERT(anon->an_lock == NULL); 605 anon->an_lock = amap->am_lock; 606 pg = uvm_pagealloc(NULL, ufi->orig_rvaddr, anon, 607 UVM_FLAG_COLORMATCH | (opg == NULL ? UVM_PGA_ZERO : 0)); 608 if (pg == NULL) { 609 anon->an_lock = NULL; 610 } 611 } else { 612 pg = NULL; 613 } 614 615 /* 616 * out of memory resources? 617 */ 618 619 if (pg == NULL) { 620 /* save anon for the next try. */ 621 if (anon != NULL) { 622 *spare = anon; 623 } 624 625 /* unlock and fail ... */ 626 uvm_page_unbusy(&uobjpage, 1); 627 uvmfault_unlockall(ufi, amap, uobj); 628 if (!uvm_reclaimable()) { 629 UVMHIST_LOG(maphist, "out of VM", 0,0,0,0); 630 uvmexp.fltnoanon++; 631 error = ENOMEM; 632 goto done; 633 } 634 635 UVMHIST_LOG(maphist, "out of RAM, waiting for more", 0,0,0,0); 636 uvmexp.fltnoram++; 637 uvm_wait("flt_noram5"); 638 error = ERESTART; 639 goto done; 640 } 641 642 /* copy page [pg now dirty] */ 643 if (opg) { 644 uvm_pagecopy(opg, pg); 645 } 646 647 amap_add(&ufi->entry->aref, ufi->orig_rvaddr - ufi->entry->start, anon, 648 oanon != NULL); 649 650 *nanon = anon; 651 error = 0; 652 done: 653 return error; 654 } 655 656 /* 657 * Update statistics after fault resolution. 658 * - maxrss 659 */ 660 void 661 uvmfault_update_stats(struct uvm_faultinfo *ufi) 662 { 663 struct vm_map *map; 664 struct vmspace *vm; 665 struct proc *p; 666 vsize_t res; 667 668 map = ufi->orig_map; 669 670 p = curproc; 671 KASSERT(p != NULL); 672 vm = p->p_vmspace; 673 674 if (&vm->vm_map != map) 675 return; 676 677 res = pmap_resident_count(map->pmap); 678 if (vm->vm_rssmax < res) 679 vm->vm_rssmax = res; 680 } 681 682 /* 683 * F A U L T - m a i n e n t r y p o i n t 684 */ 685 686 /* 687 * uvm_fault: page fault handler 688 * 689 * => called from MD code to resolve a page fault 690 * => VM data structures usually should be unlocked. however, it is 691 * possible to call here with the main map locked if the caller 692 * gets a write lock, sets it recusive, and then calls us (c.f. 693 * uvm_map_pageable). this should be avoided because it keeps 694 * the map locked off during I/O. 695 * => MUST NEVER BE CALLED IN INTERRUPT CONTEXT 696 */ 697 698 #define MASK(entry) (UVM_ET_ISCOPYONWRITE(entry) ? \ 699 ~VM_PROT_WRITE : VM_PROT_ALL) 700 701 /* fault_flag values passed from uvm_fault_wire to uvm_fault_internal */ 702 #define UVM_FAULT_WIRE (1 << 0) 703 #define UVM_FAULT_MAXPROT (1 << 1) 704 705 struct uvm_faultctx { 706 707 /* 708 * the following members are set up by uvm_fault_check() and 709 * read-only after that. 710 * 711 * note that narrow is used by uvm_fault_check() to change 712 * the behaviour after ERESTART. 713 * 714 * most of them might change after RESTART if the underlying 715 * map entry has been changed behind us. an exception is 716 * wire_paging, which does never change. 717 */ 718 vm_prot_t access_type; 719 vaddr_t startva; 720 int npages; 721 int centeridx; 722 bool narrow; /* work on a single requested page only */ 723 bool wire_mapping; /* request a PMAP_WIRED mapping 724 (UVM_FAULT_WIRE or VM_MAPENT_ISWIRED) */ 725 bool wire_paging; /* request uvm_pagewire 726 (true for UVM_FAULT_WIRE) */ 727 bool cow_now; /* VM_PROT_WRITE is actually requested 728 (ie. should break COW and page loaning) */ 729 730 /* 731 * enter_prot is set up by uvm_fault_check() and clamped 732 * (ie. drop the VM_PROT_WRITE bit) in various places in case 733 * of !cow_now. 734 */ 735 vm_prot_t enter_prot; /* prot at which we want to enter pages in */ 736 737 /* 738 * the following member is for uvmfault_promote() and ERESTART. 739 */ 740 struct vm_anon *anon_spare; 741 742 /* 743 * the folloing is actually a uvm_fault_lower() internal. 744 * it's here merely for debugging. 745 * (or due to the mechanical separation of the function?) 746 */ 747 bool promote; 748 }; 749 750 static inline int uvm_fault_check( 751 struct uvm_faultinfo *, struct uvm_faultctx *, 752 struct vm_anon ***, bool); 753 754 static int uvm_fault_upper( 755 struct uvm_faultinfo *, struct uvm_faultctx *, 756 struct vm_anon **); 757 static inline int uvm_fault_upper_lookup( 758 struct uvm_faultinfo *, const struct uvm_faultctx *, 759 struct vm_anon **, struct vm_page **); 760 static inline void uvm_fault_upper_neighbor( 761 struct uvm_faultinfo *, const struct uvm_faultctx *, 762 vaddr_t, struct vm_page *, bool); 763 static inline int uvm_fault_upper_loan( 764 struct uvm_faultinfo *, struct uvm_faultctx *, 765 struct vm_anon *, struct uvm_object **); 766 static inline int uvm_fault_upper_promote( 767 struct uvm_faultinfo *, struct uvm_faultctx *, 768 struct uvm_object *, struct vm_anon *); 769 static inline int uvm_fault_upper_direct( 770 struct uvm_faultinfo *, struct uvm_faultctx *, 771 struct uvm_object *, struct vm_anon *); 772 static int uvm_fault_upper_enter( 773 struct uvm_faultinfo *, const struct uvm_faultctx *, 774 struct uvm_object *, struct vm_anon *, 775 struct vm_page *, struct vm_anon *); 776 static inline void uvm_fault_upper_done( 777 struct uvm_faultinfo *, const struct uvm_faultctx *, 778 struct vm_anon *, struct vm_page *); 779 780 static int uvm_fault_lower( 781 struct uvm_faultinfo *, struct uvm_faultctx *, 782 struct vm_page **); 783 static inline void uvm_fault_lower_lookup( 784 struct uvm_faultinfo *, const struct uvm_faultctx *, 785 struct vm_page **); 786 static inline void uvm_fault_lower_neighbor( 787 struct uvm_faultinfo *, const struct uvm_faultctx *, 788 vaddr_t, struct vm_page *, bool); 789 static inline int uvm_fault_lower_io( 790 struct uvm_faultinfo *, const struct uvm_faultctx *, 791 struct uvm_object **, struct vm_page **); 792 static inline int uvm_fault_lower_direct( 793 struct uvm_faultinfo *, struct uvm_faultctx *, 794 struct uvm_object *, struct vm_page *); 795 static inline int uvm_fault_lower_direct_loan( 796 struct uvm_faultinfo *, struct uvm_faultctx *, 797 struct uvm_object *, struct vm_page **, 798 struct vm_page **); 799 static inline int uvm_fault_lower_promote( 800 struct uvm_faultinfo *, struct uvm_faultctx *, 801 struct uvm_object *, struct vm_page *); 802 static int uvm_fault_lower_enter( 803 struct uvm_faultinfo *, const struct uvm_faultctx *, 804 struct uvm_object *, 805 struct vm_anon *, struct vm_page *); 806 static inline void uvm_fault_lower_done( 807 struct uvm_faultinfo *, const struct uvm_faultctx *, 808 struct uvm_object *, struct vm_page *); 809 810 int 811 uvm_fault_internal(struct vm_map *orig_map, vaddr_t vaddr, 812 vm_prot_t access_type, int fault_flag) 813 { 814 struct cpu_data *cd; 815 struct uvm_cpu *ucpu; 816 struct uvm_faultinfo ufi; 817 struct uvm_faultctx flt = { 818 .access_type = access_type, 819 820 /* don't look for neighborhood * pages on "wire" fault */ 821 .narrow = (fault_flag & UVM_FAULT_WIRE) != 0, 822 823 /* "wire" fault causes wiring of both mapping and paging */ 824 .wire_mapping = (fault_flag & UVM_FAULT_WIRE) != 0, 825 .wire_paging = (fault_flag & UVM_FAULT_WIRE) != 0, 826 }; 827 const bool maxprot = (fault_flag & UVM_FAULT_MAXPROT) != 0; 828 struct vm_anon *anons_store[UVM_MAXRANGE], **anons; 829 struct vm_page *pages_store[UVM_MAXRANGE], **pages; 830 int error; 831 832 UVMHIST_FUNC("uvm_fault"); UVMHIST_CALLED(maphist); 833 834 UVMHIST_LOG(maphist, "(map=%#jx, vaddr=%#jx, at=%jd, ff=%jd)", 835 (uintptr_t)orig_map, vaddr, access_type, fault_flag); 836 837 cd = &(curcpu()->ci_data); 838 cd->cpu_nfault++; 839 ucpu = cd->cpu_uvm; 840 841 /* Don't flood RNG subsystem with samples. */ 842 if (cd->cpu_nfault % 503) 843 goto norng; 844 845 /* Don't count anything until user interaction is possible */ 846 if (__predict_true(start_init_exec)) { 847 kpreempt_disable(); 848 rnd_add_uint32(&ucpu->rs, 849 sizeof(vaddr_t) == sizeof(uint32_t) ? 850 (uint32_t)vaddr : sizeof(vaddr_t) == 851 sizeof(uint64_t) ? 852 (uint32_t)(vaddr & 0x00000000ffffffff) : 853 (uint32_t)(cd->cpu_nfault & 0x00000000ffffffff)); 854 kpreempt_enable(); 855 } 856 norng: 857 /* 858 * init the IN parameters in the ufi 859 */ 860 861 ufi.orig_map = orig_map; 862 ufi.orig_rvaddr = trunc_page(vaddr); 863 ufi.orig_size = PAGE_SIZE; /* can't get any smaller than this */ 864 865 error = ERESTART; 866 while (error == ERESTART) { /* ReFault: */ 867 anons = anons_store; 868 pages = pages_store; 869 870 error = uvm_fault_check(&ufi, &flt, &anons, maxprot); 871 if (error != 0) 872 continue; 873 874 error = uvm_fault_upper_lookup(&ufi, &flt, anons, pages); 875 if (error != 0) 876 continue; 877 878 if (pages[flt.centeridx] == PGO_DONTCARE) 879 error = uvm_fault_upper(&ufi, &flt, anons); 880 else { 881 struct uvm_object * const uobj = 882 ufi.entry->object.uvm_obj; 883 884 if (uobj && uobj->pgops->pgo_fault != NULL) { 885 /* 886 * invoke "special" fault routine. 887 */ 888 mutex_enter(uobj->vmobjlock); 889 /* locked: maps(read), amap(if there), uobj */ 890 error = uobj->pgops->pgo_fault(&ufi, 891 flt.startva, pages, flt.npages, 892 flt.centeridx, flt.access_type, 893 PGO_LOCKED|PGO_SYNCIO); 894 895 /* 896 * locked: nothing, pgo_fault has unlocked 897 * everything 898 */ 899 900 /* 901 * object fault routine responsible for 902 * pmap_update(). 903 */ 904 } else { 905 error = uvm_fault_lower(&ufi, &flt, pages); 906 } 907 } 908 } 909 910 if (flt.anon_spare != NULL) { 911 flt.anon_spare->an_ref--; 912 KASSERT(flt.anon_spare->an_ref == 0); 913 KASSERT(flt.anon_spare->an_lock == NULL); 914 uvm_anon_free(flt.anon_spare); 915 } 916 return error; 917 } 918 919 /* 920 * uvm_fault_check: check prot, handle needs-copy, etc. 921 * 922 * 1. lookup entry. 923 * 2. check protection. 924 * 3. adjust fault condition (mainly for simulated fault). 925 * 4. handle needs-copy (lazy amap copy). 926 * 5. establish range of interest for neighbor fault (aka pre-fault). 927 * 6. look up anons (if amap exists). 928 * 7. flush pages (if MADV_SEQUENTIAL) 929 * 930 * => called with nothing locked. 931 * => if we fail (result != 0) we unlock everything. 932 * => initialize/adjust many members of flt. 933 */ 934 935 static int 936 uvm_fault_check( 937 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 938 struct vm_anon ***ranons, bool maxprot) 939 { 940 struct vm_amap *amap; 941 struct uvm_object *uobj; 942 vm_prot_t check_prot; 943 int nback, nforw; 944 UVMHIST_FUNC("uvm_fault_check"); UVMHIST_CALLED(maphist); 945 946 /* 947 * lookup and lock the maps 948 */ 949 950 if (uvmfault_lookup(ufi, false) == false) { 951 UVMHIST_LOG(maphist, "<- no mapping @ 0x%#jx", ufi->orig_rvaddr, 952 0,0,0); 953 return EFAULT; 954 } 955 /* locked: maps(read) */ 956 957 #ifdef DIAGNOSTIC 958 if ((ufi->map->flags & VM_MAP_PAGEABLE) == 0) { 959 printf("Page fault on non-pageable map:\n"); 960 printf("ufi->map = %p\n", ufi->map); 961 printf("ufi->orig_map = %p\n", ufi->orig_map); 962 printf("ufi->orig_rvaddr = 0x%lx\n", (u_long) ufi->orig_rvaddr); 963 panic("uvm_fault: (ufi->map->flags & VM_MAP_PAGEABLE) == 0"); 964 } 965 #endif 966 967 /* 968 * check protection 969 */ 970 971 check_prot = maxprot ? 972 ufi->entry->max_protection : ufi->entry->protection; 973 if ((check_prot & flt->access_type) != flt->access_type) { 974 UVMHIST_LOG(maphist, 975 "<- protection failure (prot=%#jx, access=%#jx)", 976 ufi->entry->protection, flt->access_type, 0, 0); 977 uvmfault_unlockmaps(ufi, false); 978 return EFAULT; 979 } 980 981 /* 982 * "enter_prot" is the protection we want to enter the page in at. 983 * for certain pages (e.g. copy-on-write pages) this protection can 984 * be more strict than ufi->entry->protection. "wired" means either 985 * the entry is wired or we are fault-wiring the pg. 986 */ 987 988 flt->enter_prot = ufi->entry->protection; 989 if (VM_MAPENT_ISWIRED(ufi->entry)) 990 flt->wire_mapping = true; 991 992 if (flt->wire_mapping) { 993 flt->access_type = flt->enter_prot; /* full access for wired */ 994 flt->cow_now = (check_prot & VM_PROT_WRITE) != 0; 995 } else { 996 flt->cow_now = (flt->access_type & VM_PROT_WRITE) != 0; 997 } 998 999 flt->promote = false; 1000 1001 /* 1002 * handle "needs_copy" case. if we need to copy the amap we will 1003 * have to drop our readlock and relock it with a write lock. (we 1004 * need a write lock to change anything in a map entry [e.g. 1005 * needs_copy]). 1006 */ 1007 1008 if (UVM_ET_ISNEEDSCOPY(ufi->entry)) { 1009 if (flt->cow_now || (ufi->entry->object.uvm_obj == NULL)) { 1010 KASSERT(!maxprot); 1011 /* need to clear */ 1012 UVMHIST_LOG(maphist, 1013 " need to clear needs_copy and refault",0,0,0,0); 1014 uvmfault_unlockmaps(ufi, false); 1015 uvmfault_amapcopy(ufi); 1016 uvmexp.fltamcopy++; 1017 return ERESTART; 1018 1019 } else { 1020 1021 /* 1022 * ensure that we pmap_enter page R/O since 1023 * needs_copy is still true 1024 */ 1025 1026 flt->enter_prot &= ~VM_PROT_WRITE; 1027 } 1028 } 1029 1030 /* 1031 * identify the players 1032 */ 1033 1034 amap = ufi->entry->aref.ar_amap; /* upper layer */ 1035 uobj = ufi->entry->object.uvm_obj; /* lower layer */ 1036 1037 /* 1038 * check for a case 0 fault. if nothing backing the entry then 1039 * error now. 1040 */ 1041 1042 if (amap == NULL && uobj == NULL) { 1043 uvmfault_unlockmaps(ufi, false); 1044 UVMHIST_LOG(maphist,"<- no backing store, no overlay",0,0,0,0); 1045 return EFAULT; 1046 } 1047 1048 /* 1049 * establish range of interest based on advice from mapper 1050 * and then clip to fit map entry. note that we only want 1051 * to do this the first time through the fault. if we 1052 * ReFault we will disable this by setting "narrow" to true. 1053 */ 1054 1055 if (flt->narrow == false) { 1056 1057 /* wide fault (!narrow) */ 1058 KASSERT(uvmadvice[ufi->entry->advice].advice == 1059 ufi->entry->advice); 1060 nback = MIN(uvmadvice[ufi->entry->advice].nback, 1061 (ufi->orig_rvaddr - ufi->entry->start) >> PAGE_SHIFT); 1062 flt->startva = ufi->orig_rvaddr - (nback << PAGE_SHIFT); 1063 /* 1064 * note: "-1" because we don't want to count the 1065 * faulting page as forw 1066 */ 1067 nforw = MIN(uvmadvice[ufi->entry->advice].nforw, 1068 ((ufi->entry->end - ufi->orig_rvaddr) >> 1069 PAGE_SHIFT) - 1); 1070 flt->npages = nback + nforw + 1; 1071 flt->centeridx = nback; 1072 1073 flt->narrow = true; /* ensure only once per-fault */ 1074 1075 } else { 1076 1077 /* narrow fault! */ 1078 nback = nforw = 0; 1079 flt->startva = ufi->orig_rvaddr; 1080 flt->npages = 1; 1081 flt->centeridx = 0; 1082 1083 } 1084 /* offset from entry's start to pgs' start */ 1085 const voff_t eoff = flt->startva - ufi->entry->start; 1086 1087 /* locked: maps(read) */ 1088 UVMHIST_LOG(maphist, " narrow=%jd, back=%jd, forw=%jd, startva=%#jx", 1089 flt->narrow, nback, nforw, flt->startva); 1090 UVMHIST_LOG(maphist, " entry=%#jx, amap=%#jx, obj=%#jx", 1091 (uintptr_t)ufi->entry, (uintptr_t)amap, (uintptr_t)uobj, 0); 1092 1093 /* 1094 * if we've got an amap, lock it and extract current anons. 1095 */ 1096 1097 if (amap) { 1098 amap_lock(amap); 1099 amap_lookups(&ufi->entry->aref, eoff, *ranons, flt->npages); 1100 } else { 1101 *ranons = NULL; /* to be safe */ 1102 } 1103 1104 /* locked: maps(read), amap(if there) */ 1105 KASSERT(amap == NULL || mutex_owned(amap->am_lock)); 1106 1107 /* 1108 * for MADV_SEQUENTIAL mappings we want to deactivate the back pages 1109 * now and then forget about them (for the rest of the fault). 1110 */ 1111 1112 if (ufi->entry->advice == MADV_SEQUENTIAL && nback != 0) { 1113 1114 UVMHIST_LOG(maphist, " MADV_SEQUENTIAL: flushing backpages", 1115 0,0,0,0); 1116 /* flush back-page anons? */ 1117 if (amap) 1118 uvmfault_anonflush(*ranons, nback); 1119 1120 /* flush object? */ 1121 if (uobj) { 1122 voff_t uoff; 1123 1124 uoff = ufi->entry->offset + eoff; 1125 mutex_enter(uobj->vmobjlock); 1126 (void) (uobj->pgops->pgo_put)(uobj, uoff, uoff + 1127 (nback << PAGE_SHIFT), PGO_DEACTIVATE); 1128 } 1129 1130 /* now forget about the backpages */ 1131 if (amap) 1132 *ranons += nback; 1133 flt->startva += (nback << PAGE_SHIFT); 1134 flt->npages -= nback; 1135 flt->centeridx = 0; 1136 } 1137 /* 1138 * => startva is fixed 1139 * => npages is fixed 1140 */ 1141 KASSERT(flt->startva <= ufi->orig_rvaddr); 1142 KASSERT(ufi->orig_rvaddr + ufi->orig_size <= 1143 flt->startva + (flt->npages << PAGE_SHIFT)); 1144 return 0; 1145 } 1146 1147 /* 1148 * uvm_fault_upper_lookup: look up existing h/w mapping and amap. 1149 * 1150 * iterate range of interest: 1151 * 1. check if h/w mapping exists. if yes, we don't care 1152 * 2. check if anon exists. if not, page is lower. 1153 * 3. if anon exists, enter h/w mapping for neighbors. 1154 * 1155 * => called with amap locked (if exists). 1156 */ 1157 1158 static int 1159 uvm_fault_upper_lookup( 1160 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 1161 struct vm_anon **anons, struct vm_page **pages) 1162 { 1163 struct vm_amap *amap = ufi->entry->aref.ar_amap; 1164 int lcv; 1165 vaddr_t currva; 1166 bool shadowed __unused; 1167 UVMHIST_FUNC("uvm_fault_upper_lookup"); UVMHIST_CALLED(maphist); 1168 1169 /* locked: maps(read), amap(if there) */ 1170 KASSERT(amap == NULL || mutex_owned(amap->am_lock)); 1171 1172 /* 1173 * map in the backpages and frontpages we found in the amap in hopes 1174 * of preventing future faults. we also init the pages[] array as 1175 * we go. 1176 */ 1177 1178 currva = flt->startva; 1179 shadowed = false; 1180 for (lcv = 0; lcv < flt->npages; lcv++, currva += PAGE_SIZE) { 1181 /* 1182 * don't play with VAs that are already mapped 1183 * (except for center) 1184 */ 1185 if (lcv != flt->centeridx && 1186 pmap_extract(ufi->orig_map->pmap, currva, NULL)) { 1187 pages[lcv] = PGO_DONTCARE; 1188 continue; 1189 } 1190 1191 /* 1192 * unmapped or center page. check if any anon at this level. 1193 */ 1194 if (amap == NULL || anons[lcv] == NULL) { 1195 pages[lcv] = NULL; 1196 continue; 1197 } 1198 1199 /* 1200 * check for present page and map if possible. re-activate it. 1201 */ 1202 1203 pages[lcv] = PGO_DONTCARE; 1204 if (lcv == flt->centeridx) { /* save center for later! */ 1205 shadowed = true; 1206 continue; 1207 } 1208 1209 struct vm_anon *anon = anons[lcv]; 1210 struct vm_page *pg = anon->an_page; 1211 1212 KASSERT(anon->an_lock == amap->am_lock); 1213 1214 /* Ignore loaned and busy pages. */ 1215 if (pg && pg->loan_count == 0 && (pg->flags & PG_BUSY) == 0) { 1216 uvm_fault_upper_neighbor(ufi, flt, currva, 1217 pg, anon->an_ref > 1); 1218 } 1219 } 1220 1221 /* locked: maps(read), amap(if there) */ 1222 KASSERT(amap == NULL || mutex_owned(amap->am_lock)); 1223 /* (shadowed == true) if there is an anon at the faulting address */ 1224 UVMHIST_LOG(maphist, " shadowed=%jd, will_get=%jd", shadowed, 1225 (ufi->entry->object.uvm_obj && shadowed != false),0,0); 1226 1227 /* 1228 * note that if we are really short of RAM we could sleep in the above 1229 * call to pmap_enter with everything locked. bad? 1230 * 1231 * XXX Actually, that is bad; pmap_enter() should just fail in that 1232 * XXX case. --thorpej 1233 */ 1234 1235 return 0; 1236 } 1237 1238 /* 1239 * uvm_fault_upper_neighbor: enter single upper neighbor page. 1240 * 1241 * => called with amap and anon locked. 1242 */ 1243 1244 static void 1245 uvm_fault_upper_neighbor( 1246 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 1247 vaddr_t currva, struct vm_page *pg, bool readonly) 1248 { 1249 UVMHIST_FUNC("uvm_fault_upper_neighbor"); UVMHIST_CALLED(maphist); 1250 1251 /* locked: amap, anon */ 1252 1253 mutex_enter(&uvm_pageqlock); 1254 uvm_pageenqueue(pg); 1255 mutex_exit(&uvm_pageqlock); 1256 UVMHIST_LOG(maphist, 1257 " MAPPING: n anon: pm=%#jx, va=%#jx, pg=%#jx", 1258 (uintptr_t)ufi->orig_map->pmap, currva, (uintptr_t)pg, 0); 1259 uvmexp.fltnamap++; 1260 1261 /* 1262 * Since this page isn't the page that's actually faulting, 1263 * ignore pmap_enter() failures; it's not critical that we 1264 * enter these right now. 1265 */ 1266 1267 (void) pmap_enter(ufi->orig_map->pmap, currva, 1268 VM_PAGE_TO_PHYS(pg), 1269 readonly ? (flt->enter_prot & ~VM_PROT_WRITE) : 1270 flt->enter_prot, 1271 PMAP_CANFAIL | (flt->wire_mapping ? PMAP_WIRED : 0)); 1272 1273 pmap_update(ufi->orig_map->pmap); 1274 } 1275 1276 /* 1277 * uvm_fault_upper: handle upper fault. 1278 * 1279 * 1. acquire anon lock. 1280 * 2. get anon. let uvmfault_anonget do the dirty work. 1281 * 3. handle loan. 1282 * 4. dispatch direct or promote handlers. 1283 */ 1284 1285 static int 1286 uvm_fault_upper( 1287 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 1288 struct vm_anon **anons) 1289 { 1290 struct vm_amap * const amap = ufi->entry->aref.ar_amap; 1291 struct vm_anon * const anon = anons[flt->centeridx]; 1292 struct uvm_object *uobj; 1293 int error; 1294 UVMHIST_FUNC("uvm_fault_upper"); UVMHIST_CALLED(maphist); 1295 1296 /* locked: maps(read), amap, anon */ 1297 KASSERT(mutex_owned(amap->am_lock)); 1298 KASSERT(anon->an_lock == amap->am_lock); 1299 1300 /* 1301 * handle case 1: fault on an anon in our amap 1302 */ 1303 1304 UVMHIST_LOG(maphist, " case 1 fault: anon=%#jx", 1305 (uintptr_t)anon, 0, 0, 0); 1306 1307 /* 1308 * no matter if we have case 1A or case 1B we are going to need to 1309 * have the anon's memory resident. ensure that now. 1310 */ 1311 1312 /* 1313 * let uvmfault_anonget do the dirty work. 1314 * if it fails (!OK) it will unlock everything for us. 1315 * if it succeeds, locks are still valid and locked. 1316 * also, if it is OK, then the anon's page is on the queues. 1317 * if the page is on loan from a uvm_object, then anonget will 1318 * lock that object for us if it does not fail. 1319 */ 1320 1321 error = uvmfault_anonget(ufi, amap, anon); 1322 switch (error) { 1323 case 0: 1324 break; 1325 1326 case ERESTART: 1327 return ERESTART; 1328 1329 case EAGAIN: 1330 kpause("fltagain1", false, hz/2, NULL); 1331 return ERESTART; 1332 1333 default: 1334 return error; 1335 } 1336 1337 /* 1338 * uobj is non null if the page is on loan from an object (i.e. uobj) 1339 */ 1340 1341 uobj = anon->an_page->uobject; /* locked by anonget if !NULL */ 1342 1343 /* locked: maps(read), amap, anon, uobj(if one) */ 1344 KASSERT(mutex_owned(amap->am_lock)); 1345 KASSERT(anon->an_lock == amap->am_lock); 1346 KASSERT(uobj == NULL || mutex_owned(uobj->vmobjlock)); 1347 1348 /* 1349 * special handling for loaned pages 1350 */ 1351 1352 if (anon->an_page->loan_count) { 1353 error = uvm_fault_upper_loan(ufi, flt, anon, &uobj); 1354 if (error != 0) 1355 return error; 1356 } 1357 1358 /* 1359 * if we are case 1B then we will need to allocate a new blank 1360 * anon to transfer the data into. note that we have a lock 1361 * on anon, so no one can busy or release the page until we are done. 1362 * also note that the ref count can't drop to zero here because 1363 * it is > 1 and we are only dropping one ref. 1364 * 1365 * in the (hopefully very rare) case that we are out of RAM we 1366 * will unlock, wait for more RAM, and refault. 1367 * 1368 * if we are out of anon VM we kill the process (XXX: could wait?). 1369 */ 1370 1371 if (flt->cow_now && anon->an_ref > 1) { 1372 flt->promote = true; 1373 error = uvm_fault_upper_promote(ufi, flt, uobj, anon); 1374 } else { 1375 error = uvm_fault_upper_direct(ufi, flt, uobj, anon); 1376 } 1377 return error; 1378 } 1379 1380 /* 1381 * uvm_fault_upper_loan: handle loaned upper page. 1382 * 1383 * 1. if not cow'ing now, simply adjust flt->enter_prot. 1384 * 2. if cow'ing now, and if ref count is 1, break loan. 1385 */ 1386 1387 static int 1388 uvm_fault_upper_loan( 1389 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 1390 struct vm_anon *anon, struct uvm_object **ruobj) 1391 { 1392 struct vm_amap * const amap = ufi->entry->aref.ar_amap; 1393 int error = 0; 1394 UVMHIST_FUNC("uvm_fault_upper_loan"); UVMHIST_CALLED(maphist); 1395 1396 if (!flt->cow_now) { 1397 1398 /* 1399 * for read faults on loaned pages we just cap the 1400 * protection at read-only. 1401 */ 1402 1403 flt->enter_prot = flt->enter_prot & ~VM_PROT_WRITE; 1404 1405 } else { 1406 /* 1407 * note that we can't allow writes into a loaned page! 1408 * 1409 * if we have a write fault on a loaned page in an 1410 * anon then we need to look at the anon's ref count. 1411 * if it is greater than one then we are going to do 1412 * a normal copy-on-write fault into a new anon (this 1413 * is not a problem). however, if the reference count 1414 * is one (a case where we would normally allow a 1415 * write directly to the page) then we need to kill 1416 * the loan before we continue. 1417 */ 1418 1419 /* >1 case is already ok */ 1420 if (anon->an_ref == 1) { 1421 error = uvm_loanbreak_anon(anon, *ruobj); 1422 if (error != 0) { 1423 uvmfault_unlockall(ufi, amap, *ruobj); 1424 uvm_wait("flt_noram2"); 1425 return ERESTART; 1426 } 1427 /* if we were a loan reciever uobj is gone */ 1428 if (*ruobj) 1429 *ruobj = NULL; 1430 } 1431 } 1432 return error; 1433 } 1434 1435 /* 1436 * uvm_fault_upper_promote: promote upper page. 1437 * 1438 * 1. call uvmfault_promote. 1439 * 2. enqueue page. 1440 * 3. deref. 1441 * 4. pass page to uvm_fault_upper_enter. 1442 */ 1443 1444 static int 1445 uvm_fault_upper_promote( 1446 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 1447 struct uvm_object *uobj, struct vm_anon *anon) 1448 { 1449 struct vm_anon * const oanon = anon; 1450 struct vm_page *pg; 1451 int error; 1452 UVMHIST_FUNC("uvm_fault_upper_promote"); UVMHIST_CALLED(maphist); 1453 1454 UVMHIST_LOG(maphist, " case 1B: COW fault",0,0,0,0); 1455 uvmexp.flt_acow++; 1456 1457 error = uvmfault_promote(ufi, oanon, PGO_DONTCARE, &anon, 1458 &flt->anon_spare); 1459 switch (error) { 1460 case 0: 1461 break; 1462 case ERESTART: 1463 return ERESTART; 1464 default: 1465 return error; 1466 } 1467 1468 KASSERT(anon == NULL || anon->an_lock == oanon->an_lock); 1469 1470 pg = anon->an_page; 1471 mutex_enter(&uvm_pageqlock); 1472 uvm_pageenqueue(pg); /* uvm_fault_upper_done will activate the page */ 1473 mutex_exit(&uvm_pageqlock); 1474 pg->flags &= ~(PG_BUSY|PG_FAKE); 1475 UVM_PAGE_OWN(pg, NULL); 1476 1477 /* deref: can not drop to zero here by defn! */ 1478 KASSERT(oanon->an_ref > 1); 1479 oanon->an_ref--; 1480 1481 /* 1482 * note: oanon is still locked, as is the new anon. we 1483 * need to check for this later when we unlock oanon; if 1484 * oanon != anon, we'll have to unlock anon, too. 1485 */ 1486 1487 return uvm_fault_upper_enter(ufi, flt, uobj, anon, pg, oanon); 1488 } 1489 1490 /* 1491 * uvm_fault_upper_direct: handle direct fault. 1492 */ 1493 1494 static int 1495 uvm_fault_upper_direct( 1496 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 1497 struct uvm_object *uobj, struct vm_anon *anon) 1498 { 1499 struct vm_anon * const oanon = anon; 1500 struct vm_page *pg; 1501 UVMHIST_FUNC("uvm_fault_upper_direct"); UVMHIST_CALLED(maphist); 1502 1503 uvmexp.flt_anon++; 1504 pg = anon->an_page; 1505 if (anon->an_ref > 1) /* disallow writes to ref > 1 anons */ 1506 flt->enter_prot = flt->enter_prot & ~VM_PROT_WRITE; 1507 1508 return uvm_fault_upper_enter(ufi, flt, uobj, anon, pg, oanon); 1509 } 1510 1511 /* 1512 * uvm_fault_upper_enter: enter h/w mapping of upper page. 1513 */ 1514 1515 static int 1516 uvm_fault_upper_enter( 1517 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 1518 struct uvm_object *uobj, struct vm_anon *anon, struct vm_page *pg, 1519 struct vm_anon *oanon) 1520 { 1521 struct pmap *pmap = ufi->orig_map->pmap; 1522 vaddr_t va = ufi->orig_rvaddr; 1523 struct vm_amap * const amap = ufi->entry->aref.ar_amap; 1524 UVMHIST_FUNC("uvm_fault_upper_enter"); UVMHIST_CALLED(maphist); 1525 1526 /* locked: maps(read), amap, oanon, anon(if different from oanon) */ 1527 KASSERT(mutex_owned(amap->am_lock)); 1528 KASSERT(anon->an_lock == amap->am_lock); 1529 KASSERT(oanon->an_lock == amap->am_lock); 1530 KASSERT(uobj == NULL || mutex_owned(uobj->vmobjlock)); 1531 1532 /* 1533 * now map the page in. 1534 */ 1535 1536 UVMHIST_LOG(maphist, 1537 " MAPPING: anon: pm=%#jx, va=%#jx, pg=%#jx, promote=%jd", 1538 (uintptr_t)pmap, va, (uintptr_t)pg, flt->promote); 1539 if (pmap_enter(pmap, va, VM_PAGE_TO_PHYS(pg), 1540 flt->enter_prot, flt->access_type | PMAP_CANFAIL | 1541 (flt->wire_mapping ? PMAP_WIRED : 0)) != 0) { 1542 1543 /* 1544 * If pmap_enter() fails, it must not leave behind an existing 1545 * pmap entry. In particular, a now-stale entry for a different 1546 * page would leave the pmap inconsistent with the vm_map. 1547 * This is not to imply that pmap_enter() should remove an 1548 * existing mapping in such a situation (since that could create 1549 * different problems, eg. if the existing mapping is wired), 1550 * but rather that the pmap should be designed such that it 1551 * never needs to fail when the new mapping is replacing an 1552 * existing mapping and the new page has no existing mappings. 1553 */ 1554 1555 KASSERT(!pmap_extract(pmap, va, NULL)); 1556 1557 /* 1558 * No need to undo what we did; we can simply think of 1559 * this as the pmap throwing away the mapping information. 1560 * 1561 * We do, however, have to go through the ReFault path, 1562 * as the map may change while we're asleep. 1563 */ 1564 1565 uvmfault_unlockall(ufi, amap, uobj); 1566 if (!uvm_reclaimable()) { 1567 UVMHIST_LOG(maphist, 1568 "<- failed. out of VM",0,0,0,0); 1569 /* XXX instrumentation */ 1570 return ENOMEM; 1571 } 1572 /* XXX instrumentation */ 1573 uvm_wait("flt_pmfail1"); 1574 return ERESTART; 1575 } 1576 1577 uvm_fault_upper_done(ufi, flt, anon, pg); 1578 1579 /* 1580 * done case 1! finish up by unlocking everything and returning success 1581 */ 1582 1583 pmap_update(pmap); 1584 uvmfault_unlockall(ufi, amap, uobj); 1585 return 0; 1586 } 1587 1588 /* 1589 * uvm_fault_upper_done: queue upper center page. 1590 */ 1591 1592 static void 1593 uvm_fault_upper_done( 1594 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 1595 struct vm_anon *anon, struct vm_page *pg) 1596 { 1597 const bool wire_paging = flt->wire_paging; 1598 1599 UVMHIST_FUNC("uvm_fault_upper_done"); UVMHIST_CALLED(maphist); 1600 1601 /* 1602 * ... update the page queues. 1603 */ 1604 1605 mutex_enter(&uvm_pageqlock); 1606 if (wire_paging) { 1607 uvm_pagewire(pg); 1608 1609 /* 1610 * since the now-wired page cannot be paged out, 1611 * release its swap resources for others to use. 1612 * since an anon with no swap cannot be PG_CLEAN, 1613 * clear its clean flag now. 1614 */ 1615 1616 pg->flags &= ~(PG_CLEAN); 1617 1618 } else { 1619 uvm_pageactivate(pg); 1620 } 1621 mutex_exit(&uvm_pageqlock); 1622 1623 if (wire_paging) { 1624 uvm_anon_dropswap(anon); 1625 } 1626 } 1627 1628 /* 1629 * uvm_fault_lower: handle lower fault. 1630 * 1631 * 1. check uobj 1632 * 1.1. if null, ZFOD. 1633 * 1.2. if not null, look up unnmapped neighbor pages. 1634 * 2. for center page, check if promote. 1635 * 2.1. ZFOD always needs promotion. 1636 * 2.2. other uobjs, when entry is marked COW (usually MAP_PRIVATE vnode). 1637 * 3. if uobj is not ZFOD and page is not found, do i/o. 1638 * 4. dispatch either direct / promote fault. 1639 */ 1640 1641 static int 1642 uvm_fault_lower( 1643 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 1644 struct vm_page **pages) 1645 { 1646 struct vm_amap *amap __diagused = ufi->entry->aref.ar_amap; 1647 struct uvm_object *uobj = ufi->entry->object.uvm_obj; 1648 struct vm_page *uobjpage; 1649 int error; 1650 UVMHIST_FUNC("uvm_fault_lower"); UVMHIST_CALLED(maphist); 1651 1652 /* 1653 * now, if the desired page is not shadowed by the amap and we have 1654 * a backing object that does not have a special fault routine, then 1655 * we ask (with pgo_get) the object for resident pages that we care 1656 * about and attempt to map them in. we do not let pgo_get block 1657 * (PGO_LOCKED). 1658 */ 1659 1660 if (uobj == NULL) { 1661 /* zero fill; don't care neighbor pages */ 1662 uobjpage = NULL; 1663 } else { 1664 uvm_fault_lower_lookup(ufi, flt, pages); 1665 uobjpage = pages[flt->centeridx]; 1666 } 1667 1668 /* 1669 * note that at this point we are done with any front or back pages. 1670 * we are now going to focus on the center page (i.e. the one we've 1671 * faulted on). if we have faulted on the upper (anon) layer 1672 * [i.e. case 1], then the anon we want is anons[centeridx] (we have 1673 * not touched it yet). if we have faulted on the bottom (uobj) 1674 * layer [i.e. case 2] and the page was both present and available, 1675 * then we've got a pointer to it as "uobjpage" and we've already 1676 * made it BUSY. 1677 */ 1678 1679 /* 1680 * locked: 1681 * maps(read), amap(if there), uobj(if !null), uobjpage(if !null) 1682 */ 1683 KASSERT(amap == NULL || mutex_owned(amap->am_lock)); 1684 KASSERT(uobj == NULL || mutex_owned(uobj->vmobjlock)); 1685 KASSERT(uobjpage == NULL || (uobjpage->flags & PG_BUSY) != 0); 1686 1687 /* 1688 * note that uobjpage can not be PGO_DONTCARE at this point. we now 1689 * set uobjpage to PGO_DONTCARE if we are doing a zero fill. if we 1690 * have a backing object, check and see if we are going to promote 1691 * the data up to an anon during the fault. 1692 */ 1693 1694 if (uobj == NULL) { 1695 uobjpage = PGO_DONTCARE; 1696 flt->promote = true; /* always need anon here */ 1697 } else { 1698 KASSERT(uobjpage != PGO_DONTCARE); 1699 flt->promote = flt->cow_now && UVM_ET_ISCOPYONWRITE(ufi->entry); 1700 } 1701 UVMHIST_LOG(maphist, " case 2 fault: promote=%jd, zfill=%jd", 1702 flt->promote, (uobj == NULL), 0,0); 1703 1704 /* 1705 * if uobjpage is not null then we do not need to do I/O to get the 1706 * uobjpage. 1707 * 1708 * if uobjpage is null, then we need to unlock and ask the pager to 1709 * get the data for us. once we have the data, we need to reverify 1710 * the state the world. we are currently not holding any resources. 1711 */ 1712 1713 if (uobjpage) { 1714 /* update rusage counters */ 1715 curlwp->l_ru.ru_minflt++; 1716 } else { 1717 error = uvm_fault_lower_io(ufi, flt, &uobj, &uobjpage); 1718 if (error != 0) 1719 return error; 1720 } 1721 1722 /* 1723 * locked: 1724 * maps(read), amap(if !null), uobj(if !null), uobjpage(if uobj) 1725 */ 1726 KASSERT(amap == NULL || mutex_owned(amap->am_lock)); 1727 KASSERT(uobj == NULL || mutex_owned(uobj->vmobjlock)); 1728 KASSERT(uobj == NULL || (uobjpage->flags & PG_BUSY) != 0); 1729 1730 /* 1731 * notes: 1732 * - at this point uobjpage can not be NULL 1733 * - at this point uobjpage can not be PG_RELEASED (since we checked 1734 * for it above) 1735 * - at this point uobjpage could be PG_WANTED (handle later) 1736 */ 1737 1738 KASSERT(uobjpage != NULL); 1739 KASSERT(uobj == NULL || uobj == uobjpage->uobject); 1740 KASSERT(uobj == NULL || !UVM_OBJ_IS_CLEAN(uobjpage->uobject) || 1741 (uobjpage->flags & PG_CLEAN) != 0); 1742 1743 if (!flt->promote) { 1744 error = uvm_fault_lower_direct(ufi, flt, uobj, uobjpage); 1745 } else { 1746 error = uvm_fault_lower_promote(ufi, flt, uobj, uobjpage); 1747 } 1748 return error; 1749 } 1750 1751 /* 1752 * uvm_fault_lower_lookup: look up on-memory uobj pages. 1753 * 1754 * 1. get on-memory pages. 1755 * 2. if failed, give up (get only center page later). 1756 * 3. if succeeded, enter h/w mapping of neighbor pages. 1757 */ 1758 1759 static void 1760 uvm_fault_lower_lookup( 1761 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 1762 struct vm_page **pages) 1763 { 1764 struct uvm_object *uobj = ufi->entry->object.uvm_obj; 1765 int lcv, gotpages; 1766 vaddr_t currva; 1767 UVMHIST_FUNC("uvm_fault_lower_lookup"); UVMHIST_CALLED(maphist); 1768 1769 mutex_enter(uobj->vmobjlock); 1770 /* Locked: maps(read), amap(if there), uobj */ 1771 1772 uvmexp.fltlget++; 1773 gotpages = flt->npages; 1774 (void) uobj->pgops->pgo_get(uobj, 1775 ufi->entry->offset + flt->startva - ufi->entry->start, 1776 pages, &gotpages, flt->centeridx, 1777 flt->access_type & MASK(ufi->entry), ufi->entry->advice, PGO_LOCKED); 1778 1779 KASSERT(mutex_owned(uobj->vmobjlock)); 1780 1781 /* 1782 * check for pages to map, if we got any 1783 */ 1784 1785 if (gotpages == 0) { 1786 pages[flt->centeridx] = NULL; 1787 return; 1788 } 1789 1790 currva = flt->startva; 1791 for (lcv = 0; lcv < flt->npages; lcv++, currva += PAGE_SIZE) { 1792 struct vm_page *curpg; 1793 1794 curpg = pages[lcv]; 1795 if (curpg == NULL || curpg == PGO_DONTCARE) { 1796 continue; 1797 } 1798 KASSERT(curpg->uobject == uobj); 1799 1800 /* 1801 * if center page is resident and not PG_BUSY|PG_RELEASED 1802 * then pgo_get made it PG_BUSY for us and gave us a handle 1803 * to it. 1804 */ 1805 1806 if (lcv == flt->centeridx) { 1807 UVMHIST_LOG(maphist, " got uobjpage (0x%#jx) " 1808 "with locked get", (uintptr_t)curpg, 0, 0, 0); 1809 } else { 1810 bool readonly = (curpg->flags & PG_RDONLY) 1811 || (curpg->loan_count > 0) 1812 || UVM_OBJ_NEEDS_WRITEFAULT(curpg->uobject); 1813 1814 uvm_fault_lower_neighbor(ufi, flt, 1815 currva, curpg, readonly); 1816 } 1817 } 1818 pmap_update(ufi->orig_map->pmap); 1819 } 1820 1821 /* 1822 * uvm_fault_lower_neighbor: enter h/w mapping of lower neighbor page. 1823 */ 1824 1825 static void 1826 uvm_fault_lower_neighbor( 1827 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 1828 vaddr_t currva, struct vm_page *pg, bool readonly) 1829 { 1830 UVMHIST_FUNC(__func__); UVMHIST_CALLED(maphist); 1831 1832 /* locked: maps(read), amap(if there), uobj */ 1833 1834 /* 1835 * calling pgo_get with PGO_LOCKED returns us pages which 1836 * are neither busy nor released, so we don't need to check 1837 * for this. we can just directly enter the pages. 1838 */ 1839 1840 mutex_enter(&uvm_pageqlock); 1841 uvm_pageenqueue(pg); 1842 mutex_exit(&uvm_pageqlock); 1843 UVMHIST_LOG(maphist, 1844 " MAPPING: n obj: pm=%#jx, va=%#jx, pg=%#jx", 1845 (uintptr_t)ufi->orig_map->pmap, currva, (uintptr_t)pg, 0); 1846 uvmexp.fltnomap++; 1847 1848 /* 1849 * Since this page isn't the page that's actually faulting, 1850 * ignore pmap_enter() failures; it's not critical that we 1851 * enter these right now. 1852 * NOTE: page can't be PG_WANTED or PG_RELEASED because we've 1853 * held the lock the whole time we've had the handle. 1854 */ 1855 KASSERT((pg->flags & PG_PAGEOUT) == 0); 1856 KASSERT((pg->flags & PG_RELEASED) == 0); 1857 KASSERT((pg->flags & PG_WANTED) == 0); 1858 KASSERT(!UVM_OBJ_IS_CLEAN(pg->uobject) || (pg->flags & PG_CLEAN) != 0); 1859 pg->flags &= ~(PG_BUSY); 1860 UVM_PAGE_OWN(pg, NULL); 1861 1862 KASSERT(mutex_owned(pg->uobject->vmobjlock)); 1863 1864 const vm_prot_t mapprot = 1865 readonly ? (flt->enter_prot & ~VM_PROT_WRITE) : 1866 flt->enter_prot & MASK(ufi->entry); 1867 const u_int mapflags = 1868 PMAP_CANFAIL | (flt->wire_mapping ? (mapprot | PMAP_WIRED) : 0); 1869 (void) pmap_enter(ufi->orig_map->pmap, currva, 1870 VM_PAGE_TO_PHYS(pg), mapprot, mapflags); 1871 } 1872 1873 /* 1874 * uvm_fault_lower_io: get lower page from backing store. 1875 * 1876 * 1. unlock everything, because i/o will block. 1877 * 2. call pgo_get. 1878 * 3. if failed, recover. 1879 * 4. if succeeded, relock everything and verify things. 1880 */ 1881 1882 static int 1883 uvm_fault_lower_io( 1884 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 1885 struct uvm_object **ruobj, struct vm_page **ruobjpage) 1886 { 1887 struct vm_amap * const amap = ufi->entry->aref.ar_amap; 1888 struct uvm_object *uobj = *ruobj; 1889 struct vm_page *pg; 1890 bool locked; 1891 int gotpages; 1892 int error; 1893 voff_t uoff; 1894 UVMHIST_FUNC("uvm_fault_lower_io"); UVMHIST_CALLED(maphist); 1895 1896 /* update rusage counters */ 1897 curlwp->l_ru.ru_majflt++; 1898 1899 /* Locked: maps(read), amap(if there), uobj */ 1900 uvmfault_unlockall(ufi, amap, NULL); 1901 1902 /* Locked: uobj */ 1903 KASSERT(uobj == NULL || mutex_owned(uobj->vmobjlock)); 1904 1905 uvmexp.fltget++; 1906 gotpages = 1; 1907 pg = NULL; 1908 uoff = (ufi->orig_rvaddr - ufi->entry->start) + ufi->entry->offset; 1909 error = uobj->pgops->pgo_get(uobj, uoff, &pg, &gotpages, 1910 0, flt->access_type & MASK(ufi->entry), ufi->entry->advice, 1911 PGO_SYNCIO); 1912 /* locked: pg(if no error) */ 1913 1914 /* 1915 * recover from I/O 1916 */ 1917 1918 if (error) { 1919 if (error == EAGAIN) { 1920 UVMHIST_LOG(maphist, 1921 " pgo_get says TRY AGAIN!",0,0,0,0); 1922 kpause("fltagain2", false, hz/2, NULL); 1923 return ERESTART; 1924 } 1925 1926 #if 0 1927 KASSERT(error != ERESTART); 1928 #else 1929 /* XXXUEBS don't re-fault? */ 1930 if (error == ERESTART) 1931 error = EIO; 1932 #endif 1933 1934 UVMHIST_LOG(maphist, "<- pgo_get failed (code %jd)", 1935 error, 0,0,0); 1936 return error; 1937 } 1938 1939 /* 1940 * re-verify the state of the world by first trying to relock 1941 * the maps. always relock the object. 1942 */ 1943 1944 locked = uvmfault_relock(ufi); 1945 if (locked && amap) 1946 amap_lock(amap); 1947 1948 /* might be changed */ 1949 uobj = pg->uobject; 1950 1951 mutex_enter(uobj->vmobjlock); 1952 KASSERT((pg->flags & PG_BUSY) != 0); 1953 1954 mutex_enter(&uvm_pageqlock); 1955 uvm_pageactivate(pg); 1956 mutex_exit(&uvm_pageqlock); 1957 1958 /* locked(locked): maps(read), amap(if !null), uobj, pg */ 1959 /* locked(!locked): uobj, pg */ 1960 1961 /* 1962 * verify that the page has not be released and re-verify 1963 * that amap slot is still free. if there is a problem, 1964 * we unlock and clean up. 1965 */ 1966 1967 if ((pg->flags & PG_RELEASED) != 0 || 1968 (locked && amap && amap_lookup(&ufi->entry->aref, 1969 ufi->orig_rvaddr - ufi->entry->start))) { 1970 if (locked) 1971 uvmfault_unlockall(ufi, amap, NULL); 1972 locked = false; 1973 } 1974 1975 /* 1976 * didn't get the lock? release the page and retry. 1977 */ 1978 1979 if (locked == false) { 1980 UVMHIST_LOG(maphist, 1981 " wasn't able to relock after fault: retry", 1982 0,0,0,0); 1983 if (pg->flags & PG_WANTED) { 1984 wakeup(pg); 1985 } 1986 if ((pg->flags & PG_RELEASED) == 0) { 1987 pg->flags &= ~(PG_BUSY | PG_WANTED); 1988 UVM_PAGE_OWN(pg, NULL); 1989 } else { 1990 uvmexp.fltpgrele++; 1991 uvm_pagefree(pg); 1992 } 1993 mutex_exit(uobj->vmobjlock); 1994 return ERESTART; 1995 } 1996 1997 /* 1998 * we have the data in pg which is busy and 1999 * not released. we are holding object lock (so the page 2000 * can't be released on us). 2001 */ 2002 2003 /* locked: maps(read), amap(if !null), uobj, pg */ 2004 2005 *ruobj = uobj; 2006 *ruobjpage = pg; 2007 return 0; 2008 } 2009 2010 /* 2011 * uvm_fault_lower_direct: fault lower center page 2012 * 2013 * 1. adjust flt->enter_prot. 2014 * 2. if page is loaned, resolve. 2015 */ 2016 2017 int 2018 uvm_fault_lower_direct( 2019 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 2020 struct uvm_object *uobj, struct vm_page *uobjpage) 2021 { 2022 struct vm_page *pg; 2023 UVMHIST_FUNC("uvm_fault_lower_direct"); UVMHIST_CALLED(maphist); 2024 2025 /* 2026 * we are not promoting. if the mapping is COW ensure that we 2027 * don't give more access than we should (e.g. when doing a read 2028 * fault on a COPYONWRITE mapping we want to map the COW page in 2029 * R/O even though the entry protection could be R/W). 2030 * 2031 * set "pg" to the page we want to map in (uobjpage, usually) 2032 */ 2033 2034 uvmexp.flt_obj++; 2035 if (UVM_ET_ISCOPYONWRITE(ufi->entry) || 2036 UVM_OBJ_NEEDS_WRITEFAULT(uobjpage->uobject)) 2037 flt->enter_prot &= ~VM_PROT_WRITE; 2038 pg = uobjpage; /* map in the actual object */ 2039 2040 KASSERT(uobjpage != PGO_DONTCARE); 2041 2042 /* 2043 * we are faulting directly on the page. be careful 2044 * about writing to loaned pages... 2045 */ 2046 2047 if (uobjpage->loan_count) { 2048 uvm_fault_lower_direct_loan(ufi, flt, uobj, &pg, &uobjpage); 2049 } 2050 KASSERT(pg == uobjpage); 2051 2052 KASSERT(uobj == NULL || (uobjpage->flags & PG_BUSY) != 0); 2053 return uvm_fault_lower_enter(ufi, flt, uobj, NULL, pg); 2054 } 2055 2056 /* 2057 * uvm_fault_lower_direct_loan: resolve loaned page. 2058 * 2059 * 1. if not cow'ing, adjust flt->enter_prot. 2060 * 2. if cow'ing, break loan. 2061 */ 2062 2063 static int 2064 uvm_fault_lower_direct_loan( 2065 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 2066 struct uvm_object *uobj, struct vm_page **rpg, 2067 struct vm_page **ruobjpage) 2068 { 2069 struct vm_amap * const amap = ufi->entry->aref.ar_amap; 2070 struct vm_page *pg; 2071 struct vm_page *uobjpage = *ruobjpage; 2072 UVMHIST_FUNC("uvm_fault_lower_direct_loan"); UVMHIST_CALLED(maphist); 2073 2074 if (!flt->cow_now) { 2075 /* read fault: cap the protection at readonly */ 2076 /* cap! */ 2077 flt->enter_prot = flt->enter_prot & ~VM_PROT_WRITE; 2078 } else { 2079 /* write fault: must break the loan here */ 2080 2081 pg = uvm_loanbreak(uobjpage); 2082 if (pg == NULL) { 2083 2084 /* 2085 * drop ownership of page, it can't be released 2086 */ 2087 2088 if (uobjpage->flags & PG_WANTED) 2089 wakeup(uobjpage); 2090 uobjpage->flags &= ~(PG_BUSY|PG_WANTED); 2091 UVM_PAGE_OWN(uobjpage, NULL); 2092 2093 uvmfault_unlockall(ufi, amap, uobj); 2094 UVMHIST_LOG(maphist, 2095 " out of RAM breaking loan, waiting", 2096 0,0,0,0); 2097 uvmexp.fltnoram++; 2098 uvm_wait("flt_noram4"); 2099 return ERESTART; 2100 } 2101 *rpg = pg; 2102 *ruobjpage = pg; 2103 } 2104 return 0; 2105 } 2106 2107 /* 2108 * uvm_fault_lower_promote: promote lower page. 2109 * 2110 * 1. call uvmfault_promote. 2111 * 2. fill in data. 2112 * 3. if not ZFOD, dispose old page. 2113 */ 2114 2115 int 2116 uvm_fault_lower_promote( 2117 struct uvm_faultinfo *ufi, struct uvm_faultctx *flt, 2118 struct uvm_object *uobj, struct vm_page *uobjpage) 2119 { 2120 struct vm_amap * const amap = ufi->entry->aref.ar_amap; 2121 struct vm_anon *anon; 2122 struct vm_page *pg; 2123 int error; 2124 UVMHIST_FUNC("uvm_fault_lower_promote"); UVMHIST_CALLED(maphist); 2125 2126 KASSERT(amap != NULL); 2127 2128 /* 2129 * If we are going to promote the data to an anon we 2130 * allocate a blank anon here and plug it into our amap. 2131 */ 2132 error = uvmfault_promote(ufi, NULL, uobjpage, 2133 &anon, &flt->anon_spare); 2134 switch (error) { 2135 case 0: 2136 break; 2137 case ERESTART: 2138 return ERESTART; 2139 default: 2140 return error; 2141 } 2142 2143 pg = anon->an_page; 2144 2145 /* 2146 * Fill in the data. 2147 */ 2148 KASSERT(uobj == NULL || (uobjpage->flags & PG_BUSY) != 0); 2149 2150 if (uobjpage != PGO_DONTCARE) { 2151 uvmexp.flt_prcopy++; 2152 2153 /* 2154 * promote to shared amap? make sure all sharing 2155 * procs see it 2156 */ 2157 2158 if ((amap_flags(amap) & AMAP_SHARED) != 0) { 2159 pmap_page_protect(uobjpage, VM_PROT_NONE); 2160 /* 2161 * XXX: PAGE MIGHT BE WIRED! 2162 */ 2163 } 2164 2165 /* 2166 * dispose of uobjpage. it can't be PG_RELEASED 2167 * since we still hold the object lock. 2168 */ 2169 2170 if (uobjpage->flags & PG_WANTED) { 2171 /* still have the obj lock */ 2172 wakeup(uobjpage); 2173 } 2174 uobjpage->flags &= ~(PG_BUSY|PG_WANTED); 2175 UVM_PAGE_OWN(uobjpage, NULL); 2176 2177 UVMHIST_LOG(maphist, 2178 " promote uobjpage 0x%#jx to anon/page 0x%#jx/0x%#jx", 2179 (uintptr_t)uobjpage, (uintptr_t)anon, (uintptr_t)pg, 0); 2180 2181 } else { 2182 uvmexp.flt_przero++; 2183 2184 /* 2185 * Page is zero'd and marked dirty by 2186 * uvmfault_promote(). 2187 */ 2188 2189 UVMHIST_LOG(maphist," zero fill anon/page 0x%#jx/0%#jx", 2190 (uintptr_t)anon, (uintptr_t)pg, 0, 0); 2191 } 2192 2193 return uvm_fault_lower_enter(ufi, flt, uobj, anon, pg); 2194 } 2195 2196 /* 2197 * uvm_fault_lower_enter: enter h/w mapping of lower page or anon page promoted 2198 * from the lower page. 2199 */ 2200 2201 int 2202 uvm_fault_lower_enter( 2203 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 2204 struct uvm_object *uobj, 2205 struct vm_anon *anon, struct vm_page *pg) 2206 { 2207 struct vm_amap * const amap = ufi->entry->aref.ar_amap; 2208 int error; 2209 UVMHIST_FUNC("uvm_fault_lower_enter"); UVMHIST_CALLED(maphist); 2210 2211 /* 2212 * Locked: 2213 * 2214 * maps(read), amap(if !null), uobj(if !null), 2215 * anon(if !null), pg(if anon), unlock_uobj(if !null) 2216 * 2217 * Note: pg is either the uobjpage or the new page in the new anon. 2218 */ 2219 KASSERT(amap == NULL || mutex_owned(amap->am_lock)); 2220 KASSERT(uobj == NULL || mutex_owned(uobj->vmobjlock)); 2221 KASSERT(anon == NULL || anon->an_lock == amap->am_lock); 2222 KASSERT((pg->flags & PG_BUSY) != 0); 2223 2224 /* 2225 * all resources are present. we can now map it in and free our 2226 * resources. 2227 */ 2228 2229 UVMHIST_LOG(maphist, 2230 " MAPPING: case2: pm=%#jx, va=%#jx, pg=%#jx, promote=%jd", 2231 (uintptr_t)ufi->orig_map->pmap, ufi->orig_rvaddr, 2232 (uintptr_t)pg, flt->promote); 2233 KASSERT((flt->access_type & VM_PROT_WRITE) == 0 || 2234 (pg->flags & PG_RDONLY) == 0); 2235 if (pmap_enter(ufi->orig_map->pmap, ufi->orig_rvaddr, 2236 VM_PAGE_TO_PHYS(pg), 2237 (pg->flags & PG_RDONLY) != 0 ? 2238 flt->enter_prot & ~VM_PROT_WRITE : flt->enter_prot, 2239 flt->access_type | PMAP_CANFAIL | 2240 (flt->wire_mapping ? PMAP_WIRED : 0)) != 0) { 2241 2242 /* 2243 * No need to undo what we did; we can simply think of 2244 * this as the pmap throwing away the mapping information. 2245 * 2246 * We do, however, have to go through the ReFault path, 2247 * as the map may change while we're asleep. 2248 */ 2249 2250 /* 2251 * ensure that the page is queued in the case that 2252 * we just promoted the page. 2253 */ 2254 2255 mutex_enter(&uvm_pageqlock); 2256 uvm_pageenqueue(pg); 2257 mutex_exit(&uvm_pageqlock); 2258 2259 if (pg->flags & PG_WANTED) 2260 wakeup(pg); 2261 2262 /* 2263 * note that pg can't be PG_RELEASED since we did not drop 2264 * the object lock since the last time we checked. 2265 */ 2266 KASSERT((pg->flags & PG_RELEASED) == 0); 2267 2268 pg->flags &= ~(PG_BUSY|PG_FAKE|PG_WANTED); 2269 UVM_PAGE_OWN(pg, NULL); 2270 2271 uvmfault_unlockall(ufi, amap, uobj); 2272 if (!uvm_reclaimable()) { 2273 UVMHIST_LOG(maphist, 2274 "<- failed. out of VM",0,0,0,0); 2275 /* XXX instrumentation */ 2276 error = ENOMEM; 2277 return error; 2278 } 2279 /* XXX instrumentation */ 2280 uvm_wait("flt_pmfail2"); 2281 return ERESTART; 2282 } 2283 2284 uvm_fault_lower_done(ufi, flt, uobj, pg); 2285 2286 /* 2287 * note that pg can't be PG_RELEASED since we did not drop the object 2288 * lock since the last time we checked. 2289 */ 2290 KASSERT((pg->flags & PG_RELEASED) == 0); 2291 if (pg->flags & PG_WANTED) 2292 wakeup(pg); 2293 pg->flags &= ~(PG_BUSY|PG_FAKE|PG_WANTED); 2294 UVM_PAGE_OWN(pg, NULL); 2295 2296 pmap_update(ufi->orig_map->pmap); 2297 uvmfault_unlockall(ufi, amap, uobj); 2298 2299 UVMHIST_LOG(maphist, "<- done (SUCCESS!)",0,0,0,0); 2300 return 0; 2301 } 2302 2303 /* 2304 * uvm_fault_lower_done: queue lower center page. 2305 */ 2306 2307 void 2308 uvm_fault_lower_done( 2309 struct uvm_faultinfo *ufi, const struct uvm_faultctx *flt, 2310 struct uvm_object *uobj, struct vm_page *pg) 2311 { 2312 bool dropswap = false; 2313 2314 UVMHIST_FUNC("uvm_fault_lower_done"); UVMHIST_CALLED(maphist); 2315 2316 mutex_enter(&uvm_pageqlock); 2317 if (flt->wire_paging) { 2318 uvm_pagewire(pg); 2319 if (pg->pqflags & PQ_AOBJ) { 2320 2321 /* 2322 * since the now-wired page cannot be paged out, 2323 * release its swap resources for others to use. 2324 * since an aobj page with no swap cannot be PG_CLEAN, 2325 * clear its clean flag now. 2326 */ 2327 2328 KASSERT(uobj != NULL); 2329 pg->flags &= ~(PG_CLEAN); 2330 dropswap = true; 2331 } 2332 } else { 2333 uvm_pageactivate(pg); 2334 } 2335 mutex_exit(&uvm_pageqlock); 2336 2337 if (dropswap) { 2338 uao_dropswap(uobj, pg->offset >> PAGE_SHIFT); 2339 } 2340 } 2341 2342 2343 /* 2344 * uvm_fault_wire: wire down a range of virtual addresses in a map. 2345 * 2346 * => map may be read-locked by caller, but MUST NOT be write-locked. 2347 * => if map is read-locked, any operations which may cause map to 2348 * be write-locked in uvm_fault() must be taken care of by 2349 * the caller. See uvm_map_pageable(). 2350 */ 2351 2352 int 2353 uvm_fault_wire(struct vm_map *map, vaddr_t start, vaddr_t end, 2354 vm_prot_t access_type, int maxprot) 2355 { 2356 vaddr_t va; 2357 int error; 2358 2359 /* 2360 * now fault it in a page at a time. if the fault fails then we have 2361 * to undo what we have done. note that in uvm_fault VM_PROT_NONE 2362 * is replaced with the max protection if fault_type is VM_FAULT_WIRE. 2363 */ 2364 2365 /* 2366 * XXX work around overflowing a vaddr_t. this prevents us from 2367 * wiring the last page in the address space, though. 2368 */ 2369 if (start > end) { 2370 return EFAULT; 2371 } 2372 2373 for (va = start; va < end; va += PAGE_SIZE) { 2374 error = uvm_fault_internal(map, va, access_type, 2375 (maxprot ? UVM_FAULT_MAXPROT : 0) | UVM_FAULT_WIRE); 2376 if (error) { 2377 if (va != start) { 2378 uvm_fault_unwire(map, start, va); 2379 } 2380 return error; 2381 } 2382 } 2383 return 0; 2384 } 2385 2386 /* 2387 * uvm_fault_unwire(): unwire range of virtual space. 2388 */ 2389 2390 void 2391 uvm_fault_unwire(struct vm_map *map, vaddr_t start, vaddr_t end) 2392 { 2393 vm_map_lock_read(map); 2394 uvm_fault_unwire_locked(map, start, end); 2395 vm_map_unlock_read(map); 2396 } 2397 2398 /* 2399 * uvm_fault_unwire_locked(): the guts of uvm_fault_unwire(). 2400 * 2401 * => map must be at least read-locked. 2402 */ 2403 2404 void 2405 uvm_fault_unwire_locked(struct vm_map *map, vaddr_t start, vaddr_t end) 2406 { 2407 struct vm_map_entry *entry, *oentry; 2408 pmap_t pmap = vm_map_pmap(map); 2409 vaddr_t va; 2410 paddr_t pa; 2411 struct vm_page *pg; 2412 2413 /* 2414 * we assume that the area we are unwiring has actually been wired 2415 * in the first place. this means that we should be able to extract 2416 * the PAs from the pmap. we also lock out the page daemon so that 2417 * we can call uvm_pageunwire. 2418 */ 2419 2420 /* 2421 * find the beginning map entry for the region. 2422 */ 2423 2424 KASSERT(start >= vm_map_min(map) && end <= vm_map_max(map)); 2425 if (uvm_map_lookup_entry(map, start, &entry) == false) 2426 panic("uvm_fault_unwire_locked: address not in map"); 2427 2428 oentry = NULL; 2429 for (va = start; va < end; va += PAGE_SIZE) { 2430 if (pmap_extract(pmap, va, &pa) == false) 2431 continue; 2432 2433 /* 2434 * find the map entry for the current address. 2435 */ 2436 2437 KASSERT(va >= entry->start); 2438 while (va >= entry->end) { 2439 KASSERT(entry->next != &map->header && 2440 entry->next->start <= entry->end); 2441 entry = entry->next; 2442 } 2443 2444 /* 2445 * lock it. 2446 */ 2447 2448 if (entry != oentry) { 2449 if (oentry != NULL) { 2450 mutex_exit(&uvm_pageqlock); 2451 uvm_map_unlock_entry(oentry); 2452 } 2453 uvm_map_lock_entry(entry); 2454 mutex_enter(&uvm_pageqlock); 2455 oentry = entry; 2456 } 2457 2458 /* 2459 * if the entry is no longer wired, tell the pmap. 2460 */ 2461 2462 if (VM_MAPENT_ISWIRED(entry) == 0) 2463 pmap_unwire(pmap, va); 2464 2465 pg = PHYS_TO_VM_PAGE(pa); 2466 if (pg) 2467 uvm_pageunwire(pg); 2468 } 2469 2470 if (oentry != NULL) { 2471 mutex_exit(&uvm_pageqlock); 2472 uvm_map_unlock_entry(entry); 2473 } 2474 } 2475