bjayesh/m241Neelima
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

original files of m241

Browse Source
This commit is contained in:
neelimap
2026-07-30 11:19:44 +05:30
parent 170c2b3f3a
commit afc7070c1f
12254 changed files with 7655111 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
vxworks-6.9/target/h/vnode.h
+748
View File
@@ -0,0 +1,748 @@
/* vnode.h - vnode interface */
/*
* Copyright 2005-2007 Wind River Systems, Inc.
*
* The right to copy, distribute, modify or otherwise make use
* of this software may be licensed only pursuant to the terms
* of an applicable Wind River license agreement.
*/
/*
modification history
--------------------
02a,11jun07,jlk SMP work
01z,25jul06,act add vinvalbuf() prototype; vflushbuf() now returns an errno
01y,06jul06,act add vflushbuf() prototype
01x,27jun06,act add vpurgebufs
01x,05may06,pcm removed commented out ino_t typedef
01w,08nov05,jlk SPR 113295 fixed race condition during lookup
01v,04jan06,act add POSIX file locking
01u,21nov05,md make struct vnode_ops a const
01t,08nov05,jlk SPR 113295 fixed race condition during lookup
01s,07oct05,md add defines for POSIX
01r,22jul05,jlk removed IO_* macros. Updated readdir macros, prototypes to use
struct dirent * instead of struct uio *.
01q,21jul05,act change IO_* to VNIO_* to avoid clashes with ioQLib.h
01p,20jul05,act add vaccess()
01o,04jul05,jlk added macros to upgrade and downgrade vnode locks
01n,13jun05,act add VRENAME vnode flag
01m,16apr05,act don't need vop_error_link_eisdir
01l,16apr05,act add vopErrorENOTDIR and vopErrorEISDIR functions
01k,15apr05,act rm v_size, which is not being used
01j,13apr05,act add struct ucred
01i,12apr05,act vop_strategy and vop_print should return void
01h,12apr05,act can't have a generic "error rename", supply a specific one
instead
01g,05apr05,act put one cookie back into readdir vop
01f,04apr05,act remove cookies args from VOP_READDIR
01e,30mar05,act simplify various vnode ops by not requiring unlocking
01d,30mar05,act VOP_CREATE is simpler if it leaves dvp locked
01c,25feb05,act fixed several VOP macros; added prototype for vattr_null
01b,23feb05,pcm added vop_error_open()
*/
#ifndef __INCvnodeh
#define __INCvnodeh
/* from $NetBSD: vnode.h,v 1.126 2004/09/21 03:10:35 thorpej Exp $ */
/*
* Copyright (c) 1989, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)vnode.h 8.17 (Berkeley) 5/20/95
*/
#include <vxWorks.h>
#include <sys/queue.h>
#include <semLib.h>
#include <time.h>
#include <dirent.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef notyet
struct namecache;
#endif
struct componentname;
struct uio;
struct ucred;
struct vattr;
struct flock;
struct lockf;
typedef int64_t voff_t;
/*
* The vnode is the focus of all file activity. There is a
* unique vnode allocated for each active file (plus one for
* file-system-metadata).
*
* Unlike the BSDs, vnodes are allocated per mount, so vnodes never
* need to move from one file system type to another.
*/
/*
* Vnode hashing, per mount-point. This hash function probably needs
* tuning. Note that the current VN_HASH definition depends on VN_VHSIZE
* being a power of two.
*/
#define VN_VHSIZE 32
#define VN_HASH(ino) ((ino) & (VN_VHSIZE - 1))
/*
* Vnode types. VNON means no type. We may not need VBAD, and
* the block, character, link, socket, and fifo types are named
* only for BSD compatibility.
*/
enum vtype { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VMETA, VBAD };
LIST_HEAD(buflists, buf);
/*
* Reading or writing any of these items requires holding the appropriate lock.
* v_freelist is locked by the mount point's vnode hash chain lock
* v_flag, v_usecount, v_holdcount and v_writecount are
* locked by the v_interlock simple lock
*
* Each underlying filesystem has its own private area for v_data.
*
* Unlike BSD vnodes, ours have an inode number attached at all times.
* This is the same as the number that will be used in the vfs_vget operation
* (see mount.h). Vnodes can cache inode data by inode number. For a
* vnode that does not correspond to an ordinary file in the file system,
* use VNOINODE.
*
* Similarly, all vnodes always have a working vnode lock, locked
* with VN_EXLOCK (exclusive lock) or VN_SHLOCK (shared lock) and
* unlocked with VN_UNLOCK. (Upgrade/downgrade is not yet implemented
* and VN_SHLOCK is currently an exclusive lock.) There is no VOP_LOCK
* nor VOP_UNLOCK as vnodes do not stack.
*/
struct vnode {
SEM_ID v_interlock;
SEM_ID v_alloclock;
int v_flag; /* flags */
atomic_t v_numoutput; /* number of pending writes */
SEM_ID v_output_active; /* binary sem for numout==0 */
long v_usecount; /* reference count of users */
long v_writecount; /* reference count of writers */
long v_holdcnt; /* page & buffer references */
ino_t v_inode; /* inode number, or 0 */
struct mount *v_mount; /* ptr to vfs we are in */
const struct vnode_ops *v_ops; /* vnode operations */
TAILQ_ENTRY(vnode) v_freelist; /* vnode freelist */
LIST_ENTRY(vnode) v_hash; /* hash chain */
struct buflists v_cleanblkhd; /* clean blocklist head */
struct buflists v_dirtyblkhd; /* dirty blocklist head */
LIST_ENTRY(vnode) v_synclist; /* vnodes with dirty buffers */
#ifdef notyet
LIST_HEAD(, namecache) v_dnclist; /* namecaches for children */
LIST_HEAD(, namecache) v_nclist; /* namecaches for parent */
#endif
enum vtype v_type; /* vnode type */
#ifdef notyet /* don't have read/writer locks yet */
struct lock v_lock; /* lock for this vnode */
#else
SEM_ID v_lock;
#endif
struct lockf *v_lfhead; /* lockf() list head */
LIST_HEAD(, lockf) v_lfbq; /* lcokf() blocked-locks */
/*
* Per-file-system data. This is actually variable length,
* allocated when you instantiate a file system and its
* "struct mount" and so forth, according to the size you
* give for the file system module.
*/
union {
char v_data[1]; /* vnode data */
/* these merely force v_data to be aligned */
long v_un_long;
long long v_un_llong;
void *v_un_ptr;
} v_data_un;
};
#define VTODATA(type, vp) ((type *)((vp)->v_data_un.v_data))
/* inode number for "not a file" vnodes */
#define VNOINODE ((ino_t)0)
/*
* Vnode flags.
*
* Many of these (commented out) are not used in vxWorks.
* We add VRUNNING to distinguish between "vnode that is being
* initialized" and "vnode that has finished initializing".
* We add VRENAME to mark a directory that is being renamed
* (it cannot be held locked, but only one rename should be
* allowed to proceed at a time).
*/
#define VROOT 0x0001 /* root of its file system */
/* VTEXT 0x0002 -- vnode is a pure text prototype */
#define VRUNNING 0x0002 /* vnode is up and running */
/* VSYSTEM only used to skip vflush()ing quota files */
/* VSYSTEM 0x0004 -- vnode being used by kernel */
/* VISTTY used when reading dead vnodes */
/* VISTTY 0x0008 -- vnode represents a tty */
/* VEXECMAP 0x0010 -- vnode has PROT_EXEC mappings */
/* VLOCKSWORK 0x0080 -- FS supports locking discipline */
/* VXLOCK 0x0100 -- vnode is locked to change underlying type */
#define VRENAME 0x0100 /* vnode is being rename()d */
/* VXWANT 0x0200 -- process is waiting for vnode */
/* VBWAIT 0x0400 -- waiting for output to complete */
/* VALIASED 0x0800 -- vnode has an alias */
/* VDIROP 0x1000 -- LFS: vnode is involved in a directory op */
/* VLAYER 0x2000 -- vnode is on a layer filesystem */
#define VONWORKLST 0x4000 /* On syncer work-list */
/* VDIRTY 0x8000 -- vnode possibly has dirty pages */
/*
* Vnode operations.
*
* BSD computes the set of operations at boot time; we do not need this
* and just have this fixed set.
*
* For each op's vnodes, we include a specification of the locking
* protocol for that operation. The three columns are in, out, and error
* respectively. The "in" column defines the lock state on input, the
* "out" column defines the state on successful return, and the "error"
* column defines the state on error exit.
*
* The locking value can take the following values:
* L: locked
* U: unlocked
* -: not applicable, vnode does not yet (or no longer) exists
* =: the same on input and output, may be either L or U
* X: locked if not nil.
*
* The lookup operation defies simple description, however. Its lock
* state depends on the flags and operations fields in the (cnp) structure.
* Note especially that *vpp may equal dvp and both may be locked.
*
* There are three types of lookups: ".", ".." (ISDOTDOT), and other.
* On successful lookup of ".", a reference is added to dvp, and it
* is returned in *vpp.
* To look up ISDOTDOT, dvp is unlocked, the ".." node is locked, and
* then dvp is relocked iff LOCKPARENT is set and this is the last
* component name (ISLASTCN set). This preserves the protocol of
* always locking nodes from the root ("/") downward and prevents
* deadlock.
* Other lookups find the named node (creating the vnode if needed) and
* return it, locked, in *vpp.
* For non-"." lookups, if LOCKPARENT is not set or this was not the
* last component name, dvp is returned unlocked on a successful
* lookup.
* On failure, *vpp is NULL, and *dvp is left locked or unlocked (as
* desired by the file system).
*
* All of this is relaxed inside actual file systems, which merely need
* to return successful new vnodes locked in *vpp (handling "." by increasing
* the reference count), or setting the PDIRUNLOCK flag if dvp has been
* unlocked. If the file system leaves dvp locked but the lookup operation
* does not need dvp locked, the lookup code will unlock it; if the file
* system has unlocked dvp for ISDOTDOT purposes, it can leave it unlocked
* and just set PDIRUNLOCK.
*
* In other words: if you are implementing a file system, you must handle
* "." and ".." specially (by returning with *vpp = dvp in the first case,
* after increasing the reference count, and by unlocking dvp before going
* up the tree in the second case). You must also set PDIRUNLOCK if you
* return with dvp unlocked. Other than that, you should just leave dvp
* locked.
*/
struct vnode_ops {
int (*vop_lookup)(
struct vnode *dvp, /* L ? ? */
struct vnode **vpp, /* - L - */
struct componentname *cnp
);
int (*vop_create)(
struct vnode *dvp, /* L L L */
struct vnode **vpp, /* - L - */
struct componentname *cnp, /* cnp flags: CREATE, LOCKPARENT */
struct vattr *vap
);
int (*vop_open)(
struct vnode *vp, /* L L L */
int mode,
struct ucred *cred
);
int (*vop_close)(
struct vnode *vp, /* L L L */
int fflag,
struct ucred *cred
);
int (*vop_access)(
struct vnode *vp, /* L L L */
int mode,
struct ucred *cred
);
int (*vop_getattr)(
struct vnode *vp, /* = = = */
struct vattr *vap,
struct ucred *cred
);
int (*vop_setattr)(
struct vnode *vp, /* L L L */
struct vattr *vap,
struct ucred *cred
);
int (*vop_read)(
struct vnode *vp, /* L L L */
struct uio *uio,
int ioflag,
struct ucred *cred
);
int (*vop_write)(
struct vnode *vp, /* L L L */
struct uio *uio,
int ioflag,
struct ucred *cred
);
int (*vop_ioctl)(
struct vnode *vp, /* L L L */
u_long command,
void *data,
int fflag,
struct ucred *cred
);
int (*vop_fcntl)(
struct vnode *vp, /* L L L */
u_int command,
void *data,
int fflag,
struct ucred *cred
);
int (*vop_fsync)(
struct vnode *vp, /* L L L */
struct ucred *cred,
int flags
);
int (*vop_seek)(
struct vnode *vp, /* ? ? ? */
voff_t oldoff,
voff_t newoff,
struct ucred *cred
);
int (*vop_remove)(
struct vnode *dvp, /* L L L */
struct vnode *vp, /* L L L */
struct componentname *cnp /* DELETE, LOCKPARENT | LOCKLEAF */
);
int (*vop_link)(
struct vnode *dvp, /* L L L */
struct vnode *vp, /* U U U */
struct componentname *cnp /* CREATE, LOCKPARENT */
);
int (*vop_rename)(
struct vnode *fdvp, /* U U U */
struct vnode *fvp, /* U U U */
struct componentname *fcnp, /* DELETE, WANTPARENT | SAVESTART */
struct vnode *tdvp, /* L U U */
struct vnode *tvp, /* X U U */
struct componentname *tcnp /* RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART */
/* XXX the vop_rename routines should REALLY NOT be depending on SAVESTART! */
);
int (*vop_mkdir)(
struct vnode *dvp, /* L L L */
struct vnode **vpp, /* - L - */
struct componentname *cnp, /* CREATE, LOCKPARENT */
struct vattr *vap
);
int (*vop_rmdir)(
struct vnode *dvp, /* L L L */
struct vnode *vp, /* L L L */
struct componentname *cnp /* DELETE, LOCKPARENT | LOCKLEAF */
);
int (*vop_symlink)(
struct vnode *dvp, /* L L L */
struct vnode **vpp, /* - L - */
struct componentname *cnp, /* CREATE, LOCKPARENT */
struct vattr *vap,
char *target
);
int (*vop_readdir)(
struct vnode *vp, /* L L L */
struct dirent *direntp,
struct ucred *cred,
int *eofflag,
int *cookie /* really, FS-level seek offset */
);
int (*vop_readlink)(
struct vnode *vp, /* L L L */
struct uio *uio,
struct ucred *cred
);
int (*vop_abortop)(
struct vnode *dvp, /* = = = */
struct componentname *cnp /* flags per op being aborted */
);
int (*vop_activate)(
struct vnode *vp /* L L L */
);
int (*vop_inactive)(
struct vnode *vp /* L L L */
);
#if 0
int (*vop_lock)(
struct vnode *vp /* U L U */
);
int (*vop_unlock)(
struct vnode *vp /* L U L */
);
#endif
void (*vop_strategy)(
struct vnode *vp, /* = = = */
struct buf *bp
);
void (*vop_print)(
struct vnode *vp /* = = = */
);
int (*vop_pathconf)(
struct vnode *vp, /* L L L */
int name,
long *retval
);
int (*vop_advlock)(
struct vnode *vp, /* U U U */
void *id,
int op,
struct flock *fl,
int flags
);
int (*vop_truncate)(
struct vnode *vp, /* L L L */
voff_t length,
int flags,
struct ucred *ucred
);
};
/*
* Vnode attributes. A field value of VNOVAL represents a field whose value
* is unavailable (getattr) or which is not to be changed (setattr).
*/
struct vattr {
enum vtype va_type; /* vnode type (for create) */
mode_t va_mode; /* file access mode and type */
nlink_t va_nlink; /* number of references to file */
uid_t va_uid; /* owner user id */
gid_t va_gid; /* owner group id */
long va_fsid; /* file system id (dev for now) */
uint64_t va_fileid; /* file id */
uint64_t va_size; /* file size in bytes */
long va_blocksize; /* blocksize preferred for i/o */
struct timespec va_atime; /* time of last access */
struct timespec va_mtime; /* time of last modification */
struct timespec va_ctime; /* time file changed */
struct timespec va_birthtime; /* time file created */
u_long va_gen; /* generation number of file */
u_long va_flags; /* flags defined for file */
dev_t va_rdev; /* device the special file represents */
uint64_t va_bytes; /* bytes of disk space held by file */
uint64_t va_filerev; /* file modification number */
u_int va_vaflags; /* operations flags, see below */
long va_spare; /* remain quad aligned */
};
/*
* Flags for va_vaflags.
*/
#define VA_UTIMES_NULL 0x01 /* utimes argument was NULL */
#define VA_EXCLUSIVE 0x02 /* exclusive create request */
/*
* Flags for ioflag (read/write vnode ops).
*/
#define VNIO_UNIT 0x01 /* do I/O as atomic unit */
#define VNIO_APPEND 0x02 /* append write to end */
#define VNIO_SYNC (0x04|VNIO_DSYNC) /* sync I/O file integrity completion */
#define VNIO_NODELOCKED 0x08 /* underlying node already locked */
#define VNIO_NDELAY 0x10 /* FNDELAY flag set in file table */
#define VNIO_DSYNC 0x20 /* sync I/O data integrity completion */
#define VNIO_RSYNC 0x40 /* sync read operations at same level */
#define VNIO_ALTSEMANTICS 0x80 /* use alternate i/o semantics */
/*
* Modes for vaccess() (fifth argument).
*/
#define VREAD 0004 /* read, write, execute permissions */
#define VWRITE 0002
#define VEXEC 0001
/*
* Token indicating no attribute value yet assigned.
*/
#define VNOVAL (-1)
/*
* Flags to various vnode functions.
* XXX DON'T KNOW IF WE NEED MOST OF THESE
*/
/*efine SKIPSYSTEM 0x0001 -- vflush: skip vnodes marked VSYSTEM */
#define FORCECLOSE 0x0002 /* vflush: force file closeure */
#define WRITECLOSE 0x0004 /* vflush: only close writeable file */
#define DOCLOSE 0x0004 /* vclean: close active files */
#define V_SAVE 0x0001 /* vinvalbuf: sync file first */
/*
* Flags to various vnode operations.
*/
#define FSYNC_WAIT 0x0001 /* fsync: wait for completion */
#define FSYNC_DATAONLY 0x0002 /* fsync: hint: sync file data only */
#define FSYNC_RECLAIM 0x0004 /* fsync: hint: vnode is being reclaimed */
#define FSYNC_LAZY 0x0008 /* fsync: lazy sync (trickle) */
#define UPDATE_WAIT 0x0001 /* update: wait for completion */
#define UPDATE_DIROP 0x0002 /* update: hint for fs to wait or not */
#define UPDATE_CLOSE 0x0004 /* update: clean up on close */
#define VPURGE_CLEAN 1 /* vpurge: purge clean buffers */
#define VPURGE_DIRTY 2 /* vpurge: purge dirty buffers */
/* hold/holdrele should not appear outside vnodeSubr.c */
/* #define HOLDRELE(vp) holdrele(vp) */
/* #define VHOLD(vp) vhold(vp) */
#define VREF(vp) vref(vp)
/*
* Get shared or exclusive lock on vnode. Currently shared locks are
* actually exclusive.
*/
#define VN_SHLOCK(vp) semTake((vp)->v_lock, WAIT_FOREVER)
#define VN_EXLOCK(vp) semTake((vp)->v_lock, WAIT_FOREVER)
#define VN_UNLOCK(vp) semGive((vp)->v_lock)
/*
* These macros upgrade from a shared lock to an exclusive locks and downgrade
* from an exclusive lock to a shared lock. Currently, as there's no difference
* in lock types they do nothing.
*/
#define VN_UPLOCK(vp)
#define VN_DOWNLOCK(vp)
/*
* File system operations.
*/
#define VOP_LOOKUP(dvp, vpp, cnp) \
((dvp)->v_ops->vop_lookup(dvp, vpp, cnp))
#define VOP_CREATE(dvp, vpp, cnp, vap) \
((dvp)->v_ops->vop_create(dvp, vpp, cnp, vap))
#define VOP_OPEN(vp, mode, cred) \
((vp)->v_ops->vop_open(vp, mode, cred))
#define VOP_CLOSE(vp, fflag, cred) \
((vp)->v_ops->vop_close(vp, fflag, cred))
#define VOP_ACCESS(vp, mode, cred) \
((vp)->v_ops->vop_access(vp, mode, cred))
#define VOP_GETATTR(vp, vap, cred) \
((vp)->v_ops->vop_getattr(vp, vap, cred))
#define VOP_SETATTR(vp, vap, cred) \
((vp)->v_ops->vop_setattr(vp, vap, cred))
#define VOP_READ(vp, uio, ioflag, cred) \
((vp)->v_ops->vop_read(vp, uio, ioflag, cred))
#define VOP_WRITE(vp, uio, ioflag, cred) \
((vp)->v_ops->vop_write(vp, uio, ioflag, cred))
#define VOP_IOCTL(vp, cmd, data, fflag, cred) \
((vp)->v_ops->vop_ioctl(vp, cmd, data, fflag, cred))
#define VOP_FCNTL(vp, cmd, data, fflag, cred) \
((vp)->v_ops->vop_fcntl(vp, cmd, data, fflag, cred))
#define VOP_FSYNC(vp, cred, flags) \
((vp)->v_ops->vop_fsync(vp, cred, flags))
#define VOP_SEEK(vp, oldoff, newoff, cred) \
((vp)->v_ops->vop_seek(vp, oldoff, newoff, cred))
#define VOP_REMOVE(dvp, vp, cnp) \
((dvp)->v_ops->vop_remove(dvp, vp, cnp))
#define VOP_LINK(dvp, vp, cnp) \
((dvp)->v_ops->vop_link(dvp, vp, cnp))
#define VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) \
((fdvp)->v_ops->vop_rename(fdvp, fvp, fcnp, tdvp, tvp, tcnp))
#define VOP_MKDIR(dvp, vpp, cnp, vap) \
((dvp)->v_ops->vop_mkdir(dvp, vpp, cnp, vap))
#define VOP_RMDIR(dvp, vp, cnp) \
((dvp)->v_ops->vop_rmdir(dvp, vp, cnp))
#define VOP_SYMLINK(dvp, vpp, cnp, vap, target) \
((dvp)->v_ops->vop_symlink(dvp, vpp, cnp, vap, target))
#define VOP_READDIR(vp, direntp, cred, eofflag, cookie) \
((vp)->v_ops->vop_readdir(vp, direntp, cred, eofflag, cookie))
#define VOP_READLINK(vp, uio, cred) \
((vp)->v_ops->vop_readlink(vp, uio, cred))
#define VOP_PATHCONF(vp, name, retval) \
((vp)->v_ops->vop_pathconf(vp, name, retval))
#define VOP_ADVLOCK(vp, id, op, fl, flags) \
((vp)->v_ops->vop_advlock(vp, id, op, fl, flags))
#define VOP_TRUNCATE(vp, length, flags, ucred) \
((vp)->v_ops->vop_truncate(vp, length, flags, ucred))
/*
* Housekeeping and other internals. Note: VOP_ACTIVATE is not in BSD.
*/
#define VOP_ABORTOP(vp, cnp) ((vp)->v_ops->vop_abortop(vp, cnp))
#define VOP_ACTIVATE(vp) ((vp)->v_ops->vop_activate(vp))
#define VOP_INACTIVE(vp) ((vp)->v_ops->vop_inactive(vp))
#if 0
#define VOP_LOCK(vp) ((vp)->v_ops->vop_lock(vp))
#define VOP_UNLOCK(vp) ((vp)->v_ops->vop_unlock(vp))
#endif
#define VOP_STRATEGY(vp, bp) ((vp)->v_ops->vop_strategy(vp, bp))
#define VOP_PRINT(vp) ((vp)->v_ops->vop_print(vp))
extern int enosys(void);
extern int vopErrorENOTDIR(void);
extern int vopErrorEISDIR(void);
extern int vop_error_rename(struct vnode *, struct vnode *,
struct componentname *,
struct vnode *, struct vnode *, struct componentname *);
#define vop_error_lookup \
((int (*)(struct vnode *, struct vnode **, \
struct componentname *))enosys)
#define vop_error_lookup_enotdir \
((int (*)(struct vnode *, struct vnode **, \
struct componentname *))vopErrorENOTDIR)
#define vop_error_create \
((int (*)(struct vnode *, struct vnode **, struct componentname *, \
struct vattr *))enosys)
#define vop_error_open \
((int (*)(struct vnode *, int, struct ucred *))enosys)
#define vop_error_close \
((int (*)(struct vnode *, int, struct ucred *))enosys)
#define vop_error_access \
((int (*)(struct vnode *, int, struct ucred *))enosys)
#define vop_error_getattr \
((int (*)(struct vnode *, struct vattr *, struct ucred *))enosys)
#define vop_error_setattr \
((int (*)(struct vnode *, struct vattr *, struct ucred *))enosys)
#define vop_error_read \
((int (*)(struct vnode *, struct uio *, int, struct ucred *))enosys)
#define vop_error_write \
((int (*)(struct vnode *, struct uio *, int, struct ucred *))enosys)
#define vop_error_ioctl \
((int (*)(struct vnode *, u_long, void *, int, struct ucred *))enosys)
#define vop_error_fcntl \
((int (*)(struct vnode *, u_int, void *, int, struct ucred *))enosys)
#define vop_error_fsync \
((int (*)(struct vnode *, struct ucred *, int))enosys)
#define vop_error_seek \
((int (*)(struct vnode *, voff_t, voff_t, struct ucred *))enosys)
#define vop_error_remove \
((int (*)(struct vnode *, struct vnode *, \
struct componentname *))enosys)
#define vop_error_link \
((int (*)(struct vnode *, struct vnode *, \
struct componentname *))enosys)
#define vop_error_mkdir \
((int (*)(struct vnode *, struct vnode **, struct componentname *, \
struct vattr *))enosys)
#define vop_error_rmdir \
((int (*)(struct vnode *, struct vnode *, \
struct componentname *))enosys)
#define vop_error_rmdir_enotdir \
((int (*)(struct vnode *, struct vnode *, \
struct componentname *))vopErrorENOTDIR)
#define vop_error_symlink \
((int (*)(struct vnode *, struct vnode **, struct componentname *, \
struct vattr *, char *))enosys)
#define vop_error_readdir \
((int (*)(struct vnode *, struct dirent *, struct ucred *, int *, \
int *))enosys)
#define vop_error_readdir_enotdir \
((int (*)(struct vnode *, struct dirent *, struct ucred *, int *, \
int *))vopErrorENOTDIR)
#define vop_error_readlink \
((int (*)(struct vnode *, struct uio *, struct ucred *))enosys)
#define vop_error_abortop \
((int (*)(struct vnode *, struct componentname *))enosys)
/* NOTE: THERE IS NO "error" FUNCTION FOR inactive OR print */
void vop_error_strategy(struct vnode *, struct buf *);
#define vop_error_pathconf \
((int (*)(struct vnode *, int, long *))enosys)
#define vop_error_advlock \
((int (*)(struct vnode *, void *, int, struct flock *, int))enosys)
#define vop_error_truncate \
((int (*)(struct vnode *, voff_t, int, struct ucred *))enosys)
int vn_makevnodes(struct mount *, int);
void vn_deletevnodes(struct mount *);
void vattr_null(struct vattr *);
void bgetvp(struct vnode *, struct buf *);
void brelvp(struct buf *);
void vreassignbuf(struct buf *);
int vflushbuf(struct vnode *, BOOL);
int vinvalbuf(struct vnode *, int, struct ucred *);
void vpurgebufs(struct vnode *, int,
BOOL (*)(struct vnode *, struct buf *, void *), void *);
void vn_incr_numoutput(struct vnode *);
void vn_decr_numoutput(struct vnode *);
int getnewvnode(struct mount *, struct vnode_ops *, struct vnode **);
int vgetino(struct mount *, ino_t, const struct vnode_ops *,
struct vnode **);
void vref(struct vnode *);
void vput(struct vnode *);
void vrele(struct vnode *);
int vaccess(enum vtype, mode_t, uid_t, gid_t, int, struct ucred *);
void vprint(const char *, struct vnode *);
void vn_panic(const char *, int, const char *, ...);
/*
* vn_start_write and vn_finished_write are intended to allow
* mount points to be "downgraded" from r/w to r/o: if the mount
* point is waiting for a downgrade, the "start" calls will pause
* or return an error (depending on supplied flags).
*
* We do not implement this yet so we just define this away to 0
* for now.
*/
#define vn_start_write(vp, mp, flags) (0)
#define vn_finished_write(mp, flags)
/*
* This perhaps belongs elsewhere (BSD has a separate ucred.h) but
* will serve for now. Note that we only have one gid, rather than
* a group-array and number-of-groups - this may eventually change
* (for NFS)...
*/
struct ucred {
uid_t cr_uid;
gid_t cr_gid;
};
#ifdef __cplusplus
}
#endif
#endif /* __INCvnodeh */