![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to swap_pager.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / vm|
Return to swap_pager.c CVS log | Up to [Net/2] / Net2 / vm |
1.1 ! root 1: /* ! 2: * Copyright (c) 1990 University of Utah. ! 3: * Copyright (c) 1991 The Regents of the University of California. ! 4: * All rights reserved. ! 5: * ! 6: * This code is derived from software contributed to Berkeley by ! 7: * the Systems Programming Group of the University of Utah Computer ! 8: * Science Department. ! 9: * ! 10: * Redistribution and use in source and binary forms, with or without ! 11: * modification, are permitted provided that the following conditions ! 12: * are met: ! 13: * 1. Redistributions of source code must retain the above copyright ! 14: * notice, this list of conditions and the following disclaimer. ! 15: * 2. Redistributions in binary form must reproduce the above copyright ! 16: * notice, this list of conditions and the following disclaimer in the ! 17: * documentation and/or other materials provided with the distribution. ! 18: * 3. All advertising materials mentioning features or use of this software ! 19: * must display the following acknowledgement: ! 20: * This product includes software developed by the University of ! 21: * California, Berkeley and its contributors. ! 22: * 4. Neither the name of the University nor the names of its contributors ! 23: * may be used to endorse or promote products derived from this software ! 24: * without specific prior written permission. ! 25: * ! 26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 36: * SUCH DAMAGE. ! 37: * ! 38: * from: Utah $Hdr: swap_pager.c 1.4 91/04/30$ ! 39: * ! 40: * @(#)swap_pager.c 7.4 (Berkeley) 5/7/91 ! 41: */ ! 42: ! 43: /* ! 44: * Quick hack to page to dedicated partition(s). ! 45: * TODO: ! 46: * Add multiprocessor locks ! 47: * Deal with async writes in a better fashion ! 48: */ ! 49: ! 50: #include "swappager.h" ! 51: #if NSWAPPAGER > 0 ! 52: ! 53: #include "param.h" ! 54: #include "proc.h" ! 55: #include "buf.h" ! 56: #include "map.h" ! 57: #include "systm.h" ! 58: #include "specdev.h" ! 59: #include "vnode.h" ! 60: #include "malloc.h" ! 61: #include "queue.h" ! 62: ! 63: #include "vm_param.h" ! 64: #include "queue.h" ! 65: #include "lock.h" ! 66: #include "vm_prot.h" ! 67: #include "vm_object.h" ! 68: #include "vm_page.h" ! 69: #include "vm_pageout.h" ! 70: #include "swap_pager.h" ! 71: ! 72: #define NSWSIZES 16 /* size of swtab */ ! 73: #define NPENDINGIO 64 /* max # of pending cleans */ ! 74: #define MAXDADDRS 64 /* max # of disk addrs for fixed allocations */ ! 75: ! 76: #ifdef DEBUG ! 77: int swpagerdebug = 0x100; ! 78: #define SDB_FOLLOW 0x001 ! 79: #define SDB_INIT 0x002 ! 80: #define SDB_ALLOC 0x004 ! 81: #define SDB_IO 0x008 ! 82: #define SDB_WRITE 0x010 ! 83: #define SDB_FAIL 0x020 ! 84: #define SDB_ALLOCBLK 0x040 ! 85: #define SDB_FULL 0x080 ! 86: #define SDB_ANOM 0x100 ! 87: #define SDB_ANOMPANIC 0x200 ! 88: #endif ! 89: ! 90: struct swpagerclean { ! 91: queue_head_t spc_list; ! 92: int spc_flags; ! 93: struct buf *spc_bp; ! 94: sw_pager_t spc_swp; ! 95: vm_offset_t spc_kva; ! 96: vm_page_t spc_m; ! 97: } swcleanlist[NPENDINGIO]; ! 98: typedef struct swpagerclean *swp_clean_t; ! 99: ! 100: /* spc_flags values */ ! 101: #define SPC_FREE 0x00 ! 102: #define SPC_BUSY 0x01 ! 103: #define SPC_DONE 0x02 ! 104: #define SPC_ERROR 0x04 ! 105: #define SPC_DIRTY 0x08 ! 106: ! 107: struct swtab { ! 108: vm_size_t st_osize; /* size of object (bytes) */ ! 109: int st_bsize; /* vs. size of swap block (DEV_BSIZE units) */ ! 110: #ifdef DEBUG ! 111: u_long st_inuse; /* number in this range in use */ ! 112: u_long st_usecnt; /* total used of this size */ ! 113: #endif ! 114: } swtab[NSWSIZES+1]; ! 115: ! 116: #ifdef DEBUG ! 117: int swap_pager_pendingio; /* max pending async "clean" ops */ ! 118: int swap_pager_poip; /* pageouts in progress */ ! 119: int swap_pager_piip; /* pageins in progress */ ! 120: #endif ! 121: ! 122: queue_head_t swap_pager_inuse; /* list of pending page cleans */ ! 123: queue_head_t swap_pager_free; /* list of free pager clean structs */ ! 124: queue_head_t swap_pager_list; /* list of "named" anon regions */ ! 125: ! 126: void ! 127: swap_pager_init() ! 128: { ! 129: register swp_clean_t spc; ! 130: register int i, bsize; ! 131: extern int dmmin, dmmax; ! 132: int maxbsize; ! 133: ! 134: #ifdef DEBUG ! 135: if (swpagerdebug & (SDB_FOLLOW|SDB_INIT)) ! 136: printf("swpg_init()\n"); ! 137: #endif ! 138: dfltpagerops = &swappagerops; ! 139: queue_init(&swap_pager_list); ! 140: ! 141: /* ! 142: * Initialize clean lists ! 143: */ ! 144: queue_init(&swap_pager_inuse); ! 145: queue_init(&swap_pager_free); ! 146: for (i = 0, spc = swcleanlist; i < NPENDINGIO; i++, spc++) { ! 147: queue_enter(&swap_pager_free, spc, swp_clean_t, spc_list); ! 148: spc->spc_flags = SPC_FREE; ! 149: } ! 150: ! 151: /* ! 152: * Calculate the swap allocation constants. ! 153: */ ! 154: if (dmmin == 0) { ! 155: dmmin = DMMIN; ! 156: if (dmmin < CLBYTES/DEV_BSIZE) ! 157: dmmin = CLBYTES/DEV_BSIZE; ! 158: } ! 159: if (dmmax == 0) ! 160: dmmax = DMMAX; ! 161: ! 162: /* ! 163: * Fill in our table of object size vs. allocation size ! 164: */ ! 165: bsize = btodb(PAGE_SIZE); ! 166: if (bsize < dmmin) ! 167: bsize = dmmin; ! 168: maxbsize = btodb(sizeof(sw_bm_t) * NBBY * PAGE_SIZE); ! 169: if (maxbsize > dmmax) ! 170: maxbsize = dmmax; ! 171: for (i = 0; i < NSWSIZES; i++) { ! 172: swtab[i].st_osize = (vm_size_t) (MAXDADDRS * dbtob(bsize)); ! 173: swtab[i].st_bsize = bsize; ! 174: #ifdef DEBUG ! 175: if (swpagerdebug & SDB_INIT) ! 176: printf("swpg_init: ix %d, size %x, bsize %x\n", ! 177: i, swtab[i].st_osize, swtab[i].st_bsize); ! 178: #endif ! 179: if (bsize >= maxbsize) ! 180: break; ! 181: bsize *= 2; ! 182: } ! 183: swtab[i].st_osize = 0; ! 184: swtab[i].st_bsize = bsize; ! 185: } ! 186: ! 187: /* ! 188: * Allocate a pager structure and associated resources. ! 189: * Note that if we are called from the pageout daemon (handle == NULL) ! 190: * we should not wait for memory as it could resulting in deadlock. ! 191: */ ! 192: vm_pager_t ! 193: swap_pager_alloc(handle, size, prot) ! 194: caddr_t handle; ! 195: register vm_size_t size; ! 196: vm_prot_t prot; ! 197: { ! 198: register vm_pager_t pager; ! 199: register sw_pager_t swp; ! 200: struct swtab *swt; ! 201: int waitok; ! 202: ! 203: #ifdef DEBUG ! 204: if (swpagerdebug & (SDB_FOLLOW|SDB_ALLOC)) ! 205: printf("swpg_alloc(%x, %x, %x)\n", handle, size, prot); ! 206: #endif ! 207: /* ! 208: * If this is a "named" anonymous region, look it up and ! 209: * return the appropriate pager if it exists. ! 210: */ ! 211: if (handle) { ! 212: pager = vm_pager_lookup(&swap_pager_list, handle); ! 213: if (pager != NULL) { ! 214: /* ! 215: * Use vm_object_lookup to gain a reference ! 216: * to the object and also to remove from the ! 217: * object cache. ! 218: */ ! 219: if (vm_object_lookup(pager) == NULL) ! 220: panic("swap_pager_alloc: bad object"); ! 221: return(pager); ! 222: } ! 223: } ! 224: /* ! 225: * Pager doesn't exist, allocate swap management resources ! 226: * and initialize. ! 227: */ ! 228: waitok = handle ? M_WAITOK : M_NOWAIT; ! 229: pager = (vm_pager_t)malloc(sizeof *pager, M_VMPAGER, waitok); ! 230: if (pager == NULL) ! 231: return(NULL); ! 232: swp = (sw_pager_t)malloc(sizeof *swp, M_VMPGDATA, waitok); ! 233: if (swp == NULL) { ! 234: #ifdef DEBUG ! 235: if (swpagerdebug & SDB_FAIL) ! 236: printf("swpg_alloc: swpager malloc failed\n"); ! 237: #endif ! 238: free((caddr_t)pager, M_VMPAGER); ! 239: return(NULL); ! 240: } ! 241: size = round_page(size); ! 242: for (swt = swtab; swt->st_osize; swt++) ! 243: if (size <= swt->st_osize) ! 244: break; ! 245: #ifdef DEBUG ! 246: swt->st_inuse++; ! 247: swt->st_usecnt++; ! 248: #endif ! 249: swp->sw_osize = size; ! 250: swp->sw_bsize = swt->st_bsize; ! 251: swp->sw_nblocks = (btodb(size) + swp->sw_bsize - 1) / swp->sw_bsize; ! 252: swp->sw_blocks = (sw_blk_t) ! 253: malloc(swp->sw_nblocks*sizeof(*swp->sw_blocks), ! 254: M_VMPGDATA, M_NOWAIT); ! 255: if (swp->sw_blocks == NULL) { ! 256: free((caddr_t)swp, M_VMPGDATA); ! 257: free((caddr_t)pager, M_VMPAGER); ! 258: #ifdef DEBUG ! 259: if (swpagerdebug & SDB_FAIL) ! 260: printf("swpg_alloc: sw_blocks malloc failed\n"); ! 261: swt->st_inuse--; ! 262: swt->st_usecnt--; ! 263: #endif ! 264: return(FALSE); ! 265: } ! 266: bzero((caddr_t)swp->sw_blocks, ! 267: swp->sw_nblocks * sizeof(*swp->sw_blocks)); ! 268: swp->sw_poip = 0; ! 269: if (handle) { ! 270: vm_object_t object; ! 271: ! 272: swp->sw_flags = SW_NAMED; ! 273: queue_enter(&swap_pager_list, pager, vm_pager_t, pg_list); ! 274: /* ! 275: * Consistant with other pagers: return with object ! 276: * referenced. Can't do this with handle == NULL ! 277: * since it might be the pageout daemon calling. ! 278: */ ! 279: object = vm_object_allocate(size); ! 280: vm_object_enter(object, pager); ! 281: vm_object_setpager(object, pager, 0, FALSE); ! 282: } else { ! 283: swp->sw_flags = 0; ! 284: queue_init(&pager->pg_list); ! 285: } ! 286: pager->pg_handle = handle; ! 287: pager->pg_ops = &swappagerops; ! 288: pager->pg_type = PG_SWAP; ! 289: pager->pg_data = (caddr_t)swp; ! 290: ! 291: #ifdef DEBUG ! 292: if (swpagerdebug & SDB_ALLOC) ! 293: printf("swpg_alloc: pg_data %x, %x of %x at %x\n", ! 294: swp, swp->sw_nblocks, swp->sw_bsize, swp->sw_blocks); ! 295: #endif ! 296: return(pager); ! 297: } ! 298: ! 299: void ! 300: swap_pager_dealloc(pager) ! 301: vm_pager_t pager; ! 302: { ! 303: register int i; ! 304: register sw_blk_t bp; ! 305: register sw_pager_t swp; ! 306: struct swtab *swt; ! 307: int s; ! 308: ! 309: #ifdef DEBUG ! 310: /* save panic time state */ ! 311: if ((swpagerdebug & SDB_ANOMPANIC) && panicstr) ! 312: return; ! 313: if (swpagerdebug & (SDB_FOLLOW|SDB_ALLOC)) ! 314: printf("swpg_dealloc(%x)\n", pager); ! 315: #endif ! 316: /* ! 317: * Remove from list right away so lookups will fail if we ! 318: * block for pageout completion. ! 319: */ ! 320: swp = (sw_pager_t) pager->pg_data; ! 321: if (swp->sw_flags & SW_NAMED) { ! 322: queue_remove(&swap_pager_list, pager, vm_pager_t, pg_list); ! 323: swp->sw_flags &= ~SW_NAMED; ! 324: } ! 325: #ifdef DEBUG ! 326: for (swt = swtab; swt->st_osize; swt++) ! 327: if (swp->sw_osize <= swt->st_osize) ! 328: break; ! 329: swt->st_inuse--; ! 330: #endif ! 331: ! 332: /* ! 333: * Wait for all pageouts to finish and remove ! 334: * all entries from cleaning list. ! 335: */ ! 336: s = splbio(); ! 337: while (swp->sw_poip) { ! 338: swp->sw_flags |= SW_WANTED; ! 339: assert_wait((int)swp); ! 340: thread_block(); ! 341: } ! 342: splx(s); ! 343: (void) swap_pager_clean(NULL, B_WRITE); ! 344: ! 345: /* ! 346: * Free left over swap blocks ! 347: */ ! 348: for (i = 0, bp = swp->sw_blocks; i < swp->sw_nblocks; i++, bp++) ! 349: if (bp->swb_block) { ! 350: #ifdef DEBUG ! 351: if (swpagerdebug & (SDB_ALLOCBLK|SDB_FULL)) ! 352: printf("swpg_dealloc: blk %x\n", ! 353: bp->swb_block); ! 354: #endif ! 355: rmfree(swapmap, swp->sw_bsize, bp->swb_block); ! 356: } ! 357: /* ! 358: * Free swap management resources ! 359: */ ! 360: free((caddr_t)swp->sw_blocks, M_VMPGDATA); ! 361: free((caddr_t)swp, M_VMPGDATA); ! 362: free((caddr_t)pager, M_VMPAGER); ! 363: } ! 364: ! 365: swap_pager_getpage(pager, m, sync) ! 366: vm_pager_t pager; ! 367: vm_page_t m; ! 368: boolean_t sync; ! 369: { ! 370: #ifdef DEBUG ! 371: if (swpagerdebug & SDB_FOLLOW) ! 372: printf("swpg_getpage(%x, %x, %d)\n", pager, m, sync); ! 373: #endif ! 374: return(swap_pager_io((sw_pager_t)pager->pg_data, m, B_READ)); ! 375: } ! 376: ! 377: swap_pager_putpage(pager, m, sync) ! 378: vm_pager_t pager; ! 379: vm_page_t m; ! 380: boolean_t sync; ! 381: { ! 382: int flags; ! 383: ! 384: #ifdef DEBUG ! 385: if (swpagerdebug & SDB_FOLLOW) ! 386: printf("swpg_putpage(%x, %x, %d)\n", pager, m, sync); ! 387: #endif ! 388: if (pager == NULL) { ! 389: (void) swap_pager_clean(NULL, B_WRITE); ! 390: return; ! 391: } ! 392: flags = B_WRITE; ! 393: if (!sync) ! 394: flags |= B_ASYNC; ! 395: return(swap_pager_io((sw_pager_t)pager->pg_data, m, flags)); ! 396: } ! 397: ! 398: boolean_t ! 399: swap_pager_haspage(pager, offset) ! 400: vm_pager_t pager; ! 401: vm_offset_t offset; ! 402: { ! 403: register sw_pager_t swp; ! 404: register sw_blk_t swb; ! 405: int ix; ! 406: ! 407: #ifdef DEBUG ! 408: if (swpagerdebug & (SDB_FOLLOW|SDB_ALLOCBLK)) ! 409: printf("swpg_haspage(%x, %x) ", pager, offset); ! 410: #endif ! 411: swp = (sw_pager_t) pager->pg_data; ! 412: ix = offset / dbtob(swp->sw_bsize); ! 413: if (swp->sw_blocks == NULL || ix >= swp->sw_nblocks) { ! 414: #ifdef DEBUG ! 415: if (swpagerdebug & (SDB_FAIL|SDB_FOLLOW|SDB_ALLOCBLK)) ! 416: printf("swpg_haspage: %x bad offset %x, ix %x\n", ! 417: swp->sw_blocks, offset, ix); ! 418: #endif ! 419: return(FALSE); ! 420: } ! 421: swb = &swp->sw_blocks[ix]; ! 422: if (swb->swb_block) ! 423: ix = atop(offset % dbtob(swp->sw_bsize)); ! 424: #ifdef DEBUG ! 425: if (swpagerdebug & SDB_ALLOCBLK) ! 426: printf("%x blk %x+%x ", swp->sw_blocks, swb->swb_block, ix); ! 427: if (swpagerdebug & (SDB_FOLLOW|SDB_ALLOCBLK)) ! 428: printf("-> %c\n", ! 429: "FT"[swb->swb_block && (swb->swb_mask & (1 << ix))]); ! 430: #endif ! 431: if (swb->swb_block && (swb->swb_mask & (1 << ix))) ! 432: return(TRUE); ! 433: return(FALSE); ! 434: } ! 435: ! 436: /* ! 437: * Scaled down version of swap(). ! 438: * Assumes that PAGE_SIZE < MAXPHYS; i.e. only one operation needed. ! 439: * BOGUS: lower level IO routines expect a KVA so we have to map our ! 440: * provided physical page into the KVA to keep them happy. ! 441: */ ! 442: swap_pager_io(swp, m, flags) ! 443: register sw_pager_t swp; ! 444: vm_page_t m; ! 445: int flags; ! 446: { ! 447: register struct buf *bp; ! 448: register sw_blk_t swb; ! 449: register int s; ! 450: int ix; ! 451: boolean_t rv; ! 452: vm_offset_t kva, off; ! 453: swp_clean_t spc; ! 454: ! 455: #ifdef DEBUG ! 456: /* save panic time state */ ! 457: if ((swpagerdebug & SDB_ANOMPANIC) && panicstr) ! 458: return; ! 459: if (swpagerdebug & (SDB_FOLLOW|SDB_IO)) ! 460: printf("swpg_io(%x, %x, %x)\n", swp, m, flags); ! 461: #endif ! 462: ! 463: /* ! 464: * For reads (pageins) and synchronous writes, we clean up ! 465: * all completed async pageouts. ! 466: */ ! 467: if ((flags & B_ASYNC) == 0) { ! 468: s = splbio(); ! 469: #ifdef DEBUG ! 470: /* ! 471: * Check to see if this page is currently being cleaned. ! 472: * If it is, we just wait til the operation is done before ! 473: * continuing. ! 474: */ ! 475: while (swap_pager_clean(m, flags&B_READ)) { ! 476: if (swpagerdebug & SDB_ANOM) ! 477: printf("swap_pager_io: page %x cleaning\n", m); ! 478: ! 479: swp->sw_flags |= SW_WANTED; ! 480: assert_wait((int)swp); ! 481: thread_block(); ! 482: } ! 483: #else ! 484: (void) swap_pager_clean(m, flags&B_READ); ! 485: #endif ! 486: splx(s); ! 487: } ! 488: /* ! 489: * For async writes (pageouts), we cleanup completed pageouts so ! 490: * that all available resources are freed. Also tells us if this ! 491: * page is already being cleaned. If it is, or no resources ! 492: * are available, we try again later. ! 493: */ ! 494: else if (swap_pager_clean(m, B_WRITE) || ! 495: queue_empty(&swap_pager_free)) { ! 496: #ifdef DEBUG ! 497: if ((swpagerdebug & SDB_ANOM) && ! 498: !queue_empty(&swap_pager_free)) ! 499: printf("swap_pager_io: page %x already cleaning\n", m); ! 500: #endif ! 501: return(VM_PAGER_FAIL); ! 502: } ! 503: ! 504: /* ! 505: * Determine swap block and allocate as necessary. ! 506: */ ! 507: off = m->offset + m->object->paging_offset; ! 508: ix = off / dbtob(swp->sw_bsize); ! 509: if (swp->sw_blocks == NULL || ix >= swp->sw_nblocks) { ! 510: #ifdef DEBUG ! 511: if (swpagerdebug & SDB_FAIL) ! 512: printf("swpg_io: bad offset %x+%x(%d) in %x\n", ! 513: m->offset, m->object->paging_offset, ! 514: ix, swp->sw_blocks); ! 515: #endif ! 516: return(VM_PAGER_FAIL); ! 517: } ! 518: swb = &swp->sw_blocks[ix]; ! 519: off = off % dbtob(swp->sw_bsize); ! 520: if (flags & B_READ) { ! 521: if (swb->swb_block == 0 || ! 522: (swb->swb_mask & (1 << atop(off))) == 0) { ! 523: #ifdef DEBUG ! 524: if (swpagerdebug & (SDB_ALLOCBLK|SDB_FAIL)) ! 525: printf("swpg_io: %x bad read: blk %x+%x, mask %x, off %x+%x\n", ! 526: swp->sw_blocks, ! 527: swb->swb_block, atop(off), ! 528: swb->swb_mask, ! 529: m->offset, m->object->paging_offset); ! 530: #endif ! 531: /* XXX: should we zero page here?? */ ! 532: return(VM_PAGER_FAIL); ! 533: } ! 534: } else if (swb->swb_block == 0) { ! 535: swb->swb_block = rmalloc(swapmap, swp->sw_bsize); ! 536: if (swb->swb_block == 0) { ! 537: #ifdef DEBUG ! 538: if (swpagerdebug & SDB_FAIL) ! 539: printf("swpg_io: rmalloc of %x failed\n", ! 540: swp->sw_bsize); ! 541: #endif ! 542: return(VM_PAGER_FAIL); ! 543: } ! 544: #ifdef DEBUG ! 545: if (swpagerdebug & (SDB_FULL|SDB_ALLOCBLK)) ! 546: printf("swpg_io: %x alloc blk %x at ix %x\n", ! 547: swp->sw_blocks, swb->swb_block, ix); ! 548: #endif ! 549: } ! 550: ! 551: /* ! 552: * Allocate a kernel virtual address and initialize so that PTE ! 553: * is available for lower level IO drivers. ! 554: */ ! 555: kva = vm_pager_map_page(m); ! 556: ! 557: /* ! 558: * Get a swap buffer header and perform the IO ! 559: */ ! 560: s = splbio(); ! 561: while (bswlist.av_forw == NULL) { ! 562: #ifdef DEBUG ! 563: if (swpagerdebug & SDB_ANOM) ! 564: printf("swap_pager_io: wait on swbuf for %x (%d)\n", ! 565: m, flags); ! 566: #endif ! 567: bswlist.b_flags |= B_WANTED; ! 568: sleep((caddr_t)&bswlist, PSWP+1); ! 569: } ! 570: bp = bswlist.av_forw; ! 571: bswlist.av_forw = bp->av_forw; ! 572: splx(s); ! 573: bp->b_flags = B_BUSY | (flags & B_READ); ! 574: bp->b_proc = &proc0; /* XXX (but without B_PHYS set this is ok) */ ! 575: bp->b_un.b_addr = (caddr_t)kva; ! 576: bp->b_blkno = swb->swb_block + btodb(off); ! 577: VHOLD(swapdev_vp); ! 578: bp->b_vp = swapdev_vp; ! 579: if (swapdev_vp->v_type == VBLK) ! 580: bp->b_dev = swapdev_vp->v_rdev; ! 581: bp->b_bcount = PAGE_SIZE; ! 582: if ((bp->b_flags & B_READ) == 0) ! 583: swapdev_vp->v_numoutput++; ! 584: ! 585: /* ! 586: * If this is an async write we set up additional buffer fields ! 587: * and place a "cleaning" entry on the inuse queue. ! 588: */ ! 589: if ((flags & (B_READ|B_ASYNC)) == B_ASYNC) { ! 590: #ifdef DEBUG ! 591: if (queue_empty(&swap_pager_free)) ! 592: panic("swpg_io: lost spc"); ! 593: #endif ! 594: queue_remove_first(&swap_pager_free, ! 595: spc, swp_clean_t, spc_list); ! 596: #ifdef DEBUG ! 597: if (spc->spc_flags != SPC_FREE) ! 598: panic("swpg_io: bad free spc"); ! 599: #endif ! 600: spc->spc_flags = SPC_BUSY; ! 601: spc->spc_bp = bp; ! 602: spc->spc_swp = swp; ! 603: spc->spc_kva = kva; ! 604: spc->spc_m = m; ! 605: bp->b_flags |= B_CALL; ! 606: bp->b_iodone = swap_pager_iodone; ! 607: s = splbio(); ! 608: swp->sw_poip++; ! 609: queue_enter(&swap_pager_inuse, spc, swp_clean_t, spc_list); ! 610: ! 611: #ifdef DEBUG ! 612: swap_pager_poip++; ! 613: if (swpagerdebug & SDB_WRITE) ! 614: printf("swpg_io: write: bp=%x swp=%x spc=%x poip=%d\n", ! 615: bp, swp, spc, swp->sw_poip); ! 616: if ((swpagerdebug & SDB_ALLOCBLK) && ! 617: (swb->swb_mask & (1 << atop(off))) == 0) ! 618: printf("swpg_io: %x write blk %x+%x\n", ! 619: swp->sw_blocks, swb->swb_block, atop(off)); ! 620: #endif ! 621: swb->swb_mask |= (1 << atop(off)); ! 622: splx(s); ! 623: } ! 624: #ifdef DEBUG ! 625: if (swpagerdebug & SDB_IO) ! 626: printf("swpg_io: IO start: bp %x, db %x, va %x, pa %x\n", ! 627: bp, swb->swb_block+btodb(off), kva, VM_PAGE_TO_PHYS(m)); ! 628: #endif ! 629: VOP_STRATEGY(bp); ! 630: if ((flags & (B_READ|B_ASYNC)) == B_ASYNC) { ! 631: #ifdef DEBUG ! 632: if (swpagerdebug & SDB_IO) ! 633: printf("swpg_io: IO started: bp %x\n", bp); ! 634: #endif ! 635: return(VM_PAGER_PEND); ! 636: } ! 637: s = splbio(); ! 638: #ifdef DEBUG ! 639: if (flags & B_READ) ! 640: swap_pager_piip++; ! 641: else ! 642: swap_pager_poip++; ! 643: #endif ! 644: while ((bp->b_flags & B_DONE) == 0) { ! 645: assert_wait((int)bp); ! 646: thread_block(); ! 647: } ! 648: #ifdef DEBUG ! 649: if (flags & B_READ) ! 650: --swap_pager_piip; ! 651: else ! 652: --swap_pager_poip; ! 653: #endif ! 654: rv = (bp->b_flags & B_ERROR) ? VM_PAGER_FAIL : VM_PAGER_OK; ! 655: bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS|B_PAGET|B_UAREA|B_DIRTY); ! 656: bp->av_forw = bswlist.av_forw; ! 657: bswlist.av_forw = bp; ! 658: if (bp->b_vp) ! 659: brelvp(bp); ! 660: if (bswlist.b_flags & B_WANTED) { ! 661: bswlist.b_flags &= ~B_WANTED; ! 662: thread_wakeup((int)&bswlist); ! 663: } ! 664: if ((flags & B_READ) == 0 && rv == VM_PAGER_OK) { ! 665: m->clean = TRUE; ! 666: pmap_clear_modify(VM_PAGE_TO_PHYS(m)); ! 667: } ! 668: splx(s); ! 669: #ifdef DEBUG ! 670: if (swpagerdebug & SDB_IO) ! 671: printf("swpg_io: IO done: bp %x, rv %d\n", bp, rv); ! 672: if ((swpagerdebug & SDB_FAIL) && rv == VM_PAGER_FAIL) ! 673: printf("swpg_io: IO error\n"); ! 674: #endif ! 675: vm_pager_unmap_page(kva); ! 676: return(rv); ! 677: } ! 678: ! 679: boolean_t ! 680: swap_pager_clean(m, rw) ! 681: vm_page_t m; ! 682: int rw; ! 683: { ! 684: register swp_clean_t spc, tspc; ! 685: register int s; ! 686: ! 687: #ifdef DEBUG ! 688: /* save panic time state */ ! 689: if ((swpagerdebug & SDB_ANOMPANIC) && panicstr) ! 690: return; ! 691: if (swpagerdebug & SDB_FOLLOW) ! 692: printf("swpg_clean(%x, %d)\n", m, rw); ! 693: #endif ! 694: tspc = NULL; ! 695: for (;;) { ! 696: /* ! 697: * Look up and removal from inuse list must be done ! 698: * at splbio() to avoid conflicts with swap_pager_iodone. ! 699: */ ! 700: s = splbio(); ! 701: spc = (swp_clean_t) queue_first(&swap_pager_inuse); ! 702: while (!queue_end(&swap_pager_inuse, (queue_entry_t)spc)) { ! 703: if ((spc->spc_flags & SPC_DONE) && ! 704: swap_pager_finish(spc)) { ! 705: queue_remove(&swap_pager_inuse, spc, ! 706: swp_clean_t, spc_list); ! 707: break; ! 708: } ! 709: if (m && m == spc->spc_m) { ! 710: #ifdef DEBUG ! 711: if (swpagerdebug & SDB_ANOM) ! 712: printf("swap_pager_clean: page %x on list, flags %x\n", ! 713: m, spc->spc_flags); ! 714: #endif ! 715: tspc = spc; ! 716: } ! 717: spc = (swp_clean_t) queue_next(&spc->spc_list); ! 718: } ! 719: ! 720: /* ! 721: * No operations done, thats all we can do for now. ! 722: */ ! 723: if (queue_end(&swap_pager_inuse, (queue_entry_t)spc)) ! 724: break; ! 725: splx(s); ! 726: ! 727: /* ! 728: * The desired page was found to be busy earlier in ! 729: * the scan but has since completed. ! 730: */ ! 731: if (tspc && tspc == spc) { ! 732: #ifdef DEBUG ! 733: if (swpagerdebug & SDB_ANOM) ! 734: printf("swap_pager_clean: page %x done while looking\n", ! 735: m); ! 736: #endif ! 737: tspc = NULL; ! 738: } ! 739: spc->spc_flags = SPC_FREE; ! 740: vm_pager_unmap_page(spc->spc_kva); ! 741: queue_enter(&swap_pager_free, spc, swp_clean_t, spc_list); ! 742: #ifdef DEBUG ! 743: if (swpagerdebug & SDB_WRITE) ! 744: printf("swpg_clean: free spc %x\n", spc); ! 745: #endif ! 746: } ! 747: #ifdef DEBUG ! 748: /* ! 749: * If we found that the desired page is already being cleaned ! 750: * mark it so that swap_pager_iodone() will not set the clean ! 751: * flag before the pageout daemon has another chance to clean it. ! 752: */ ! 753: if (tspc && rw == B_WRITE) { ! 754: if (swpagerdebug & SDB_ANOM) ! 755: printf("swap_pager_clean: page %x on clean list\n", ! 756: tspc); ! 757: tspc->spc_flags |= SPC_DIRTY; ! 758: } ! 759: #endif ! 760: splx(s); ! 761: ! 762: #ifdef DEBUG ! 763: if (swpagerdebug & SDB_WRITE) ! 764: printf("swpg_clean: return %d\n", tspc ? TRUE : FALSE); ! 765: if ((swpagerdebug & SDB_ANOM) && tspc) ! 766: printf("swpg_clean: %s of cleaning page %x\n", ! 767: rw == B_READ ? "get" : "put", m); ! 768: #endif ! 769: return(tspc ? TRUE : FALSE); ! 770: } ! 771: ! 772: swap_pager_finish(spc) ! 773: register swp_clean_t spc; ! 774: { ! 775: vm_object_t object = spc->spc_m->object; ! 776: ! 777: /* ! 778: * Mark the paging operation as done. ! 779: * (XXX) If we cannot get the lock, leave it til later. ! 780: * (XXX) Also we are assuming that an async write is a ! 781: * pageout operation that has incremented the counter. ! 782: */ ! 783: if (!vm_object_lock_try(object)) ! 784: return(0); ! 785: ! 786: if (--object->paging_in_progress == 0) ! 787: thread_wakeup((int) object); ! 788: ! 789: #ifdef DEBUG ! 790: /* ! 791: * XXX: this isn't even close to the right thing to do, ! 792: * introduces a variety of race conditions. ! 793: * ! 794: * If dirty, vm_pageout() has attempted to clean the page ! 795: * again. In this case we do not do anything as we will ! 796: * see the page again shortly. ! 797: */ ! 798: if (spc->spc_flags & SPC_DIRTY) { ! 799: if (swpagerdebug & SDB_ANOM) ! 800: printf("swap_pager_finish: page %x dirty again\n", ! 801: spc->spc_m); ! 802: spc->spc_m->busy = FALSE; ! 803: PAGE_WAKEUP(spc->spc_m); ! 804: vm_object_unlock(object); ! 805: return(1); ! 806: } ! 807: #endif ! 808: /* ! 809: * If no error mark as clean and inform the pmap system. ! 810: * If error, mark as dirty so we will try again. ! 811: * (XXX could get stuck doing this, should give up after awhile) ! 812: */ ! 813: if (spc->spc_flags & SPC_ERROR) { ! 814: printf("swap_pager_finish: clean of page %x failed\n", ! 815: VM_PAGE_TO_PHYS(spc->spc_m)); ! 816: spc->spc_m->laundry = TRUE; ! 817: } else { ! 818: spc->spc_m->clean = TRUE; ! 819: pmap_clear_modify(VM_PAGE_TO_PHYS(spc->spc_m)); ! 820: } ! 821: spc->spc_m->busy = FALSE; ! 822: PAGE_WAKEUP(spc->spc_m); ! 823: ! 824: vm_object_unlock(object); ! 825: return(1); ! 826: } ! 827: ! 828: swap_pager_iodone(bp) ! 829: register struct buf *bp; ! 830: { ! 831: register swp_clean_t spc; ! 832: daddr_t blk; ! 833: int s; ! 834: ! 835: #ifdef DEBUG ! 836: /* save panic time state */ ! 837: if ((swpagerdebug & SDB_ANOMPANIC) && panicstr) ! 838: return; ! 839: if (swpagerdebug & SDB_FOLLOW) ! 840: printf("swpg_iodone(%x)\n", bp); ! 841: #endif ! 842: s = splbio(); ! 843: spc = (swp_clean_t) queue_first(&swap_pager_inuse); ! 844: while (!queue_end(&swap_pager_inuse, (queue_entry_t)spc)) { ! 845: if (spc->spc_bp == bp) ! 846: break; ! 847: spc = (swp_clean_t) queue_next(&spc->spc_list); ! 848: } ! 849: #ifdef DEBUG ! 850: if (queue_end(&swap_pager_inuse, (queue_entry_t)spc)) ! 851: panic("swap_pager_iodone: bp not found"); ! 852: #endif ! 853: ! 854: spc->spc_flags &= ~SPC_BUSY; ! 855: spc->spc_flags |= SPC_DONE; ! 856: if (bp->b_flags & B_ERROR) ! 857: spc->spc_flags |= SPC_ERROR; ! 858: spc->spc_bp = NULL; ! 859: blk = bp->b_blkno; ! 860: ! 861: #ifdef DEBUG ! 862: --swap_pager_poip; ! 863: if (swpagerdebug & SDB_WRITE) ! 864: printf("swpg_iodone: bp=%x swp=%x flags=%x spc=%x poip=%x\n", ! 865: bp, spc->spc_swp, spc->spc_swp->sw_flags, ! 866: spc, spc->spc_swp->sw_poip); ! 867: #endif ! 868: ! 869: spc->spc_swp->sw_poip--; ! 870: if (spc->spc_swp->sw_flags & SW_WANTED) { ! 871: spc->spc_swp->sw_flags &= ~SW_WANTED; ! 872: thread_wakeup((int)spc->spc_swp); ! 873: } ! 874: ! 875: bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS|B_PAGET|B_UAREA|B_DIRTY); ! 876: bp->av_forw = bswlist.av_forw; ! 877: bswlist.av_forw = bp; ! 878: if (bp->b_vp) ! 879: brelvp(bp); ! 880: if (bswlist.b_flags & B_WANTED) { ! 881: bswlist.b_flags &= ~B_WANTED; ! 882: thread_wakeup((int)&bswlist); ! 883: } ! 884: thread_wakeup((int) &vm_pages_needed); ! 885: splx(s); ! 886: } ! 887: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.