home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 4 / hacker04 / 04_HACK04.ISO / darwin / darwinx86.iso / usr / include / sys / vnode.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-09-30  |  18.2 KB  |  501 lines
  1. /*
  2.  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
  3.  *
  4.  * @APPLE_LICENSE_HEADER_START@
  5.  * 
  6.  * The contents of this file constitute Original Code as defined in and
  7.  * are subject to the Apple Public Source License Version 1.1 (the
  8.  * "License").  You may not use this file except in compliance with the
  9.  * License.  Please obtain a copy of the License at
  10.  * http://www.apple.com/publicsource and read it before using this file.
  11.  * 
  12.  * This Original Code and all software distributed under the License are
  13.  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14.  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16.  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17.  * License for the specific language governing rights and limitations
  18.  * under the License.
  19.  * 
  20.  * @APPLE_LICENSE_HEADER_END@
  21.  */
  22. /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  23. /*
  24.  * Copyright (c) 1989, 1993
  25.  *    The Regents of the University of California.  All rights reserved.
  26.  *
  27.  * Redistribution and use in source and binary forms, with or without
  28.  * modification, are permitted provided that the following conditions
  29.  * are met:
  30.  * 1. Redistributions of source code must retain the above copyright
  31.  *    notice, this list of conditions and the following disclaimer.
  32.  * 2. Redistributions in binary form must reproduce the above copyright
  33.  *    notice, this list of conditions and the following disclaimer in the
  34.  *    documentation and/or other materials provided with the distribution.
  35.  * 3. All advertising materials mentioning features or use of this software
  36.  *    must display the following acknowledgement:
  37.  *    This product includes software developed by the University of
  38.  *    California, Berkeley and its contributors.
  39.  * 4. Neither the name of the University nor the names of its contributors
  40.  *    may be used to endorse or promote products derived from this software
  41.  *    without specific prior written permission.
  42.  *
  43.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  44.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  47.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53.  * SUCH DAMAGE.
  54.  *
  55.  *    @(#)vnode.h    8.17 (Berkeley) 5/20/95
  56.  */
  57.  
  58. #ifndef _VNODE_H_
  59. #define _VNODE_H_
  60.  
  61. #include <sys/cdefs.h>
  62. #include <sys/queue.h>
  63. #include <sys/lock.h>
  64.  
  65. #include <sys/time.h>
  66. #include <sys/uio.h>
  67.  
  68. #include <sys/vm.h>
  69. #ifdef KERNEL
  70. #include <sys/systm.h>
  71. #include <vm/vm_pageout.h>
  72. #endif
  73.  
  74. /*
  75.  * The vnode is the focus of all file activity in UNIX.  There is a
  76.  * unique vnode allocated for each active file, each current directory,
  77.  * each mounted-on file, text file, and the root.
  78.  */
  79.  
  80. /*
  81.  * Vnode types.  VNON means no type.
  82.  */
  83. enum vtype    { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD, VSTR,
  84.               VCPLX };
  85.  
  86. /*
  87.  * Vnode tag types.
  88.  * These are for the benefit of external programs only (e.g., pstat)
  89.  * and should NEVER be inspected by the kernel.
  90.  */
  91. enum vtagtype    {
  92.     VT_NON, VT_UFS, VT_NFS, VT_MFS, VT_MSDOSFS, VT_LFS, VT_LOFS, VT_FDESC,
  93.     VT_PORTAL, VT_NULL, VT_UMAP, VT_KERNFS, VT_PROCFS, VT_AFS, VT_ISOFS,
  94.     VT_UNION, VT_HFS, VT_VOLFS, VT_DEVFS, VT_WEBDAV, VT_UDF, VT_AFP,
  95.     VT_CDDA, VT_CIFS,VT_OTHER};
  96.  
  97. /*
  98.  * Each underlying filesystem allocates its own private area and hangs
  99.  * it from v_data.  If non-null, this area is freed in getnewvnode().
  100.  */
  101. LIST_HEAD(buflists, buf);
  102.  
  103. /*
  104.  * Reading or writing any of these items requires holding the appropriate lock.
  105.  * v_freelist is locked by the global vnode_free_list simple lock.
  106.  * v_mntvnodes is locked by the global mntvnodes simple lock.
  107.  * v_flag, v_usecount, v_holdcount and v_writecount are
  108.  *    locked by the v_interlock simple lock.
  109.  */
  110. struct vnode {
  111.     u_long    v_flag;                /* vnode flags (see below) */
  112.     long    v_usecount;            /* reference count of users */
  113.     long    v_holdcnt;            /* page & buffer references */
  114.     daddr_t    v_lastr;            /* last read (read-ahead) */
  115.     u_long    v_id;                /* capability identifier */
  116.     struct    mount *v_mount;            /* ptr to vfs we are in */
  117.     int     (**v_op)(void *);        /* vnode operations vector */
  118.     TAILQ_ENTRY(vnode) v_freelist;        /* vnode freelist */
  119.     LIST_ENTRY(vnode) v_mntvnodes;        /* vnodes for mount point */
  120.     struct    buflists v_cleanblkhd;        /* clean blocklist head */
  121.     struct    buflists v_dirtyblkhd;        /* dirty blocklist head */
  122.     long    v_numoutput;            /* num of writes in progress */
  123.     enum    vtype v_type;            /* vnode type */
  124.     union {
  125.         struct mount    *vu_mountedhere;/* ptr to mounted vfs (VDIR) */
  126.         struct socket    *vu_socket;    /* unix ipc (VSOCK) */
  127.         struct specinfo    *vu_specinfo;    /* device (VCHR, VBLK) */
  128.         struct fifoinfo    *vu_fifoinfo;    /* fifo (VFIFO) */
  129.     } v_un;
  130.     struct ubc_info *v_ubcinfo;    /* valid for (VREG) */
  131.     struct    nqlease *v_lease;        /* Soft reference to lease */
  132.     daddr_t    v_lastw;            /* last write (write cluster) */
  133.     daddr_t    v_cstart;            /* start block of cluster */
  134.     daddr_t    v_ciosiz;            /* real size of I/O for cluster */
  135.     int    v_clen;                /* length of current cluster */
  136.     int    v_ralen;            /* Read-ahead length */
  137.     daddr_t    v_maxra;            /* last readahead block */
  138.     simple_lock_data_t v_interlock;        /* lock on usecount and flag */
  139.     struct    lock__bsd__ *v_vnlock;        /* used for non-locking fs's */
  140.     long    v_writecount;            /* reference count of writers */
  141.     enum    vtagtype v_tag;            /* type of underlying data */
  142.     void     *v_data;            /* private data for fs */
  143. };
  144. #define    v_mountedhere    v_un.vu_mountedhere
  145. #define    v_socket    v_un.vu_socket
  146. #define    v_specinfo    v_un.vu_specinfo
  147. #define    v_fifoinfo    v_un.vu_fifoinfo
  148.  
  149. /*
  150.  * Vnode flags.
  151.  */
  152. #define    VROOT        0x000001    /* root of its file system */
  153. #define    VTEXT        0x000002    /* vnode is a pure text prototype */
  154. #define    VSYSTEM        0x000004    /* vnode being used by kernel */
  155. #define    VISTTY        0x000008    /* vnode represents a tty */
  156. #define    VWASMAPPED    0x000010    /* vnode was mapped before */
  157. #define    VTERMINATE    0x000020    /* terminating memory object */
  158. #define    VTERMWANT    0x000040    /* wating for memory object death */
  159. #define    VMOUNT        0x000080    /* mount operation in progress */
  160. #define    VXLOCK        0x000100    /* vnode is locked to change underlying type */
  161. #define    VXWANT        0x000200    /* process is waiting for vnode */
  162. #define    VBWAIT        0x000400    /* waiting for output to complete */
  163. #define    VALIASED    0x000800    /* vnode has an alias */
  164. #define    VORECLAIM    0x001000    /* vm object is being reclaimed */
  165. #define    VNOCACHE_DATA    0x002000    /* don't keep data cached once it's been consumed */
  166. #define    VSTANDARD    0x004000    /* vnode obtained from common pool */
  167. #define    VAGE        0x008000    /* Insert vnode at head of free list */
  168. #define    VRAOFF        0x010000    /* read ahead disabled */
  169. #define    VUINIT        0x020000    /* ubc_info being initialized */
  170. #define    VUWANT        0x040000    /* process is wating for VUINIT */
  171. #define    VUINACTIVE    0x080000    /* UBC vnode is on inactive list */
  172. #define    VHASDIRTY    0x100000    /* UBC vnode may have 1 or more */
  173.         /* delayed dirty pages that need to be flushed at the next 'sync' */
  174. #define    VSWAP        0x200000    /* vnode is being used as swapfile */
  175. #define VTHROTTLED      0x400000        /* writes or pageouts have been throttled */
  176.                 /* wakeup tasks waiting when count falls below threshold */
  177.  
  178. /*
  179.  * Vnode attributes.  A field value of VNOVAL represents a field whose value
  180.  * is unavailable (getattr) or which is not to be changed (setattr).
  181.  */
  182. struct vattr {
  183.     enum vtype    va_type;    /* vnode type (for create) */
  184.     u_short        va_mode;    /* files access mode and type */
  185.     short        va_nlink;    /* number of references to file */
  186.     uid_t        va_uid;        /* owner user id */
  187.     gid_t        va_gid;        /* owner group id */
  188.     long        va_fsid;    /* file system id (dev for now) */
  189.     long        va_fileid;    /* file id */
  190.     u_quad_t    va_size;    /* file size in bytes */
  191.     long        va_blocksize;    /* blocksize preferred for i/o */
  192.     struct timespec    va_atime;    /* time of last access */
  193.     struct timespec    va_mtime;    /* time of last modification */
  194.     struct timespec    va_ctime;    /* time file changed */
  195.     u_long        va_gen;        /* generation number of file */
  196.     u_long        va_flags;    /* flags defined for file */
  197.     dev_t        va_rdev;    /* device the special file represents */
  198.     u_quad_t    va_bytes;    /* bytes of disk space held by file */
  199.     u_quad_t    va_filerev;    /* file modification number */
  200.     u_int        va_vaflags;    /* operations flags, see below */
  201.     long        va_spare;    /* remain quad aligned */
  202. };
  203.  
  204. /*
  205.  * Flags for va_vaflags.
  206.  */
  207. #define    VA_UTIMES_NULL    0x01        /* utimes argument was NULL */
  208. #define VA_EXCLUSIVE    0x02        /* exclusive create request */
  209.  
  210. /*
  211.  * Flags for ioflag.
  212.  */
  213. #define    IO_UNIT        0x01        /* do I/O as atomic unit */
  214. #define    IO_APPEND    0x02        /* append write to end */
  215. #define    IO_SYNC        0x04        /* do I/O synchronously */
  216. #define    IO_NODELOCKED    0x08        /* underlying node already locked */
  217. #define    IO_NDELAY    0x10        /* FNDELAY flag set in file table */
  218. #define IO_NOZEROFILL   0x20        /* F_SETSIZE fcntl uses to prevent zero filling */
  219. #define IO_TAILZEROFILL 0x40        /* zero fills at the tail of write */
  220. #define IO_HEADZEROFILL    0x80        /* zero fills at the head of write */
  221. #define IO_NOZEROVALID    0x100        /* do not zero fill if valid page */
  222.  
  223. /*
  224.  *  Modes.  Some values same as Ixxx entries from inode.h for now.
  225.  */
  226. #define    VSUID    04000        /* set user id on execution */
  227. #define    VSGID    02000        /* set group id on execution */
  228. #define    VSVTX    01000        /* save swapped text even after use */
  229. #define    VREAD    00400        /* read, write, execute permissions */
  230. #define    VWRITE    00200
  231. #define    VEXEC    00100
  232.  
  233. /*
  234.  * Token indicating no attribute value yet assigned.
  235.  */
  236. #define    VNOVAL    (-1)
  237.  
  238. #ifdef KERNEL
  239. /*
  240.  * Convert between vnode types and inode formats (since POSIX.1
  241.  * defines mode word of stat structure in terms of inode formats).
  242.  */
  243. extern enum vtype    iftovt_tab[];
  244. extern int        vttoif_tab[];
  245. #define IFTOVT(mode)    (iftovt_tab[((mode) & S_IFMT) >> 12])
  246. #define VTTOIF(indx)    (vttoif_tab[(int)(indx)])
  247. #define MAKEIMODE(indx, mode)    (int)(VTTOIF(indx) | (mode))
  248.  
  249. /*
  250.  * Flags to various vnode functions.
  251.  */
  252. #define    SKIPSYSTEM    0x0001        /* vflush: skip vnodes marked VSYSTEM */
  253. #define    FORCECLOSE    0x0002        /* vflush: force file closeure */
  254. #define    WRITECLOSE    0x0004        /* vflush: only close writeable files */
  255. #define SKIPSWAP    0x0008        /* vflush: skip vnodes marked VSWAP */
  256.  
  257. #define    DOCLOSE        0x0008        /* vclean: close active files */
  258.  
  259. #define    V_SAVE        0x0001        /* vinvalbuf: sync file first */
  260. #define    V_SAVEMETA    0x0002        /* vinvalbuf: leave indirect blocks */
  261.  
  262. #define    REVOKEALL    0x0001        /* vop_revoke: revoke all aliases */
  263.  
  264. /* flags for vop_allocate */
  265. #define    PREALLOCATE        0x00000001    /* preallocate allocation blocks */
  266. #define    ALLOCATECONTIG    0x00000002    /* allocate contigious space */
  267. #define    ALLOCATEALL        0x00000004    /* allocate all requested space */
  268.                                     /* or no space at all */
  269. #define    FREEREMAINDER    0x00000008    /* deallocate allocated but */
  270.                                     /* unfilled blocks */
  271. #define    ALLOCATEFROMPEOF    0x00000010    /* allocate from the physical eof */
  272. #define    ALLOCATEFROMVOL        0x00000020    /* allocate from the volume offset */
  273.  
  274. #if DIAGNOSTIC
  275. #define    VATTR_NULL(vap)    vattr_null(vap)
  276. #define    HOLDRELE(vp)    holdrele(vp)
  277. #define    VHOLD(vp)    vhold(vp)
  278.  
  279. void    holdrele __P((struct vnode *));
  280. void    vattr_null __P((struct vattr *));
  281. void    vhold __P((struct vnode *));
  282. #else
  283. #define    VATTR_NULL(vap)    (*(vap) = va_null)    /* initialize a vattr */
  284. #define    HOLDRELE(vp)    holdrele(vp)        /* decrease buf or page ref */
  285. extern __inline void holdrele(struct vnode *vp)
  286. {
  287.     simple_lock(&vp->v_interlock);
  288.     vp->v_holdcnt--;
  289.     simple_unlock(&vp->v_interlock);
  290. }
  291. #define    VHOLD(vp)    vhold(vp)        /* increase buf or page ref */
  292. extern __inline void vhold(struct vnode *vp)
  293. {
  294.     simple_lock(&vp->v_interlock);
  295.     if (++vp->v_holdcnt <= 0)
  296.         panic("vhold: v_holdcnt");
  297.     simple_unlock(&vp->v_interlock);
  298. }
  299. #endif /* DIAGNOSTIC */
  300.  
  301. #define    VREF(vp)    vref(vp)
  302. void    vref __P((struct vnode *));
  303. #define    NULLVP    ((struct vnode *)NULL)
  304.  
  305. /*
  306.  * Global vnode data.
  307.  */
  308. extern    struct vnode *rootvnode;    /* root (i.e. "/") vnode */
  309. extern    int desiredvnodes;        /* number of vnodes desired */
  310. extern    struct vattr va_null;        /* predefined null vattr structure */
  311.  
  312. /*
  313.  * Macro/function to check for client cache inconsistency w.r.t. leasing.
  314.  */
  315. #define    LEASE_READ    0x1        /* Check lease for readers */
  316. #define    LEASE_WRITE    0x2        /* Check lease for modifiers */
  317.  
  318. #endif /* KERNEL */
  319.  
  320. /*
  321.  * Mods for exensibility.
  322.  */
  323.  
  324. /*
  325.  * Flags for vdesc_flags:
  326.  */
  327. #define VDESC_MAX_VPS        16
  328. /* Low order 16 flag bits are reserved for willrele flags for vp arguments. */
  329. #define VDESC_VP0_WILLRELE    0x0001
  330. #define VDESC_VP1_WILLRELE    0x0002
  331. #define VDESC_VP2_WILLRELE    0x0004
  332. #define VDESC_VP3_WILLRELE    0x0008
  333. #define VDESC_NOMAP_VPP        0x0100
  334. #define VDESC_VPP_WILLRELE    0x0200
  335.  
  336. /*
  337.  * VDESC_NO_OFFSET is used to identify the end of the offset list
  338.  * and in places where no such field exists.
  339.  */
  340. #define VDESC_NO_OFFSET -1
  341.  
  342. /*
  343.  * This structure describes the vnode operation taking place.
  344.  */
  345. struct vnodeop_desc {
  346.     int    vdesc_offset;        /* offset in vector--first for speed */
  347.     char    *vdesc_name;        /* a readable name for debugging */
  348.     int    vdesc_flags;        /* VDESC_* flags */
  349.  
  350.     /*
  351.      * These ops are used by bypass routines to map and locate arguments.
  352.      * Creds and procs are not needed in bypass routines, but sometimes
  353.      * they are useful to (for example) transport layers.
  354.      * Nameidata is useful because it has a cred in it.
  355.      */
  356.     int    *vdesc_vp_offsets;    /* list ended by VDESC_NO_OFFSET */
  357.     int    vdesc_vpp_offset;    /* return vpp location */
  358.     int    vdesc_cred_offset;    /* cred location, if any */
  359.     int    vdesc_proc_offset;    /* proc location, if any */
  360.     int    vdesc_componentname_offset; /* if any */
  361.     /*
  362.      * Finally, we've got a list of private data (about each operation)
  363.      * for each transport layer.  (Support to manage this list is not
  364.      * yet part of BSD.)
  365.      */
  366.     caddr_t    *vdesc_transports;
  367. };
  368.  
  369. #ifdef KERNEL
  370. /*
  371.  * A list of all the operation descs.
  372.  */
  373. extern struct vnodeop_desc *vnodeop_descs[];
  374.  
  375. /*
  376.  * Interlock for scanning list of vnodes attached to a mountpoint
  377.  */
  378. extern struct slock mntvnode_slock;
  379.  
  380. /*
  381.  * This macro is very helpful in defining those offsets in the vdesc struct.
  382.  *
  383.  * This is stolen from X11R4.  I ingored all the fancy stuff for
  384.  * Crays, so if you decide to port this to such a serious machine,
  385.  * you might want to consult Intrisics.h's XtOffset{,Of,To}.
  386.  */
  387. #define VOPARG_OFFSET(p_type,field) \
  388.         ((int) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL)))
  389. #define VOPARG_OFFSETOF(s_type,field) \
  390.     VOPARG_OFFSET(s_type*,field)
  391. #define VOPARG_OFFSETTO(S_TYPE,S_OFFSET,STRUCT_P) \
  392.     ((S_TYPE)(((char*)(STRUCT_P))+(S_OFFSET)))
  393.  
  394.  
  395. /*
  396.  * This structure is used to configure the new vnodeops vector.
  397.  */
  398. struct vnodeopv_entry_desc {
  399.     struct vnodeop_desc *opve_op;   /* which operation this is */
  400.     int (*opve_impl)(void *);        /* code implementing this operation */
  401. };
  402. struct vnodeopv_desc {
  403.             /* ptr to the ptr to the vector where op should go */
  404.     int (***opv_desc_vector_p)(void *);
  405.     struct vnodeopv_entry_desc *opv_desc_ops;   /* null terminated list */
  406. };
  407.  
  408. /*
  409.  * A default routine which just returns an error.
  410.  */
  411. int vn_default_error __P((void));
  412.  
  413. /*
  414.  * A generic structure.
  415.  * This can be used by bypass routines to identify generic arguments.
  416.  */
  417. struct vop_generic_args {
  418.     struct vnodeop_desc *a_desc;
  419.     /* other random data follows, presumably */
  420. };
  421.  
  422. /*
  423.  * VOCALL calls an op given an ops vector.  We break it out because BSD's
  424.  * vclean changes the ops vector and then wants to call ops with the old
  425.  * vector.
  426.  */
  427. #define VOCALL(OPSV,OFF,AP) (( *((OPSV)[(OFF)])) (AP))
  428.  
  429. /*
  430.  * This call works for vnodes in the kernel.
  431.  */
  432. #define VCALL(VP,OFF,AP) VOCALL((VP)->v_op,(OFF),(AP))
  433. #define VDESC(OP) (& __CONCAT(OP,_desc))
  434. #define VOFFSET(OP) (VDESC(OP)->vdesc_offset)
  435.  
  436. /*
  437.  * Finally, include the default set of vnode operations.
  438.  */
  439. #include <sys/vnode_if.h>
  440.  
  441. /*
  442.  * Public vnode manipulation functions.
  443.  */
  444. struct file;
  445. struct mount;
  446. struct nameidata;
  447. struct ostat;
  448. struct proc;
  449. struct stat;
  450. struct ucred;
  451. struct uio;
  452. struct vattr;
  453. struct vnode;
  454. struct vop_bwrite_args;
  455.  
  456. int     bdevvp __P((dev_t dev, struct vnode **vpp));
  457. void    cvtstat __P((struct stat *st, struct ostat *ost));
  458. int     getnewvnode __P((enum vtagtype tag,
  459.         struct mount *mp, int (**vops)(void *), struct vnode **vpp));
  460. void    insmntque __P((struct vnode *vp, struct mount *mp));
  461. void     vattr_null __P((struct vattr *vap));
  462. int     vcount __P((struct vnode *vp));
  463. int    vflush __P((struct mount *mp, struct vnode *skipvp, int flags));
  464. int     vget __P((struct vnode *vp, int lockflag, struct proc *p));
  465. void     vgone __P((struct vnode *vp));
  466. int    vinvalbuf __P((struct vnode *vp, int save, struct ucred *cred,
  467.         struct proc *p, int slpflag, int slptimeo));
  468. void    vprint __P((char *label, struct vnode *vp));
  469. int    vrecycle __P((struct vnode *vp, struct slock *inter_lkp,
  470.         struct proc *p));
  471. int    vn_bwrite __P((struct vop_bwrite_args *ap));
  472. int     vn_close __P((struct vnode *vp,
  473.         int flags, struct ucred *cred, struct proc *p));
  474. int     vn_closefile __P((struct file *fp, struct proc *p));
  475. int    vn_ioctl __P((struct file *fp, u_long com, caddr_t data,
  476.         struct proc *p));
  477. int    vn_lock __P((struct vnode *vp, int flags, struct proc *p));
  478. int     vn_open __P((struct nameidata *ndp, int fmode, int cmode));
  479. int     vn_rdwr __P((enum uio_rw rw, struct vnode *vp, caddr_t base,
  480.         int len, off_t offset, enum uio_seg segflg, int ioflg,
  481.         struct ucred *cred, int *aresid, struct proc *p));
  482. int    vn_read __P((struct file *fp, struct uio *uio, struct ucred *cred));
  483. int    vn_select __P((struct file *fp, int which, void * wql, struct proc *p));
  484. int    vn_stat __P((struct vnode *vp, struct stat *sb, struct proc *p));
  485. int    vn_write __P((struct file *fp, struct uio *uio, struct ucred *cred));
  486. int    vop_noislocked __P((struct vop_islocked_args *));
  487. int    vop_nolock __P((struct vop_lock_args *));
  488. int    vop_nounlock __P((struct vop_unlock_args *));
  489. int    vop_revoke __P((struct vop_revoke_args *));
  490. struct vnode *
  491.     checkalias __P((struct vnode *vp, dev_t nvp_rdev, struct mount *mp));
  492. void     vput __P((struct vnode *vp));
  493. void     vrele __P((struct vnode *vp));
  494. int    vaccess __P((mode_t file_mode, uid_t uid, gid_t gid,
  495.         mode_t acc_mode, struct ucred *cred));
  496. int    getvnode __P((struct proc *p, int fd, struct file **fpp));
  497.  
  498. #endif /* KERNEL */
  499.  
  500. #endif /* !_VNODE_H_ */
  501.