![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfs_bio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to vfs_bio.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution is only permitted until one year after the first shipment ! 6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 7: * binary forms are permitted provided that: (1) source distributions retain ! 8: * this entire copyright notice and comment, and (2) distributions including ! 9: * binaries display the following acknowledgement: This product includes ! 10: * software developed by the University of California, Berkeley and its ! 11: * contributors'' in the documentation or other materials provided with the ! 12: * distribution and in all advertising materials mentioning features or use ! 13: * of this software. Neither the name of the University nor the names of ! 14: * its contributors may be used to endorse or promote products derived from ! 15: * this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)vfs_bio.c 7.30 (Berkeley) 6/28/90 ! 21: */ ! 22: ! 23: #include "param.h" ! 24: #include "user.h" ! 25: #include "buf.h" ! 26: #include "vnode.h" ! 27: #include "specdev.h" ! 28: #include "mount.h" ! 29: #include "trace.h" ! 30: #include "ucred.h" ! 31: ! 32: /* ! 33: * Read in (if necessary) the block and return a buffer pointer. ! 34: */ ! 35: bread(vp, blkno, size, cred, bpp) ! 36: struct vnode *vp; ! 37: daddr_t blkno; ! 38: int size; ! 39: struct ucred *cred; ! 40: struct buf **bpp; ! 41: { ! 42: register struct buf *bp; ! 43: ! 44: if (size == 0) ! 45: panic("bread: size 0"); ! 46: *bpp = bp = getblk(vp, blkno, size); ! 47: if (bp->b_flags&(B_DONE|B_DELWRI)) { ! 48: trace(TR_BREADHIT, pack(vp, size), blkno); ! 49: return (0); ! 50: } ! 51: bp->b_flags |= B_READ; ! 52: if (bp->b_bcount > bp->b_bufsize) ! 53: panic("bread"); ! 54: if (bp->b_rcred == NOCRED && cred != NOCRED) { ! 55: crhold(cred); ! 56: bp->b_rcred = cred; ! 57: } ! 58: VOP_STRATEGY(bp); ! 59: trace(TR_BREADMISS, pack(vp, size), blkno); ! 60: u.u_ru.ru_inblock++; /* pay for read */ ! 61: return (biowait(bp)); ! 62: } ! 63: ! 64: /* ! 65: * Read in the block, like bread, but also start I/O on the ! 66: * read-ahead block (which is not allocated to the caller) ! 67: */ ! 68: breada(vp, blkno, size, rablkno, rabsize, cred, bpp) ! 69: struct vnode *vp; ! 70: daddr_t blkno; int size; ! 71: daddr_t rablkno; int rabsize; ! 72: struct ucred *cred; ! 73: struct buf **bpp; ! 74: { ! 75: register struct buf *bp, *rabp; ! 76: ! 77: bp = NULL; ! 78: /* ! 79: * If the block isn't in core, then allocate ! 80: * a buffer and initiate i/o (getblk checks ! 81: * for a cache hit). ! 82: */ ! 83: if (!incore(vp, blkno)) { ! 84: *bpp = bp = getblk(vp, blkno, size); ! 85: if ((bp->b_flags&(B_DONE|B_DELWRI)) == 0) { ! 86: bp->b_flags |= B_READ; ! 87: if (bp->b_bcount > bp->b_bufsize) ! 88: panic("breada"); ! 89: if (bp->b_rcred == NOCRED && cred != NOCRED) { ! 90: crhold(cred); ! 91: bp->b_rcred = cred; ! 92: } ! 93: VOP_STRATEGY(bp); ! 94: trace(TR_BREADMISS, pack(vp, size), blkno); ! 95: u.u_ru.ru_inblock++; /* pay for read */ ! 96: } else ! 97: trace(TR_BREADHIT, pack(vp, size), blkno); ! 98: } ! 99: ! 100: /* ! 101: * If there's a read-ahead block, start i/o ! 102: * on it also (as above). ! 103: */ ! 104: if (!incore(vp, rablkno)) { ! 105: rabp = getblk(vp, rablkno, rabsize); ! 106: if (rabp->b_flags & (B_DONE|B_DELWRI)) { ! 107: brelse(rabp); ! 108: trace(TR_BREADHITRA, pack(vp, rabsize), rablkno); ! 109: } else { ! 110: rabp->b_flags |= B_READ|B_ASYNC; ! 111: if (rabp->b_bcount > rabp->b_bufsize) ! 112: panic("breadrabp"); ! 113: if (rabp->b_rcred == NOCRED && cred != NOCRED) { ! 114: crhold(cred); ! 115: rabp->b_rcred = cred; ! 116: } ! 117: VOP_STRATEGY(rabp); ! 118: trace(TR_BREADMISSRA, pack(vp, rabsize), rablkno); ! 119: u.u_ru.ru_inblock++; /* pay in advance */ ! 120: } ! 121: } ! 122: ! 123: /* ! 124: * If block was in core, let bread get it. ! 125: * If block wasn't in core, then the read was started ! 126: * above, and just wait for it. ! 127: */ ! 128: if (bp == NULL) ! 129: return (bread(vp, blkno, size, cred, bpp)); ! 130: return (biowait(bp)); ! 131: } ! 132: ! 133: /* ! 134: * Write the buffer, waiting for completion. ! 135: * Then release the buffer. ! 136: */ ! 137: bwrite(bp) ! 138: register struct buf *bp; ! 139: { ! 140: register int flag; ! 141: int s, error; ! 142: ! 143: flag = bp->b_flags; ! 144: bp->b_flags &= ~(B_READ | B_DONE | B_ERROR | B_DELWRI); ! 145: if ((flag&B_DELWRI) == 0) ! 146: u.u_ru.ru_oublock++; /* noone paid yet */ ! 147: else ! 148: reassignbuf(bp, bp->b_vp); ! 149: trace(TR_BWRITE, pack(bp->b_vp, bp->b_bcount), bp->b_lblkno); ! 150: if (bp->b_bcount > bp->b_bufsize) ! 151: panic("bwrite"); ! 152: s = splbio(); ! 153: bp->b_vp->v_numoutput++; ! 154: splx(s); ! 155: VOP_STRATEGY(bp); ! 156: ! 157: /* ! 158: * If the write was synchronous, then await i/o completion. ! 159: * If the write was "delayed", then we put the buffer on ! 160: * the q of blocks awaiting i/o completion status. ! 161: */ ! 162: if ((flag&B_ASYNC) == 0) { ! 163: error = biowait(bp); ! 164: brelse(bp); ! 165: } else if (flag & B_DELWRI) { ! 166: bp->b_flags |= B_AGE; ! 167: error = 0; ! 168: } ! 169: return (error); ! 170: } ! 171: ! 172: /* ! 173: * Release the buffer, marking it so that if it is grabbed ! 174: * for another purpose it will be written out before being ! 175: * given up (e.g. when writing a partial block where it is ! 176: * assumed that another write for the same block will soon follow). ! 177: * This can't be done for magtape, since writes must be done ! 178: * in the same order as requested. ! 179: */ ! 180: bdwrite(bp) ! 181: register struct buf *bp; ! 182: { ! 183: ! 184: if ((bp->b_flags & B_DELWRI) == 0) { ! 185: bp->b_flags |= B_DELWRI; ! 186: reassignbuf(bp, bp->b_vp); ! 187: u.u_ru.ru_oublock++; /* noone paid yet */ ! 188: } ! 189: /* ! 190: * If this is a tape drive, the write must be initiated. ! 191: */ ! 192: if (VOP_IOCTL(bp->b_vp, 0, B_TAPE, 0, NOCRED) == 0) { ! 193: bawrite(bp); ! 194: } else { ! 195: bp->b_flags |= B_DELWRI | B_DONE; ! 196: brelse(bp); ! 197: } ! 198: } ! 199: ! 200: /* ! 201: * Release the buffer, start I/O on it, but don't wait for completion. ! 202: */ ! 203: bawrite(bp) ! 204: register struct buf *bp; ! 205: { ! 206: ! 207: bp->b_flags |= B_ASYNC; ! 208: (void) bwrite(bp); ! 209: } ! 210: ! 211: /* ! 212: * Release the buffer, with no I/O implied. ! 213: */ ! 214: brelse(bp) ! 215: register struct buf *bp; ! 216: { ! 217: register struct buf *flist; ! 218: register s; ! 219: ! 220: trace(TR_BRELSE, pack(bp->b_vp, bp->b_bufsize), bp->b_lblkno); ! 221: /* ! 222: * If a process is waiting for the buffer, or ! 223: * is waiting for a free buffer, awaken it. ! 224: */ ! 225: if (bp->b_flags&B_WANTED) ! 226: wakeup((caddr_t)bp); ! 227: if (bfreelist[0].b_flags&B_WANTED) { ! 228: bfreelist[0].b_flags &= ~B_WANTED; ! 229: wakeup((caddr_t)bfreelist); ! 230: } ! 231: /* ! 232: * Retry I/O for locked buffers rather than invalidating them. ! 233: */ ! 234: if ((bp->b_flags & B_ERROR) && (bp->b_flags & B_LOCKED)) ! 235: bp->b_flags &= ~B_ERROR; ! 236: ! 237: /* ! 238: * Disassociate buffers that are no longer valid. ! 239: */ ! 240: if (bp->b_flags & (B_NOCACHE|B_ERROR)) ! 241: bp->b_flags |= B_INVAL; ! 242: if ((bp->b_bufsize <= 0) || (bp->b_flags & (B_ERROR|B_INVAL))) { ! 243: if (bp->b_vp) ! 244: brelvp(bp); ! 245: bp->b_flags &= ~B_DELWRI; ! 246: } ! 247: /* ! 248: * Stick the buffer back on a free list. ! 249: */ ! 250: s = splbio(); ! 251: if (bp->b_bufsize <= 0) { ! 252: /* block has no buffer ... put at front of unused buffer list */ ! 253: flist = &bfreelist[BQ_EMPTY]; ! 254: binsheadfree(bp, flist); ! 255: } else if (bp->b_flags & (B_ERROR|B_INVAL)) { ! 256: /* block has no info ... put at front of most free list */ ! 257: flist = &bfreelist[BQ_AGE]; ! 258: binsheadfree(bp, flist); ! 259: } else { ! 260: if (bp->b_flags & B_LOCKED) ! 261: flist = &bfreelist[BQ_LOCKED]; ! 262: else if (bp->b_flags & B_AGE) ! 263: flist = &bfreelist[BQ_AGE]; ! 264: else ! 265: flist = &bfreelist[BQ_LRU]; ! 266: binstailfree(bp, flist); ! 267: } ! 268: bp->b_flags &= ~(B_WANTED|B_BUSY|B_ASYNC|B_AGE|B_NOCACHE); ! 269: splx(s); ! 270: } ! 271: ! 272: /* ! 273: * See if the block is associated with some buffer ! 274: * (mainly to avoid getting hung up on a wait in breada) ! 275: */ ! 276: incore(vp, blkno) ! 277: struct vnode *vp; ! 278: daddr_t blkno; ! 279: { ! 280: register struct buf *bp; ! 281: register struct buf *dp; ! 282: ! 283: dp = BUFHASH(vp, blkno); ! 284: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) ! 285: if (bp->b_lblkno == blkno && bp->b_vp == vp && ! 286: (bp->b_flags & B_INVAL) == 0) ! 287: return (1); ! 288: return (0); ! 289: } ! 290: ! 291: /* ! 292: * Return a block if it is in memory. ! 293: */ ! 294: baddr(vp, blkno, size, cred, bpp) ! 295: struct vnode *vp; ! 296: daddr_t blkno; ! 297: int size; ! 298: struct ucred *cred; ! 299: struct buf **bpp; ! 300: { ! 301: ! 302: if (incore(vp, blkno)) ! 303: return (bread(vp, blkno, size, cred, bpp)); ! 304: *bpp = 0; ! 305: return (0); ! 306: } ! 307: ! 308: /* ! 309: * Assign a buffer for the given block. If the appropriate ! 310: * block is already associated, return it; otherwise search ! 311: * for the oldest non-busy buffer and reassign it. ! 312: * ! 313: * We use splx here because this routine may be called ! 314: * on the interrupt stack during a dump, and we don't ! 315: * want to lower the ipl back to 0. ! 316: */ ! 317: struct buf * ! 318: getblk(vp, blkno, size) ! 319: register struct vnode *vp; ! 320: daddr_t blkno; ! 321: int size; ! 322: { ! 323: register struct buf *bp, *dp; ! 324: int s; ! 325: ! 326: if (size > MAXBSIZE) ! 327: panic("getblk: size too big"); ! 328: /* ! 329: * Search the cache for the block. If we hit, but ! 330: * the buffer is in use for i/o, then we wait until ! 331: * the i/o has completed. ! 332: */ ! 333: dp = BUFHASH(vp, blkno); ! 334: loop: ! 335: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) { ! 336: if (bp->b_lblkno != blkno || bp->b_vp != vp || ! 337: bp->b_flags&B_INVAL) ! 338: continue; ! 339: s = splbio(); ! 340: if (bp->b_flags&B_BUSY) { ! 341: bp->b_flags |= B_WANTED; ! 342: sleep((caddr_t)bp, PRIBIO+1); ! 343: splx(s); ! 344: goto loop; ! 345: } ! 346: bremfree(bp); ! 347: bp->b_flags |= B_BUSY; ! 348: splx(s); ! 349: if (bp->b_bcount != size) { ! 350: printf("getblk: stray size"); ! 351: bp->b_flags |= B_INVAL; ! 352: bwrite(bp); ! 353: goto loop; ! 354: } ! 355: bp->b_flags |= B_CACHE; ! 356: return (bp); ! 357: } ! 358: bp = getnewbuf(); ! 359: bfree(bp); ! 360: bremhash(bp); ! 361: bgetvp(vp, bp); ! 362: bp->b_lblkno = blkno; ! 363: bp->b_blkno = blkno; ! 364: bp->b_error = 0; ! 365: bp->b_resid = 0; ! 366: binshash(bp, dp); ! 367: brealloc(bp, size); ! 368: return (bp); ! 369: } ! 370: ! 371: /* ! 372: * get an empty block, ! 373: * not assigned to any particular device ! 374: */ ! 375: struct buf * ! 376: geteblk(size) ! 377: int size; ! 378: { ! 379: register struct buf *bp, *flist; ! 380: ! 381: if (size > MAXBSIZE) ! 382: panic("geteblk: size too big"); ! 383: bp = getnewbuf(); ! 384: bp->b_flags |= B_INVAL; ! 385: bfree(bp); ! 386: bremhash(bp); ! 387: flist = &bfreelist[BQ_AGE]; ! 388: bp->b_error = 0; ! 389: bp->b_resid = 0; ! 390: binshash(bp, flist); ! 391: brealloc(bp, size); ! 392: return (bp); ! 393: } ! 394: ! 395: /* ! 396: * Allocate space associated with a buffer. ! 397: */ ! 398: brealloc(bp, size) ! 399: register struct buf *bp; ! 400: int size; ! 401: { ! 402: daddr_t start, last; ! 403: register struct buf *ep; ! 404: struct buf *dp; ! 405: int s; ! 406: ! 407: if (size == bp->b_bcount) ! 408: return; ! 409: allocbuf(bp, size); ! 410: } ! 411: ! 412: /* ! 413: * Find a buffer which is available for use. ! 414: * Select something from a free list. ! 415: * Preference is to AGE list, then LRU list. ! 416: */ ! 417: struct buf * ! 418: getnewbuf() ! 419: { ! 420: register struct buf *bp, *dp; ! 421: register struct ucred *cred; ! 422: int s; ! 423: ! 424: loop: ! 425: s = splbio(); ! 426: for (dp = &bfreelist[BQ_AGE]; dp > bfreelist; dp--) ! 427: if (dp->av_forw != dp) ! 428: break; ! 429: if (dp == bfreelist) { /* no free blocks */ ! 430: dp->b_flags |= B_WANTED; ! 431: sleep((caddr_t)dp, PRIBIO+1); ! 432: splx(s); ! 433: goto loop; ! 434: } ! 435: bp = dp->av_forw; ! 436: bremfree(bp); ! 437: bp->b_flags |= B_BUSY; ! 438: splx(s); ! 439: if (bp->b_flags & B_DELWRI) { ! 440: (void) bawrite(bp); ! 441: goto loop; ! 442: } ! 443: trace(TR_BRELSE, pack(bp->b_vp, bp->b_bufsize), bp->b_lblkno); ! 444: if (bp->b_vp) ! 445: brelvp(bp); ! 446: if (bp->b_rcred != NOCRED) { ! 447: cred = bp->b_rcred; ! 448: bp->b_rcred = NOCRED; ! 449: crfree(cred); ! 450: } ! 451: if (bp->b_wcred != NOCRED) { ! 452: cred = bp->b_wcred; ! 453: bp->b_wcred = NOCRED; ! 454: crfree(cred); ! 455: } ! 456: bp->b_flags = B_BUSY; ! 457: return (bp); ! 458: } ! 459: ! 460: /* ! 461: * Wait for I/O completion on the buffer; return errors ! 462: * to the user. ! 463: */ ! 464: biowait(bp) ! 465: register struct buf *bp; ! 466: { ! 467: int s; ! 468: ! 469: s = splbio(); ! 470: while ((bp->b_flags & B_DONE) == 0) ! 471: sleep((caddr_t)bp, PRIBIO); ! 472: splx(s); ! 473: /* ! 474: * Pick up the device's error number and pass it to the user; ! 475: * if there is an error but the number is 0 set a generalized code. ! 476: */ ! 477: if ((bp->b_flags & B_ERROR) == 0) ! 478: return (0); ! 479: if (bp->b_error) ! 480: return (bp->b_error); ! 481: return (EIO); ! 482: } ! 483: ! 484: /* ! 485: * Mark I/O complete on a buffer. ! 486: * If someone should be called, e.g. the pageout ! 487: * daemon, do so. Otherwise, wake up anyone ! 488: * waiting for it. ! 489: */ ! 490: biodone(bp) ! 491: register struct buf *bp; ! 492: { ! 493: register struct vnode *vp; ! 494: ! 495: if (bp->b_flags & B_DONE) ! 496: panic("dup biodone"); ! 497: bp->b_flags |= B_DONE; ! 498: if ((bp->b_flags & B_READ) == 0) { ! 499: bp->b_dirtyoff = bp->b_dirtyend = 0; ! 500: if (vp = bp->b_vp) { ! 501: vp->v_numoutput--; ! 502: if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) { ! 503: if (vp->v_numoutput < 0) ! 504: panic("biodone: neg numoutput"); ! 505: vp->v_flag &= ~VBWAIT; ! 506: wakeup((caddr_t)&vp->v_numoutput); ! 507: } ! 508: } ! 509: } ! 510: if (bp->b_flags & B_CALL) { ! 511: bp->b_flags &= ~B_CALL; ! 512: (*bp->b_iodone)(bp); ! 513: return; ! 514: } ! 515: if (bp->b_flags&B_ASYNC) ! 516: brelse(bp); ! 517: else { ! 518: bp->b_flags &= ~B_WANTED; ! 519: wakeup((caddr_t)bp); ! 520: } ! 521: } ! 522: ! 523: /* ! 524: * Make sure all write-behind blocks associated ! 525: * with mount point are flushed out (from sync). ! 526: */ ! 527: mntflushbuf(mountp, flags) ! 528: struct mount *mountp; ! 529: int flags; ! 530: { ! 531: register struct vnode *vp; ! 532: ! 533: if ((mountp->mnt_flag & MNT_MPBUSY) == 0) ! 534: panic("mntflushbuf: not busy"); ! 535: loop: ! 536: for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) { ! 537: if (vget(vp)) ! 538: goto loop; ! 539: vflushbuf(vp, flags); ! 540: vput(vp); ! 541: if (vp->v_mount != mountp) ! 542: goto loop; ! 543: } ! 544: } ! 545: ! 546: /* ! 547: * Flush all dirty buffers associated with a vnode. ! 548: */ ! 549: vflushbuf(vp, flags) ! 550: register struct vnode *vp; ! 551: int flags; ! 552: { ! 553: register struct buf *bp; ! 554: struct buf *nbp; ! 555: int s; ! 556: ! 557: loop: ! 558: s = splbio(); ! 559: for (bp = vp->v_dirtyblkhd; bp; bp = nbp) { ! 560: nbp = bp->b_blockf; ! 561: if ((bp->b_flags & B_BUSY)) ! 562: continue; ! 563: if ((bp->b_flags & B_DELWRI) == 0) ! 564: panic("vflushbuf: not dirty"); ! 565: bremfree(bp); ! 566: bp->b_flags |= B_BUSY; ! 567: splx(s); ! 568: /* ! 569: * Wait for I/O associated with indirect blocks to complete, ! 570: * since there is no way to quickly wait for them below. ! 571: * NB - This is really specific to ufs, but is done here ! 572: * as it is easier and quicker. ! 573: */ ! 574: if (bp->b_vp == vp || (flags & B_SYNC) == 0) { ! 575: (void) bawrite(bp); ! 576: s = splbio(); ! 577: } else { ! 578: (void) bwrite(bp); ! 579: goto loop; ! 580: } ! 581: } ! 582: splx(s); ! 583: if ((flags & B_SYNC) == 0) ! 584: return; ! 585: s = splbio(); ! 586: while (vp->v_numoutput) { ! 587: vp->v_flag |= VBWAIT; ! 588: sleep((caddr_t)&vp->v_numoutput, PRIBIO+1); ! 589: } ! 590: splx(s); ! 591: if (vp->v_dirtyblkhd) { ! 592: vprint("vflushbuf: dirty", vp); ! 593: goto loop; ! 594: } ! 595: } ! 596: ! 597: /* ! 598: * Invalidate in core blocks belonging to closed or umounted filesystem ! 599: * ! 600: * Go through the list of vnodes associated with the file system; ! 601: * for each vnode invalidate any buffers that it holds. Normally ! 602: * this routine is preceeded by a bflush call, so that on a quiescent ! 603: * filesystem there will be no dirty buffers when we are done. Binval ! 604: * returns the count of dirty buffers when it is finished. ! 605: */ ! 606: mntinvalbuf(mountp) ! 607: struct mount *mountp; ! 608: { ! 609: register struct vnode *vp; ! 610: int dirty = 0; ! 611: ! 612: if ((mountp->mnt_flag & MNT_MPBUSY) == 0) ! 613: panic("mntinvalbuf: not busy"); ! 614: loop: ! 615: for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) { ! 616: if (vget(vp)) ! 617: goto loop; ! 618: dirty += vinvalbuf(vp, 1); ! 619: vput(vp); ! 620: if (vp->v_mount != mountp) ! 621: goto loop; ! 622: } ! 623: return (dirty); ! 624: } ! 625: ! 626: /* ! 627: * Flush out and invalidate all buffers associated with a vnode. ! 628: * Called with the underlying object locked. ! 629: */ ! 630: vinvalbuf(vp, save) ! 631: register struct vnode *vp; ! 632: int save; ! 633: { ! 634: register struct buf *bp; ! 635: struct buf *nbp, *blist; ! 636: int s, dirty = 0; ! 637: ! 638: for (;;) { ! 639: if (blist = vp->v_dirtyblkhd) ! 640: /* void */; ! 641: else if (blist = vp->v_cleanblkhd) ! 642: /* void */; ! 643: else ! 644: break; ! 645: for (bp = blist; bp; bp = nbp) { ! 646: nbp = bp->b_blockf; ! 647: s = splbio(); ! 648: if (bp->b_flags & B_BUSY) { ! 649: bp->b_flags |= B_WANTED; ! 650: sleep((caddr_t)bp, PRIBIO+1); ! 651: splx(s); ! 652: break; ! 653: } ! 654: bremfree(bp); ! 655: bp->b_flags |= B_BUSY; ! 656: splx(s); ! 657: if (save && (bp->b_flags & B_DELWRI)) { ! 658: dirty++; ! 659: (void) bwrite(bp); ! 660: break; ! 661: } ! 662: if (bp->b_vp != vp) ! 663: reassignbuf(bp, bp->b_vp); ! 664: else ! 665: bp->b_flags |= B_INVAL; ! 666: brelse(bp); ! 667: } ! 668: } ! 669: if (vp->v_dirtyblkhd || vp->v_cleanblkhd) ! 670: panic("vinvalbuf: flush failed"); ! 671: return (dirty); ! 672: } ! 673: ! 674: /* ! 675: * Associate a buffer with a vnode. ! 676: */ ! 677: bgetvp(vp, bp) ! 678: register struct vnode *vp; ! 679: register struct buf *bp; ! 680: { ! 681: ! 682: if (bp->b_vp) ! 683: panic("bgetvp: not free"); ! 684: VHOLD(vp); ! 685: bp->b_vp = vp; ! 686: if (vp->v_type == VBLK || vp->v_type == VCHR) ! 687: bp->b_dev = vp->v_rdev; ! 688: else ! 689: bp->b_dev = NODEV; ! 690: /* ! 691: * Insert onto list for new vnode. ! 692: */ ! 693: if (vp->v_cleanblkhd) { ! 694: bp->b_blockf = vp->v_cleanblkhd; ! 695: bp->b_blockb = &vp->v_cleanblkhd; ! 696: vp->v_cleanblkhd->b_blockb = &bp->b_blockf; ! 697: vp->v_cleanblkhd = bp; ! 698: } else { ! 699: vp->v_cleanblkhd = bp; ! 700: bp->b_blockb = &vp->v_cleanblkhd; ! 701: bp->b_blockf = NULL; ! 702: } ! 703: } ! 704: ! 705: /* ! 706: * Disassociate a buffer from a vnode. ! 707: */ ! 708: brelvp(bp) ! 709: register struct buf *bp; ! 710: { ! 711: struct buf *bq; ! 712: struct vnode *vp; ! 713: ! 714: if (bp->b_vp == (struct vnode *) 0) ! 715: panic("brelvp: NULL"); ! 716: /* ! 717: * Delete from old vnode list, if on one. ! 718: */ ! 719: if (bp->b_blockb) { ! 720: if (bq = bp->b_blockf) ! 721: bq->b_blockb = bp->b_blockb; ! 722: *bp->b_blockb = bq; ! 723: bp->b_blockf = NULL; ! 724: bp->b_blockb = NULL; ! 725: } ! 726: vp = bp->b_vp; ! 727: bp->b_vp = (struct vnode *) 0; ! 728: HOLDRELE(vp); ! 729: } ! 730: ! 731: /* ! 732: * Reassign a buffer from one vnode to another. ! 733: * Used to assign file specific control information ! 734: * (indirect blocks) to the vnode to which they belong. ! 735: */ ! 736: reassignbuf(bp, newvp) ! 737: register struct buf *bp; ! 738: register struct vnode *newvp; ! 739: { ! 740: register struct buf *bq, **listheadp; ! 741: ! 742: if (newvp == NULL) ! 743: panic("reassignbuf: NULL"); ! 744: /* ! 745: * Delete from old vnode list, if on one. ! 746: */ ! 747: if (bp->b_blockb) { ! 748: if (bq = bp->b_blockf) ! 749: bq->b_blockb = bp->b_blockb; ! 750: *bp->b_blockb = bq; ! 751: } ! 752: /* ! 753: * If dirty, put on list of dirty buffers; ! 754: * otherwise insert onto list of clean buffers. ! 755: */ ! 756: if (bp->b_flags & B_DELWRI) ! 757: listheadp = &newvp->v_dirtyblkhd; ! 758: else ! 759: listheadp = &newvp->v_cleanblkhd; ! 760: if (*listheadp) { ! 761: bp->b_blockf = *listheadp; ! 762: bp->b_blockb = listheadp; ! 763: bp->b_blockf->b_blockb = &bp->b_blockf; ! 764: *listheadp = bp; ! 765: } else { ! 766: *listheadp = bp; ! 767: bp->b_blockb = listheadp; ! 768: bp->b_blockf = NULL; ! 769: } ! 770: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.