bsd/sys/vnode.h

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