unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (NetBSD-2.0)
Page:
Section:
Apropos / Subsearch:
optional field

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_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_BLKATOFF, VOP_VALLOC, VOP_BALLOC, VOP_REALLOCBLKS,
     VOP_VFREE, VOP_TRUNCATE, VOP_UPDATE, VOP_LEASE, VOP_WHITEOUT,
     VOP_GETPAGES, VOP_PUTPAGES, VOP_STRATEGY, VOP_BWRITE -- vnode operations

SYNOPSIS
     #include <&lt;sys/param.h>&gt;
     #include <&lt;sys/buf.h>&gt;
     #include <&lt;sys/dirent.h>&gt;
     #include <&lt;sys/lock.h>&gt;
     #include <&lt;sys/vnode.h>&gt;
     #include <&lt;sys/mount.h>&gt;
     #include <&lt;sys/namei.h>&gt;
     #include <&lt;sys/unistd.h>&gt;
     #include <&lt;sys/fcntl.h>&gt;
     #include <&lt;sys/lockf.h>&gt;

     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, struct ucred *cred, struct proc *p);

     int
     VOP_CLOSE(struct vnode *vp, int fflag, struct ucred *cred,
         struct proc *p);

     int
     VOP_ACCESS(struct vnode *vp, int mode, struct ucred *cred,
         struct proc *p);

     int
     VOP_GETATTR(struct vnode *vp, struct vattr *vap, struct ucred *cred,
         struct proc *p);

     int
     VOP_SETATTR(struct vnode *vp, struct vattr *vap, struct ucred *cred,
         struct proc *p);

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

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

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

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

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

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

     int
     VOP_MMAP(struct vnode *vp, int fflags, struct ucred *cred,
         struct proc *p);

     int
     VOP_FSYNC(struct vnode *vp, struct ucred *cred, int flags, off_t offlo,
         off_t offhi, struct proc *p);

     int
     VOP_SEEK(struct vnode *vp, off_t oldoff, off_t newoff,
         struct ucred *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 *vp,
         struct componentname *fcnp, struct componentname *tdvp,
         struct vnode *tvp, struct componentname *tcnp);

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

     int
     VOP_RMDIR(struct vnode *vp, 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, struct ucred *cred,
         int *eofflag, cookies, ncookies);

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

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

     int
     VOP_INACTIVE(struct vnode *vp, struct proc *p);

     int
     VOP_RECLAIM(struct vnode *vp, struct proc *p);

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

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

     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_BLKATOFF(struct vnode *vp, off_t offset, char **res,
         struct buf **bpp);

     int
     VOP_VALLOC(struct vnode *pvp, int mode, struct ucred *cred,
         struct vnode **vpp);

     int
     VOP_BALLOC(struct vnode *vp, off_t startoffset, int size,
         struct ucred *cred, int flags, struct buf **bpp);

     int
     VOP_REALLOCBLKS(struct vnode *vp, struct cluster_save *buflist);

     int
     VOP_VFREE(struct vnode *pvp, ino_t ino, int mode);

     int
     VOP_TRUNCATE(struct vnode *vp, off_t length, int flags,
         struct ucred *cred, struct proc *p);

     int
     VOP_UPDATE(struct vnode *vp, struct timespec *access,
         struct timespec *modify, int flags);

     int
     VOP_LEASE(struct vnode *vp, struct proc *p, struct ucred *cred,
         int flag);

     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 offlo, int flags);

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

     int
     VOP_BWRITE(struct buf *bp);

     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 opera-
     tions vector for each file system type configured into the kernel.  The
     vnode operations vector contains a pointer to a function for each opera-
     tion 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 specialised
     macros.  The following table lists the elements of the vnode operations
     vector, the corresponding invocation macro, and a description of the ele-
     ment.

     Vector element            Macro            Description
     int (*vop_lookup)()       VOP_LOOKUP       Lookup file name in name cache
     int (*vop_create)()       VOP_CREATE       Create a new file
     int (*vop_mknod)()        VOP_MKNOD        Make a new device
     int (*vop_open)()         VOP_OPEN         Open a file
     int (*vop_close)()        VOP_CLOSE        Close a file
     int (*vop_access)()       VOP_ACCESS       Determine file accessibility
     int (*vop_getattr)()      VOP_GETATTR      Get file attributes
     int (*vop_setattr)()      VOP_SETATTR      Set file attributes
     int (*vop_read)()         VOP_READ         Read from a file
     int (*vop_write)()        VOP_WRITE        Write to a file
     int (*vop_ioctl)()        VOP_IOCTL        Perform device-specific I/O
     int (*vop_fcntl)()        VOP_FCNTL        Perform file control
     int (*vop_poll)()         VOP_POLL         Test if poll event has occurred
     int (*vop_revoke)()       VOP_REVOKE       Eliminate vode activity
     int (*vop_mmap)()         VOP_MMAP         Map file into user address space
     int (*vop_fsync)()        VOP_FSYNC        Flush pending data to disk
     int (*vop_seek)()         VOP_SEEK         Test if file is seekable
     int (*vop_remove)()       VOP_REMOVE       Remove a file
     int (*vop_link)()         VOP_LINK         Link a file
     int (*vop_rename)()       VOP_RENAME       Rename a file
     int (*vop_mkdir)()        VOP_MKDIR        Make a new directory
     int (*vop_rmdir)()        VOP_RMDIR        Remove a directory
     int (*vop_symlink)()      VOP_SYMLINK      Create a symbolic link
     int (*vop_readdir)()      VOP_READDIR      Read directory entry
     int (*vop_readlink)()     VOP_READLINK     Read contents of a symlink
     int (*vop_abortop)()      VOP_ABORTOP      Abort pending operation
     int (*vop_inactive)()     VOP_INACTIVE     Release the inactive vnode
     int (*vop_reclaim)()      VOP_RECLAIM      Reclaim vnode for another file
     int (*vop_lock)()         VOP_LOCK         Sleep until vnode lock is free
     int (*vop_unlock)()       VOP_UNLOCK       Wake up process sleeping on lock
     int (*vop_islocked)()     VOP_ISLOCKED     Test if vnode is locked
     int (*vop_bmap)()         VOP_BMAP         Logical block number conversion
     int (*vop_print)()        VOP_PRINT        Print debugging information
     int (*vop_pathconf)()     VOP_PATHCONF     Return POSIX pathconf data
     int (*vop_advlock)()      VOP_ADVLOCK      Advisory record locking
     int (*vop_blkatoff)()     VOP_BLKATOFF     Retrieve buffer from offset
     int (*vop_valloc)()       VOP_VALLOC       Allocate fs-specific data
     int (*vop_balloc)()       VOP_BALLOC       Allocate physical blocks
     int (*vop_reallocblks)()  VOP_REALLOCBLKS  Rearrange blocks contiguously
     int (*vop_vfree)()        VOP_VFREE        Release file resources
     int (*vop_truncate)()     VOP_TRUNCATE     Truncate file and free blocks
     int (*vop_update)()       VOP_UPDATE       Update time on a file
     int (*vop_lease)()        VOP_LEASE        Validate vnode credentials
     int (*vop_whiteout)()     VOP_WHITEOUT     Whiteout vnode
     int (*vop_getpages)()     VOP_GETPAGES     Read VM pages from file
     int (*vop_putpages)()     VOP_PUTPAGES     Write VM pages to file
     int (*vop_strategy)()     VOP_STRATEGY     Read/write a file system buffer
     int (*vop_bwrite)()       VOP_BWRITE       Write a file system buffer

     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 function in the vnode operations vec-
     tor 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.  Is is used to encapsulate many parameters into a single func-
     tion argument.  It has the following structure:

     struct componentname {
             /*
              * Arguments to lookup.
              */
             u_long  cn_nameiop;     /* namei operation */
             u_long  cn_flags;       /* flags to namei */
             struct  proc *cn_proc;  /* process requesting lookup */
             struct  ucred *cn_cred; /* credentials */
             /*
              * Shared between lookup and commit routines.
              */
             char    *cn_pnbuf;      /* pathname buffer */
             const char *cn_nameptr; /* pointer to looked up name */
             long    cn_namelen;     /* length of looked up component */
             u_long  cn_hash;        /* hash value of looked up name */
             long    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 initialised by the caller.  The seman-
     tics 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-&gt;cn_flags are:

           LOCKLEAF    lock inode on return
           LOCKPARENT  want parent vnode returned locked
           WANTPARENT  want parent vnode returned unlocked
           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 opera-
     tions also require the vnode to be locked on entry.  To prevent dead-
     locks, when acquiring locks on multiple vnodes, the lock of parent direc-
     tory 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 path-
              name component is found, the address of the resulting locked
              vnode is returned in vpp.  The operation specified in
              cnp-&gt;cn_nameiop gives VOP_LOOKUP() hints about the reason for
              requesting the lookup and uses it to cache file system type spe-
              cific information in the vnode for subsequent operations.

              There are three types of lookups: ".", ".." (ISDOTDOT), and
              other.  If the pathname 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 if and only if LOCKPARENT and ISLASTCN is set in
              cnp-&gt;cn_flags.  If LOCKPARENT or ISLATCN is not set, dvp is
              returned unlocked on a successful lookup.  This process pre-
              serves the protocol of always locking nodes from root downward
              and prevents deadlock.  For other pathname components,
              VOP_LOOKUP() checks the accessibility 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.  If LOCKPARENT or ISLATCN is
              not set, dvp is returned unlocked on a successful lookup.

              On failure *vpp is NULL, and *dvp is left locked.  If there was
              an error relocking dvp (for instance in the ISDOTDOT case) the
              error is returned with PDIRUNLOCK set in cnp-&gt;cn_flags.  This
              flag signals to the caller that dvp ' s lock state has changed.
              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.

              This function is called after VOP_LOOKUP() when a file is being
              created.  Normally, VOP_LOOKUP() will have set the SAVENAME flag
              in cnp-&gt;cn_flags to keep the memory pointed to by cnp-&gt;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-&gt;cn_flags.

     VOP_MKNOD(dvp, vpp, cnp, vap)
              Make a new device-special file in a given directory.  The argu-
              ment 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 created.  Normally, VOP_LOOKUP() will have set the
              SAVENAME flag in cnp-&gt;cn_flags to keep the memory pointed to by
              cnp-&gt;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-&gt;cn_flags.

     VOP_OPEN(vp, mode, cred, p)
              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 process and its credentials are specified
              by p and cred respectively.  The access mode is a set of flags,
              including FREAD, FWRITE, O_NONBLOCK, 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, p)
              Close a file.  The argument vp is the vnode of the file to close
              and fflags specifies the access mode by the calling process.
              The calling process and its credentials are specified by p and
              cred respectively.  VOP_CLOSE() must be called after a file is
              finished with.

              VOP_CLOSE() expects at least a reference to be associated with
              the vnode and does not care whether the vnode is locked.  The
              lock and reference state is left unchanged on return.

     VOP_ACCESS(vp, mode, cred, p)
              Determine the accessibility (permissions) of the file against
              the specified credentials.  The argument vp is the vnode of the
              file to check, mode is the type of access required, cred con-
              tains the user credentials to check and p is the process which
              is checking the credentials.  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, p)
              Get specific vnode attributes on a file.  The argument vp is the
              locked vnode of the file to get the attributes for.  The argu-
              ments p and cred specifies the calling process and its creden-
              tials respectively.  VOP_GETATTR() uses the file system type
              specific data object vp-&gt;v_data to reference the underlying file
              attributes.  Attributes associated with the file are collected
              by setting the required attribute bits in vap-&gt;va_mask.  The
              attributes are returned in vap.  Attributes which are not avail-
              able are set to the value VNOVAL.

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

     VOP_SETATTR(vp, vap, cred, p)
              Set specific vnode attributes on a file.  The argument vp is the
              locked vnode of the file to set the attributes for.  The argu-
              ments p and cred specifies the calling process and its creden-
              tials respectively.  VOP_SETATTR() uses the file system type
              specific data object vp-&gt;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-&gt;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        do I/O synchronously
                    IO_NODELOCKED  underlying node already locked
                    IO_NDELAY      FNDELAY flag set in file table
                    IO_VMIO        data already in VMIO space

              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 credentials 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, p)
              Perform device-specific I/O.  The argument vp is the locked
              vnode of the file, normally representing a device.  The argument
              command specifies the device-specific operation to perform and
              cnp provides extra data for the specified operation.  The argu-
              ment fflags is a set of flags.  The argument cred is the call-
              er's credentials and p the calling process.  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 implements the ioctl(2) system call.

     VOP_FCNTL(vp, command, data, fflag, cred, p)
              Perform file control.  The argument vp is the locked vnode of
              the file.  The argument command specifies the operation to per-
              form 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 and p the calling process.  If the opera-
              tion is successful, zero is returned, otherwise an appropriate
              error code is returned.

     VOP_POLL(vp, events, p)
              Test if a poll event has occurred.  The argument vp is the
              locked vnode of the file to poll and p is the calling process.
              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).  If the operation is successful
              zero is returned, otherwise an appropriate error code is
              returned.

     VOP_REVOKE(vp, flags)
              Eliminate all activity associated with the vnode vp.  The argu-
              ment 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 appropri-
              ate error is returned.

     VOP_MMAP(vp, fflags, cred, p)
              Map file into user address space.  The argument vp is the locked
              vnode of the file to map into an address space.  The argument
              fflags is a set of flags.  The argument cred is the caller's
              credentials and p the calling process requesting the map.  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_MMAP().  This
              function implements the mmap(2) system call.

     VOP_FSYNC(vp, cred, flags, offlo, offhi, p)
              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 and p the calling process.  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 filesystems 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 should be locked on entry and remain locked on
              return.

     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
              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 remain locked 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 containing in the file to be renamed and fvp is the
              vnode of the file to be renamed.  The argument fcnp is the path-
              name component about the file to be remained.  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 and 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 directory
              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.  Normally, VOP_LOOKUP() will have set the SAVE-
              NAME flag in cnp-&gt;cn_flags to keep the memory pointed to by
              cnp-&gt;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-&gt;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 directory 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 remain locked 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 success-
              fully 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-&gt;cn_flags to keep the memory pointed to by
              cnp-&gt;cn_pnbuf valid.  If an error is detected when creating the
              symbolic link, this memory is released.  If the symbolic link is
              created successfully it will be released unless the SAVESTART
              flags in specified in cnp-&gt;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 and 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 cookies gen-
              erated 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.  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.

              If VOP_READDIR() is called from the NFS server, the extra argu-
              ments eofflag, ncookies and cookies are used.  The value of
              *eofflag will be set to TRUE if the end of the directory is
              reached while reading.  The directory seek cookies are returned
              to the NFS client and may be used later to restart a directory
              read part way through the directory.  There should be one cookie
              returned per directory entry.  The value of the cookie should be
              the offset within the directory where the on-disk version of the
              appropriate directory entry starts.

     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 argument 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.  This operation is rarely
              implemented in file systems.

     VOP_INACTIVE(vp, p)
              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 argu-
              ment vp is the locked vnode to be released.  The argument p is
              the calling process.  If the operation is successful zero is
              returned, otherwise an appropriate error code is returned.  The
              vnode vp must be locked on entry, and will be unlocked on
              return.

     VOP_RECLAIM(vp, p)
              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 associated with the vnode
              should be freed.  The argument vp is the locked vnode to be
              reclaimed.  The argument p is the calling process.  If the oper-
              ation is successful zero is returned, otherwise an appropriate
              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 a set of
              lockmgr(9) flags.  If the operation is successful zero is
              returned, otherwise an appropriate error code is returned.
              VOP_LOCK() is used to serialise access to the file system such
              as to present 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, flags)
              Wake up process sleeping on lock.  The argument vp is the vnode
              of the file to be unlocked.  The argument flags is a set of
              lockmgr(9) flags.  If the operation is successful zero is
              returned, otherwise an appropriate error code is returned.
              VOP_UNLOCK() is used to serialise access to the file system such
              as to present two writes to the same file from happening at the
              same time.

     VOP_ISLOCKED(vp)
              Test if the vnode vp is locked.  A non-zero values is returned
              if the vnode is not locked, otherwise zero is returned.

     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.  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 maximum blocksize is returned in the address specified by
              runp.

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

     VOP_PATHCONF(vp, name, retval)
              Implement POSIX pathconf(2) and fpathconf(2) support.  The argu-
              ment vp is the locked vnode to get information about.  The argu-
              ment 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 written 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 recognised, *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 file.  The argument vp is
              the vnode is the file for the advisory record lock.  The argu-
              ment 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.  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_BLKATOFF(vp, offset, res, bpp)
              Return buffer bpp with the contents of block offset from the
              beginning of directory specified by vnode vp.  If res is non-
              zero, fill it in with a pointer to the remaining space in the
              directory.

     VOP_VALLOC(pvp, mode, cred, vpp)
              Allocate file system type specific data a new file in the file
              system.  The argument pvp specifies the vnode of the directory
              to create the new file.  The argument mode specifies file system
              type specific flags and cred are the credentials of the calling
              process.  The vnode of the new file is returned in the address
              specified by vpp.

     VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
              Allocate the physical blocks on a device given the vnode vp and
              the offset logical block number startoffset in a file.  The
              argument size specifies the size to be allocated.  The creden-
              tials of the calling processing are specified by cred.  If the
              argument bpp is not NULL, the buffer is written to the allocated
              blocks.  The argument flags is a set of flags controlling the
              low-level allocation when the buffer is written.  Valid values
              defined in <sys/buf.h> are:

                    B_CLRBUF  request allocated buffer be cleared
                    B_SYNC    do all allocations synchronously
              If the operation is successful zero is returned, otherwise an
              appropriate error is returned.

     VOP_REALLOCBLKS(vp, buflist)
              Rearrange block in a file to be contiguous.  The argument vp is
              the vnode of the file to manipulate.  The argument buflist is a
              list of buffers to rearrange.  If the operation is successful
              zero is returned, otherwise an appropriate error is returned.

     VOP_VFREE(pvp, ino, mode)
              Release file resources.  This function is used by the file sys-
              tem to release cached file system specific data associated with
              the file when the vnode is recycled.

     VOP_TRUNCATE(vp, length, flags, cred, p)
              Truncate the file specified by the vnode vp to at most length
              size and free the unused disk blocks.  The arguments p and cred
              is the calling process and its credentials respectively.  The
              argument flags is a set of I/O flags.  Valid values are:

                    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

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

     VOP_UPDATE(vp, access, modify, flags)
              Update times on file with vnode vp.  The access and modification
              times are specified by the arguments access and modify respec-
              tively.  The change time is always taken from the current time.
              The argument flags is a set of file system type dependent flags
              indicating how times should be updated:

                    UPDATE_WAIT   wait for completion
                    UPDATE_DIROP  hint to file system to wait or not

     VOP_LEASE(vp, p, cred, flags)
              Validate vnode credentials and operation type.  The argument vp
              is the locked vnode of the file to validate credentials cred.
              The argument p specifies the calling process and flags specifies
              the operation flags.  If the operation is successful zero is
              returned, otherwise an appropriate error code is returned.  The
              vnode must be locked on entry and remains locked on return.

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

     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 mecha-
              nism.

     VOP_PUTPAGES(vp, offset, len, flags)
              Write modified (dirty) VM pages to file.  The argument vp is the
              locked vnode to write the VM pages to and offset and len speci-
              fies the range of VM pages to write.  There seems to be some
              confusion in the code whether offset and len specify the start
              and length of the VM pages for the start and end of the VM
              pages.  The argument flags specifies whether the pages should be
              written asynchronously and also whether they should be marked
              invalid one the write back operation has completed.  If the
              operation is successful zero is returned, otherwise an appropri-
              ate error code is returned.

              The function is primarily used by the pageout handling mecha-
              nism.

     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-&gt;b_flags.  If the operation is
              successful zero is returned, otherwise an appropriate error code
              is returned.

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

ERRORS
     [ENOTDIR]          The vnode does not represent a directory.

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

     [ENOSPC]           The file system is full.

     [EDQUOT]           Quota exceeded.

     [EACCES]           Access for the specified operation is denied.

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

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

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

     [EINVAL]           attempt to read from an illegal offset in the direc-
                        tory; unrecognised input

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

     [EROFS]            the filesystem is read-only

SEE ALSO
     intro(9), lock(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                             Januar 25, 2004                            BSD