Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
VNODE(9)		 BSD Kernel Developer's	Manual		      VNODE(9)

     vnode -- internal representation of a file	or directory

     #include <sys/param.h>
     #include <sys/vnode.h>

      *	Vnode types.  VNON means no type.
     enum vtype	     { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD };

      *	Vnode tag types.
      *	These are for the benefit of external programs only (e.g., pstat)
      *	and should NEVER be inspected by the kernel.
     enum vtagtype   {

      *	Each underlying	file system allocates its own private area and hangs
      *	it from	v_data.	 If non-null, this area	is freed in getnewvnode().
     TAILQ_HEAD(buflists, buf);

     typedef int     vop_t(void	*);
     struct namecache;

      *	Reading	or writing any of these	items requires holding the appropriate lock.
      *	v_freelist is locked by	the global vnode_free_list simple lock.
      *	v_mntvnodes is locked by the global mntvnodes simple lock.
      *	v_flag,	v_usecount, v_holdcount	and v_writecount are
      *	   locked by the v_interlock simple lock.
      *	v_pollinfo is locked by	the lock contained inside it.
     struct vnode {
	     u_long  v_flag;			     /*	vnode flags (see below)	*/
	     int     v_usecount;		     /*	reference count	of users */
	     int     v_writecount;		     /*	reference count	of writers */
	     int     v_holdcnt;			     /*	page & buffer references */
	     u_long  v_id;			     /*	capability identifier */
	     struct  mount *v_mount;		     /*	ptr to vfs we are in */
	     vop_t   **v_op;			     /*	vnode operations vector	*/
	     TAILQ_ENTRY(vnode)	v_freelist;	     /*	vnode freelist */
	     LIST_ENTRY(vnode) v_mntvnodes;	     /*	vnodes for mount point */
	     struct  buflists v_cleanblkhd;	     /*	clean blocklist	head */
	     struct  buflists v_dirtyblkhd;	     /*	dirty blocklist	head */
	     LIST_ENTRY(vnode) v_synclist;	     /*	vnodes with dirty buffers */
	     long    v_numoutput;		     /*	num of writes in progress */
	     enum    vtype v_type;		     /*	vnode type */
	     union {
		     struct mount    *vu_mountedhere;/*	ptr to mounted vfs (VDIR) */
		     struct socket   *vu_socket;     /*	unix ipc (VSOCK) */
		     struct {
			     struct specinfo *vu_specinfo; /* device (VCHR, VBLK) */
			     SLIST_ENTRY(vnode)	vu_specnext;
		     } vu_spec;
		     struct fifoinfo *vu_fifoinfo;   /*	fifo (VFIFO) */
	     } v_un;
	     struct  nqlease *v_lease;		     /*	Soft reference to lease	*/
	     daddr_t v_lastw;			     /*	last write (write cluster) */
	     daddr_t v_cstart;			     /*	start block of cluster */
	     daddr_t v_lasta;			     /*	last allocation	*/
	     int     v_clen;			     /*	length of current cluster */
	     struct vm_object *v_object;	     /*	Place to store VM object */
	     struct  simplelock	v_interlock;	     /*	lock on	usecount and flag */
	     struct  lock *v_vnlock;		     /*	used for non-locking fs's */
	     enum    vtagtype v_tag;		     /*	type of	underlying data	*/
	     void    *v_data;			     /*	private	data for fs */
	     LIST_HEAD(, namecache) v_cache_src;     /*	Cache entries from us */
	     TAILQ_HEAD(, namecache) v_cache_dst;    /*	Cache entries to us */
	     struct  vnode *v_dd;		     /*	.. vnode */
	     u_long  v_ddid;			     /*	.. capability identifier */
	     struct  {
		     struct  simplelock	vpi_lock;    /*	lock to	protect	below */
		     struct  selinfo vpi_selinfo;    /*	identity of poller(s) */
		     short   vpi_events;	     /*	what they are looking for */
		     short   vpi_revents;	     /*	what has happened */
	     } v_pollinfo;
     #define v_mountedhere   v_un.vu_mountedhere
     #define v_socket	     v_un.vu_socket
     #define v_rdev	     v_un.vu_spec.vu_specinfo
     #define v_specnext	     v_un.vu_spec.vu_specnext
     #define v_fifoinfo	     v_un.vu_fifoinfo

      *	Vnode flags.
     #define VROOT	     0x00001 /*	root of	its file system	*/
     #define VTEXT	     0x00002 /*	vnode is a pure	text prototype */
     #define VSYSTEM	     0x00004 /*	vnode being used by kernel */
     #define VISTTY	     0x00008 /*	vnode represents a tty */
     #define VXLOCK	     0x00100 /*	vnode is locked	to change underlying type */
     #define VXWANT	     0x00200 /*	process	is waiting for vnode */
     #define VBWAIT	     0x00400 /*	waiting	for output to complete */
     #define VOBJBUF	     0x02000 /*	Allocate buffers in VM object */
     #define VAGE	     0x08000 /*	Insert vnode at	head of	free list */
     #define VOLOCK	     0x10000 /*	vnode is locked	waiting	for an object */
     #define VOWANT	     0x20000 /*	a process is waiting for VOLOCK	*/
     #define VDOOMED	     0x40000 /*	This vnode is being recycled */
     #define VFREE	     0x80000 /*	This vnode is on the freelist */
     #define VTBFREE	     0x100000 /* This vnode is on the to-be-freelist */
     #define VONWORKLST	     0x200000 /* On syncer work-list */
     #define VMOUNT	     0x400000 /* Mount in progress */

     The vnode is the focus of all file	activity in UNIX.  There is a unique
     vnode allocated for each active file, each	current	directory, each
     mounted-on	file, text file, and the root.

     Each vnode	has three reference counts, v_usecount,	v_holdcnt and
     v_writecount.  The	first is the number of clients within the kernel which
     are using this vnode.  This count is maintained by	vref(9), vrele(9) and
     vput(9).  The second is the number	of clients within the kernel who veto
     the recycling of this vnode.  This	count is maintained by vhold(9)	and
     vdrop(9).	When both the v_usecount and the v_holdcnt of a	vnode reaches
     zero then the vnode will be put on	the freelist and may be	reused for an-
     other file, possibly in another file system.  The transition to and from
     the freelist is handled by	getnewvnode(9),	vfree(9) and vbusy(9).	The
     third is a	count of the number of clients which are writing into the
     file.  It is maintained by	the open(2) and	close(2) system	calls.

     Any call which returns a vnode (e.g. VFS_GET(9), VOP_LOOKUP(9) etc.)
     will increase the v_usecount of the vnode by one.	When the caller	is
     finished with the vnode, it should	release	this reference by calling
     vrele(9) (or vput(9) if the vnode is locked).

     Other commonly used members of the	vnode structure	are v_id which is used
     to	maintain consistency in	the name cache,	v_mount	which points at	the
     file system which owns the	vnode, v_type which contains the type of ob-
     ject the vnode represents and v_data which	is used	by file	systems	to
     store file	system specific	data with the vnode.  The v_op field is	used
     by	the VOP_* macros to call functions in the file system which implement
     the vnode's functionality.

     VNON   No type.

     VREG   A regular file; may	be with	or without VM object backing.  If you
	    want to make sure this get a backing object, call

     VDIR   A directory.

     VBLK   A block device; may	be with	or without VM object backing.  If you
	    want to make sure this get a backing object, call

     VCHR   A character	device.

     VLNK   A symbolic link.

     VSOCK  A socket.  Advisory	locking	won't work on this.

     VFIFO  A FIFO (named pipe).  Advisory locking won't work on this.

     VBAD   An old style bad sector map

     VFIFO uses	the "struct fileops" from /sys/kern/sys_pipe.c.	 VSOCK uses
     the "struct fileops" from /sys/kern/sys_socket.c.	Everything else	uses
     the one from /sys/kern/vfs_vnops.c.

     The VFIFO/VSOCK code, which is why	"struct	fileops" is used at all, is an
     artifact of an incomplete integration of the VFS code into	the kernel.


     This man page was written by Doug Rabson.

BSD				 June 30, 1999				   BSD


Want to link to this manual page? Use this URL:

home | help