| BUFFERCACHE(9) | Kernel Developer's Manual | BUFFERCACHE(9) | 
buffercache, bread,
  breadn, bwrite,
  bawrite, bdwrite,
  getblk, geteblk,
  incore, allocbuf,
  brelse —
#include <sys/buf.h>
int
  
  bread(struct
    vnode *vp, daddr_t
    blkno, int size,
    int flags,
    buf_t **bpp);
int
  
  breadn(struct
    vnode *vp, daddr_t
    blkno, int size,
    daddr_t rablks[],
    int rasizes[],
    int nrablks,
    int flags,
    buf_t **bpp);
int
  
  bwrite(buf_t
    *bp);
void
  
  bawrite(buf_t
    *bp);
void
  
  bdwrite(buf_t
    *bp);
buf_t *
  
  getblk(struct
    vnode *vp, daddr_t
    blkno, int size,
    int slpflag,
    int slptimeo);
buf_t *
  
  geteblk(int
    size);
buf_t *
  
  incore(struct
    vnode *vp, daddr_t
    blkno);
void
  
  allocbuf(buf_t
    *bp, int size,
    int preserve);
void
  
  brelse(buf_t
    *bp, int set);
buffercache interface is used by each filesystems to
  improve I/O performance 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 driver interface.
bread(vp,
    blkno, size,
    flags, bpp)VOP_STRATEGY()
      routine for the vp vnode. For device special files,
      blkno is in units of
      DEV_BSIZE and both blkno and
      size must be multiples of the underlying device's
      block size. For other files, blkno is in units
      chosen by the file system containing vp.
    If the buffer is not found (i.e. the block is not cached in
        memory), bread() allocates a buffer with enough
        pages for size and reads the specified disk block
        into it.
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 written 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, flags,
    bpp)bread(). In addition,
      breadn() will start read-ahead of blocks specified
      by rablks, rasizes,
      nrablks.bwrite(bp)VOP_STRATEGY(). Then, unless the
      B_ASYNC flag is set in bp,
      bwrite() waits for the I/O to complete.bawrite(bp)B_ASYNC flag
      in bp and simply call
      VOP_BWRITE(), which results in
      bwrite() for most filesystems.bdwrite(bp)bawrite(),
      bdwrite() won't start any I/O. It only marks the
      buffer as dirty (BO_DELWRI) and unbusy it.getblk(vp,
    blkno, size,
    slpflag, slptimeo)If getblk() needs to sleep,
        slpflag and slptimeo are
        used as arguments for cv_timedwait().
geteblk(size)incore(vp,
    blkno)incore() doesn't busy the buffer unlike
      getblk().allocbuf(bp,
    size, preserve)brelse(bp,
    set)Maurice J. Bach, The Design of the UNIX Operating System, Prentice Hall, 1986.
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.
| April 11, 2017 | NetBSD 9.3 |