/* ufs_bio.c 4.41 82/12/19 */ #include "../machine/pte.h" #include "../h/param.h" #include "../h/systm.h" #include "../h/dir.h" #include "../h/user.h" #include "../h/buf.h" #include "../h/conf.h" #include "../h/proc.h" #include "../h/seg.h" #include "../h/vm.h" #include "../h/trace.h" /* * Read in (if necessary) the block and return a buffer pointer. */ struct buf * bread(dev, blkno, size) dev_t dev; daddr_t blkno; int size; { register struct buf *bp; if (size == 0) panic("bread: size 0"); bp = getblk(dev, blkno, size); if (bp->b_flags&B_DONE) { trace(TR_BREADHIT, dev, blkno); return(bp); } bp->b_flags |= B_READ; if (bp->b_bcount > bp->b_bufsize) panic("bread"); (*bdevsw[major(dev)].d_strategy)(bp); trace(TR_BREADMISS, dev, blkno); u.u_ru.ru_inblock++; /* pay for read */ biowait(bp); return(bp); } /* * Read in the block, like bread, but also start I/O on the * read-ahead block (which is not allocated to the caller) */ struct buf * breada(dev, blkno, size, rablkno, rabsize) dev_t dev; daddr_t blkno; int size; daddr_t rablkno; int rabsize; { register struct buf *bp, *rabp; bp = NULL; /* * If the block isn't in core, then allocate * a buffer and initiate i/o (getblk checks * for a cache hit). */ if (!incore(dev, blkno)) { bp = getblk(dev, blkno, size); if ((bp->b_flags&B_DONE) == 0) { bp->b_flags |= B_READ; if (bp->b_bcount > bp->b_bufsize) panic("breada"); (*bdevsw[major(dev)].d_strategy)(bp); trace(TR_BREADMISS, dev, blkno); u.u_ru.ru_inblock++; /* pay for read */ } else trace(TR_BREADHIT, dev, blkno); } /* * If there's a read-ahead block, start i/o * on it also (as above). */ if (rablkno && !incore(dev, rablkno)) { rabp = getblk(dev, rablkno, rabsize); if (rabp->b_flags & B_DONE) { brelse(rabp); trace(TR_BREADHITRA, dev, blkno); } else { rabp->b_flags |= B_READ|B_ASYNC; if (rabp->b_bcount > rabp->b_bufsize) panic("breadrabp"); (*bdevsw[major(dev)].d_strategy)(rabp); trace(TR_BREADMISSRA, dev, rablock); u.u_ru.ru_inblock++; /* pay in advance */ } } /* * If block was in core, let bread get it. * If block wasn't in core, then the read was started * above, and just wait for it. */ if (bp == NULL) return (bread(dev, blkno, size)); biowait(bp); return (bp); } /* * Write the buffer, waiting for completion. * Then release the buffer. */ bwrite(bp) register struct buf *bp; { register flag; flag = bp->b_flags; bp->b_flags &= ~(B_READ | B_DONE | B_ERROR | B_DELWRI); if ((flag&B_DELWRI) == 0) u.u_ru.ru_oublock++; /* noone paid yet */ trace(TR_BWRITE, bp->b_dev, bp->b_blkno); if (bp->b_bcount > bp->b_bufsize) panic("bwrite"); (*bdevsw[major(bp->b_dev)].d_strategy)(bp); /* * If the write was synchronous, then await i/o completion. * If the write was "delayed", then we put the buffer on * the q of blocks awaiting i/o completion status. */ if ((flag&B_ASYNC) == 0) { biowait(bp); brelse(bp); } else if (flag & B_DELWRI) bp->b_flags |= B_AGE; } /* * Release the buffer, marking it so that if it is grabbed * for another purpose it will be written out before being * given up (e.g. when writing a partial block where it is * assumed that another write for the same block will soon follow). * This can't be done for magtape, since writes must be done * in the same order as requested. */ bdwrite(bp) register struct buf *bp; { register int flags; if ((bp->b_flags&B_DELWRI) == 0) u.u_ru.ru_oublock++; /* noone paid yet */ flags = bdevsw[major(bp->b_dev)].d_flags; if(flags & B_TAPE) bawrite(bp); else { bp->b_flags |= B_DELWRI | B_DONE; brelse(bp); } } /* * Release the buffer, start I/O on it, but don't wait for completion. */ bawrite(bp) register struct buf *bp; { bp->b_flags |= B_ASYNC; bwrite(bp); } /* * Release the buffer, with no I/O implied. */ brelse(bp) register struct buf *bp; { register struct buf *flist; register s; /* * If someone's waiting for the buffer, or * is waiting for a buffer wake 'em up. */ if (bp->b_flags&B_WANTED) wakeup((caddr_t)bp); if (bfreelist[0].b_flags&B_WANTED) { bfreelist[0].b_flags &= ~B_WANTED; wakeup((caddr_t)bfreelist); } if (bp->b_flags&B_ERROR) if (bp->b_flags & B_LOCKED) bp->b_flags &= ~B_ERROR; /* try again later */ else bp->b_dev = NODEV; /* no assoc */ /* * Stick the buffer back on a free list. */ s = spl6(); if (bp->b_bufsize <= 0) { /* block has no buffer ... put at front of unused buffer list */ flist = &bfreelist[BQ_EMPTY]; binsheadfree(bp, flist); } else if (bp->b_flags & (B_ERROR|B_INVAL)) { /* block has no info ... put at front of most free list */ flist = &bfreelist[BQ_AGE]; binsheadfree(bp, flist); } else { if (bp->b_flags & B_LOCKED) flist = &bfreelist[BQ_LOCKED]; else if (bp->b_flags & B_AGE) flist = &bfreelist[BQ_AGE]; else flist = &bfreelist[BQ_LRU]; binstailfree(bp, flist); } bp->b_flags &= ~(B_WANTED|B_BUSY|B_ASYNC|B_AGE); splx(s); } /* * See if the block is associated with some buffer * (mainly to avoid getting hung up on a wait in breada) */ incore(dev, blkno) dev_t dev; daddr_t blkno; { register struct buf *bp; register struct buf *dp; dp = BUFHASH(dev, blkno); for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) if (bp->b_blkno == blkno && bp->b_dev == dev && (bp->b_flags & B_INVAL) == 0) return (1); return (0); } struct buf * baddr(dev, blkno, size) dev_t dev; daddr_t blkno; int size; { if (incore(dev, blkno)) return (bread(dev, blkno, size)); return (0); } /* * Assign a buffer for the given block. If the appropriate * block is already associated, return it; otherwise search * for the oldest non-busy buffer and reassign it. * * We use splx here because this routine may be called * on the interrupt stack during a dump, and we don't * want to lower the ipl back to 0. */ struct buf * getblk(dev, blkno, size) dev_t dev; daddr_t blkno; int size; { register struct buf *bp, *dp; int s; if ((unsigned)blkno >= 1 << (sizeof(int)*NBBY-PGSHIFT)) /* XXX */ blkno = 1 << ((sizeof(int)*NBBY-PGSHIFT) + 1); /* * Search the cache for the block. If we hit, but * the buffer is in use for i/o, then we wait until * the i/o has completed. */ dp = BUFHASH(dev, blkno); loop: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) { if (bp->b_blkno != blkno || bp->b_dev != dev || bp->b_flags&B_INVAL) continue; s = spl6(); if (bp->b_flags&B_BUSY) { bp->b_flags |= B_WANTED; sleep((caddr_t)bp, PRIBIO+1); splx(s); goto loop; } splx(s); notavail(bp); if (brealloc(bp, size) == 0) goto loop; bp->b_flags |= B_CACHE; return(bp); } if (major(dev) >= nblkdev) panic("blkdev"); bp = getnewbuf(); bfree(bp); bremhash(bp); binshash(bp, dp); bp->b_dev = dev; bp->b_blkno = blkno; bp->b_error = 0; if (brealloc(bp, size) == 0) goto loop; return(bp); } /* * get an empty block, * not assigned to any particular device */ struct buf * geteblk(size) int size; { register struct buf *bp, *flist; loop: bp = getnewbuf(); bp->b_flags |= B_INVAL; bfree(bp); bremhash(bp); flist = &bfreelist[BQ_AGE]; binshash(bp, flist); bp->b_dev = (dev_t)NODEV; bp->b_error = 0; if (brealloc(bp, size) == 0) goto loop; return(bp); } /* * Allocate space associated with a buffer. * If can't get space, buffer is released */ brealloc(bp, size) register struct buf *bp; int size; { daddr_t start, last; register struct buf *ep; struct buf *dp; int s; /* * First need to make sure that all overlaping previous I/O * is dispatched with. */ if (size == bp->b_bcount) return (1); if (size < bp->b_bcount) { if (bp->b_flags & B_DELWRI) { bwrite(bp); return (0); } if (bp->b_flags & B_LOCKED) panic("brealloc"); return (allocbuf(bp, size)); } bp->b_flags &= ~B_DONE; if (bp->b_dev == NODEV) return (allocbuf(bp, size)); /* * Search cache for any buffers that overlap the one that we * are trying to allocate. Overlapping buffers must be marked * invalid, after being written out if they are dirty. (indicated * by B_DELWRI) A disk block must be mapped by at most one buffer * at any point in time. Care must be taken to avoid deadlocking * when two buffer are trying to get the same set of disk blocks. */ start = bp->b_blkno; last = start + (size / DEV_BSIZE) - 1; dp = BUFHASH(bp->b_dev, bp->b_blkno); loop: for (ep = dp->b_forw; ep != dp; ep = ep->b_forw) { if (ep == bp || ep->b_dev != bp->b_dev || (ep->b_flags&B_INVAL)) continue; /* look for overlap */ if (ep->b_bcount == 0 || ep->b_blkno > last || ep->b_blkno + (ep->b_bcount / DEV_BSIZE) <= start) continue; s = spl6(); if (ep->b_flags&B_BUSY) { ep->b_flags |= B_WANTED; sleep((caddr_t)ep, PRIBIO+1); splx(s); goto loop; } splx(s); notavail(ep); if (ep->b_flags & B_DELWRI) { bwrite(ep); goto loop; } ep->b_flags |= B_INVAL; brelse(ep); } return (allocbuf(bp, size)); } /* * Expand or contract the actual memory allocated to a buffer. * If no memory is available, release buffer and take error exit */ allocbuf(tp, size) register struct buf *tp; int size; { register struct buf *bp, *ep; int sizealloc, take; #ifdef sun register char *a; int osize; #endif #ifndef sun sizealloc = roundup(size, CLBYTES); #else sizealloc = roundup(size, BUFALLOCSIZE); #endif /* * Buffer size does not change */ if (sizealloc == tp->b_bufsize) goto out; #ifndef sun /* * Buffer size is shrinking. * Place excess space in a buffer header taken from the * BQ_EMPTY buffer list and placed on the "most free" list. * If no extra buffer headers are available, leave the * extra space in the present buffer. */ if (sizealloc < tp->b_bufsize) { ep = bfreelist[BQ_EMPTY].av_forw; if (ep == &bfreelist[BQ_EMPTY]) goto out; notavail(ep); pagemove(tp->b_un.b_addr + sizealloc, ep->b_un.b_addr, (int)tp->b_bufsize - sizealloc); ep->b_bufsize = tp->b_bufsize - sizealloc; tp->b_bufsize = sizealloc; ep->b_flags |= B_INVAL; ep->b_bcount = 0; brelse(ep); goto out; } /* * More buffer space is needed. Get it out of buffers on * the "most free" list, placing the empty headers on the * BQ_EMPTY buffer header list. */ while (tp->b_bufsize < sizealloc) { take = sizealloc - tp->b_bufsize; bp = getnewbuf(); if (take >= bp->b_bufsize) take = bp->b_bufsize; pagemove(&bp->b_un.b_addr[bp->b_bufsize - take], &tp->b_un.b_addr[tp->b_bufsize], take); tp->b_bufsize += take; bp->b_bufsize = bp->b_bufsize - take; if (bp->b_bcount > bp->b_bufsize) bp->b_bcount = bp->b_bufsize; if (bp->b_bufsize <= 0) { bremhash(bp); binshash(bp, &bfreelist[BQ_EMPTY]); bp->b_dev = (dev_t)NODEV; bp->b_error = 0; bp->b_flags |= B_INVAL; } brelse(bp); } #else /* * Buffer size is shrinking * Just put the tail end back in the map */ if (sizealloc < tp->b_bufsize) { rmfree(buffermap, (long)(tp->b_bufsize - sizealloc), (long)(tp->b_un.b_addr + sizealloc)); tp->b_bufsize = sizealloc; goto out; } /* * Buffer is being expanded or created * If being expanded, attempt to get contiguous * section, otherwise get a new chunk and copy. * If no space, free up a buffer on the AGE list * and try again. */ do { if ((osize = tp->b_bufsize)) { a = (char *)rmget(buffermap, (long)(sizealloc-osize), (long)(tp->b_un.b_addr + osize)); if (a == 0) { a = (char *)rmalloc(buffermap, (long)sizealloc); if (a != 0) { bcopy(tp->b_un.b_addr, a, osize); rmfree(buffermap, (long)osize, (long)tp->b_un.b_addr); tp->b_un.b_addr = a; } } } else { a = (char *)rmalloc(buffermap, (long)sizealloc); if (a != 0) tp->b_un.b_addr = a; } } while (a == 0 && bfreemem()); if (a == 0) { brelse(tp); return (0); } tp->b_bufsize = sizealloc; #endif out: tp->b_bcount = size; return (1); } /* * Release space associated with a buffer. */ bfree(bp) struct buf *bp; { #ifdef sun if (bp->b_bufsize) { rmfree(buffermap, (long)bp->b_bufsize, (long)bp->b_un.b_addr); bp->b_bufsize = 0; } #endif bp->b_bcount = 0; } #ifdef sun /* * Attempt to free up buffer space by flushing * something in the free list. * Don't wait for something, that could cause deadlocks * We start with BQ_AGE because we know BQ_EMPTY take no memory. */ bfreemem() { register struct buf *bp, *dp; int s; loop: s = spl6(); for (dp = &bfreelist[BQ_AGE]; dp > bfreelist; dp--) if (dp->av_forw != dp) break; splx(s); if (dp == bfreelist) { /* no free blocks */ return (0); } bp = dp->av_forw; notavail(bp); if (bp->b_flags & B_DELWRI) { bp->b_flags |= B_ASYNC; bwrite(bp); goto loop; } trace(TR_BRELSE, bp->b_dev, bp->b_blkno); bp->b_flags = B_BUSY | B_INVAL; bfree(bp); bremhash(bp); binshash(bp, &bfreelist[BQ_EMPTY]); bp->b_dev = (dev_t)NODEV; bp->b_error = 0; brelse(bp); return (1); } #endif /* * Find a buffer which is available for use. * Select something from a free list. * Preference is to AGE list, then LRU list. */ struct buf * getnewbuf() { register struct buf *bp, *dp; int s; loop: s = spl6(); #ifndef sun for (dp = &bfreelist[BQ_AGE]; dp > bfreelist; dp--) #else for (dp = &bfreelist[BQ_EMPTY]; dp > bfreelist; dp--) #endif if (dp->av_forw != dp) break; if (dp == bfreelist) { /* no free blocks */ dp->b_flags |= B_WANTED; sleep((caddr_t)dp, PRIBIO+1); goto loop; } splx(s); bp = dp->av_forw; notavail(bp); if (bp->b_flags & B_DELWRI) { bp->b_flags |= B_ASYNC; bwrite(bp); goto loop; } trace(TR_BRELSE, bp->b_dev, bp->b_blkno); bp->b_flags = B_BUSY; return (bp); } /* * Wait for I/O completion on the buffer; return errors * to the user. */ biowait(bp) register struct buf *bp; { int s; s = spl6(); while ((bp->b_flags&B_DONE)==0) sleep((caddr_t)bp, PRIBIO); splx(s); u.u_error = geterror(bp); } /* * Mark I/O complete on a buffer. If the header * indicates a dirty page push completion, the * header is inserted into the ``cleaned'' list * to be processed by the pageout daemon. Otherwise * release it if I/O is asynchronous, and wake * up anyone waiting for it. */ biodone(bp) register struct buf *bp; { register int s; if (bp->b_flags & B_DONE) panic("dup biodone"); bp->b_flags |= B_DONE; if (bp->b_flags & B_DIRTY) { if (bp->b_flags & B_ERROR) panic("IO err in push"); s = spl6(); bp->av_forw = bclnlist; bp->b_bcount = swsize[bp - swbuf]; bp->b_pfcent = swpf[bp - swbuf]; cnt.v_pgout++; cnt.v_pgpgout += bp->b_bcount / NBPG; bclnlist = bp; if (bswlist.b_flags & B_WANTED) wakeup((caddr_t)&proc[2]); splx(s); return; } if (bp->b_flags & B_CALL) { bp->b_flags &= ~B_CALL; (*bp->b_iodone)(bp); return; } if (bp->b_flags&B_ASYNC) brelse(bp); else { bp->b_flags &= ~B_WANTED; wakeup((caddr_t)bp); } } /* * Insure that no part of a specified block is in an incore buffer. */ blkflush(dev, blkno, size) dev_t dev; daddr_t blkno; long size; { register struct buf *ep; struct buf *dp; daddr_t start, last; int s; start = blkno; last = start + (size / DEV_BSIZE) - 1; dp = BUFHASH(dev, blkno); loop: for (ep = dp->b_forw; ep != dp; ep = ep->b_forw) { if (ep->b_dev != dev || (ep->b_flags&B_INVAL)) continue; /* look for overlap */ if (ep->b_bcount == 0 || ep->b_blkno > last || ep->b_blkno + (ep->b_bcount / DEV_BSIZE) <= start) continue; s = spl6(); if (ep->b_flags&B_BUSY) { ep->b_flags |= B_WANTED; sleep((caddr_t)ep, PRIBIO+1); splx(s); goto loop; } if (ep->b_flags & B_DELWRI) { splx(s); notavail(ep); bwrite(ep); goto loop; } splx(s); } } /* * make sure all write-behind blocks * on dev (or NODEV for all) * are flushed out. * (from umount and update) * (and temporarily pagein) */ bflush(dev) dev_t dev; { register struct buf *bp; register struct buf *flist; int s; loop: s = spl6(); for (flist = bfreelist; flist < &bfreelist[BQ_EMPTY]; flist++) for (bp = flist->av_forw; bp != flist; bp = bp->av_forw) { if ((bp->b_flags & B_DELWRI) == 0) continue; if (dev == NODEV || dev == bp->b_dev) { bp->b_flags |= B_ASYNC; notavail(bp); bwrite(bp); goto loop; } } splx(s); } /* * Pick up the device's error number and pass it to the user; * if there is an error but the number is 0 set a generalized * code. Actually the latter is always true because devices * don't yet return specific errors. */ geterror(bp) register struct buf *bp; { int error = 0; if (bp->b_flags&B_ERROR) if ((error = bp->b_error)==0) return (EIO); return (error); } /* * Invalidate in core blocks belonging to closed or umounted filesystem * * This is not nicely done at all - the buffer ought to be removed from the * hash chains & have its dev/blkno fields clobbered, but unfortunately we * can't do that here, as it is quite possible that the block is still * being used for i/o. Eventually, all disc drivers should be forced to * have a close routine, which ought ensure that the queue is empty, then * properly flush the queues. Until that happy day, this suffices for * correctness. ... kre */ binval(dev) dev_t dev; { register struct buf *bp; register struct bufhd *hp; #define dp ((struct buf *)hp) for (hp = bufhash; hp < &bufhash[BUFHSZ]; hp++) for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) if (bp->b_dev == dev) bp->b_flags |= B_INVAL; }