![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / io|
Return to bio.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 ! root 1: #include "sys/param.h" ! 2: #include "sys/user.h" ! 3: #include "sys/buf.h" ! 4: #include "sys/conf.h" ! 5: #include "sys/proc.h" ! 6: #include "sys/pte.h" ! 7: #include "sys/vm.h" ! 8: ! 9: /* ! 10: * The following several routines allocate and free ! 11: * buffers with various side effects. In general the ! 12: * arguments to an allocate routine are a device and ! 13: * a block number, and the value is a pointer to ! 14: * to the buffer header; the buffer is marked "busy" ! 15: * so that no one else can touch it. If the block was ! 16: * already in core, no I/O need be done; if it is ! 17: * already busy, the process waits until it becomes free. ! 18: * The following routines allocate a buffer: ! 19: * getblk ! 20: * bread ! 21: * breada ! 22: * baddr (if it is incore) ! 23: * Eventually the buffer must be released, possibly with the ! 24: * side effect of writing it out, by using one of ! 25: * bwrite ! 26: * bdwrite ! 27: * bawrite ! 28: * brelse ! 29: */ ! 30: ! 31: struct buf bfreelist[BQUEUES]; ! 32: struct buf bswlist, *bclnlist; ! 33: ! 34: extern int bufhcnt; ! 35: extern struct bufhd bufhash[]; ! 36: #define BUFHASH(dev, dblkno) \ ! 37: ((struct buf *)&bufhash[((int)(dev)+(int)(dblkno)) % bufhcnt]) ! 38: ! 39: /* ! 40: * Initialize hash links for buffers. ! 41: */ ! 42: bhinit() ! 43: { ! 44: register int i; ! 45: register struct bufhd *bp; ! 46: ! 47: for (bp = bufhash, i = 0; i < bufhcnt; i++, bp++) ! 48: bp->b_forw = bp->b_back = (struct buf *)bp; ! 49: } ! 50: ! 51: #define DISKMON 1 ! 52: ! 53: #ifdef DISKMON ! 54: struct { ! 55: long ndwrite; /* bdwrite, not real io */ ! 56: long nread; /* someone's waiting for this one */ ! 57: long nreada; /* readahead from disk */ ! 58: long ncache; /* blocks found in cache, so not read */ ! 59: long nwrite; /* acutally written */ ! 60: long bufcount[64]; ! 61: } io_info; ! 62: #endif ! 63: ! 64: #define CECMON 0 ! 65: ! 66: #define CFS 64 ! 67: ! 68: #ifdef CECMON ! 69: struct { ! 70: long cread; /* someone's waiting for this one */ ! 71: long creada; /* readahead from disk */ ! 72: long ccache; /* blocks found in cache, so not read */ ! 73: long cwrite; /* acutally written */ ! 74: } cec_info[CFS]; ! 75: #endif ! 76: ! 77: ! 78: /* ! 79: * Swap IO headers - ! 80: * They contain the necessary information for the swap I/O. ! 81: * At any given time, a swap header can be in three ! 82: * different lists. When free it is in the free list, ! 83: * when allocated and the I/O queued, it is on the swap ! 84: * device list, and finally, if the operation was a dirty ! 85: * page push, when the I/O completes, it is inserted ! 86: * in a list of cleaned pages to be processed by the pageout daemon. ! 87: */ ! 88: extern struct buf swapbuf[]; ! 89: extern struct swapinfo swapinfo[]; ! 90: ! 91: #ifndef UNFAST ! 92: #define notavail(bp) \ ! 93: { \ ! 94: int s = spl6(); \ ! 95: (bp)->av_back->av_forw = (bp)->av_forw; \ ! 96: (bp)->av_forw->av_back = (bp)->av_back; \ ! 97: (bp)->b_flags |= B_BUSY; \ ! 98: splx(s); \ ! 99: } ! 100: #endif ! 101: ! 102: /* ! 103: * Read in (if necessary) the block and return a buffer pointer. ! 104: */ ! 105: struct buf * ! 106: bread(dev, blkno) ! 107: dev_t dev; ! 108: daddr_t blkno; ! 109: { ! 110: register struct buf *bp; ! 111: #ifdef CECMON ! 112: register int sub; ! 113: #endif ! 114: ! 115: bp = getblk(dev, blkno); ! 116: if (bp->b_flags&B_DONE) { ! 117: #ifdef DISKMON ! 118: io_info.ncache++; ! 119: #endif ! 120: #ifdef CECMON ! 121: sub = minor(dev); ! 122: cec_info[(sub >= CFS)?(sub - CFS) : sub].ccache++; ! 123: #endif ! 124: return(bp); ! 125: } ! 126: bp->b_flags |= B_READ; ! 127: bp->b_bcount = BSIZE(dev); ! 128: (*bdevsw[major(dev)]->d_strategy)(bp); ! 129: #ifdef DISKMON ! 130: io_info.nread++; ! 131: #endif ! 132: #ifdef CECMON ! 133: sub = minor(dev); ! 134: cec_info[(sub >= CFS)?(sub - CFS) : sub].cread++; ! 135: #endif ! 136: u.u_vm.vm_inblk++; /* pay for read */ ! 137: iowait(bp); ! 138: return(bp); ! 139: } ! 140: ! 141: /* ! 142: * Read in the block, like bread, but also start I/O on the ! 143: * read-ahead block (which is not allocated to the caller) ! 144: */ ! 145: struct buf * ! 146: breada(dev, blkno, rablkno) ! 147: dev_t dev; ! 148: daddr_t blkno, rablkno; ! 149: { ! 150: register struct buf *bp, *rabp; ! 151: #ifdef CECMON ! 152: register int sub; ! 153: #endif ! 154: ! 155: bp = NULL; ! 156: if (!incore(dev, blkno)) { ! 157: bp = getblk(dev, blkno); ! 158: if ((bp->b_flags&B_DONE) == 0) { ! 159: bp->b_flags |= B_READ; ! 160: bp->b_bcount = BSIZE(dev); ! 161: (*bdevsw[major(dev)]->d_strategy)(bp); ! 162: #ifdef DISKMON ! 163: io_info.nread++; ! 164: #endif ! 165: #ifdef CECMON ! 166: sub = minor(dev); ! 167: cec_info[(sub >= CFS) ? (sub - CFS) : sub].cread++; ! 168: #endif ! 169: u.u_vm.vm_inblk++; /* pay for read */ ! 170: } ! 171: } ! 172: if (rablkno && !incore(dev, rablkno)) { ! 173: rabp = getblk(dev, rablkno); ! 174: if (rabp->b_flags & B_DONE) { ! 175: brelse(rabp); ! 176: } else { ! 177: rabp->b_flags |= B_READ|B_ASYNC; ! 178: rabp->b_bcount = BSIZE(dev); ! 179: (*bdevsw[major(dev)]->d_strategy)(rabp); ! 180: #ifdef DISKMON ! 181: io_info.nreada++; ! 182: #endif ! 183: #ifdef CECMON ! 184: sub = minor(dev); ! 185: cec_info[(sub >= CFS) ? (sub - CFS) : sub].creada++; ! 186: #endif ! 187: u.u_vm.vm_inblk++; /* pay in advance */ ! 188: } ! 189: } ! 190: if(bp == NULL) ! 191: return(bread(dev, blkno)); ! 192: iowait(bp); ! 193: return(bp); ! 194: } ! 195: ! 196: /* ! 197: * Write the buffer, waiting for completion. ! 198: * Then release the buffer. ! 199: */ ! 200: bwrite(bp) ! 201: register struct buf *bp; ! 202: { ! 203: register flag; ! 204: #ifdef CECMON ! 205: register int sub; ! 206: #endif ! 207: ! 208: flag = bp->b_flags; ! 209: bp->b_flags &= ~(B_READ | B_DONE | B_ERROR | B_DELWRI | B_AGE); ! 210: bp->b_bcount = BSIZE(bp->b_dev); ! 211: #ifdef DISKMON ! 212: io_info.nwrite++; ! 213: #endif ! 214: #ifdef CECMON ! 215: sub = minor(bp->b_dev); ! 216: cec_info[(sub >= CFS) ? (sub - CFS) : sub].cwrite++; ! 217: #endif ! 218: if ((flag&B_DELWRI) == 0) ! 219: u.u_vm.vm_oublk++; /* noone paid yet */ ! 220: (*bdevsw[major(bp->b_dev)]->d_strategy)(bp); ! 221: if ((flag&B_ASYNC) == 0) { ! 222: iowait(bp); ! 223: brelse(bp); ! 224: } else if (flag & B_DELWRI) ! 225: bp->b_flags |= B_AGE; ! 226: else ! 227: geterror(bp); ! 228: } ! 229: ! 230: /* ! 231: * Release the buffer, marking it so that if it is grabbed ! 232: * for another purpose it will be written out before being ! 233: * given up (e.g. when writing a partial block where it is ! 234: * assumed that another write for the same block will soon follow). ! 235: * This can't be done for magtape, since writes must be done ! 236: * in the same order as requested. ! 237: */ ! 238: bdwrite(bp) ! 239: register struct buf *bp; ! 240: { ! 241: ! 242: if ((bp->b_flags&B_DELWRI) == 0) ! 243: u.u_vm.vm_oublk++; /* noone paid yet */ ! 244: if(bdevsw[major(bp->b_dev)]->d_flags & B_TAPE) ! 245: bawrite(bp); ! 246: else { ! 247: #ifdef DISKMON ! 248: io_info.ndwrite++; ! 249: #endif ! 250: bp->b_flags |= B_DELWRI | B_DONE; ! 251: brelse(bp); ! 252: } ! 253: } ! 254: ! 255: /* ! 256: * Release the buffer, start I/O on it, but don't wait for completion. ! 257: */ ! 258: bawrite(bp) ! 259: register struct buf *bp; ! 260: { ! 261: ! 262: bp->b_flags |= B_ASYNC; ! 263: bwrite(bp); ! 264: } ! 265: ! 266: /* ! 267: * release the buffer, with no I/O implied. ! 268: */ ! 269: brelse(bp) ! 270: register struct buf *bp; ! 271: { ! 272: register struct buf *flist; ! 273: register s; ! 274: ! 275: if (bp->b_flags&B_WANTED) ! 276: wakeup((caddr_t)bp); ! 277: if (bfreelist[0].b_flags&B_WANTED) { ! 278: bfreelist[0].b_flags &= ~B_WANTED; ! 279: wakeup((caddr_t)bfreelist); ! 280: } ! 281: if (bp->b_flags&B_ERROR) ! 282: if (bp->b_flags & B_LOCKED) ! 283: bp->b_flags &= ~B_ERROR; /* try again later */ ! 284: else ! 285: bp->b_dev = NODEV; /* no assoc */ ! 286: s = spl6(); ! 287: if (bp->b_flags & (B_ERROR|B_INVAL)) { ! 288: /* block has no info ... put at front of most free list */ ! 289: flist = &bfreelist[BQUEUES-1]; ! 290: flist->av_forw->av_back = bp; ! 291: bp->av_forw = flist->av_forw; ! 292: flist->av_forw = bp; ! 293: bp->av_back = flist; ! 294: } else { ! 295: if (bp->b_flags & B_LOCKED) ! 296: flist = &bfreelist[BQ_LOCKED]; ! 297: else if (bp->b_flags & B_AGE) ! 298: flist = &bfreelist[BQ_AGE]; ! 299: else ! 300: flist = &bfreelist[BQ_LRU]; ! 301: flist->av_back->av_forw = bp; ! 302: bp->av_back = flist->av_back; ! 303: flist->av_back = bp; ! 304: bp->av_forw = flist; ! 305: } ! 306: bp->b_flags &= ~(B_WANTED|B_BUSY|B_ASYNC|B_AGE); ! 307: splx(s); ! 308: } ! 309: ! 310: /* ! 311: * See if the block is associated with some buffer ! 312: * (mainly to avoid getting hung up on a wait in breada) ! 313: */ ! 314: incore(dev, blkno) ! 315: dev_t dev; ! 316: daddr_t blkno; ! 317: { ! 318: register struct buf *bp; ! 319: register struct buf *dp; ! 320: register int dblkno = fsbtodb(dev, blkno); ! 321: ! 322: dp = BUFHASH(dev, dblkno); ! 323: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) ! 324: if (bp->b_blkno == dblkno && bp->b_dev == dev && ! 325: !(bp->b_flags & B_INVAL)) ! 326: return (1); ! 327: return (0); ! 328: } ! 329: ! 330: struct buf * ! 331: baddr(dev, blkno) ! 332: dev_t dev; ! 333: daddr_t blkno; ! 334: { ! 335: ! 336: if (incore(dev, blkno)) ! 337: return (bread(dev, blkno)); ! 338: return (0); ! 339: } ! 340: ! 341: /* ! 342: * Assign a buffer for the given block. If the appropriate ! 343: * block is already associated, return it; otherwise search ! 344: * for the oldest non-busy buffer and reassign it. ! 345: */ ! 346: struct buf * ! 347: getblk(dev, blkno) ! 348: dev_t dev; ! 349: daddr_t blkno; ! 350: { ! 351: register struct buf *bp, *dp, *ep; ! 352: register daddr_t dblkno; ! 353: #ifdef DISKMON ! 354: register int i; ! 355: #endif ! 356: ! 357: if ((unsigned)blkno >= 1 << (sizeof(int)*NBBY-PGSHIFT)) ! 358: blkno = 1 << ((sizeof(int)*NBBY-PGSHIFT) + 1); ! 359: dblkno = fsbtodb(dev, blkno); ! 360: dp = BUFHASH(dev, dblkno); ! 361: loop: ! 362: (void) spl0(); ! 363: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) { ! 364: if (bp->b_blkno != dblkno || bp->b_dev != dev || ! 365: bp->b_flags&B_INVAL) ! 366: continue; ! 367: (void) spl6(); ! 368: if (bp->b_flags&B_BUSY) { ! 369: bp->b_flags |= B_WANTED; ! 370: sleep((caddr_t)bp, PRIBIO+1); ! 371: goto loop; ! 372: } ! 373: (void) spl0(); ! 374: #ifdef DISKMON ! 375: i = 0; ! 376: dp = bp->av_forw; ! 377: while ((dp->b_flags & B_HEAD) == 0) { ! 378: i++; ! 379: dp = dp->av_forw; ! 380: } ! 381: if (i<64) ! 382: io_info.bufcount[i]++; ! 383: #endif ! 384: notavail(bp); ! 385: return(bp); ! 386: } ! 387: if (major(dev) >= nblkdev) ! 388: panic("blkdev"); ! 389: (void) spl6(); ! 390: for (ep = &bfreelist[BQUEUES-1]; ep > bfreelist; ep--) ! 391: if (ep->av_forw != ep) ! 392: break; ! 393: if (ep == bfreelist) { /* no free blocks at all */ ! 394: ep->b_flags |= B_WANTED; ! 395: sleep((caddr_t)ep, PRIBIO+1); ! 396: goto loop; ! 397: } ! 398: (void) spl0(); ! 399: bp = ep->av_forw; ! 400: notavail(bp); ! 401: if (bp->b_flags & B_DELWRI) { ! 402: bp->b_flags |= B_ASYNC; ! 403: bwrite(bp); ! 404: goto loop; ! 405: } ! 406: bp->b_flags = B_BUSY; ! 407: bp->b_back->b_forw = bp->b_forw; ! 408: bp->b_forw->b_back = bp->b_back; ! 409: bp->b_forw = dp->b_forw; ! 410: bp->b_back = dp; ! 411: dp->b_forw->b_back = bp; ! 412: dp->b_forw = bp; ! 413: bp->b_dev = dev; ! 414: bp->b_blkno = dblkno; ! 415: return(bp); ! 416: } ! 417: ! 418: /* ! 419: * get an empty block, ! 420: * not assigned to any particular device ! 421: */ ! 422: struct buf * ! 423: geteblk() ! 424: { ! 425: register struct buf *bp, *dp; ! 426: register int s; ! 427: ! 428: loop: ! 429: s = spl6(); ! 430: for (dp = &bfreelist[BQUEUES-1]; dp > bfreelist; dp--) ! 431: if (dp->av_forw != dp) ! 432: break; ! 433: if (dp == bfreelist) { /* no free blocks */ ! 434: dp->b_flags |= B_WANTED; ! 435: sleep((caddr_t)dp, PRIBIO+1); ! 436: goto loop; ! 437: } ! 438: (void) splx(s); ! 439: bp = dp->av_forw; ! 440: notavail(bp); ! 441: if (bp->b_flags & B_DELWRI) { ! 442: bp->b_flags |= B_ASYNC; ! 443: bwrite(bp); ! 444: goto loop; ! 445: } ! 446: bp->b_flags = B_BUSY|B_INVAL; ! 447: bp->b_back->b_forw = bp->b_forw; ! 448: bp->b_forw->b_back = bp->b_back; ! 449: bp->b_forw = dp->b_forw; ! 450: bp->b_back = dp; ! 451: dp->b_forw->b_back = bp; ! 452: dp->b_forw = bp; ! 453: bp->b_dev = (dev_t)NODEV; ! 454: bp->b_bcount = BUFSIZE; ! 455: return(bp); ! 456: } ! 457: ! 458: /* ! 459: * Wait for I/O completion on the buffer; return errors ! 460: * to the user. ! 461: */ ! 462: iowait(bp) ! 463: register struct buf *bp; ! 464: { ! 465: ! 466: (void) spl6(); ! 467: while ((bp->b_flags&B_DONE)==0) ! 468: sleep((caddr_t)bp, PRIBIO); ! 469: (void) spl0(); ! 470: geterror(bp); ! 471: } ! 472: ! 473: #ifdef UNFAST ! 474: /* ! 475: * Unlink a buffer from the available list and mark it busy. ! 476: * (internal interface) ! 477: */ ! 478: notavail(bp) ! 479: register struct buf *bp; ! 480: { ! 481: register s; ! 482: ! 483: s = spl6(); ! 484: bp->av_back->av_forw = bp->av_forw; ! 485: bp->av_forw->av_back = bp->av_back; ! 486: bp->b_flags |= B_BUSY; ! 487: splx(s); ! 488: } ! 489: #endif ! 490: ! 491: /* ! 492: * Mark I/O complete on a buffer. If the header ! 493: * indicates a dirty page push completion, the ! 494: * header is inserted into the ``cleaned'' list ! 495: * to be processed by the pageout daemon. Otherwise ! 496: * release it if I/O is asynchronous, and wake ! 497: * up anyone waiting for it. ! 498: */ ! 499: iodone(bp) ! 500: register struct buf *bp; ! 501: { ! 502: register int s; ! 503: ! 504: if (bp->b_flags & B_DONE) ! 505: panic("dup iodone"); ! 506: bp->b_flags |= B_DONE; ! 507: if (bp->b_flags & B_DIRTY) { ! 508: if (bp->b_flags & B_ERROR) ! 509: panic("IO err in push"); ! 510: s = spl6(); ! 511: bp->av_forw = bclnlist; ! 512: bp->b_bcount = swapinfo[bp - swapbuf].swsize; ! 513: bp->b_pfcent = swapinfo[bp - swapbuf].swpf; ! 514: cnt.v_pgout++; ! 515: cnt.v_pgpgout += bp->b_bcount / NBPG; ! 516: bclnlist = bp; ! 517: if (bswlist.b_flags & B_WANTED) ! 518: wakeup((caddr_t)&proc[PAGEPID]); ! 519: splx(s); ! 520: return; ! 521: } ! 522: if (bp->b_flags&B_ASYNC) ! 523: brelse(bp); ! 524: else { ! 525: bp->b_flags &= ~B_WANTED; ! 526: wakeup((caddr_t)bp); ! 527: } ! 528: } ! 529: ! 530: /* ! 531: * Zero the core associated with a buffer. ! 532: */ ! 533: clrbuf(bp) ! 534: struct buf *bp; ! 535: { ! 536: register *p; ! 537: register c; ! 538: ! 539: p = bp->b_un.b_words; ! 540: c = BUFSIZE/sizeof(int); ! 541: do ! 542: *p++ = 0; ! 543: while (--c); ! 544: bp->b_resid = 0; ! 545: } ! 546: ! 547: /* ! 548: * swap I/O - ! 549: * ! 550: * If the flag indicates a dirty page push initiated ! 551: * by the pageout daemon, we map the page into the i th ! 552: * virtual page of process 2 (the daemon itself) where i is ! 553: * the index of the swap header that has been allocated. ! 554: * We simply initialize the header and queue the I/O but ! 555: * do not wait for completion. When the I/O completes, ! 556: * iodone() will link the header to a list of cleaned ! 557: * pages to be processed by the pageout daemon. ! 558: */ ! 559: swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent) ! 560: struct proc *p; ! 561: swblk_t dblkno; ! 562: caddr_t addr; ! 563: int flag, nbytes; ! 564: dev_t dev; ! 565: unsigned pfcent; ! 566: { ! 567: register struct buf *bp; ! 568: register int c; ! 569: int p2dp; ! 570: register struct pte *dpte, *vpte; ! 571: ! 572: (void) spl6(); ! 573: while (bswlist.av_forw == NULL) { ! 574: bswlist.b_flags |= B_WANTED; ! 575: sleep((caddr_t)&bswlist, PSWP+1); ! 576: } ! 577: bp = bswlist.av_forw; ! 578: bswlist.av_forw = bp->av_forw; ! 579: (void) spl0(); ! 580: ! 581: bp->b_flags = B_BUSY | B_PHYS | rdflg | flag; ! 582: if ((bp->b_flags & (B_DIRTY|B_PGIN)) == 0) ! 583: if (rdflg == B_READ) ! 584: sum.v_pswpin += btoc(nbytes); ! 585: else ! 586: sum.v_pswpout += btoc(nbytes); ! 587: bp->b_proc = p; ! 588: if (flag & B_DIRTY) { ! 589: p2dp = ((bp - swapbuf) * CLSIZE) * KLMAX; ! 590: dpte = dptopte(&proc[PAGEPID], p2dp); ! 591: vpte = vtopte(p, btop(addr)); ! 592: for (c = 0; c < nbytes; c += NBPG) { ! 593: if (vpte->pg_pfnum == 0 || vpte->pg_fod) ! 594: panic("swap bad pte"); ! 595: *dpte++ = *vpte++; ! 596: } ! 597: bp->b_un.b_addr = (caddr_t)ctob(p2dp); ! 598: } else ! 599: bp->b_un.b_addr = addr; ! 600: while (nbytes > 0) { ! 601: c = imin(ctob(120), nbytes); ! 602: bp->b_bcount = c; ! 603: bp->b_blkno = dblkno; ! 604: bp->b_dev = dev; ! 605: if (flag & B_DIRTY) { ! 606: swapinfo[bp - swapbuf].swpf = pfcent; ! 607: swapinfo[bp - swapbuf].swsize = nbytes; ! 608: } ! 609: if (bdevsw[major(dev)] == NULL) ! 610: panic("swap"); ! 611: (*bdevsw[major(dev)]->d_strategy)(bp); ! 612: if (flag & B_DIRTY) { ! 613: if (c < nbytes) ! 614: panic("big push"); ! 615: return; ! 616: } ! 617: (void) spl6(); ! 618: while((bp->b_flags&B_DONE)==0) ! 619: sleep((caddr_t)bp, PSWP); ! 620: (void) spl0(); ! 621: bp->b_un.b_addr += c; ! 622: bp->b_flags &= ~B_DONE; ! 623: if (bp->b_flags & B_ERROR) { ! 624: if ((flag & (B_UAREA|B_PAGET)) || rdflg == B_WRITE) ! 625: panic("hard IO err in swap"); ! 626: swkill(p, (char *)0); ! 627: } ! 628: nbytes -= c; ! 629: dblkno += btoc(c); ! 630: } ! 631: (void) spl6(); ! 632: bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS|B_PAGET|B_UAREA|B_DIRTY); ! 633: bp->av_forw = bswlist.av_forw; ! 634: bswlist.av_forw = bp; ! 635: if (bswlist.b_flags & B_WANTED) { ! 636: bswlist.b_flags &= ~B_WANTED; ! 637: wakeup((caddr_t)&bswlist); ! 638: wakeup((caddr_t)&proc[PAGEPID]); ! 639: } ! 640: (void) spl0(); ! 641: } ! 642: ! 643: /* ! 644: * Initialize linked list of free swap ! 645: * headers. These do not actually point ! 646: * to buffers, but rather to pages that ! 647: * are being swapped in and out. ! 648: */ ! 649: bswinit() ! 650: { ! 651: extern int swbufcnt; ! 652: register int i; ! 653: register struct buf *sp = swapbuf; ! 654: ! 655: bswlist.av_forw = sp; ! 656: for (i=0; i<swbufcnt-1; i++, sp++) ! 657: sp->av_forw = sp+1; ! 658: sp->av_forw = NULL; ! 659: } ! 660: ! 661: /* ! 662: * If rout == 0 then killed on swap error, else ! 663: * rout is the name of the routine where we ran out of ! 664: * swap space. ! 665: */ ! 666: swkill(p, rout) ! 667: struct proc *p; ! 668: char *rout; ! 669: { ! 670: ! 671: printf("pid %d: ", p->p_pid); ! 672: if (rout) ! 673: printf("killed due to no swap space\n"); ! 674: else ! 675: printf("killed on swap error\n"); ! 676: /* ! 677: * To be sure no looping (e.g. in vmsched trying to ! 678: * swap out) mark process locked in core (as though ! 679: * done by user) after killing it so noone will try ! 680: * to swap it out. ! 681: */ ! 682: psignal(p, SIGKILL); ! 683: p->p_flag |= SULOCK; ! 684: } ! 685: ! 686: /* ! 687: * make sure all write-behind blocks ! 688: * on dev (or NODEV for all) ! 689: * are flushed out. ! 690: * (from umount and update) ! 691: */ ! 692: bflush(dev) ! 693: dev_t dev; ! 694: { ! 695: register struct buf *bp; ! 696: register struct buf *flist; ! 697: register s; ! 698: ! 699: loop: ! 700: s = spl6(); ! 701: for (flist = bfreelist; flist < &bfreelist[BQUEUES]; flist++) ! 702: for (bp = flist->av_forw; bp != flist; bp = bp->av_forw) { ! 703: if (bp->b_flags&B_DELWRI && (dev == NODEV||dev==bp->b_dev)) { ! 704: bp->b_flags |= B_ASYNC; ! 705: notavail(bp); ! 706: splx(s); ! 707: bwrite(bp); ! 708: goto loop; ! 709: } ! 710: } ! 711: splx(s); ! 712: } ! 713: ! 714: /* ! 715: * Raw I/O. The arguments are ! 716: * The strategy routine for the device ! 717: * A buffer, which will always be a special buffer ! 718: * header owned exclusively by the device for this purpose ! 719: * The device number ! 720: * Read/write flag ! 721: * Essentially all the work is computing physical addresses and ! 722: * validating them. ! 723: * If the user has the proper access privilidges, the process is ! 724: * marked 'delayed unlock' and the pages involved in the I/O are ! 725: * faulted and locked. After the completion of the I/O, the above pages ! 726: * are unlocked. ! 727: */ ! 728: ! 729: physio(strat, bp, dev, rw, mincnt) ! 730: int (*strat)(); ! 731: register struct buf *bp; ! 732: unsigned (*mincnt)(); ! 733: { ! 734: register int c; ! 735: char *a; ! 736: register int s; ! 737: ! 738: if (useracc(u.u_base,u.u_count,rw==B_READ?B_WRITE:B_READ) == NULL) { ! 739: u.u_error = EFAULT; ! 740: return; ! 741: } ! 742: s = spl6(); ! 743: while (bp->b_flags&B_BUSY) { ! 744: bp->b_flags |= B_WANTED; ! 745: /*sleep((caddr_t)bp, PRIBIO+1);*/ ! 746: switch(tsleep((caddr_t)bp, PRIBIO+1, 20)) { ! 747: case TS_OK: ! 748: continue; ! 749: case TS_SIG: /* can't happen at PRIBIO+1*/ ! 750: continue; ! 751: case TS_TIME: ! 752: u.u_error = EIO; ! 753: (void) splx(s); ! 754: return; ! 755: } ! 756: } ! 757: (void) splx(s); ! 758: bp->b_error = 0; ! 759: bp->b_proc = u.u_procp; ! 760: bp->b_un.b_addr = u.u_base; ! 761: while (u.u_count != 0) { ! 762: bp->b_flags = B_BUSY | B_PHYS | rw; ! 763: bp->b_dev = dev; ! 764: bp->b_blkno = Lshift(u.u_offset, PGSHIFT); ! 765: bp->b_bcount = u.u_count; ! 766: (*mincnt)(bp); ! 767: c = bp->b_bcount; ! 768: u.u_procp->p_flag |= SPHYSIO; ! 769: vslock(a = bp->b_un.b_addr, c); ! 770: (*strat)(bp); ! 771: s = spl6(); ! 772: while ((bp->b_flags&B_DONE) == 0) ! 773: sleep((caddr_t)bp, PRIBIO); ! 774: vsunlock(a, c, rw); ! 775: u.u_procp->p_flag &= ~SPHYSIO; ! 776: if (bp->b_flags&B_WANTED) ! 777: wakeup((caddr_t)bp); ! 778: (void) splx(s); ! 779: bp->b_un.b_addr += c; ! 780: u.u_count -= c; ! 781: u.u_offset = Lladd(u.u_offset, c); ! 782: if (bp->b_flags&B_ERROR) ! 783: break; ! 784: } ! 785: bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS); ! 786: u.u_count = bp->b_resid; ! 787: geterror(bp); ! 788: } ! 789: ! 790: /*ARGSUSED*/ ! 791: unsigned ! 792: minphys(bp) ! 793: struct buf *bp; ! 794: { ! 795: ! 796: if (bp->b_bcount > (64*1024)-512) ! 797: bp->b_bcount = (64*1024)-512; ! 798: } ! 799: ! 800: /* ! 801: * Pick up the device's error number and pass it to the user; ! 802: * if there is an error but the number is 0 set a generalized ! 803: * code. Actually the latter is always true because devices ! 804: * don't yet return specific errors. ! 805: */ ! 806: geterror(bp) ! 807: register struct buf *bp; ! 808: { ! 809: ! 810: if (bp->b_flags&B_ERROR) ! 811: if ((u.u_error = bp->b_error)==0) ! 812: u.u_error = EIO; ! 813: } ! 814: ! 815: /* ! 816: * Invalidate in core blocks belonging to closed or umounted filesystem ! 817: * ! 818: * This is not nicely done at all - the buffer ought to be removed from the ! 819: * hash chains & have its dev/blkno fields clobbered, but unfortunately we ! 820: * can't do that here, as it is quite possible that the block is still ! 821: * being used for i/o. Eventually, all disc drivers should be forced to ! 822: * have a close routine, which ought ensure that the queue is empty, then ! 823: * properly flush the queues. Until that happy day, this suffices for ! 824: * correctness. ... kre ! 825: */ ! 826: binval(dev) ! 827: dev_t dev; ! 828: { ! 829: register struct buf *bp; ! 830: register struct bufhd *hp; ! 831: #define dp ((struct buf *)hp) ! 832: ! 833: for (hp = &bufhash[bufhcnt-1]; hp >= bufhash; hp--) ! 834: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) ! 835: if (bp->b_dev == dev) ! 836: bp->b_flags |= B_INVAL; ! 837: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.