BUFFERCACHE(9) BSD Kernel Developer's Manual BUFFERCACHE(9)
buffercache, bread, breada, breadn, bwrite, bawrite, bdwrite, getblk,
geteblk, incore, allocbuf, brelse, biodone, biowait -- buffer cache
bread(struct vnode *vp, daddr_t blkno, int size, struct ucred *cred,
struct buf **bpp);
breadn(struct vnode *vp, daddr_t blkno, int size, daddr_t rablks,
int rasizes, int nrablks, struct ucred *cred, struct buf **bpp);
breada(struct vnode *vp, daddr_t blkno, int size, daddr_t rablkno,
int rabsize, struct ucred *cred, struct buf **bpp);
bwrite(struct buf *bp);
bawrite(struct buf *bp);
bdwrite(struct buf *bp);
struct buf *
getblk(struct vnode *vp, daddr_t blkno, int size, int slpflag,
struct buf *
struct buf *
incore(struct vnode *vp, daddr_t blkno);
allocbuf(struct buf *bp, int size);
brelse(struct buf *bp);
biodone(struct buf *bp);
biowait(struct buf *bp);
The buffercache interface is used by each filesystems to improve I/O per-
formance using in-core caches of filesystem blocks.
The kernel memory used to cache a block is called a buffer and described
by a buf structure. In addition to describing a cached block, a buf
structure is also used to describe an I/O request as a part of the disk
bread(vp, blkno, size, cred, bpp)
Read a block corresponding to vp and blkno. The buffer is
returned via bpp.
If the buffer is not found (i.e. the block is not cached in mem-
ory), bread() allocates a buffer with enough pages for size and
reads the specified disk block into it using credential cred.
The buffer returned by bread() is marked as busy. (The B_BUSY
flag is set.) After manipulation of the buffer returned from
bread(), the caller should unbusy it so that another thread can
get it. If the buffer contents are modified and should be writ-
ten back to disk, it should be unbusied using one of variants of
bwrite(). Otherwise, it should be unbusied using brelse().
breadn(vp, blkno, size, rablks, rasizes, nrablks, cred, bpp)
Get a buffer as bread(). In addition, breadn() will start read-
ahead of blocks specified by rablk(), rasizes(), nrablks().
breada(vp, blkno, size, rablkno, rabsize, cred, bpp)
Same as breadn() with single block read-ahead. This function is
for compatibility with old filesystem code and shouldn't be used
by new ones.
Write a block. Start I/O for write using VOP_STRATEGY(). Then,
unless the B_ASYNC flag is set in bp, bwrite() waits for the I/O
Write a block asynchronously. Set the B_ASYNC flag in bp and
simply call VOP_BWRITE(), which results in bwrite() for most
Delayed write. Unlike bawrite(), bdwrite() won't start any I/O.
It only marks the buffer as dirty (B_DELWRI) and unbusy it.
getblk(vp, blkno, size, slpflag, slptimeo)
Get a block of requested size size that is associated with a
given vnode and block offset, specified by vp and blkno. If it
is found in the block cache, make it busy and return it. Other-
wise, return an empty block of the correct size. It is up to
the caller to ensure that the cached blocks are of the correct
If getblk() needs to sleep, slpflag and slptimeo are used as
arguments for ltsleep().
Allocate an empty, disassociated block of a given size size.
Determine if a block associated to a given vnode and block off-
set is in the cache. If it's there, return a pointer to it.
Note that incore() doesn't busy the buffer unlike getblk().
Expand or contract the actual memory allocated to a buffer. If
the buffer shrinks, data is lost, so it's up to the caller to
have written it out *first*; this routine will not start a
write. If the buffer grows, it's the callers responsibility to
fill out the buffer's additional contents.
Unbusy a buffer and release it to the free lists.
Mark I/O complete on a buffer. If a callback has been requested
by B_CALL, do so. Otherwise, wakeup waiters.
Wait for operations on the buffer to complete. When they do,
extract and return the I/O's error value.
This section describes places within the NetBSD source tree where actual
code implementing the buffer cache subsystem can be found. All pathnames
are relative to /usr/src.
The buffer cache subsystem is implemented within the file
Maurice J. Bach, The Design of the UNIX Operating System, Prentice Hall,
Marshall Kirk McKusick, Keith Bostic, Michael J. Karels, and John S.
Quarterman, The Design and Implementation of the 4.4BSD Operating System,
Addison Wesley, 1996.
In the current implementation, bread() and its variants don't use a spec-
BSD September 15, 2003 BSD