bsd/sys/vnode.h

   1 /*
   2  * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  24 /*
  25  * Copyright (c) 1989, 1993
  26  *      The Regents of the University of California.  All rights reserved.
  27  *
  28  * Redistribution and use in source and binary forms, with or without
  29  * modification, are permitted provided that the following conditions
  30  * are met:
  31  * 1. Redistributions of source code must retain the above copyright
  32  *    notice, this list of conditions and the following disclaimer.
  33  * 2. Redistributions in binary form must reproduce the above copyright
  34  *    notice, this list of conditions and the following disclaimer in the
  35  *    documentation and/or other materials provided with the distribution.
  36  * 3. All advertising materials mentioning features or use of this software
  37  *    must display the following acknowledgement:
  38  *      This product includes software developed by the University of
  39  *      California, Berkeley and its contributors.
  40  * 4. Neither the name of the University nor the names of its contributors
  41  *    may be used to endorse or promote products derived from this software
  42  *    without specific prior written permission.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  45  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  48  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54  * SUCH DAMAGE.
  55  *
  56  *      @(#)vnode.h     8.17 (Berkeley) 5/20/95
  57  */
  58
  59 #ifndef _VNODE_H_
  60 #define _VNODE_H_
  61
  62 #include <sys/appleapiopts.h>
  63 #include <sys/cdefs.h>
  64 #ifdef KERNEL
  65 #include <sys/kernel_types.h>
  66 #include <sys/signal.h>
  67 #endif
  68
  69 /*
  70  * The vnode is the focus of all file activity in UNIX.  There is a
  71  * unique vnode allocated for each active file, each current directory,
  72  * each mounted-on file, text file, and the root.
  73  */
  74
  75 /*
  76  * Vnode types.  VNON means no type.
  77  */
  78 enum vtype      { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD, VSTR,
  79                           VCPLX };
  80
  81 /*
  82  * Vnode tag types.
  83  * These are for the benefit of external programs only (e.g., pstat)
  84  * and should NEVER be inspected by the kernel.
  85  */
  86 enum vtagtype   {
  87         VT_NON, VT_UFS, VT_NFS, VT_MFS, VT_MSDOSFS, VT_LFS, VT_LOFS, VT_FDESC,
  88         VT_PORTAL, VT_NULL, VT_UMAP, VT_KERNFS, VT_PROCFS, VT_AFS, VT_ISOFS,
  89         VT_UNION, VT_HFS, VT_VOLFS, VT_DEVFS, VT_WEBDAV, VT_UDF, VT_AFP,
  90         VT_CDDA, VT_CIFS,VT_OTHER};
  91
  92
  93 /*
  94  * flags for VNOP_BLOCKMAP
  95  */
  96 #define VNODE_READ      0x01
  97 #define VNODE_WRITE     0x02
  98
  99
 100
 101 /* flags for VNOP_ALLOCATE */
 102 #define PREALLOCATE             0x00000001      /* preallocate allocation blocks */
 103 #define ALLOCATECONTIG  0x00000002      /* allocate contigious space */
 104 #define ALLOCATEALL             0x00000004      /* allocate all requested space */
 105                                                                         /* or no space at all */
 106 #define FREEREMAINDER   0x00000008      /* deallocate allocated but */
 107                                                                         /* unfilled blocks */
 108 #define ALLOCATEFROMPEOF        0x00000010      /* allocate from the physical eof */
 109 #define ALLOCATEFROMVOL         0x00000020      /* allocate from the volume offset */
 110
 111 /*
 112  * Token indicating no attribute value yet assigned. some user source uses this
 113  */
 114 #define VNOVAL  (-1)
 115
 116 #ifdef KERNEL
 117
 118 /*
 119  * Flags for ioflag.
 120  */
 121 #define IO_UNIT         0x0001          /* do I/O as atomic unit */
 122 #define IO_APPEND       0x0002          /* append write to end */
 123 #define IO_SYNC         0x0004          /* do I/O synchronously */
 124 #define IO_NODELOCKED   0x0008          /* underlying node already locked */
 125 #define IO_NDELAY       0x0010          /* FNDELAY flag set in file table */
 126 #define IO_NOZEROFILL   0x0020          /* F_SETSIZE fcntl uses to prevent zero filling */
 127 #define IO_TAILZEROFILL 0x0040          /* zero fills at the tail of write */
 128 #define IO_HEADZEROFILL 0x0080          /* zero fills at the head of write */
 129 #define IO_NOZEROVALID  0x0100          /* do not zero fill if valid page */
 130 #define IO_NOZERODIRTY  0x0200          /* do not zero fill if page is dirty */
 131 #define IO_CLOSE        0x0400          /* I/O issued from close path */
 132 #define IO_NOCACHE      0x0800          /* same effect as VNOCACHE_DATA, but only for this 1 I/O */
 133 #define IO_RAOFF        0x1000          /* same effect as VRAOFF, but only for this 1 I/O */
 134 #define IO_DEFWRITE     0x2000          /* defer write if vfs.defwrite is set */
 135
 136 /*
 137  * Component Name: this structure describes the pathname
 138  * information that is passed through the VNOP interface.
 139  */
 140 struct componentname {
 141         /*
 142          * Arguments to lookup.
 143          */
 144         u_long  cn_nameiop;     /* lookup operation */
 145         u_long  cn_flags;       /* flags (see below) */
 146 #ifdef BSD_KERNEL_PRIVATE
 147         vfs_context_t   cn_context;
 148         void * pad_obsolete2;
 149
 150 /* XXX use of these defines are deprecated */
 151 #define cn_proc         (cn_context->vc_proc + 0)       /* non-lvalue */
 152 #define cn_cred         (cn_context->vc_ucred + 0)      /* non-lvalue */
 153
 154 #else
 155         void * obsolete1;       /* use vfs_context_t */
 156         void * obsolete2;       /* use vfs_context_t */
 157 #endif
 158         /*
 159          * Shared between lookup and commit routines.
 160          */
 161         char    *cn_pnbuf;      /* pathname buffer */
 162         long    cn_pnlen;       /* length of allocated buffer */
 163         char    *cn_nameptr;    /* pointer to looked up name */
 164         long    cn_namelen;     /* length of looked up component */
 165         u_long  cn_hash;        /* hash value of looked up name */
 166         long    cn_consume;     /* chars to consume in lookup() */
 167 };
 168
 169 /*
 170  * component name operations (for VNOP_LOOKUP)
 171  */
 172 #define LOOKUP          0       /* perform name lookup only */
 173 #define CREATE          1       /* setup for file creation */
 174 #define DELETE          2       /* setup for file deletion */
 175 #define RENAME          3       /* setup for file renaming */
 176 #define OPMASK          3       /* mask for operation */
 177
 178 /*
 179  * component name operational modifier flags
 180  */
 181 #define FOLLOW          0x0040  /* follow symbolic links */
 182
 183 /*
 184  * component name parameter descriptors.
 185  */
 186 #define ISDOTDOT        0x002000 /* current component name is .. */
 187 #define MAKEENTRY       0x004000 /* entry is to be added to name cache */
 188 #define ISLASTCN        0x008000 /* this is last component of pathname */
 189 #define ISWHITEOUT      0x020000 /* found whiteout */
 190 #define DOWHITEOUT      0x040000 /* do whiteouts */
 191
 192
 193
 194 /* The following structure specifies a vnode for creation */
 195 struct vnode_fsparam {
 196         struct mount * vnfs_mp;         /* mount point to which this vnode_t is part of */
 197         enum vtype      vnfs_vtype;             /* vnode type */
 198         const char * vnfs_str;          /* File system Debug aid */
 199         struct vnode * vnfs_dvp;                        /* The parent vnode */
 200         void * vnfs_fsnode;                     /* inode */
 201         int (**vnfs_vops)(void *);              /* vnode dispatch table */
 202         int vnfs_markroot;                      /* is this a root vnode in FS (not a system wide one) */
 203         int vnfs_marksystem;            /* is  a system vnode */
 204         dev_t vnfs_rdev;                        /* dev_t  for block or char vnodes */
 205         off_t vnfs_filesize;            /* that way no need for getattr in UBC */
 206         struct componentname * vnfs_cnp; /* component name to add to namecache */
 207         uint32_t vnfs_flags;            /* flags */
 208 };
 209
 210 #define VNFS_NOCACHE    0x01    /* do not add to name cache at this time */
 211 #define VNFS_CANTCACHE  0x02    /* never add this instance to the name cache */
 212
 213 #define VNCREATE_FLAVOR 0
 214 #define VCREATESIZE sizeof(struct vnode_fsparam)
 215
 216 /*
 217  * Vnode attributes, new-style.
 218  *
 219  * The vnode_attr structure is used to transact attribute changes and queries
 220  * with the filesystem.
 221  *
 222  * Note that this structure may be extended, but existing fields must not move.
 223  */
 224
 225 #define VATTR_INIT(v)                   do {(v)->va_supported = (v)->va_active = 0ll; (v)->va_vaflags = 0;} while(0)
 226 #define VATTR_SET_ACTIVE(v, a)          ((v)->va_active |= VNODE_ATTR_ ## a)
 227 #define VATTR_SET_SUPPORTED(v, a)       ((v)->va_supported |= VNODE_ATTR_ ## a)
 228 #define VATTR_IS_SUPPORTED(v, a)        ((v)->va_supported & VNODE_ATTR_ ## a)
 229 #define VATTR_CLEAR_ACTIVE(v, a)        ((v)->va_active &= ~VNODE_ATTR_ ## a)
 230 #define VATTR_CLEAR_SUPPORTED(v, a)     ((v)->va_supported &= ~VNODE_ATTR_ ## a)
 231 #define VATTR_IS_ACTIVE(v, a)           ((v)->va_active & VNODE_ATTR_ ## a)
 232 #define VATTR_ALL_SUPPORTED(v)          (((v)->va_active & (v)->va_supported) == (v)->va_active)
 233 #define VATTR_INACTIVE_SUPPORTED(v)     do {(v)->va_active &= ~(v)->va_supported; (v)->va_supported = 0;} while(0)
 234 #define VATTR_SET(v, a, x)              do { (v)-> a = (x); VATTR_SET_ACTIVE(v, a);} while(0)
 235 #define VATTR_WANTED(v, a)              VATTR_SET_ACTIVE(v, a)
 236 #define VATTR_RETURN(v, a, x)           do { (v)-> a = (x); VATTR_SET_SUPPORTED(v, a);} while(0)
 237 #define VATTR_NOT_RETURNED(v, a)        (VATTR_IS_ACTIVE(v, a) && !VATTR_IS_SUPPORTED(v, a))
 238
 239 /*
 240  * Two macros to simplify conditional checking in kernel code.
 241  */
 242 #define VATTR_IS(v, a, x)               (VATTR_IS_SUPPORTED(v, a) && (v)-> a == (x))
 243 #define VATTR_IS_NOT(v, a, x)           (VATTR_IS_SUPPORTED(v, a) && (v)-> a != (x))
 244
 245 #define VNODE_ATTR_va_rdev              (1LL<< 0)       /* 00000001 */
 246 #define VNODE_ATTR_va_nlink             (1LL<< 1)       /* 00000002 */
 247 #define VNODE_ATTR_va_total_size        (1LL<< 2)       /* 00000004 */
 248 #define VNODE_ATTR_va_total_alloc       (1LL<< 3)       /* 00000008 */
 249 #define VNODE_ATTR_va_data_size         (1LL<< 4)       /* 00000010 */
 250 #define VNODE_ATTR_va_data_alloc        (1LL<< 5)       /* 00000020 */
 251 #define VNODE_ATTR_va_iosize            (1LL<< 6)       /* 00000040 */
 252 #define VNODE_ATTR_va_uid               (1LL<< 7)       /* 00000080 */
 253 #define VNODE_ATTR_va_gid               (1LL<< 8)       /* 00000100 */
 254 #define VNODE_ATTR_va_mode              (1LL<< 9)       /* 00000200 */
 255 #define VNODE_ATTR_va_flags             (1LL<<10)       /* 00000400 */
 256 #define VNODE_ATTR_va_acl               (1LL<<11)       /* 00000800 */
 257 #define VNODE_ATTR_va_create_time       (1LL<<12)       /* 00001000 */
 258 #define VNODE_ATTR_va_access_time       (1LL<<13)       /* 00002000 */
 259 #define VNODE_ATTR_va_modify_time       (1LL<<14)       /* 00004000 */
 260 #define VNODE_ATTR_va_change_time       (1LL<<15)       /* 00008000 */
 261 #define VNODE_ATTR_va_backup_time       (1LL<<16)       /* 00010000 */
 262 #define VNODE_ATTR_va_fileid            (1LL<<17)       /* 00020000 */
 263 #define VNODE_ATTR_va_linkid            (1LL<<18)       /* 00040000 */
 264 #define VNODE_ATTR_va_parentid          (1LL<<19)       /* 00080000 */
 265 #define VNODE_ATTR_va_fsid              (1LL<<20)       /* 00100000 */
 266 #define VNODE_ATTR_va_filerev           (1LL<<21)       /* 00200000 */
 267 #define VNODE_ATTR_va_gen               (1LL<<22)       /* 00400000 */
 268 #define VNODE_ATTR_va_encoding          (1LL<<23)       /* 00800000 */
 269 #define VNODE_ATTR_va_type              (1LL<<24)       /* 01000000 */
 270 #define VNODE_ATTR_va_name              (1LL<<25)       /* 02000000 */
 271 #define VNODE_ATTR_va_uuuid             (1LL<<26)       /* 04000000 */
 272 #define VNODE_ATTR_va_guuid             (1LL<<27)       /* 08000000 */
 273 #define VNODE_ATTR_va_nchildren         (1LL<<28)       /* 10000000 */
 274
 275 #define VNODE_ATTR_BIT(n)       (VNODE_ATTR_ ## n)
 276 /*
 277  * Read-only attributes.
 278  */
 279 #define VNODE_ATTR_RDONLY       (VNODE_ATTR_BIT(va_rdev) |              \
 280                                 VNODE_ATTR_BIT(va_nlink) |              \
 281                                 VNODE_ATTR_BIT(va_total_size) |         \
 282                                 VNODE_ATTR_BIT(va_total_alloc) |        \
 283                                 VNODE_ATTR_BIT(va_data_alloc) |         \
 284                                 VNODE_ATTR_BIT(va_iosize) |             \
 285                                 VNODE_ATTR_BIT(va_fileid) |             \
 286                                 VNODE_ATTR_BIT(va_linkid) |             \
 287                                 VNODE_ATTR_BIT(va_parentid) |           \
 288                                 VNODE_ATTR_BIT(va_fsid) |               \
 289                                 VNODE_ATTR_BIT(va_filerev) |            \
 290                                 VNODE_ATTR_BIT(va_gen) |                \
 291                                 VNODE_ATTR_BIT(va_name) |               \
 292                                 VNODE_ATTR_BIT(va_type) |               \
 293                                 VNODE_ATTR_BIT(va_nchildren))
 294 /*
 295  * Attributes that can be applied to a new file object.
 296  */
 297 #define VNODE_ATTR_NEWOBJ       (VNODE_ATTR_BIT(va_rdev) |              \
 298                                 VNODE_ATTR_BIT(va_uid)  |               \
 299                                 VNODE_ATTR_BIT(va_gid) |                \
 300                                 VNODE_ATTR_BIT(va_mode) |               \
 301                                 VNODE_ATTR_BIT(va_flags) |              \
 302                                 VNODE_ATTR_BIT(va_acl) |                \
 303                                 VNODE_ATTR_BIT(va_create_time) |        \
 304                                 VNODE_ATTR_BIT(va_modify_time) |        \
 305                                 VNODE_ATTR_BIT(va_change_time) |        \
 306                                 VNODE_ATTR_BIT(va_encoding) |           \
 307                                 VNODE_ATTR_BIT(va_type) |               \
 308                                 VNODE_ATTR_BIT(va_uuuid) |              \
 309                                 VNODE_ATTR_BIT(va_guuid))
 310
 311 struct vnode_attr {
 312         /* bitfields */
 313         uint64_t        va_supported;
 314         uint64_t        va_active;
 315
 316         /*
 317          * Control flags.  The low 16 bits are reserved for the
 318          * ioflags being passed for truncation operations.
 319          */
 320         int             va_vaflags;
 321
 322         /* traditional stat(2) parameter fields */
 323         dev_t           va_rdev;        /* device id (device nodes only) */
 324         uint64_t        va_nlink;       /* number of references to this file */
 325         uint64_t        va_total_size;  /* size in bytes of all forks */
 326         uint64_t        va_total_alloc; /* disk space used by all forks */
 327         uint64_t        va_data_size;   /* size in bytes of the main(data) fork */
 328         uint64_t        va_data_alloc;  /* disk space used by the main(data) fork */
 329         uint32_t        va_iosize;      /* optimal I/O blocksize */
 330
 331         /* file security information */
 332         uid_t           va_uid;         /* owner UID */
 333         gid_t           va_gid;         /* owner GID */
 334         mode_t          va_mode;        /* posix permissions */
 335         uint32_t        va_flags;       /* file flags */
 336         struct kauth_acl *va_acl;       /* access control list */
 337
 338         /* timestamps */
 339         struct timespec va_create_time; /* time of creation */
 340         struct timespec va_access_time; /* time of last access */
 341         struct timespec va_modify_time; /* time of last data modification */
 342         struct timespec va_change_time; /* time of last metadata change */
 343         struct timespec va_backup_time; /* time of last backup */
 344
 345         /* file parameters */
 346         uint64_t        va_fileid;      /* file unique ID in filesystem */
 347         uint64_t        va_linkid;      /* file link unique ID */
 348         uint64_t        va_parentid;    /* parent ID */
 349         uint32_t        va_fsid;        /* filesystem ID */
 350         uint64_t        va_filerev;     /* file revision counter */     /* XXX */
 351         uint32_t        va_gen;         /* file generation count */     /* XXX - relationship of
 352                                                                         * these two? */
 353         /* misc parameters */
 354         uint32_t        va_encoding;    /* filename encoding script */
 355
 356         enum vtype      va_type;        /* file type (create only) */
 357         char *          va_name;        /* Name for ATTR_CMN_NAME; MAXPATHLEN bytes */
 358         guid_t          va_uuuid;       /* file owner UUID */
 359         guid_t          va_guuid;       /* file group UUID */
 360
 361         uint64_t        va_nchildren;   /* Number of items in a directory */
 362                                         /* Meaningful for directories only */
 363
 364         /* add new fields here only */
 365 };
 366
 367 /*
 368  * Flags for va_vaflags.
 369  */
 370 #define VA_UTIMES_NULL  0x010000        /* utimes argument was NULL */
 371 #define VA_EXCLUSIVE    0x020000        /* exclusive create request */
 372
 373
 374
 375 /*
 376  *  Modes.  Some values same as Ixxx entries from inode.h for now.
 377  */
 378 #define VSUID   0x800 /*04000*/ /* set user id on execution */
 379 #define VSGID   0x400 /*02000*/ /* set group id on execution */
 380 #define VSVTX   0x200 /*01000*/ /* save swapped text even after use */
 381 #define VREAD   0x100 /*00400*/ /* read, write, execute permissions */
 382 #define VWRITE  0x080 /*00200*/
 383 #define VEXEC   0x040 /*00100*/
 384
 385
 386 /*
 387  * Convert between vnode types and inode formats (since POSIX.1
 388  * defines mode word of stat structure in terms of inode formats).
 389  */
 390 extern enum vtype       iftovt_tab[];
 391 extern int              vttoif_tab[];
 392 #define IFTOVT(mode)    (iftovt_tab[((mode) & S_IFMT) >> 12])
 393 #define VTTOIF(indx)    (vttoif_tab[(int)(indx)])
 394 #define MAKEIMODE(indx, mode)   (int)(VTTOIF(indx) | (mode))
 395
 396
 397 /*
 398  * Flags to various vnode functions.
 399  */
 400 #define SKIPSYSTEM      0x0001          /* vflush: skip vnodes marked VSYSTEM */
 401 #define FORCECLOSE      0x0002          /* vflush: force file closeure */
 402 #define WRITECLOSE      0x0004          /* vflush: only close writeable files */
 403 #define SKIPSWAP        0x0008          /* vflush: skip vnodes marked VSWAP */
 404 #define SKIPROOT        0x0010          /* vflush: skip root vnodes marked VROOT */
 405
 406 #define DOCLOSE         0x0008          /* vclean: close active files */
 407
 408 #define V_SAVE          0x0001          /* vinvalbuf: sync file first */
 409 #define V_SAVEMETA      0x0002          /* vinvalbuf: leave indirect blocks */
 410
 411 #define REVOKEALL       0x0001          /* vnop_revoke: revoke all aliases */
 412
 413 /* VNOP_REMOVE: do not delete busy files (Carbon remove file semantics) */
 414 #define VNODE_REMOVE_NODELETEBUSY  0x0001
 415
 416 /* VNOP_READDIR flags: */
 417 #define VNODE_READDIR_EXTENDED    0x0001   /* use extended directory entries */
 418 #define VNODE_READDIR_REQSEEKOFF  0x0002   /* requires seek offset (cookies) */
 419 #define VNODE_READDIR_SEEKOFF32   0x0004   /* seek offset values should fit in 32 bits */
 420
 421
 422 #define NULLVP  ((struct vnode *)NULL)
 423
 424 /*
 425  * Macro/function to check for client cache inconsistency w.r.t. leasing.
 426  */
 427 #define LEASE_READ      0x1             /* Check lease for readers */
 428 #define LEASE_WRITE     0x2             /* Check lease for modifiers */
 429
 430
 431 #ifndef BSD_KERNEL_PRIVATE
 432 struct vnodeop_desc;
 433 #endif
 434
 435 extern  int desiredvnodes;              /* number of vnodes desired */
 436
 437
 438 /*
 439  * This structure is used to configure the new vnodeops vector.
 440  */
 441 struct vnodeopv_entry_desc {
 442         struct vnodeop_desc *opve_op;   /* which operation this is */
 443         int (*opve_impl)(void *);               /* code implementing this operation */
 444 };
 445 struct vnodeopv_desc {
 446                         /* ptr to the ptr to the vector where op should go */
 447         int (***opv_desc_vector_p)(void *);
 448         struct vnodeopv_entry_desc *opv_desc_ops;   /* null terminated list */
 449 };
 450
 451 /*
 452  * A default routine which just returns an error.
 453  */
 454 int vn_default_error(void);
 455
 456 /*
 457  * A generic structure.
 458  * This can be used by bypass routines to identify generic arguments.
 459  */
 460 struct vnop_generic_args {
 461         struct vnodeop_desc *a_desc;
 462         /* other random data follows, presumably */
 463 };
 464
 465 #ifndef _KAUTH_ACTION_T
 466 typedef int kauth_action_t;
 467 # define _KAUTH_ACTION_T
 468 #endif
 469
 470 #include <sys/vnode_if.h>
 471
 472 __BEGIN_DECLS
 473
 474 errno_t vnode_create(int, size_t, void  *, vnode_t *);
 475 int     vnode_addfsref(vnode_t);
 476 int     vnode_removefsref(vnode_t);
 477
 478 int     vnode_hasdirtyblks(vnode_t);
 479 int     vnode_hascleanblks(vnode_t);
 480 #define VNODE_ASYNC_THROTTLE    18
 481 /* timeout is in 10 msecs and not hz tick based */
 482 int     vnode_waitforwrites(vnode_t, int, int, int, char *);
 483 void    vnode_startwrite(vnode_t);
 484 void    vnode_writedone(vnode_t);
 485
 486 enum vtype      vnode_vtype(vnode_t);
 487 uint32_t        vnode_vid(vnode_t);
 488 mount_t vnode_mountedhere(vnode_t vp);
 489 mount_t vnode_mount(vnode_t);
 490 dev_t   vnode_specrdev(vnode_t);
 491 void *  vnode_fsnode(vnode_t);
 492 void    vnode_clearfsnode(vnode_t);
 493
 494 int     vnode_isvroot(vnode_t);
 495 int     vnode_issystem(vnode_t);
 496 int     vnode_ismount(vnode_t);
 497 int     vnode_isreg(vnode_t);
 498 int     vnode_isdir(vnode_t);
 499 int     vnode_islnk(vnode_t);
 500 int     vnode_isfifo(vnode_t);
 501 int     vnode_isblk(vnode_t);
 502 int     vnode_ischr(vnode_t);
 503
 504 int     vnode_ismountedon(vnode_t);
 505 void    vnode_setmountedon(vnode_t);
 506 void    vnode_clearmountedon(vnode_t);
 507
 508 int     vnode_isnocache(vnode_t);
 509 void    vnode_setnocache(vnode_t);
 510 void    vnode_clearnocache(vnode_t);
 511 int     vnode_isnoreadahead(vnode_t);
 512 void    vnode_setnoreadahead(vnode_t);
 513 void    vnode_clearnoreadahead(vnode_t);
 514 /* left only for compat reasons as User code depends on this from getattrlist, for ex */
 515 void    vnode_settag(vnode_t, int);
 516 int     vnode_tag(vnode_t);
 517 int     vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx);
 518 int     vnode_setattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx);
 519
 520 #ifdef BSD_KERNEL_PRIVATE
 521
 522 /*
 523  * Indicate that a file has multiple hard links.  VFS will always call
 524  * VNOP_LOOKUP on this vnode.  Volfs will always ask for it's parent
 525  * object ID (instead of using the v_parent pointer).
 526  */
 527 void    vnode_set_hard_link(vnode_t vp);
 528
 529 vnode_t vnode_parent(vnode_t);
 530 void vnode_setparent(vnode_t, vnode_t);
 531 char * vnode_name(vnode_t);
 532 void vnode_setname(vnode_t, char *);
 533 int vnode_isnoflush(vnode_t);
 534 void vnode_setnoflush(vnode_t);
 535 void vnode_clearnoflush(vnode_t);
 536 #endif
 537
 538 uint32_t  vnode_vfsmaxsymlen(vnode_t);
 539 int     vnode_vfsisrdonly(vnode_t);
 540 int     vnode_vfstypenum(vnode_t);
 541 void    vnode_vfsname(vnode_t, char *);
 542 int     vnode_vfs64bitready(vnode_t);
 543
 544 proc_t  vfs_context_proc(vfs_context_t);
 545 ucred_t vfs_context_ucred(vfs_context_t);
 546 int     vfs_context_issuser(vfs_context_t);
 547 int     vfs_context_pid(vfs_context_t);
 548 int     vfs_context_issignal(vfs_context_t, sigset_t);
 549 int     vfs_context_suser(vfs_context_t);
 550 int     vfs_context_is64bit(vfs_context_t);
 551 vfs_context_t vfs_context_create(vfs_context_t);
 552 int vfs_context_rele(vfs_context_t);
 553
 554
 555 int     vflush(struct mount *mp, struct vnode *skipvp, int flags);
 556 int     vnode_get(vnode_t);
 557 int     vnode_getwithvid(vnode_t, int);
 558 int     vnode_put(vnode_t);
 559 int     vnode_ref(vnode_t);
 560 void    vnode_rele(vnode_t);
 561 int     vnode_isinuse(vnode_t, int);
 562 void    vnode_lock(vnode_t);
 563 void    vnode_unlock(vnode_t);
 564 int             vnode_recycle(vnode_t);
 565 void    vnode_reclaim(vnode_t);
 566
 567 #define VNODE_UPDATE_PARENT     0x01
 568 #define VNODE_UPDATE_NAME       0x02
 569 #define VNODE_UPDATE_CACHE      0x04
 570 void    vnode_update_identity(vnode_t vp, vnode_t dvp, char *name, int name_len, int name_hashval, int flags);
 571
 572 int     vn_bwrite(struct vnop_bwrite_args *ap);
 573
 574 int     vnode_authorize(vnode_t /*vp*/, vnode_t /*dvp*/, kauth_action_t, vfs_context_t);
 575 int     vnode_authattr(vnode_t, struct vnode_attr *, kauth_action_t *, vfs_context_t);
 576 int     vnode_authattr_new(vnode_t /*dvp*/, struct vnode_attr *, int /*noauth*/, vfs_context_t);
 577 errno_t vnode_close(vnode_t, int, vfs_context_t);
 578
 579 int vn_getpath(struct vnode *vp, char *pathbuf, int *len);
 580
 581 /*
 582  * Flags for the vnode_lookup and vnode_open
 583  */
 584 #define VNODE_LOOKUP_NOFOLLOW           0x01
 585 #define VNODE_LOOKUP_NOCROSSMOUNT       0x02
 586 #define VNODE_LOOKUP_DOWHITEOUT         0x04
 587
 588 errno_t vnode_lookup(const char *, int, vnode_t *, vfs_context_t);
 589 errno_t vnode_open(const char *, int, int, int, vnode_t *, vfs_context_t);
 590
 591 /*
 592  * exported vnode operations
 593  */
 594
 595 int     vnode_iterate(struct mount *, int, int (*)(struct vnode *, void *), void *);
 596 /*
 597  * flags passed into vnode_iterate
 598  */
 599 #define VNODE_RELOAD                    0x01
 600 #define VNODE_WAIT                              0x02
 601 #define VNODE_WRITEABLE                 0x04
 602 #define VNODE_WITHID                    0x08
 603 #define VNODE_NOLOCK_INTERNAL   0x10
 604 #define VNODE_NODEAD                    0x20
 605 #define VNODE_NOSUSPEND                 0x40
 606 #define VNODE_ITERATE_ALL               0x80
 607 #define VNODE_ITERATE_ACTIVE    0x100
 608 #define VNODE_ITERATE_INACTIVE  0x200
 609
 610 /*
 611  * return values from callback
 612  */
 613 #define VNODE_RETURNED          0       /* done with vnode, reference can be dropped */
 614 #define VNODE_RETURNED_DONE     1       /* done with vnode, reference can be dropped, terminate iteration */
 615 #define VNODE_CLAIMED           2       /* don't drop reference */
 616 #define VNODE_CLAIMED_DONE      3       /* don't drop reference, terminate iteration */
 617
 618
 619 struct stat;
 620 int     vn_stat(struct vnode *vp, struct stat *sb, kauth_filesec_t *xsec, vfs_context_t ctx);
 621 int     vn_stat_noauth(struct vnode *vp, struct stat *sb, kauth_filesec_t *xsec, vfs_context_t ctx);
 622 int     vn_revoke(vnode_t vp, int flags, vfs_context_t);
 623 /* XXX BOGUS */
 624 int     vaccess(mode_t file_mode, uid_t uid, gid_t gid,
 625                         mode_t acc_mode, struct ucred *cred);
 626
 627
 628 /* namecache function prototypes */
 629 int     cache_lookup(vnode_t dvp, vnode_t *vpp, struct componentname *cnp);
 630 void    cache_enter(vnode_t dvp, vnode_t vp, struct componentname *cnp);
 631 void    cache_purge(vnode_t vp);
 632 void    cache_purge_negatives(vnode_t vp);
 633
 634 /*
 635  * Global string-cache routines.  You can pass zero for nc_hash
 636  * if you don't know it (add_name() will then compute the hash).
 637  * There are no flags for now but maybe someday.
 638  */
 639 char *vfs_addname(const char *name, size_t len, u_int nc_hash, u_int flags);
 640 int   vfs_removename(const char *name);
 641
 642 __END_DECLS
 643
 644 #endif /* KERNEL */
 645
 646 #endif /* !_VNODE_H_ */