Unix/Linux Go Back    


NetBSD 6.1.5 - man page for vop_getextattr (netbsd section 9)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


VNODEOPS(9)			  BSD Kernel Developer's Manual 		      VNODEOPS(9)

NAME
     vnodeops, VOP_LOOKUP, VOP_CREATE, VOP_MKNOD, VOP_OPEN, VOP_CLOSE, VOP_ACCESS, VOP_GETATTR,
     VOP_SETATTR, VOP_READ, VOP_WRITE, VOP_IOCTL, VOP_FCNTL, VOP_POLL, VOP_KQFILTER, VOP_REVOKE,
     VOP_MMAP, VOP_FSYNC, VOP_SEEK, VOP_REMOVE, VOP_LINK, VOP_RENAME, VOP_MKDIR, VOP_RMDIR,
     VOP_SYMLINK, VOP_READDIR, VOP_READLINK, VOP_ABORTOP, VOP_INACTIVE, VOP_RECLAIM, VOP_LOCK,
     VOP_UNLOCK, VOP_ISLOCKED, VOP_BMAP, VOP_PRINT, VOP_PATHCONF, VOP_ADVLOCK, VOP_WHITEOUT,
     VOP_GETPAGES, VOP_PUTPAGES, VOP_STRATEGY, VOP_BWRITE, VOP_GETEXTATTR, VOP_SETEXTATTR,
     VOP_LISTEXTATTR, VOP_DELETEEXTATTR -- vnode operations

SYNOPSIS
     #include <sys/param.h>
     #include <sys/buf.h>
     #include <sys/dirent.h>
     #include <sys/vnode.h>
     #include <sys/mount.h>
     #include <sys/namei.h>
     #include <sys/unistd.h>
     #include <sys/fcntl.h>
     #include <sys/lockf.h>
     #include <sys/extattr.h>

     int
     VOP_LOOKUP(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp);

     int
     VOP_CREATE(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
	 struct vattr *vap);

     int
     VOP_MKNOD(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
	 struct vattr *vap);

     int
     VOP_OPEN(struct vnode *vp, int mode, kauth_cred_t cred);

     int
     VOP_CLOSE(struct vnode *vp, int fflag, kauth_cred_t cred);

     int
     VOP_ACCESS(struct vnode *vp, int mode, kauth_cred_t cred);

     int
     VOP_GETATTR(struct vnode *vp, struct vattr *vap, kauth_cred_t cred);

     int
     VOP_SETATTR(struct vnode *vp, struct vattr *vap, kauth_cred_t cred);

     int
     VOP_READ(struct vnode *vp, struct uio *uio, int ioflag, kauth_cred_t cred);

     int
     VOP_WRITE(struct vnode *vp, struct uio *uio, int ioflag, kauth_cred_t cred);

     int
     VOP_IOCTL(struct vnode *vp, u_long command, void *data, int fflag, kauth_cred_t cred);

     int
     VOP_FCNTL(struct vnode *vp, u_int command, void *data, int fflag, kauth_cred_t cred);

     int
     VOP_POLL(struct vnode *vp, int events);

     int
     VOP_KQFILTER(struct vnode *vp, struct knote *kn);

     int
     VOP_REVOKE(struct vnode *vp, int flags);

     int
     VOP_MMAP(struct vnode *vp, vm_prot_t prot, kauth_cred_t cred);

     int
     VOP_FSYNC(struct vnode *vp, kauth_cred_t cred, int flags, off_t offlo, off_t offhi);

     int
     VOP_SEEK(struct vnode *vp, off_t oldoff, off_t newoff, kauth_cred_t cred);

     int
     VOP_REMOVE(struct vnode *vp, struct vnode *vp, struct componentname *cnp);

     int
     VOP_LINK(struct vnode *dvp, struct vnode *vp, struct componentname *cnp);

     int
     VOP_RENAME(struct vnode *fdvp, struct vnode *fvp, struct componentname *fcnp,
	 struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp);

     int
     VOP_MKDIR(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
	 struct vattr *vap);

     int
     VOP_RMDIR(struct vnode *dvp, struct vnode *vp, struct componentname *cnp);

     int
     VOP_SYMLINK(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
	 struct vattr *vap, char *target);

     int
     VOP_READDIR(struct vnode *vp, struct uio *uio, kauth_cred_t cred, int *eofflag,
	 off_t **cookies, int *ncookies);

     int
     VOP_READLINK(struct vnode *vp, struct uio *uio, kauth_cred_t cred);

     int
     VOP_ABORTOP(struct vnode *dvp, struct componentname *cnp);

     int
     VOP_INACTIVE(struct vnode *vp);

     int
     VOP_RECLAIM(struct vnode *vp);

     int
     VOP_LOCK(struct vnode *vp, int flags);

     int
     VOP_UNLOCK(struct vnode *vp);

     int
     VOP_ISLOCKED(struct vnode *vp);

     int
     VOP_BMAP(struct vnode *vp, daddr_t bn, struct vnode **vpp, daddr_t *bnp, int *runp);

     int
     VOP_PRINT(struct vnode *vp);

     int
     VOP_PATHCONF(struct vnode *vp, int name, register_t *retval);

     int
     VOP_ADVLOCK(struct vnode *vp, void *id, int op, struct flock *fl, int flags);

     int
     VOP_WHITEOUT(struct vnode *dvp, struct componentname *cnp, int flags);

     int
     VOP_GETPAGES(struct vnode *vp, voff_t offset, struct vm_page **m, int *count, int centeridx,
	 vm_prot_t access_type, int advice, int flags);

     int
     VOP_PUTPAGES(struct vnode *vp, voff_t offlo, voff_t offhi, int flags);

     int
     VOP_STRATEGY(struct vnode *vp, struct buf *bp);

     int
     VOP_BWRITE(struct vnode *vp, struct buf *bp);

     int
     VOP_GETEXTATTR(struct vnode *vp, int attrnamespace, const char *name, struct uio *uio,
	 size_t *size, kauth_cred_t cred);

     int
     VOP_SETEXTATTR(struct vnode *vp, int attrnamespace, const char *name, struct uio *uio,
	 kauth_cred_t cred);

     int
     VOP_LISTEXTATTR(struct vnode *vp, int attrnamespace, struct uio *uio, size_t *size,
	 kauth_cred_t cred);

     int
     VOP_DELETEEXTATTR(struct vnode *vp, int attrnamespace, const char *name, kauth_cred_t cred);

     Not all header files are required for each function.

DESCRIPTION
     The vnode operations vector describes what operations can be done to the file associated
     with the vnode.  The system maintains one vnode operations vector for each file system type
     configured into the kernel.  The vnode operations vector contains a pointer to a function
     for each operation supported by the file system.  Many of the functions described in the
     vnode operations vector are closely related to their corresponding system calls.  In most
     cases, they are called as a result of the system call associated with the operation being
     invoked.

     Functions in the vnode operations vector are invoked using specialized macros.  The follow-
     ing table gives a summary of the operations.

     Macro		  Description
     VOP_LOOKUP 	  Lookup file name in name cache
     VOP_CREATE 	  Create a new file
     VOP_MKNOD		  Make a new device
     VOP_OPEN		  Open a file
     VOP_CLOSE		  Close a file
     VOP_ACCESS 	  Determine file accessibility
     VOP_GETATTR	  Get file attributes
     VOP_SETATTR	  Set file attributes
     VOP_READ		  Read from a file
     VOP_WRITE		  Write to a file
     VOP_IOCTL		  Perform device-specific I/O
     VOP_FCNTL		  Perform file control
     VOP_POLL		  Test if poll event has occurred
     VOP_KQFILTER	  Register a knote
     VOP_REVOKE 	  Eliminate vode activity
     VOP_MMAP		  Map file into user address space
     VOP_FSYNC		  Flush pending data to disk
     VOP_SEEK		  Test if file is seekable
     VOP_REMOVE 	  Remove a file
     VOP_LINK		  Link a file
     VOP_RENAME 	  Rename a file
     VOP_MKDIR		  Make a new directory
     VOP_RMDIR		  Remove a directory
     VOP_SYMLINK	  Create a symbolic link
     VOP_READDIR	  Read directory entry
     VOP_READLINK	  Read contents of a symlink
     VOP_ABORTOP	  Abort pending operation
     VOP_INACTIVE	  Release the inactive vnode
     VOP_RECLAIM	  Reclaim vnode for another file
     VOP_LOCK		  Sleep until vnode lock is free
     VOP_UNLOCK 	  Wake up process sleeping on lock
     VOP_ISLOCKED	  Test if vnode is locked
     VOP_BMAP		  Logical block number conversion
     VOP_PRINT		  Print debugging information
     VOP_PATHCONF	  Return POSIX pathconf data
     VOP_ADVLOCK	  Advisory record locking
     VOP_WHITEOUT	  Whiteout vnode
     VOP_GETPAGES	  Read VM pages from file
     VOP_PUTPAGES	  Write VM pages to file
     VOP_STRATEGY	  Read/write a file system buffer
     VOP_BWRITE 	  Write a file system buffer
     VOP_GETEXTATTR	  Get extended attribute
     VOP_SETEXTATTR	  Set extended attribute
     VOP_LISTEXTATTR	  List extended attributes
     VOP_DELETEEXTATTR	  Remove extended attribute

     The implementation details of the vnode operations vector are not quite what is described
     here.

     If the file system type does not support a specific operation, it must nevertheless assign
     an appropriate stub in the vnode operations vector to do the minimum required of it.  In
     most cases, such functions either do nothing or return an error value to the effect that it
     is not supported.

     Many of the functions in the vnode operations vector take a componentname structure.  It is
     used to encapsulate many parameters into a single function argument.  It has the following
     structure:

     struct componentname {
	     /*
	      * Arguments to lookup.
	      */
	     uint32_t cn_nameiop;    /* namei operation */
	     uint32_t cn_flags;      /* flags to namei */
	     kauth_cred_t cn_cred;   /* credentials */
	     /*
	      * Shared between lookup and commit routines.
	      */
	     char    *cn_pnbuf;      /* pathname buffer */
	     const char *cn_nameptr; /* pointer to looked up name */
	     size_t  cn_namelen;     /* length of looked up component */
	     u_long  cn_hash;	     /* hash value of looked up name */
	     size_t  cn_consume;     /* chars to consume in lookup() */
     };

     The top half of the structure is used exclusively for the pathname lookups using
     VOP_LOOKUP() and is initialized by the caller.  The semantics of the lookup are affected by
     the lookup operation specified in cn_nameiop and the flags specified in cn_flags.	Valid
     operations are:

	   LOOKUP  perform name lookup only
	   CREATE  set up for file creation
	   DELETE  set up for file deletion
	   RENAME  set up for file renaming
	   OPMASK  mask for operation

     Valid values for cn->cn_flags are:

	   LOCKLEAF    lock inode on return
	   LOCKPARENT  want parent vnode returned locked
	   NOCACHE     name must not be left in name cache (see namecache(9))
	   FOLLOW      follow symbolic links
	   NOFOLLOW    do not follow symbolic links (pseudo)
	   MODMASK     mask of operational modifiers

     No vnode operations may be called from interrupt context.	Most operations also require the
     vnode to be locked on entry.  To prevent deadlocks, when acquiring locks on multiple vnodes,
     the lock of parent directory must be acquired before the lock on the child directory.

     Vnode operations for a file system type generally should not be called directly from the
     kernel, but accessed indirectly through the high-level convenience functions discussed in
     vnsubr(9).

FUNCTIONS
     VOP_LOOKUP(dvp, vpp, cnp)
	      Lookup a single pathname component in a given directory.	The argument dvp is the
	      locked vnode of the directory to search and cnp is the pathname component to be
	      searched for.  If the pathname component is found, the address of the resulting
	      locked vnode is returned in vpp.	The operation specified in cnp->cn_nameiop indi-
	      cates VOP_LOOKUP() the reason for requesting the lookup and uses it to cache file
	      system type specific information in the vnode for subsequent operations.

	      There are three types of lookups: ".", ".." (ISDOTDOT), and regular.  If the path-
	      name component being searched for is ".", then dvp has an extra reference added to
	      it and it is returned in *vpp.  If the pathname component being search for is ".."
	      (ISDOTDOT), dvp is unlocked, the ".." node is locked and then dvp is relocked.
	      This process preserves the protocol of always locking nodes from root downward and
	      prevents deadlock.  For other pathname components, VOP_LOOKUP() checks the accessi-
	      bility of the directory and searches the name cache for the pathname component.
	      See namecache(9).  If the pathname is not found in the name cache, the directory is
	      searched for the pathname.  The resulting locked vnode is returned in vpp.  dvp is
	      always returned locked.

	      On failure *vpp is NULL, and *dvp is left locked.  If the operation is successful
	      *vpp is locked and zero is returned.  Typically, if *vpp and dvp are the same vnode
	      the caller will need to release twice (decrement the reference count) and unlock
	      once.

     VOP_CREATE(dvp, vpp, cnp, vap)
	      Create a new file in a given directory.  The argument dvp is the locked vnode of
	      the directory to create the new file in and cnp is the pathname component of the
	      new file.  The argument vap specifies the attributes that the new file should be
	      created with.  If the file is successfully created, the address of the resulting
	      locked vnode is returned in vpp and zero is returned.  Regardless of the return
	      value, the directory vnode dvp will be unlocked on return.

	      This function is called after VOP_LOOKUP() when a file is being created.	Normally,
	      VOP_LOOKUP() will have set the SAVENAME flag in cnp->cn_flags to keep the memory
	      pointed to by cnp->cn_pnbuf valid.  If an error is detected when creating the file,
	      this memory is released.	If the file is created successfully it will be released
	      unless the SAVESTART flags in specified in cnp->cn_flags.

     VOP_MKNOD(dvp, vpp, cnp, vap)
	      Make a new device-special file in a given directory.  The argument dvp is the
	      locked vnode of the directory to create the new device-special file in and cnp is
	      the pathname component of the new device-special file.  The argument vap specifies
	      the attributes that the new device-special file should be created with.  If the
	      file is successfully created, the address of the resulting locked vnode is returned
	      in vpp and zero is returned.

	      This function is called after VOP_LOOKUP() when a device-special file is being cre-
	      ated.  Normally, VOP_LOOKUP() will have set the SAVENAME flag in cnp->cn_flags to
	      keep the memory pointed to by cnp->cn_pnbuf valid.  If an error is detected when
	      creating the device-special file, this memory is released.  If the device-special
	      file is created successfully it will be released unless the SAVESTART flags in
	      specified in cnp->cn_flags.

     VOP_OPEN(vp, mode, cred)
	      Open a file.  The argument vp is the vnode of the file to open and mode specifies
	      the access mode required by the calling process.	The calling credentials are spec-
	      ified by cred.  The access mode is a set of flags, including FREAD, FWRITE, O_NON-
	      BLOCK, O_APPEND, etc.  VOP_OPEN() must be called before a file can be accessed by a
	      thread.  The vnode reference count is incremented.

	      VOP_OPEN() expects the vnode vp to be locked on entry and will leave it locked on
	      return.  If the operation is successful zero is returned, otherwise an appropriate
	      error code is returned.

     VOP_CLOSE(vp, fflag, cred)
	      Close a file.  The argument vp is the vnode of the file to close and fflag speci-
	      fies the access mode by the calling process.  The possible flags are FREAD, FWRITE
	      and FNONBLOCK.  The calling credentials are specified by cred.  VOP_CLOSE() frees
	      resources allocated by VOP_OPEN().

	      The vnode vp will be locked on entry and should remain locked on return.

     VOP_ACCESS(vp, mode, cred)
	      Determine the accessibility (permissions) of the file against the specified creden-
	      tials.  The argument vp is the vnode of the file to check, mode is the type of
	      access required and cred contains the user credentials to check.	The argument mode
	      is a mask which can contain VREAD, VWRITE or VEXEC.  If the file is accessible in
	      the specified way, zero is returned, otherwise an appropriate error code is
	      returned.

	      The vnode vp will be locked on entry and should remain locked on return.

     VOP_GETATTR(vp, vap, cred)
	      Get specific vnode attributes on a file.	The argument vp is the vnode of the file
	      to get the attributes for.  The argument cred specifies the calling credentials.
	      VOP_GETATTR() uses the file system type specific data object vp->v_data to refer-
	      ence the underlying file attributes.  Attributes associated with the file are col-
	      lected by setting the required attribute bits in vap->va_mask.  The attributes are
	      returned in vap.	Attributes which are not available are set to the value VNOVAL.

	      For more information on vnode attributes see vattr(9).

	      The vnode vp will be locked on entry and should remain locked on return.

     VOP_SETATTR(vp, vap, cred)
	      Set specific vnode attributes on a file.	The argument vp is the locked vnode of
	      the file to set the attributes for.  The argument cred specifies the calling cre-
	      dentials.  VOP_SETATTR() uses the file system type specific data object vp->v_data
	      to reference the underlying file attributes.  The new attributes are defined in
	      vap.  Attributes associated with the file are set by setting the required attribute
	      bits in vap->va_mask.  Attributes which are not being modified by VOP_SETATTR()
	      should be set to the value VNOVAL.  If the operation is successful zero is
	      returned, otherwise an appropriate error is returned.

	      For more information on vnode attributes see vattr(9).

     VOP_READ(vp, uio, ioflag, cred)
	      Read the contents of a file.  The argument vp is the vnode of the file to read
	      from, uio is the location to read the data into, ioflag is a set of flags and cred
	      are the credentials of the calling process.

	      The ioflag argument is used to give directives and hints to the file system.  When
	      attempting a read, the high 16 bits are used to provide a read-ahead hint (in unit
	      of file system blocks) that the file system should attempt.  The low 16 bits are a
	      bit mask which can contain the following flags:

		    IO_UNIT	     do I/O as atomic unit
		    IO_APPEND	     append write to end
		    IO_SYNC	     sync I/O file integrity completion
		    IO_NODELOCKED    underlying node already locked
		    IO_NDELAY	     FNDELAY flag set in file table
		    IO_DSYNC	     sync I/O data integrity completion
		    IO_ALTSEMANTICS  use alternate I/O semantics
		    IO_NORMAL	     operate on regular data
		    IO_EXT	     operate on extended attributes
		    IO_DIRECT	     do not buffer data in the kernel

	      Zero is returned on success, otherwise an error is returned.  The vnode should be
	      locked on entry and remains locked on exit.

     VOP_WRITE(vp, uio, ioflag, cred)
	      Write to a file.	The argument vp is the vnode of the file to write to, uio is the
	      location of the data to write, ioflag is a set of flags and cred are the creden-
	      tials of the calling process.

	      The ioflag argument is used to give directives and hints to the file system.  The
	      low 16 bits are a bit mask which can contain the same flags as VOP_READ().

	      Zero is returned on success, otherwise an error is returned.  The vnode should be
	      locked on entry and remains locked on exit.

     VOP_IOCTL(vp, command, data, fflag, cred)
	      Perform device-specific I/O.  The argument vp is the locked vnode of the file, nor-
	      mally representing a device.  The argument command specifies the device-specific
	      operation to perform and cnp provides extra data for the specified operation.  The
	      argument fflags is a set of flags.  The argument cred is the caller's credentials.
	      If the operation is successful, zero is returned, otherwise an appropriate error
	      code is returned.

	      Most file systems do not supply a function for VOP_IOCTL().  This function imple-
	      ments the ioctl(2) system call.

     VOP_FCNTL(vp, command, data, fflag, cred)
	      Perform file control.  The argument vp is the locked vnode of the file.  The argu-
	      ment command specifies the operation to perform and cnp provides extra data for the
	      specified operation.  The argument fflags is a set of flags.  The argument cred is
	      the caller's credentials.  If the operation is successful, zero is returned, other-
	      wise an appropriate error code is returned.

     VOP_POLL(vp, events)
	      Test if a poll event has occurred.  The argument vp is the vnode of the file to
	      poll.  It returns any events of interest as specified by events that may have
	      occurred for the file.  The argument events is a set of flags as specified by
	      poll(2).

	      The vnode vp remains unlocked throughout the whole operation.

     VOP_KQFILTER(vp, kn)
	      Register a knote kn with the vnode vn.  If the operation is successful zero is
	      returned, otherwise an appropriate error code is returned.

	      The vnode vp remains unlocked throughout the whole operation.

     VOP_REVOKE(vp, flags)
	      Eliminate all activity associated with the vnode vp.  The argument flags is a set
	      of flags.  If REVOKEALL is set in flags all vnodes aliased to the vnode vp are also
	      eliminated.  If the operation is successful zero is returned, otherwise an appro-
	      priate error is returned.

	      The vnode vp remains unlocked throughout the whole operation.

     VOP_MMAP(vp, prot, cred)
	      Inform file system that vp is in the process of being memory mapped.  The argument
	      prot specifies the vm access protection the vnode is going to be mapped with.  The
	      argument cred is the caller's credentials.  If the file system allows the memory
	      mapping, zero is returned, otherwise an appropriate error code is returned.

	      Most file systems do not supply a function for VOP_MMAP() and use genfs_mmap() to
	      default for success.  Only file systems which do not integrate with the page cache
	      at all typically want to disallow memory mapping.

     VOP_FSYNC(vp, cred, flags, offlo, offhi)
	      Flush pending data buffers for a file to disk.  The argument vp is the locked vnode
	      of the file for flush.  The argument cred is the caller's credentials.  The argu-
	      ment flags is a set of flags.  If FSYNC_WAIT is specified in flags, the function
	      should wait for I/O to complete before returning.  The argument offlo and offhi
	      specify the range of file to flush.  If the operation is successful zero is
	      returned, otherwise an appropriate error code is returned.

	      This function implements the sync(2) and fsync(2) system calls.

     VOP_SEEK(vp, oldoff, newoff, cred)
	      Test if the file is seekable for the specified offset newoff.  The argument vp is
	      the locked vnode of the file to test.  For most file systems this function simply
	      tests if newoff is valid.  If the specified newoff is less than zero, the function
	      returns error code EINVAL.

     VOP_REMOVE(dvp, vp, cnp)
	      Remove a file.  The argument dvp is the locked vnode of the directory to remove the
	      file from and vp is the locked vnode of the file to remove.  The argument cnp is
	      the pathname component about the file to remove.	If the operation is successful
	      zero is returned, otherwise an appropriate error code is returned.  Both dvp and vp
	      are locked on entry and are to be unlocked before returning.

     VOP_LINK(dvp, vp, cnp)
	      Link to a file.  The argument dvp is the locked node of the directory to create the
	      new link and vp is the vnode of the file to be linked.  The argument cnp is the
	      pathname component of the new link.  If the operation is successful zero is
	      returned, otherwise an error code is returned.  The directory vnode dvp should be
	      locked on entry and will be released and unlocked on return.  The vnode vp should
	      not be locked on entry and will remain unlocked on return.

     VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
	      Rename a file.  The argument fdvp is the vnode of the old parent directory contain-
	      ing in the file to be renamed and fvp is the vnode of the file to be renamed.  The
	      argument fcnp is the pathname component about the file to be renamed.  The argument
	      tdvp is the vnode of the new directory of the target file and tvp is the vnode of
	      the target file (if it exists).  The argument tcnp is the pathname component about
	      the file's new name.  If the operation is successful zero is returned, otherwise an
	      error code is returned.

	      The source directory and file vnodes should be unlocked and their reference counts
	      should be incremented before entry.  The target directory and file vnodes should
	      both be locked on entry.	VOP_RENAME() updates the reference counts prior to
	      returning.

     VOP_MKDIR(dvp, vpp, cnp, vap)
	      Make a new directory in a given directory.  The argument dvp is the locked vnode of
	      the directory to create the new directory in and cnp is the pathname component of
	      the new directory.  The argument vap specifies the attributes that the new direc-
	      tory should be created with.  If the file is successfully created, the address of
	      the resulting locked vnode is returned in vpp and zero is returned.

	      This function is called after VOP_LOOKUP() when a directory is being created.  Nor-
	      mally, VOP_LOOKUP() will have set the SAVENAME flag in cnp->cn_flags to keep the
	      memory pointed to by cnp->cn_pnbuf valid.  If an error is detected when creating
	      the directory, this memory is released.  If the directory is created successfully
	      it will be released unless the SAVESTART flags in specified in cnp->cn_flags.

     VOP_RMDIR(dvp, vp, cnp)
	      Remove a directory in a given directory.	The argument dvp is the locked vnode of
	      the directory to remove the directory from and vp is the locked vnode of the direc-
	      tory to remove.  The argument cnp is the pathname component of the directory.  Zero
	      is returned on success, otherwise an error code is returned.  Both dvp and vp
	      should be locked on entry and will be released and unlocked on return.

     VOP_SYMLINK(dvp, vpp, cnp, vap, target)
	      Create a symbolic link in a given directory.  The argument dvp is the locked vnode
	      of the directory to create the symbolic link in and cnp is the pathname component
	      of the symbolic link.  The argument vap specifies the attributes that the symbolic
	      link should be created with and target specifies the pathname of the target of the
	      symbolic link.  If the symbolic link is successfully created, the address of the
	      resulting locked vnode is returned in vpp and zero is returned.

	      This function is called after VOP_LOOKUP() when a symbolic link is being created.
	      Normally, VOP_LOOKUP() will have set the SAVENAME flag in cnp->cn_flags to keep the
	      memory pointed to by cnp->cn_pnbuf valid.  If an error is detected when creating
	      the symbolic link, this memory is released.  If the symbolic link is created suc-
	      cessfully it will be released unless the SAVESTART flags in specified in
	      cnp->cn_flags.

     VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies)
	      Read directory entry.  The argument vp is the vnode of the directory to read the
	      contents of and uio is the destination location to read the contents into.  The
	      argument cred is the caller's credentials.  The argument eofflag is the pointer to
	      a flag which is set by VOP_READDIR() to indicate an end-of-file condition.  If
	      eofflag is NULL, the end-of-file condition is not returned.  The arguments cookies
	      and ncookies specify the addresses for the list and number of directory seek cook-
	      ies generated for NFS.  Both cookies and ncookies should be NULL if they aren't
	      required to be returned by VOP_READDIR().  The directory contents are read into
	      struct dirent structures and uio->uio_offset is set to the offset of the next
	      unread directory entry.  This offset may be used in a following invocation to con-
	      tinue a sequential read of the directory contents.  If the operation is successful
	      zero is returned, otherwise an appropriate error code is returned.

	      The directory should be locked on entry and will remain locked on return.

	      In case ncookies and cookies are supplied, one cookie should be returned per direc-
	      tory entry.  The value of the cookie for each directory entry should be the offset
	      within the directory where the on-disk version of the following directory entry
	      starts.  That is, for each directory entry i, the corresponding cookie should refer
	      to the offset of directory entry i + 1.

	      Note that the cookies array must be allocated by the callee using the M_TEMP malloc
	      type as callers of VOP_READDIR() must be able to free the allocation.

     VOP_READLINK(vp, uio, cred)
	      Read the contents of a symbolic link.  The argument vp is the locked vnode of the
	      symlink and uio is the destination location to read the contents into.  The argu-
	      ment cred is the credentials of the caller.  If the operation is successful zero is
	      returned, otherwise an error code is returned.

	      The vnode should be locked on entry and will remain locked on return.

     VOP_ABORTOP(dvp, cnp)
	      Abort pending operation on vnode dvp and free resources allocated in cnp.

	      This operation is rarely implemented in file systems and genfs_abortop() is typi-
	      cally used instead.

     VOP_INACTIVE(vp)
	      Release the inactive vnode.  VOP_INACTIVE() is called when the kernel is no longer
	      using the vnode.	This may be because the reference count reaches zero or it may be
	      that the file system is being forcibly unmounted while there are open files.  It
	      can be used to reclaim space for open but deleted files.	The argument vp is the
	      locked vnode to be released.  If the operation is successful zero is returned, oth-
	      erwise an appropriate error code is returned.  The vnode vp must be locked on
	      entry, and will be unlocked on return.

     VOP_RECLAIM(vp)
	      Reclaim the vnode for another file system.  VOP_RECLAIM() is called when a vnode is
	      being reused for a different file system.  Any file system specific resources asso-
	      ciated with the vnode should be freed.  The argument vp is the vnode to be
	      reclaimed.  If the operation is successful zero is returned, otherwise an appropri-
	      ate error code is returned.  The vnode vp should not be locked on entry, and will
	      remain unlocked on return.

     VOP_LOCK(vp, flags)
	      Sleep until vnode lock is free.  The argument vp is the vnode of the file to be
	      locked.  The argument flags is LK_EXCLUSIVE to take the lock exclusively or
	      LK_SHARED to take a shared lock.	If flags contains LK_NOWAIT and the lock is busy,
	      the operation will return immediately with an error code.  If the operation is suc-
	      cessful zero is returned, otherwise an appropriate error code is returned.
	      VOP_LOCK() is used to serialize access to the file system such as to prevent two
	      writes to the same file from happening at the same time.	Kernel code should use
	      vn_lock(9) to lock a vnode rather than calling VOP_LOCK() directly.

     VOP_UNLOCK(vp)
	      Wake up process sleeping on lock.  The argument vp is the vnode of the file to be
	      unlocked.  If the operation is successful zero is returned, otherwise an appropri-
	      ate error code is returned.  VOP_UNLOCK() is used to serialize access to the file
	      system such as to prevent two writes to the same file from happening at the same
	      time.

     VOP_ISLOCKED(vp)
	      Test if the vnode vp is locked.  Possible return values are LK_EXCLUSIVE, LK_SHARED
	      or 0 for lock held exclusively by the calling thread, shared lock held by anyone or
	      unlocked, respectively.

	      This function must never be used to make locking decisions at run time: it is pro-
	      vided only for diagnostic purposes.

     VOP_BMAP(vp, bn, vpp, bnp, runp)
	      Convert the logical block number bn of a file specified by vnode vp to its physical
	      block number on the disk.  The physical block is returned in bnp.  In case the log-
	      ical block is not allocated, -1 is used.

	      If vpp is not NULL, the vnode of the device vnode for the file system is returned
	      in the address specified by vpp.	If runp is not NULL, the number of contiguous
	      blocks starting from the next block after the queried block will be returned in
	      runp.

     VOP_PRINT(vp)
	      Print debugging information.  The argument vp is the vnode to print.  If the opera-
	      tion is successful zero is returned, otherwise an appropriate error code is
	      returned.

     VOP_PATHCONF(vp, name, retval)
	      Implement POSIX pathconf(2) and fpathconf(2) support.  The argument vp is the
	      locked vnode to get information about.  The argument name specified the type of
	      information to return.  The information is returned in the address specified by
	      retval.  Valid values for name are:

		    _PC_LINK_MAX	  return the maximum number of links to a file
		    _PC_NAME_MAX	  return the maximum number of bytes in a file name
		    _PC_PATH_MAX	  return the maximum number of bytes in a pathname
		    _PC_PIPE_BUF	  return the maximum number of bytes which will be writ-
					  ten atomically to a pipe
		    _PC_CHOWN_RESTRICTED  return 1 if appropriate privileges are required for the
					  chown(2) system call, otherwise zero
		    _PC_NO_TRUNC	  return if file names longer than KERN_NAME_MAX are
					  truncated

	      If name is recognized, *retval is set to the specified value and zero is returned,
	      otherwise an appropriate error is returned.

     VOP_ADVLOCK(vp, id, op, fl, flags)
	      Manipulate Advisory record locks on a vnode.  The argument vp is the vnode on which
	      locks are manipulated.  The argument id is the id token which is changing the lock
	      and op is the fcntl(2) operation to perform.  Valid values are:

		    F_SETLK  set lock
		    F_GETLK  get the first conflicted lock
		    F_UNLCK  clear lock

	      The argument fl is a description of the lock.  In the case of SEEK_CUR, The caller
	      should add the current file offset to fl->l_start beforehand.  VOP_ADVLOCK() treats
	      SEEK_CUR as SEEK_SET.

	      The argument flags is the set of flags.  Valid values are:

		    F_WAIT   wait until lock is granted
		    F_FLOCK  use flock(2) semantics for lock
		    F_POSIX  use POSIX semantics for lock

	      If the operation is successful zero is returned, otherwise an appropriate error is
	      returned.

     VOP_WHITEOUT(dvp, cnp, flags)
	      Whiteout pathname component in directory with vnode dvp.	The argument cnp speci-
	      fies the pathname component to whiteout.

	      The vnode dvp should be locked on entry and will remain locked on return.

     VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags)
	      Read VM pages from file.	The argument vp is the locked vnode to read the VM pages
	      from.  The argument offset is offset in the file to start accessing and m is an
	      array of VM pages.  The argument count points a variable that specifies the number
	      of pages to read.  If the operation is successful zero is returned, otherwise an
	      appropriate error code is returned.  If PGO_LOCKED is specified in flags,
	      VOP_GETPAGES() might return less pages than requested.  In that case, the variable
	      pointed to by count will be updated.

	      This function is primarily used by the page-fault handing mechanism.

     VOP_PUTPAGES(vp, offlo, offhi, flags)
	      Write modified (dirty) VM pages to file.	The argument vp is the vnode to write the
	      VM pages to.  The vnode's vm object lock (v_uobj.vmobjlock) must be held by the
	      caller and will be released upon return.	The arguments offlo and offhi specify the
	      range of VM pages to write.  In case offhi is given as 0, all pages at and after
	      the start offset offlo belonging the vnode vp will be written.  The argument flags
	      controls the behavior of the routine and takes the vm pager's flags (PGO_
	      -prefixed).  If the operation is successful zero is returned, otherwise an appro-
	      priate error code is returned.

	      The function is primarily used by the pageout handling mechanism and is commonly
	      implemented indirectly by genfs_putpages() with the help of VOP_STRATEGY() and
	      VOP_BMAP().

     VOP_STRATEGY(vp, bp)
	      Read/write a file system buffer.	The argument vp is the vnode to read/write to.
	      The argument bp is the buffer to be read or written.  VOP_STRATEGY() will either
	      read or write data to the file depending on the value of bp->b_flags.  If the oper-
	      ation is successful zero is returned, otherwise an appropriate error code is
	      returned.

     VOP_BWRITE(vp, bp)
	      Write a file system buffer.  The argument vp is the vnode to write to.  The argu-
	      ment bp specifies the buffer to be written.  If the operation is successful zero is
	      returned, otherwise an appropriate error code is returned.

     VOP_GETEXTATTR(vp, attrnamespace, name, uio, size, cred)
	      Get an extended attribute.  The argument vp is the locked vnode of the file or
	      directory from which to retrieve the attribute.  The argument attrnamespace speci-
	      fies the extended attribute namespace.  The argument name is a nul-terminated char-
	      acter string naming the attribute to retrieve.  The argument uio, if not NULL,
	      specifies where the extended attribute value is to be written.  The argument size,
	      if not NULL, will contain the number of bytes required to read all of the attribute
	      data upon return.  In most cases, uio will be NULL when size is not, and vice
	      versa.  The argument cred specifies the user credentials to use when authorizing
	      the request.

     VOP_SETEXTATTR(vp, attrnamespace, name, uio, cred)
	      Set an extended attribute.  The argument vp is the locked vnode of the file or
	      directory to which to store the attribute.  The argument namespace specifies the
	      extended attribute namespace.  The argument name is a nul-terminated character
	      string naming the attribute to store.  The argument uio specifies the source of the
	      extended attribute data.	The argument cred specifies the user credentials to use
	      when authorizing the request.

     VOP_LISTEXTATTR(vp, attrnamespace, uio, size, cred)
	      Retrieve the list of extended attributes.  The argument vp is the locked vnode of
	      the file or directory whose attributes are to be listed.	The argument
	      attrnamespace specifies the extended attribute namespace.  The argument uio, if not
	      NULL, specifies where the extended attribute list is to be written.  The argument
	      size, if not NULL, will contain the number of bytes required to read all of the
	      attribute names upon return.  In most cases, uio will be NULL when size is not, and
	      vice versa.  The argument cred specifies the user credentials to use when authoriz-
	      ing the request.

     VOP_DELETEEXTATTR(vp, attrnamespace, name, cred)
	      Remove attribute name from file associated with vp.  The argument attrnamespace
	      specifies the extended attribute namespace.  If full removal is not supported, the
	      file system should return EOPNOTSUPP to allow the caller to zero out the value with
	      VOP_SETEXTATTR().

	      The vnode vp should be locked on entry and will remain locked on return.

FILES
     src/sys/kern/vnode_if.src contains the list of vnode functions, their definitions and an
     exact locking protocol.

ERRORS
     [EACCES]		Access for the specified operation is denied.

     [EDQUOT]		Quota exceeded.

     [EINVAL]		attempt to read from an illegal offset in the directory; unrecognized
			input

     [EIO]		a read error occurred while reading the directory or reading the contents
			of a symbolic link

     [EJUSTRETURN]	A CREATE or RENAME operation would be successful.

     [ENOATTR]		The requested attribute is not defined for this vnode.

     [ENOENT]		The component was not found in the directory.

     [ENOSPC]		The file system is full.

     [ENOTDIR]		The vnode does not represent a directory.

     [ENOTEMPTY]	attempt to remove a directory which is not empty

     [EPERM]		an attempt was made to change an immutable file

     [EROFS]		the file system is read-only

SEE ALSO
     extattr(9), intro(9), namei(9), vattr(9), vfs(9), vfsops(9), vnode(9)

HISTORY
     The vnode operations vector, its functions and the corresponding macros appeared in 4.3BSD.

BSD					February 13, 2012				      BSD
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 04:13 PM.