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
#include <sys/param.h>
#include <sys/buf.h>
#include <sys/dirent.h>
#include <sys/lock.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>
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, caddr_t data, int fflag,
struct ucred *cred, struct proc *p);
int
VOP_FCNTL(struct vnode *vp, u_int command, caddr_t 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, caddr_t 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 *centeridx, int access_type, vm_prot_t advice, int flags);
int
VOP_PUTPAGES(struct vnode *vp, voff_t offlo, voff_t offlo, int flags);
int
VOP_STRATEGY(struct buf *bp);
int
VOP_BWRITE(struct buf *bp);
Not all header files are required for each function.
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 specialised
macros. The following table lists the elements of the vnode operations
vector, the corresponding invocation macro, and a description of the element.
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 Implement POSIX pathconf support
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 as contiguous
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 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. Is is used to encapsulate many parameters into a singla function
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 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 setup for file creation
DELETE setup for file deletion
RENAME setup 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
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 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).
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 gives VOP_LOOKUP() hints about 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
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->cn_flags. If LOCKPARENT or ISLATCN is not set, dvp is
returned unlocked on a successful lookup. This process preserves
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->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->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 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
device-special file, this memory is released. If the devicespecial
file is created successfully it will be released unless
the SAVESTART flags in specified in cnp->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 contains
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 arguments
p and cred specifies the calling process and its credentials
respectively. VOP_GETATTR() uses the file system type
specific data object vp->v_data to reference the underlying file
attributes. Attributes associated with the file are collected
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).
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 arguments
p and cred specifies the calling process and its credentials
respectively. 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 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 argument
fflags is a set of flags. The argument cred is the
caller'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 implments 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 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 and p the calling process. If the operation
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 callling 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 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 appropriate
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 argument
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 oldoff.
The argument vp is the locked vnode of the file to test. For
most filesystems this function simply tests if oldoff is valid.
If the specified oldoff 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 pathname
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 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 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 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 successfully 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 credientials. 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 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. 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 arguments
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 argument
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 operation
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, 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 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 argument
id is the id token which is changing the lock and op is the
fcntl(2) operation to perform. The argument fl is a description
of the lock. The argument flags is the set of flags. Valid
values are:
F_RDLCK shared or read lock
F_UNLCK unlock
F_WRLCK exclusive or write lock
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 nonzero,
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 credentials
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 system
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 respectively.
The change time is always taken from the current time.
The argument flags is a set of file system type dependent flags
indicating which times should be updated.
VOP_LEASE(vp, p, cred, flag)
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( 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 specifies the number of pages to
read. If the operation is successful zero is returned, otherwise
an appropriate error code is returned.
This function is primarily used by the page-fault handing mechanism.
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 specifies
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 appropriate
error code is returned.
The function is primarily used by the pageout handling mechanism.
VOP_STRATEGY(bp)
Read/write a file system buffer. 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 vp->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
buffer to be written. If the operation is successful zero is
returned, otherwise an appropriate error code is returned.
[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 directory;
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
intro(9), lock(9), namei(9), vattr(9), vfs(9), vnode(9)
The vnode operations vector, its functions and the corresponding macros
appeared in 4.3BSD.
BSD October 16, 2001 BSD
[ Back ] |
