incore man page on OpenBSD

Man page or keyword search:  
man Server   11362 pages
apropos Keyword Search (all sections)
Output format
OpenBSD logo
[printable version]

BUFFERCACHE(9)		     OpenBSD Kernel Manual		BUFFERCACHE(9)

     buffercache, bread, breadn, bwrite, bawrite, bdwrite, getblk, geteblk,
     incore, allocbuf, brelse, biodone, biowait - buffer cache interfaces

     #include <sys/buf.h>

     bread(struct vnode *vp, daddr64_t blkno, int size, struct ucred
     *cred, struct buf **bpp);

     breadn(struct vnode *vp, daddr64_t blkno, int size, daddr64_t
     rablks[], int rasizes[], int nrablks, struct ucred *cred, struct buf

     bwrite(struct buf *bp);

     bawrite(struct buf *bp);

     bdwrite(struct buf *bp);

     struct buf *
     getblk(struct vnode *vp, daddr64_t blkno, int size, int slpflag, int

     struct buf *
     geteblk(int size);

     struct buf *
     incore(struct vnode *vp, daddr64_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 filesystem 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, 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
	      memory), bread() calls getblk() to allocate 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 the
	      variants of bwrite().  Otherwise, it should be unbusied using

     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 rablks, rasizes, and nrablks.  The
	      read-ahead blocks aren't returned, but are available in cache
	      for future accesses.

	      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
	      to complete.

	      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 unbusies it.
	      This routine should be used when the buffer is expected to be
	      modified again soon, typically a small write that partially
	      fills a buffer.

     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, mark it as having been found, make
	      it busy and return it.  Otherwise, return an empty block of the
	      correct size.  It is up to the caller to ensure that the cached
	      blocks are of the correct size.

	      If getblk() needs to sleep, slpflag and slptimeo are used as
	      arguments for tsleep().

	      Allocate an empty, disassociated block of a given size size.

     incore(vp, blkno)
	      Determine if a block associated with a given vnode and block
	      offset is in the cache.  If it is there, return a pointer to it.
	      Note that incore() doesn't mark the buffer as busy unlike

     allocbuf(bp, size)
	      Expand or contract the actual memory allocated to a buffer.  If
	      the buffer shrinks, the truncated part of the data is lost, so
	      it is up to the caller to have written it out first if needed;
	      this routine will not start a write.  If the buffer grows, it is
	      the caller's responsibility to fill out the buffer's additional

	      Unlock a buffer by clearing the B_AGE, B_ASYNC, B_BUSY,
	      B_NOCACHE, and B_DEFERRED flags and release it to the free

	      Mark I/O complete on a buffer.  If a callback has been requested
	      by B_CALL, do so.	 Otherwise, wake up the waiting processes.

	      Wait for operations on the buffer to complete.  When they do,
	      extract and return the I/O's error value.	 If the operation on
	      the buffer is being done via a direct call to a strategy() type
	      function, then the buffer must be previously initialized with
	      the B_RAW flag.

     This section describes places within the OpenBSD 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

     intro(9), vnode(9), VOP_STRATEGY(9)

     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.

     Leffler, et. al., The Design and Implementation of the 4.3 BSD Unix
     Operating System, Addison Wesley, 1989.

     In the current implementation, bread() and its variants don't use a
     specified credential.

OpenBSD 4.9			 July 24, 2008			   OpenBSD 4.9

List of man pages available for OpenBSD

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net