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